kugetsu/skills/kugetsu/scripts/kugetsu-session.sh

#!/bin/bash
set -euo pipefail

# Source required modules for session management functions
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "$SCRIPT_DIR/kugetsu-config.sh"
source "$SCRIPT_DIR/kugetsu-index.sh"
source "$SCRIPT_DIR/kugetsu-worktree.sh"
source "$SCRIPT_DIR/kugetsu-log.sh"

count_active_dev_sessions() {
    local count=0
    if [ -d "$SESSIONS_DIR" ]; then
        for session_file in "$SESSIONS_DIR"/*.json; do
            if [ -f "$session_file" ]; then
                local filename
                filename=$(basename "$session_file")
                if [ "$filename" != "base.json" ] && [ "$filename" != "pm-agent.json" ]; then
                    count=$((count + 1))
                fi
            fi
        done
    fi
    echo "$count"
}

cmd_init() {
    local force=false

    while [ $# -gt 0 ]; do
        case "$1" in
            --force)
                force=true
                ;;
            *)
                ;;
        esac
        shift
    done

    ensure_dirs

    if [ ! -f "$KUGETSU_DIR/config" ]; then
        cat > "$KUGETSU_DIR/config" << 'EOF'
# User configuration overrides
# Values set here take precedence over defaults
# Changes take effect immediately (no re-init needed)

# Max concurrent dev agents (default: 3)
# MAX_CONCURRENT_AGENTS=5

# Git server configurations
# Format: GIT_SERVERS["hostname"]="https://hostname"
declare -A GIT_SERVERS
GIT_SERVERS["github.com"]="https://github.com"
GIT_SERVERS["git.fbrns.co"]="https://git.fbrns.co"
DEFAULT_GIT_SERVER="github.com"
EOF
        echo "Created config file: $KUGETSU_DIR/config"
    fi

    mkdir -p "$ENV_DIR"
    if [ ! -f "$ENV_DIR/default.env" ]; then
        cat > "$ENV_DIR/default.env" << 'EOF'
# Environment variables for agents
# Copy this file to <agent-type>.env (e.g., pm-agent.env, dev.env)
# and set your tokens and configuration

# Required: Gitea token for API access
# GITEA_TOKEN=your_gitea_token_here

# Optional: GitHub token (if using GitHub)
# GITHUB_TOKEN=your_github_token_here

# Optional: GitLab token (if using GitLab)
# GITLAB_TOKEN=your_gitlab_token_here
EOF
        echo "Created env template: $ENV_DIR/default.env"
    fi

    local existing_base=$(get_base_session_id)
    local existing_pm=$(get_pm_agent_session_id)
    
    if [ -n "$existing_base" ] && [ "$existing_base" != "null" ]; then
        if [ "$force" = true ]; then
            echo "Warning: Reinitializing sessions (force mode)" >&2
            echo "Destroying all sessions, worktrees, and logs..." >&2
            cmd_destroy --base -y 2>/dev/null || true
            cmd_destroy --pm-agent -y 2>/dev/null || true
            rm -f "$LOGS_DIR"/*.log 2>/dev/null || true
        else
            echo "Error: Base session already exists: $existing_base" >&2
            echo "Use --force to reinitialize" >&2
            exit 1
        fi
    fi

    if ! test -t 0; then
        echo "Error: init requires a terminal (TTY)" >&2
        echo "Please run this command in an interactive shell" >&2
        exit 1
    fi

    echo "Starting TUI to create base session..."
    echo "Press Ctrl+C to cancel or wait for session to be created"
    sleep 2

    local before_sessions=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' || true)

    opencode

    local after_sessions=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' || true)
    local session_ids=""
    while IFS= read -r line; do
        local sid=$(echo "$line" | awk '{print $1}')
        if [ -n "$sid" ] && ! echo "$before_sessions" | grep -q "^${sid}$"; then
            session_ids="$sid"
            break
        fi
    done <<< "$after_sessions"

    if [ -z "$session_ids" ]; then
        echo "Error: Could not find newly created session" >&2
        exit 1
    fi

    echo "$session_ids" > "$SESSIONS_DIR/base.json"
    set_base_in_index "$session_ids"

    echo "Base session created: $session_ids"
    echo "Starting PM agent..."

    before_sessions="$after_sessions"

    opencode

    after_sessions=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' || true)
    local pm_session_ids=""
    while IFS= read -r line; do
        local sid=$(echo "$line" | awk '{print $1}')
        if [ -n "$sid" ] && ! echo "$before_sessions" | grep -q "^${sid}$"; then
            pm_session_ids="$sid"
            break
        fi
    done <<< "$after_sessions"

    if [ -z "$pm_session_ids" ]; then
        echo "Warning: Could not find separate PM agent session" >&2
        pm_session_ids="$session_ids"
    fi

    echo "$pm_session_ids" > "$SESSIONS_DIR/pm-agent.json"
    set_pm_agent_in_index "$pm_session_ids"

    load_agent_env "pm-agent"

    local pm_system_prompt=""
    if [ -f "$KUGETSU_DIR/pm-agent.md" ]; then
        pm_system_prompt=$(cat "$KUGETSU_DIR/pm-agent.md")
        echo "Injecting PM agent system prompt from $KUGETSU_DIR/pm-agent.md"
    fi

    echo "PM agent session created: $pm_session_ids"
    echo ""
    echo "kugetsu initialized successfully!"
    echo "  Base session: $session_ids"
    echo "  PM agent: $pm_session_ids"
}

extract_issue_ref_from_message() {
    local message="$1"
    
    if [ -z "$message" ]; then
        echo ""
        return
    fi
    
    if [[ "$message" =~ ^([a-zA-Z0-9.-]+/[a-zA-Z0-9._-]+/[a-zA-Z0-9._-]+#[0-9]+) ]]; then
        echo "${BASH_REMATCH[1]}"
        return
    fi
    
    if [[ "$message" =~ (https?://)?([a-zA-Z0-9.-]+)/([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)/(issues|pull)/([0-9]+) ]]; then
        local instance="${BASH_REMATCH[2]}"
        local owner="${BASH_REMATCH[3]}"
        local repo="${BASH_REMATCH[4]}"
        local num="${BASH_REMATCH[6]}"
        echo "${instance}/${owner}/${repo}#${num}"
        return
    fi
    
    echo ""
}

cmd_delegate() {
    local message="${1:-}"
    
    if [ -z "$message" ]; then
        echo "Error: message is required" >&2
        echo "Usage: kugetsu delegate <message>" >&2
        exit 1
    fi
    
    local issue_ref=$(extract_issue_ref_from_message "$message")
    
    if [ -n "$issue_ref" ] && [[ "$issue_ref" =~ \#[0-9]+$ ]]; then
        # Enqueue for daemon to process via cmd_start/cmd_continue
        enqueue_task "$issue_ref" "$message"
        return
    fi
    
    # No issue ref detected — fork a new session from base session
    local base_session=$(get_base_session_id)
    if [ -z "$base_session" ] || [ "$base_session" = "null" ]; then
        echo "Error: Base session not found. Run 'kugetsu init' first." >&2
        exit 1
    fi
    
    mkdir -p "$LOGS_DIR"
    local log_file="$LOGS_DIR/delegate-$(date +%s).log"
    load_agent_env "pm-agent"
    
    local new_session=$(create_session "$base_session")
    if [ -z "$new_session" ]; then
        echo "Error: Failed to create session" >&2
        exit 1
    fi
    
    local msg_file="$LOGS_DIR/msg-$new_session.txt"
    printf '%s' "$message" > "$msg_file"
    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$new_session'" >> "$log_file" 2>&1 &
    echo "Delegated to new session (logged to $(basename "$log_file"))"
}

create_session() {
    local base_session="${1:-$base_session_id}"
    
    if [ -z "$base_session" ] || [ "$base_session" = "null" ]; then
        echo "Error: base session not found. Run 'kugetsu init' first." >&2
        return 1
    fi
    
    local before_file
    before_file="$KUGETSU_DIR/sessions/before$$.json"
    local after_file
    after_file="$KUGETSU_DIR/sessions/after$$.json"
    
    opencode session list --format=json > "$before_file" 2>/dev/null || printf '{}' > "$before_file"
    
    local fork_success=false
    local attempt=0
    local max_attempts="${NETWORK_RETRY_ATTEMPTS:-3}"
    
    while [ $attempt -lt $max_attempts ] && [ "$fork_success" = false ]; do
        attempt=$((attempt + 1))
        if opencode run --fork --session "$base_session" "new session" >/dev/null 2>&1; then
            fork_success=true
        elif [ $attempt -lt $max_attempts ]; then
            log "warn" "create_session" "Fork attempt $attempt failed, retrying..."
            sleep "$((attempt * 2))"
        fi
    done
    
    if [ "$fork_success" = false ]; then
        log "error" "create_session" "Failed to fork session after $max_attempts attempts"
        rm -f "$before_file" "$after_file"
        return 1
    fi
    
    sleep 1
    
    opencode session list --format=json > "$after_file" 2>/dev/null || printf '{}' > "$after_file"
    
    local new_session_id
    new_session_id=$(python3 << PYEOF
import json

with open("$before_file", 'r') as f:
    before = json.load(f)
with open("$after_file", 'r') as f:
    after = json.load(f)

before_ids = set(s['id'] for s in before)
for s in after:
    if s['id'] not in before_ids:
        print(s['id'])
        break
PYEOF
)
    
    rm -f "$before_file" "$after_file"
    
    echo "$new_session_id"
}

build_dev_agent_message() {
    local issue_ref="$1"
    local user_message="${2:-}"
    
    local instance=$(echo "$issue_ref" | cut -d'/' -f1 | cut -d'#' -f1)
    local owner=$(echo "$issue_ref" | cut -d'/' -f2)
    local repo=$(echo "$issue_ref" | cut -d'/' -f3 | cut -d'#' -f1)
    local number=$(echo "$issue_ref" | grep -oE '#[0-9]+$' | tr -d '#')
    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref")
    
    local conflict_check=""
    local review_notes=""
    local delegator_header=""
    local delegator_footer=""
    if [ -n "$user_message" ]; then
        conflict_check="   - CRITICAL: Check if PR has merge conflicts before asking for review:
     - Use: curl -s \"https://$instance/api/v1/repos/$owner/$repo/pulls/$number\" -H \"Authorization: Bearer \$GITEA_TOKEN\"
     - If \"mergeable\": false, there ARE conflicts - you MUST resolve them FIRST
     - To resolve: cd to worktree, git fetch origin, git rebase origin/main, resolve conflicts, git rebase --continue, git push --force-with-lease
     - Only after resolving conflicts (mergeable: true) can you ask for review"
        delegator_header="IMPORTANT: Follow the workflow below as your guideline, but prioritize the delegator's message.

Workflow:"
        delegator_footer="

Delegator's message:
$user_message"
    else
        review_notes="  - IMPORTANT: After listing reviews, READ the review comments and incorporate feedback
  - Check for review state: \"APPROVED\" means ready to merge, \"COMMENT\" means feedback to address"
        delegator_header="Workflow:"
    fi
    
    cat <<EOF
You are assigned to work on $issue_ref.

$delegator_header
1. Read the issue at $instance/$owner/$repo/issues/$number AND all comments on that issue
2. Check if a PR already exists for this issue
   - If PR exists and is open, review it and learn from it
$conflict_check
   - If PR makes sense to continue, work on it instead
   - If PR is not worth continuing, create a new branch/PR but explain in PR description why you're creating a new one instead of continuing the existing PR
3. Read README.md (if exists) to understand the general concept of this repository
4. Read CONTRIBUTING.md (if exists) to understand how to contribute
   - If CONTRIBUTING.md doesn't exist, follow steps 5-9 as your guideline
5. Explore the repository to understand the codebase
6. If anything is unclear, post a comment on the issue asking for clarification before implementing
7. Implement the solution
8. Create a branch named fix/issue-$number and implement the fix
9. Create a PR when the implementation is complete using: tea pr create --repo $owner/$repo --title "Your PR title" --body "PR description"
   - Make sure you are logged in with: tea login add --name gitea --token \$GITEA_TOKEN --url https://$instance
   - If tea is not available, use: curl -X POST "https://$instance/api/v1/repos/$owner/$repo/pulls" -H "Authorization: Bearer \$GITEA_TOKEN" -H "Content-Type: application/json" -d '{"title":"PR Title","head":"branch-name","base":"main","body":"PR description"}'

Tools for PR interaction:
- Post issue/PR comment: curl -X POST "https://$instance/api/v1/repos/$owner/$repo/issues/$number/comments" -H "Authorization: Bearer \$GITEA_TOKEN" -H "Content-Type: application/json" -d '{"body":"Your comment"}'
- List PR comments: curl -s "https://$instance/api/v1/repos/$owner/$repo/issues/$number/comments" -H "Authorization: Bearer \$GITEA_TOKEN"
- List PR reviews: curl -s "https://$instance/api/v1/repos/$owner/$repo/pulls/$number/reviews" -H "Authorization: Bearer \$GITEA_TOKEN"
$review_notes
- Merge PR (only with approval): tea pr merge --repo $owner/$repo $number --style merge
  - MERGING requires approval first! Check for: approval in reviews, OR "lgtm"/"approved" in comments
  - If no approval, ask reviewer to approve first before merging
$delegator_footer

Work directory: $worktree_path
EOF
}

ensure_worktree() {
    local issue_ref="$1"
    
    if worktree_exists "$issue_ref" "$WORKTREES_DIR"; then
        log "info" "ensure_worktree" "Worktree already exists for $issue_ref"
        echo "existed"
        return 0
    fi
    
    local base_session_id=$(get_base_session_id)
    if [ -z "$base_session_id" ] || [ "$base_session_id" = "null" ]; then
        log "error" "ensure_worktree" "Base session not found for $issue_ref"
        echo "error"
        return 1
    fi
    
    local active_count=$(count_active_dev_sessions)
    if [ "$active_count" -ge "${MAX_CONCURRENT_AGENTS:-3}" ]; then
        log "error" "ensure_worktree" "Max concurrent agents reached for $issue_ref"
        echo "error"
        return 1
    fi
    
    if create_worktree "$issue_ref" "$WORKTREES_DIR" 2>&1 | tee >(cat >&2); then
        log "info" "ensure_worktree" "Created worktree for $issue_ref"
        echo "created"
        return 0
    else
        log "error" "ensure_worktree" "Failed to create worktree for $issue_ref"
        echo "error"
        return 1
    fi
}

ensure_session() {
    local issue_ref="$1"
    
    local session_file=$(issue_ref_to_filename "$issue_ref")
    local session_path="$SESSIONS_DIR/$session_file"
    
    local worktree_exists=false
    if worktree_exists "$issue_ref" "$WORKTREES_DIR"; then
        worktree_exists=true
    fi
    
    local session_exists=false
    if [ -f "$session_path" ]; then
        session_exists=true
    fi
    
    if [ "$worktree_exists" = true ] && [ "$session_exists" = true ]; then
        log "info" "ensure_session" "Session already exists for $issue_ref"
        echo "continued"
        return 0
    fi
    
    if [ "$worktree_exists" = false ] && [ "$session_exists" = true ]; then
        log "warn" "ensure_session" "Session exists but worktree is missing. Removing stale session..."
        rm -f "$session_path"
        remove_issue_from_index "$issue_ref"
        session_exists=false
    fi
    
    if [ "$worktree_exists" = false ]; then
        local wt_status=$(ensure_worktree "$issue_ref")
        if [ "$wt_status" != "created" ] && [ "$wt_status" != "existed" ]; then
            log "error" "ensure_session" "Failed to ensure worktree for $issue_ref"
            echo "error"
            return 1
        fi
    fi
    
    local base_session_id=$(get_base_session_id)
    if [ -z "$base_session_id" ] || [ "$base_session_id" = "null" ]; then
        log "error" "ensure_session" "Base session not found for $issue_ref"
        echo "error"
        return 1
    fi
    
    local new_session_id=$(create_session "$base_session_id")
    
    if [ -z "$new_session_id" ]; then
        log "error" "ensure_session" "Could not create session for $issue_ref"
        echo "error"
        return 1
    fi
    
    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref")
    
    printf '{"type": "forked", "issue_ref": "%s", "opencode_session_id": "%s", "worktree_path": "%s", "created_at": "%s", "state": "idle"}\n' \
        "$issue_ref" "$new_session_id" "$worktree_path" "$(date -Iseconds)" > "$SESSIONS_DIR/$session_file"
    
    add_issue_to_index "$issue_ref" "$session_file"
    
    log "info" "ensure_session" "Created session for $issue_ref: $new_session_id"
    echo "created"
    return 0
}

fork_agent() {
    local session_id="$1"
    local worktree_path="$2"
    local message="$3"
    
    if [ -z "$worktree_path" ] || [ ! -d "$worktree_path" ]; then
        log "error" "fork_agent" "Invalid worktree path: $worktree_path"
        echo "error"
        return 1
    fi
    
    load_agent_env "dev"
    
    cd "$worktree_path"
    local sanitized_id=$(echo "$session_id" | sed 's/[^a-zA-Z0-9_-]/_/g')
    mkdir -p "$worktree_path/.kugetsu"
    if [ ! -f "$worktree_path/.gitignore" ] || ! grep -q "^.kugetsu/" "$worktree_path/.gitignore"; then
        echo ".kugetsu/" >> "$worktree_path/.gitignore" 2>/dev/null || true
    fi
    local msg_file="$worktree_path/.kugetsu/msg.txt"
    printf '%s' "$message" > "$msg_file"
    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$session_id'" >> "$LOGS_DIR/dev-$sanitized_id.log" 2>&1 &
    
    log "info" "fork_agent" "Forked agent for session $session_id in $worktree_path"
    echo "forked"
    return 0
}

cmd_start() {
    cmd_continue "$@"
}

cmd_continue() {
    local issue_ref="${1:-}"
    local message="${2:-}"
    
    if [ -z "$issue_ref" ]; then
        echo "Error: issue ref is required" >&2
        echo "Usage: kugetsu continue <issue-ref> [message]" >&2
        exit 1
    fi
    
    validate_issue_ref "$issue_ref"
    
    if [ -z "$message" ]; then
        message=$(build_dev_agent_message "$issue_ref" "")
    else
        message=$(build_dev_agent_message "$issue_ref" "$message")
    fi
    
    local worktree_status=$(ensure_worktree "$issue_ref")
    if [ "$worktree_status" = "error" ]; then
        echo "Error: Failed to ensure worktree for '$issue_ref'" >&2
        exit 1
    fi
    
    local session_status=$(ensure_session "$issue_ref")
    if [ "$session_status" = "error" ]; then
        echo "Error: Failed to ensure session for '$issue_ref'" >&2
        exit 1
    fi
    
    kugetsu_context_dump "$issue_ref" "$message" "$(issue_ref_to_branch_name "$issue_ref")"
    
    local session_file=$(issue_ref_to_filename "$issue_ref")
    local session_path="$SESSIONS_DIR/$session_file"
    local opencode_session_id=$(python3 -c "import json; print(json.load(open('$session_path')).get('opencode_session_id', ''))" 2>/dev/null || echo "")
    local worktree_path=$(python3 -c "import json; print(json.load(open('$session_path')).get('worktree_path', ''))" 2>/dev/null || echo "")
    
    local fork_status=$(fork_agent "$opencode_session_id" "$worktree_path" "$message")
    if [ "$fork_status" = "error" ]; then
        echo "Error: Failed to fork agent for '$issue_ref'" >&2
        exit 1
    fi
    
    log "info" "cmd_continue" "Result for $issue_ref: worktree=$worktree_status session=$session_status fork=$fork_status"
    
    echo "Session continued for '$issue_ref': $opencode_session_id"
    echo "Worktree: $worktree_path"
    echo "${worktree_status}-${session_status}-${fork_status}"
}

cmd_list() {
    echo "=== kugetsu sessions ==="
    echo ""
    
    local base_id=$(get_base_session_id)
    if [ -n "$base_id" ] && [ "$base_id" != "null" ]; then
        echo "Base session: $base_id"
    else
        echo "Base session: not initialized"
    fi
    
    local pm_id=$(get_pm_agent_session_id)
    if [ -n "$pm_id" ] && [ "$pm_id" != "null" ]; then
        echo "PM agent: $pm_id"
    else
        echo "PM agent: not initialized"
    fi
    
    echo ""
    echo "Issue sessions:"
    
    if [ -d "$SESSIONS_DIR" ]; then
        for session_file in "$SESSIONS_DIR"/*.json; do
            if [ -f "$session_file" ]; then
                local filename=$(basename "$session_file")
                if [ "$filename" != "base.json" ] && [ "$filename" != "pm-agent.json" ]; then
                    local issue_ref=$(filename_to_issue_ref "$filename")
                    local opencode_sid=$(python3 -c "import json; print(json.load(open('$session_file')).get('opencode_session_id', 'unknown'))" 2>/dev/null || echo "unknown")
                    local state=$(python3 -c "import json; print(json.load(open('$session_file')).get('state', 'unknown'))" 2>/dev/null || echo "unknown")
                    local worktree_path=$(python3 -c "import json; print(json.load(open('$session_file')).get('worktree_path', ''))" 2>/dev/null || echo "")
                    local worktree_status=""
                    if [ -n "$worktree_path" ]; then
                        if [ -d "$worktree_path" ]; then
                            worktree_status="(worktree exists)"
                        else
                            worktree_status="(worktree MISSING)"
                        fi
                    fi
                    echo "  $filename"
                    echo "    Issue: $issue_ref"
                    echo "    Session: $opencode_sid"
                    echo "    State: $state"
                    echo "    $worktree_status"
                fi
            fi
        done
    fi
    
    if [ -d "$WORKTREES_DIR" ]; then
        echo ""
        echo "Worktrees without sessions:"
        for worktree in $(find "$WORKTREES_DIR" -mindepth 1 -maxdepth 1 -type d 2>/dev/null); do
            local worktree_name=$(basename "$worktree")
            local has_session=false
            for session_file in "$SESSIONS_DIR"/*.json; do
                if [ -f "$session_file" ]; then
                    local wt_path=$(python3 -c "import json; print(json.load(open('$session_file')).get('worktree_path', ''))" 2>/dev/null || echo "")
                    if [ "$wt_path" = "$worktree" ]; then
                        has_session=true
                        break
                    fi
                fi
            done
            if [ "$has_session" = false ]; then
                echo "  $worktree_name (no session)"
            fi
        done
    fi
}

cmd_prune() {
    local force=false
    
    if [ "$1" = "--force" ]; then
        force=true
    fi
    
    echo "=== kugetsu prune ==="
    echo ""
    
    local orphaned=()
    
    if [ -d "$SESSIONS_DIR" ]; then
        for session_file in "$SESSIONS_DIR"/*.json; do
            [ -f "$session_file" ] || continue
            local filename=$(basename "$session_file")
            if [ "$filename" = "base.json" ] || [ "$filename" = "pm-agent.json" ]; then
                continue
            fi
            
            local opencode_sid=$(python3 -c "import json; print(json.load(open('$session_file')).get('opencode_session_id', ''))" 2>/dev/null || echo "")
            
            if [ -n "$opencode_sid" ]; then
                local exists=$(opencode session list 2>/dev/null | grep -c "^$opencode_sid" || echo "0")
                if [ "$exists" -eq 0 ]; then
                    orphaned+=("$session_file")
                fi
            else
                orphaned+=("$session_file")
            fi
        done
    fi
    
    if [ ${#orphaned[@]} -eq 0 ]; then
        echo "No orphaned sessions found."
        return
    fi
    
    echo "Found ${#orphaned[@]} orphaned session(s):"
    for session in "${orphaned[@]}"; do
        echo "  $session"
    done
    echo ""
    
    if [ "$force" = false ]; then
        read -p "Remove these sessions? [y/N] " -r answer
        if [[ ! "$answer" =~ ^[Yy]$ ]]; then
            echo "Aborted."
            return
        fi
    fi
    
    for session in "${orphaned[@]}"; do
        local issue_ref=$(python3 -c "import json; print(json.load(open('$session')).get('issue_ref', ''))" 2>/dev/null || echo "")
        local worktree_path=$(python3 -c "import json; print(json.load(open('$session')).get('worktree_path', ''))" 2>/dev/null || echo "")
        
        if [ -n "$worktree_path" ] && [ -d "$worktree_path" ]; then
            echo "Removing worktree: $worktree_path"
            git worktree remove "$worktree_path" 2>/dev/null || rm -rf "$worktree_path"
        fi
        
        rm -f "$session"
        
        if [ -n "$issue_ref" ]; then
            remove_issue_from_index "$issue_ref"
        fi
        
        echo "Removed: $session"
    done
    
    echo ""
    echo "Pruned ${#orphaned[@]} orphaned session(s)."
}

cmd_destroy() {
    local target="${1:-}"
    local force=false
    
    if [ "${2:-}" = "-y" ]; then
        force=true
    fi
    
    if [ -z "$target" ]; then
        echo "Error: target is required" >&2
        echo "Usage: kugetsu destroy <issue-ref> [-y]" >&2
        echo "       kugetsu destroy --pm-agent [-y]" >&2
        echo "       kugetsu destroy --base [-y]" >&2
        exit 1
    fi
    
    if [ "$target" = "--pm-agent" ]; then
        if [ "$force" = false ]; then
            echo "Warning: Destroying PM agent session is not recommended." >&2
            read -p "Continue? [y/N] " -r answer
            if [[ ! "$answer" =~ ^[Yy]$ ]]; then
                echo "Aborted."
                return
            fi
        fi
        
        local pm_session=$(get_pm_agent_session_id)
        if [ -n "$pm_session" ] && [ "$pm_session" != "null" ]; then
            echo "Stopping PM agent session: $pm_session"
            opencode session stop "$pm_session" 2>/dev/null || true
        fi
        
        rm -f "$SESSIONS_DIR/pm-agent.json"
        set_pm_agent_in_index "null"
        echo "PM agent session destroyed"
    elif [ "$target" = "--base" ]; then
        if [ "$force" = false ]; then
            echo "Warning: Destroying base session will remove ALL sessions." >&2
            read -p "Continue? [y/N] " -r answer
            if [[ ! "$answer" =~ ^[Yy]$ ]]; then
                echo "Aborted."
                return
            fi
        fi
        
        for session_file in "$SESSIONS_DIR"/*.json; do
            [ -f "$session_file" ] || continue
            rm -f "$session_file"
        done
        
        for worktree in "$WORKTREES_DIR"/.kugetsu-worktrees/*; do
            if [ -d "$worktree" ]; then
                git worktree remove "$worktree" 2>/dev/null || rm -rf "$worktree"
            fi
        done
        
        write_index "null" "null" "{}"
        echo "Base session and all worktrees destroyed"
    else
        validate_issue_ref "$target"
        
        local session_file=$(get_session_for_issue "$target")
        if [ -z "$session_file" ] || [ "$session_file" = "null" ]; then
            echo "Error: No session found for '$target'" >&2
            exit 1
        fi
        
        local session_path="$SESSIONS_DIR/$session_file"
        
        if [ "$force" = true ]; then
            remove_worktree_for_issue "$target"
            rm -f "$session_path"
            remove_issue_from_index "$target"
            echo "Session for '$target' destroyed"
        else
            echo "Warning: This will delete session and worktree for '$target'" >&2
            read -p "Continue? [y/N] " -r answer
            if [[ ! "$answer" =~ ^[Yy]$ ]]; then
                echo "Aborted."
                return
            fi
            
            remove_worktree_for_issue "$target"
            rm -f "$session_path"
            remove_issue_from_index "$target"
            echo "Session for '$target' destroyed"
        fi
    fi
}

cmd_status() {
    echo "=== kugetsu status ==="
    
    local base_id=$(get_base_session_id)
    local pm_id=$(get_pm_agent_session_id)
    
    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
        echo "Status: Not initialized"
        echo "Run 'kugetsu init' to initialize."
        return
    fi
    
    echo "Base session: $base_id"
    
    if [ -n "$pm_id" ] && [ "$pm_id" != "null" ]; then
        echo "PM agent: $pm_id"
    else
        echo "PM agent: not running"
    fi
    
    local active_count=$(count_active_dev_sessions)
    echo "Active issue sessions: $active_count / ${MAX_CONCURRENT_AGENTS:-3}"
    
    echo ""
    echo "OpenCode sessions:"
    opencode session list 2>/dev/null || echo "  (unable to list sessions)"
}