Merge origin/main into fix/issue-116-modularize-script

2026-04-05 10:56:35 +00:00
11 changed files with 315 additions and 1129 deletions
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -6,25 +6,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

 ## [Unreleased]

-## [v0.2.4] - 2026-04-06
-
-### Fixed
- Queue daemon: Locking to prevent daemon vs manual conflicts
- Queue daemon: Proper error handling for failed tasks
- Queue daemon: Fix GITEA_TOKEN loading from pm-agent.env
- cmd_delegate: Enqueue tasks instead of bypassing queue
- Notifications: Call kugetsu_add_notification from bash instead of os.system()
- kugetsu: Remove duplicate update_queue_item_state that overwrote fixed version
-
-### Added
- Queue functions moved to kugetsu-index.sh for daemon access
- kugetsu-session.sh sources required modules for daemon use
-
-## [v0.2.3] - 2026-04-06
-
-### Fixed
- get_pending_tasks() returns proper JSON array instead of concatenated JSON objects
-
 ## [v0.2.1] - 2026-04-03

 ### Fixed
--- a/skills/kugetsu/scripts/kugetsu
+++ b/skills/kugetsu/scripts/kugetsu
@@ -93,16 +93,23 @@ EOF

 ensure_dirs() {
    mkdir -p "$SESSIONS_DIR"
-    mkdir -p "$LOGS_DIR"
-    mkdir -p "$WORKTREES_DIR"
-    mkdir -p "$QUEUE_DIR"
-    mkdir -p "$QUEUE_ITEMS_DIR"
 }

 ensure_worktree_dir() {
    mkdir -p "$WORKTREES_DIR"
 }

+issue_ref_to_filename() {
+    local issue_ref="$1"
+    echo "$issue_ref" | sed 's/[\/:]/-/g' | sed 's/#/-/'
+}
+
+filename_to_issue_ref() {
+    local filename="$1"
+    local name="${filename%.json}"
+    echo "$name" | sed 's/-\([0-9]*\)$/#\1/' | sed 's/-/\//g'
+}
+
 issue_ref_to_context_file() {
    local issue_ref="$1"
    local context_filename=$(issue_ref_to_filename "$issue_ref")
@@ -261,9 +268,7 @@ PYEOF
 }

 ensure_queue_dirs() {
-    mkdir -p "$QUEUE_DIR"
    mkdir -p "$QUEUE_ITEMS_DIR"
-    mkdir -p "$LOGS_DIR"
 }

 generate_queue_id() {
@@ -316,31 +321,12 @@ get_pending_tasks() {
        return
    fi
    
-    python3 -c "
-import json
-import os
-import sys
-
-queue_dir = os.environ.get('QUEUE_ITEMS_DIR', '')
-limit = int(sys.argv[1]) if len(sys.argv) > 1 else 10
-
-items = []
-if os.path.isdir(queue_dir):
-    for filename in os.listdir(queue_dir):
-        if filename.endswith('.json'):
-            filepath = os.path.join(queue_dir, filename)
-            try:
-                with open(filepath) as f:
-                    data = json.load(f)
-                    if data.get('state') == 'pending':
-                        items.append(data)
-                        if len(items) >= limit:
-                            break
-            except:
-                pass
-
-print(json.dumps(items))
-" "$limit"
+    find "$QUEUE_ITEMS_DIR" -name "*.json" -type f 2>/dev/null | while read -r file; do
+        local state=$(python3 -c "import json; print(json.load(open('$file')).get('state', ''))" 2>/dev/null || echo "")
+        if [ "$state" = "pending" ]; then
+            cat "$file"
+        fi
+    done | head -"$limit"
 }

 get_queue_stats() {
@@ -367,6 +353,55 @@ get_queue_stats() {
    echo "{\"total\": $total, \"pending\": $pending, \"notified\": $notified, \"completed\": $completed, \"error\": $error}"
 }

+update_queue_item_state() {
+    local queue_id="$1"
+    local new_state="$2"
+    local session_id="${3:-}"
+    local pid="${4:-}"
+    
+    local item_file="$QUEUE_ITEMS_DIR/${queue_id}.json"
+    if [ ! -f "$item_file" ]; then
+        echo "Error: Queue item not found: $queue_id" >&2
+        return 1
+    fi
+    
+    python3 << PYEOF
+import json
+import os
+from datetime import datetime
+
+item_file = "$item_file"
+new_state = "$new_state"
+session_id = "$session_id"
+pid = "$pid"
+
+with open(item_file, 'r') as f:
+    item = json.load(f)
+
+issue_ref = item.get('issue_ref', '')
+
+item['state'] = new_state
+
+if new_state == "notified":
+    item['notified_at'] = datetime.now().isoformat() + "Z"
+    if session_id:
+        item['opencode_session_id'] = session_id
+    if pid:
+        item['pid'] = int(pid) if pid.isdigit() else None
+elif new_state == "completed":
+    item['completed_at'] = datetime.now().isoformat() + "Z"
+    os.system(f"kugetsu_add_notification 'task_completed' 'Task completed: {issue_ref}' '{issue_ref}'")
+elif new_state == "error":
+    item['error'] = datetime.now().isoformat() + "Z"
+    os.system(f"kugetsu_add_notification 'task_error' 'Task error: {issue_ref}' '{issue_ref}'")
+
+with open(item_file, 'w') as f:
+    json.dump(item, f, indent=2)
+
+print(f"Updated $queue_id to state: $new_state")
+PYEOF
+}
+
 check_task_timeouts() {
    if [ ! -d "$QUEUE_ITEMS_DIR" ]; then
        return
@@ -475,6 +510,97 @@ read_index() {
    fi
 }

+write_index() {
+    local base="$1"
+    local pm_agent="$2"
+    local issues_json="$3"
+    local temp_file="$INDEX_FILE.tmp.$$"
+    printf '{"base": %s, "pm_agent": %s, "issues": %s}\n' "$base" "$pm_agent" "$issues_json" > "$temp_file"
+    mv "$temp_file" "$INDEX_FILE"
+}
+
+get_base_session_id() {
+    local index=$(read_index)
+    echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print(d.get('base') or '')"
+}
+
+get_pm_agent_session_id() {
+    local index=$(read_index)
+    echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print(d.get('pm_agent') or '')"
+}
+
+get_session_for_issue() {
+    local issue_ref="$1"
+    local index=$(read_index)
+    echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print(d['issues'].get('$issue_ref') or '')"
+}
+
+set_base_in_index() {
+    local base_session_id="$1"
+    local pm_agent=$(get_pm_agent_session_id)
+    local issues_json=$(read_index | python3 -c "import sys, json; d=json.load(sys.stdin); print(json.dumps(d['issues']))")
+    if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
+        write_index "\"$base_session_id\"" "null" "$issues_json"
+    else
+        write_index "\"$base_session_id\"" "\"$pm_agent\"" "$issues_json"
+    fi
+}
+
+set_pm_agent_in_index() {
+    local pm_agent_session_id="$1"
+    local base=$(get_base_session_id)
+    local issues_json=$(read_index | python3 -c "import sys, json; d=json.load(sys.stdin); print(json.dumps(d['issues']))")
+    if [ -z "$base" ] || [ "$base" = "null" ]; then
+        write_index "null" "\"$pm_agent_session_id\"" "$issues_json"
+    else
+        write_index "\"$base\"" "\"$pm_agent_session_id\"" "$issues_json"
+    fi
+}
+
+add_issue_to_index() {
+    local issue_ref="$1"
+    local session_file="$2"
+    local index=$(read_index)
+    local base=$(get_base_session_id)
+    local pm_agent=$(get_pm_agent_session_id)
+    local issues=$(echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print(json.dumps(d['issues']))")
+    local new_issues=$(echo "$issues" | python3 -c "import sys, json; d=json.load(sys.stdin); d['$issue_ref']='$session_file'; print(json.dumps(d))")
+    if [ -z "$base" ] || [ "$base" = "null" ]; then
+        if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
+            write_index "null" "null" "$new_issues"
+        else
+            write_index "null" "\"$pm_agent\"" "$new_issues"
+        fi
+    else
+        if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
+            write_index "\"$base\"" "null" "$new_issues"
+        else
+            write_index "\"$base\"" "\"$pm_agent\"" "$new_issues"
+        fi
+    fi
+}
+
+remove_issue_from_index() {
+    local issue_ref="$1"
+    local index=$(read_index)
+    local base=$(get_base_session_id)
+    local pm_agent=$(get_pm_agent_session_id)
+    local new_issues=$(echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); d['issues'].pop('$issue_ref', None); print(json.dumps(d['issues']))")
+    if [ -z "$base" ] || [ "$base" = "null" ]; then
+        if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
+            write_index "null" "null" "$new_issues"
+        else
+            write_index "null" "\"$pm_agent\"" "$new_issues"
+        fi
+    else
+        if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
+            write_index "\"$base\"" "null" "$new_issues"
+        else
+            write_index "\"$base\"" "\"$pm_agent\"" "$new_issues"
+        fi
+    fi
+}
+
 validate_issue_ref() {
    local issue_ref="$1"
    if [[ ! "$issue_ref" =~ ^[^/]+/[^/]+/[^#]+#[0-9]+$ ]]; then
@@ -694,18 +820,6 @@ cmd_status() {
        return
    fi
    
-    local opencode_sessions=$(opencode session list 2>/dev/null | grep -oP '^ses_\w+' || true)
-    
-    if ! echo "$opencode_sessions" | grep -q "^${base}$"; then
-        echo "error: base session '$base' not found in opencode"
-        return
-    fi
-    
-    if ! echo "$opencode_sessions" | grep -q "^${pm_agent}$"; then
-        echo "error: pm_agent session '$pm_agent' not found in opencode"
-        return
-    fi
-    
    echo "ok"
 }

@@ -763,11 +877,6 @@ EOF
 }

 parse_issue_ref_from_message() {
-    # DEPRECATED: This function is not called anywhere.
-    # The active implementation is extract_issue_ref_from_message()
-    # in kugetsu-session.sh which is used by cmd_delegate.
-    # This function is kept for backwards compatibility and will
-    # be removed in a future release.
    local message="$1"
    
    local gitserver=""
@@ -775,20 +884,21 @@ parse_issue_ref_from_message() {
    local repo=""
    local issue_number=""
    
-    if [[ "$message" =~ (https?://)?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)/(issues|pull)/([0-9]+) ]]; then
-        gitserver="${BASH_REMATCH[2]}"
-        owner="${BASH_REMATCH[3]}"
-        repo="${BASH_REMATCH[4]}"
-        issue_number="${BASH_REMATCH[6]}"
-    elif [[ "$message" =~ (https?://)?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)#([0-9]+) ]]; then
-        gitserver="${BASH_REMATCH[2]}"
-        owner="${BASH_REMATCH[3]}"
-        repo="${BASH_REMATCH[4]}"
-        issue_number="${BASH_REMATCH[5]}"
-    elif [[ "$message" =~ ([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)#([0-9]+) ]]; then
-        owner="${BASH_REMATCH[1]}"
-        repo="${BASH_REMATCH[2]}"
-        issue_number="${BASH_REMATCH[3]}"
+    if echo "$message" | grep -qE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+/(issues|pull)/[0-9]+'; then
+        gitserver=$(echo "$message" | grep -oE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+' | head -1 | sed 's/\/[^/]*\/[^/]*$//')
+        local full_path=$(echo "$message" | grep -oE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+/(issues|pull)/[0-9]+' | head -1)
+        owner=$(echo "$full_path" | cut -d'/' -f2)
+        repo=$(echo "$full_path" | cut -d'/' -f3)
+        issue_number=$(echo "$full_path" | grep -oE '[0-9]+$' | head -1)
+    elif echo "$message" | grep -qE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#[0-9]+'; then
+        gitserver=$(echo "$message" | grep -oE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+' | head -1)
+        owner=$(echo "$gitserver" | cut -d'/' -f2)
+        repo=$(echo "$gitserver" | cut -d'/' -f3)
+        issue_number=$(echo "$message" | grep -oE '#[0-9]+' | grep -oE '[0-9]+' | head -1)
+    elif echo "$message" | grep -qE '[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#([0-9]+)'; then
+        owner=$(echo "$message" | grep -oE '[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#' | sed 's/#$//' | cut -d'/' -f1)
+        repo=$(echo "$message" | grep -oE '[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#' | sed 's/#$//' | cut -d'/' -f2)
+        issue_number=$(echo "$message" | grep -oE '#[0-9]+' | grep -oE '[0-9]+' | head -1)
    fi
    
    echo "${gitserver}|${owner}|${repo}|${issue_number}"
@@ -864,6 +974,7 @@ find_sessions_by_issue_number() {
    echo "$results"
 }

+>>>>>>> origin/main
 cmd_queue() {
    local action="${1:-list}"
    shift
--- a/skills/kugetsu/scripts/kugetsu-config.sh
+++ b/skills/kugetsu/scripts/kugetsu-config.sh
@@ -53,9 +53,5 @@ load_agent_env() {
        set -a
        source "$ENV_DIR/default.env"
        set +a
-    elif [ -f "$ENV_DIR/pm-agent.env" ]; then
-        set -a
-        source "$ENV_DIR/pm-agent.env"
-        set +a
    fi
 }
--- a/skills/kugetsu/scripts/kugetsu-index.sh
+++ b/skills/kugetsu/scripts/kugetsu-index.sh
@@ -15,13 +15,6 @@ write_index() {
    local issues_json="$3"
    local temp_file="$INDEX_FILE.tmp.$$"
    printf '{"base": %s, "pm_agent": %s, "issues": %s}\n' "$base" "$pm_agent" "$issues_json" > "$temp_file"
-    
-    if ! python3 -c "import json; json.load(open('$temp_file'))" 2>/dev/null; then
-        echo "Error: write_index would create malformed JSON, aborting. base=$base, pm_agent=$pm_agent, issues_json=$issues_json" >&2
-        rm -f "$temp_file"
-        return 1
-    fi
-    
    mv "$temp_file" "$INDEX_FILE"
 }

@@ -50,11 +43,7 @@ set_base_in_index() {
    if [ "$session_id" = "null" ]; then
        write_index "null" "$pm_agent" "$issues"
    else
-        if [ "$pm_agent" = "null" ]; then
-            write_index "\"$session_id\"" "null" "$issues"
-        else
-            write_index "\"$session_id\"" "\"$pm_agent\"" "$issues"
-        fi
+        write_index "\"$session_id\"" "$pm_agent" "$issues"
    fi
 }

@@ -67,11 +56,7 @@ set_pm_agent_in_index() {
    if [ "$session_id" = "null" ]; then
        write_index "$base" "null" "$issues"
    else
-        if [ "$base" = "null" ]; then
-            write_index "null" "\"$session_id\"" "$issues"
-        else
-            write_index "\"$base\"" "\"$session_id\"" "$issues"
-        fi
+        write_index "$base" "\"$session_id\"" "$issues"
    fi
 }

@@ -87,19 +72,7 @@ add_issue_to_index() {
    
    issues=$(python3 -c "import sys, json; d=json.load(sys.stdin); d['$issue_ref']='$session_file'; print(json.dumps(d))" <<< "$issues")
    
-    if [ "$base" = "null" ]; then
-        if [ "$pm_agent" = "null" ]; then
-            write_index "null" "null" "$issues"
-        else
-            write_index "null" "\"$pm_agent\"" "$issues"
-        fi
-    else
-        if [ "$pm_agent" = "null" ]; then
-            write_index "\"$base\"" "null" "$issues"
-        else
-            write_index "\"$base\"" "\"$pm_agent\"" "$issues"
-        fi
-    fi
+    write_index "$base" "$pm_agent" "$issues"
 }

 remove_issue_from_index() {
@@ -113,19 +86,7 @@ remove_issue_from_index() {
    
    issues=$(python3 -c "import sys, json; d=json.load(sys.stdin); d.pop('$issue_ref', None); print(json.dumps(d))" <<< "$issues")
    
-    if [ "$base" = "null" ]; then
-        if [ "$pm_agent" = "null" ]; then
-            write_index "null" "null" "$issues"
-        else
-            write_index "null" "\"$pm_agent\"" "$issues"
-        fi
-    else
-        if [ "$pm_agent" = "null" ]; then
-            write_index "\"$base\"" "null" "$issues"
-        else
-            write_index "\"$base\"" "\"$pm_agent\"" "$issues"
-        fi
-    fi
+    write_index "$base" "$pm_agent" "$issues"
 }

 validate_issue_ref() {
@@ -169,114 +130,6 @@ session['pr_url'] = pr_url
 with open(session_path, 'w') as f:
    json.dump(session, f, indent=2)

-    print(f"Updated PR URL for $issue_ref: $pr_url")
+print(f"Updated PR URL for $issue_ref: $pr_url")
 PYEOF
 }
-
-# Convert issue ref to session filename
-issue_ref_to_filename() {
-    local issue_ref="$1"
-    echo "$issue_ref" | sed 's/[\/:]/-/g' | sed 's/#/-/'
-}
-
-# Convert session filename back to issue ref
-filename_to_issue_ref() {
-    local filename="$1"
-    local name="${filename%.json}"
-    echo "$name" | sed 's-\([0-9]*\)$-#\1-' | sed 's/-/\//g'
-}
-
-# Add notification to notifications file
-kugetsu_add_notification() {
-    local type="$1"
-    local message="$2"
-    local issue_ref="${3:-}"
-    local gitea_url="${4:-}"
-    
-    mkdir -p "$(dirname "$NOTIFICATIONS_FILE")"
-    
-    python3 << PYEOF
-import json
-import os
-from datetime import datetime
-
-notification = {
-    "type": "$type",
-    "message": "$message",
-    "issue_ref": "$issue_ref" if "$issue_ref" else None,
-    "gitea_url": "$gitea_url" if "$gitea_url" else None,
-    "timestamp": datetime.now().isoformat(),
-    "read": False
-}
-
-file_path = os.path.expanduser("$NOTIFICATIONS_FILE")
-notifications = []
-
-if os.path.exists(file_path):
-    try:
-        with open(file_path, 'r') as f:
-            notifications = json.load(f)
-    except:
-        notifications = []
-
-notifications.append(notification)
-
-with open(file_path, 'w') as f:
-    json.dump(notifications, f, indent=2)
-
-print("Notification added")
-PYEOF
-}
-
-# Update queue item state
-update_queue_item_state() {
-    local queue_id="$1"
-    local new_state="$2"
-    local session_id="${3:-}"
-    local pid="${4:-}"
-    
-    local item_file="$QUEUE_ITEMS_DIR/${queue_id}.json"
-    if [ ! -f "$item_file" ]; then
-        echo "Error: Queue item not found: $queue_id" >&2
-        return 1
-    fi
-    
-    local issue_ref=$(python3 -c "import json; print(json.load(open('$item_file')).get('issue_ref', ''))" 2>/dev/null || echo "")
-    
-    python3 << PYEOF
-import json
-from datetime import datetime
-
-item_file = "$item_file"
-new_state = "$new_state"
-session_id = "$session_id"
-pid = "$pid"
-
-with open(item_file, 'r') as f:
-    item = json.load(f)
-
-item['state'] = new_state
-
-if new_state == "notified":
-    item['notified_at'] = datetime.now().isoformat() + "Z"
-    if session_id:
-        item['opencode_session_id'] = session_id
-    if pid:
-        item['pid'] = int(pid) if pid.isdigit() else None
-elif new_state == "completed":
-    item['completed_at'] = datetime.now().isoformat() + "Z"
-elif new_state == "error":
-    item['error'] = datetime.now().isoformat() + "Z"
-
-with open(item_file, 'w') as f:
-    json.dump(item, f, indent=2)
-
-print(f"Updated $queue_id to state: $new_state")
-PYEOF
-    
-    if [ "$new_state" = "completed" ]; then
-        kugetsu_add_notification "task_completed" "Task completed: $issue_ref" "$issue_ref"
-    elif [ "$new_state" = "error" ]; then
-        kugetsu_add_notification "task_error" "Task error: $issue_ref" "$issue_ref"
-    fi
-}
--- a/skills/kugetsu/scripts/kugetsu-log.sh
+++ b/skills/kugetsu/scripts/kugetsu-log.sh
@@ -43,24 +43,15 @@ kugetsu_add_notification() {
        notifications=$(cat "$NOTIFICATIONS_FILE")
    fi
    
-    notifications=$(echo "$notifications" | python3 -c "
-import json
-import sys
-
-notifications = json.load(sys.stdin)
-new_notification = {
+    local new_notification=$(python3 -c "import json; print(json.dumps({
        'type': '$notification_type',
-    'message': '''$message'''.replace('\"', '\"'),
-    'issue_ref': '$issue_ref' if '$issue_ref' else None,
+        'message': '$message',
+        'issue_ref': '$issue_ref',
        'timestamp': '$timestamp',
        'read': False
-}
+    }))")
    
-notifications.append(new_notification)
-notifications = notifications[-50:] if len(notifications) > 50 else notifications
-
-print(json.dumps(notifications, indent=2))
-")
+    notifications=$(python3 -c "import json; n=json.loads('$notifications'); n.append(json.loads('$new_notification')); print(json.dumps(n[-50:] if len(n)>50 else n, indent=2))")
    
    echo "$notifications" > "$NOTIFICATIONS_FILE"
 }
--- a/skills/kugetsu/scripts/kugetsu-queue-daemon.sh
+++ b/skills/kugetsu/scripts/kugetsu-queue-daemon.sh
@@ -8,146 +8,23 @@ source "$SCRIPT_DIR/kugetsu-index.sh"
 source "$SCRIPT_DIR/kugetsu-worktree.sh"
 source "$SCRIPT_DIR/kugetsu-log.sh"

-load_agent_env "pm-agent"
-
-acquire_lock() {
-    local issue_ref="$1"
-    local lock_file="$QUEUE_DIR/locks/$(echo "$issue_ref" | sed 's/[\/:]/-/g' | sed 's/#/-/').lock"
-    mkdir -p "$(dirname "$lock_file")"
-    if [ -f "$lock_file" ]; then
-        local pid=$(cat "$lock_file" 2>/dev/null || echo "")
-        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
-            return 1
-        fi
-        rm -f "$lock_file"
-    fi
-    echo $$ > "$lock_file"
-    return 0
-}
-
-release_lock() {
-    local issue_ref="$1"
-    local lock_file="$QUEUE_DIR/locks/$(echo "$issue_ref" | sed 's/[\/:]/-/g' | sed 's/#/-/').lock"
-    rm -f "$lock_file"
-}
-
-check_task_completion() {
-    local item="$1"
-    local queue_id=$(basename "$item" .json)
-    local state=$(python3 -c "import json; print(json.load(open('$item')).get('state', ''))" 2>/dev/null)
-
-    [ "$state" = "notified" ] || return 0
-
-    local session_id=$(python3 -c "import json; print(json.load(open('$item')).get('opencode_session_id', ''))" 2>/dev/null)
-    local issue_ref=$(python3 -c "import json; print(json.load(open('$item')).get('issue_ref', ''))" 2>/dev/null)
-    local pid=$(python3 -c "import json; print(json.load(open('$item')).get('pid', ''))" 2>/dev/null)
-
-    if [ -n "$pid" ] && [ "$pid" != "None" ]; then
-        if ! kill -0 "$pid" 2>/dev/null; then
-            local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$WORKTREES_DIR")
-            local has_commits=false
-
-            if [ -d "$worktree_path" ] && [ -d "$worktree_path/.git" ]; then
-                if [ -n "$(git -C "$worktree_path" log --oneline origin/main..HEAD 2>/dev/null)" ]; then
-                    has_commits=true
-                fi
-            fi
-
-            if [ "$has_commits" = true ]; then
-                update_queue_item_state "$queue_id" "completed"
-                echo "Task $queue_id ($issue_ref) completed — new commits found"
-            else
-                update_queue_item_state "$queue_id" "error"
-                echo "Task $queue_id ($issue_ref) marked error — no commits found after session ended"
-            fi
-            release_lock "$issue_ref"
-        fi
-    else
-        if [ -n "$session_id" ] && ! opencode session list 2>/dev/null | grep -q "$session_id"; then
-            local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$WORKTREES_DIR")
-            local has_commits=false
-
-            if [ -d "$worktree_path" ] && [ -d "$worktree_path/.git" ]; then
-                if [ -n "$(git -C "$worktree_path" log --oneline origin/main..HEAD 2>/dev/null)" ]; then
-                    has_commits=true
-                fi
-            fi
-
-            if [ "$has_commits" = true ]; then
-                update_queue_item_state "$queue_id" "completed"
-                echo "Task $queue_id ($issue_ref) completed — new commits found"
-            else
-                update_queue_item_state "$queue_id" "error"
-                echo "Task $queue_id ($issue_ref) marked error — no commits found after session ended"
-            fi
-            release_lock "$issue_ref"
-        fi
-    fi
-}
-
-get_session_id_for_issue() {
-    local issue_ref="$1"
-    local session_file=$(issue_ref_to_filename "$issue_ref")
-    local session_path="$SESSIONS_DIR/$session_file"
-    if [ -f "$session_path" ]; then
-        python3 -c "import json; print(json.load(open('$session_path')).get('opencode_session_id', ''))" 2>/dev/null || echo ""
-    else
-        echo ""
-    fi
-}
-
-process_task() {
-    local item="$1"
-    local queue_id=$(basename "$item" .json)
-    local issue_ref=$(python3 -c "import json; print(json.load(open('$item')).get('issue_ref', ''))" 2>/dev/null)
-    local message=$(python3 -c "import json; print(json.load(open('$item')).get('message', ''))" 2>/dev/null)
-
-    if ! acquire_lock "$issue_ref"; then
-        echo "Task $queue_id ($issue_ref) skipped — another process is handling it"
-        return
-    fi
-
-    source "$SCRIPT_DIR/kugetsu-session.sh"
-
-    if worktree_exists "$issue_ref" "$WORKTREES_DIR" || [ -f "$SESSIONS_DIR/$(issue_ref_to_filename "$issue_ref").json" ]; then
-        log_file="$LOGS_DIR/delegate-$(date +%s).log"
-        if cmd_continue "$issue_ref" "$message" >> "$log_file" 2>&1; then
-            sleep 1
-            local session_id=$(get_session_id_for_issue "$issue_ref")
-            update_queue_item_state "$queue_id" "notified" "$session_id" ""
-            echo "Task $queue_id continued for $issue_ref"
-        else
-            update_queue_item_state "$queue_id" "error"
-            echo "Task $queue_id ($issue_ref) failed to continue"
-        fi
-    else
-        log_file="$LOGS_DIR/delegate-$(date +%s).log"
-        if cmd_start "$issue_ref" "$message" >> "$log_file" 2>&1; then
-            sleep 1
-            local session_id=$(get_session_id_for_issue "$issue_ref")
-            update_queue_item_state "$queue_id" "notified" "$session_id" ""
-            echo "Task $queue_id started for $issue_ref"
-        else
-            update_queue_item_state "$queue_id" "error"
-            echo "Task $queue_id ($issue_ref) failed to start"
-        fi
-    fi
-
-    release_lock "$issue_ref"
-}
-
 while true; do
    if [ -d "$QUEUE_ITEMS_DIR" ]; then
-        for item in "$QUEUE_ITEMS_DIR"/*.json; do
-            [ -f "$item" ] || continue
-            check_task_completion "$item"
-        done
-
        for item in "$QUEUE_ITEMS_DIR"/*.json; do
            [ -f "$item" ] || continue
            state=$(python3 -c "import json; print(json.load(open('$item')).get('state', ''))" 2>/dev/null)
            if [ "$state" = "pending" ]; then
-                process_task "$item"
+                queue_id=$(basename "$item" .json)
+                issue_ref=$(python3 -c "import json; print(json.load(open('$item')).get('issue_ref', ''))" 2>/dev/null)
+                message=$(python3 -c "import json; print(json.load(open('$item')).get('message', ''))" 2>/dev/null)
+                
+                pm_session=$(get_pm_agent_session_id)
+                if [ -n "$pm_session" ] && [ "$pm_session" != "null" ]; then
+                    log_file="$LOGS_DIR/delegate-$(date +%s).log"
+                    GITEA_TOKEN="${GITEA_TOKEN:-}" nohup sh -c "opencode run '$message' --continue --session '$pm_session' >> '$log_file' 2>&1" > /dev/null 2>&1 &
+                    pid=$!
+                    update_queue_item_state "$queue_id" "notified" "$pm_session" "$pid"
+                fi
            fi
        done
    fi
--- a/skills/kugetsu/scripts/kugetsu-session.sh
+++ b/skills/kugetsu/scripts/kugetsu-session.sh
@@ -1,13 +1,6 @@
 #!/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
@@ -58,35 +51,12 @@ 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
@@ -104,20 +74,9 @@ EOF
    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"
-
+    local session_ids=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' | tail -1)
    if [ -z "$session_ids" ]; then
        echo "Error: Could not find newly created session" >&2
        exit 1
@@ -129,20 +88,9 @@ EOF
    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"
-
+    local pm_session_ids=$(opencode session list 2>/dev/null | grep -E '^ses_' | grep -v "$session_ids" | tail -1)
    if [ -z "$pm_session_ids" ]; then
        echo "Warning: Could not find separate PM agent session" >&2
        pm_session_ids="$session_ids"
@@ -179,11 +127,13 @@ extract_issue_ref_from_message() {
        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]}"
+    if [[ "$message" =~ (https?://[a-zA-Z0-9.-]+/[a-zA-Z0-9._-]+/[a-zA-Z0-9._-]+/(issues|pull)/[0-9]+) ]]; then
+        local url="${BASH_REMATCH[1]}"
+        local path=$(echo "$url" | sed 's|https\?://||' | cut -d'/' -f2-)
+        local instance=$(echo "$path" | cut -d'/' -f1)
+        local owner=$(echo "$path" | cut -d'/' -f2)
+        local repo=$(echo "$path" | cut -d'/' -f3)
+        local num=$(echo "$path" | grep -oE '[0-9]+$')
        echo "${instance}/${owner}/${repo}#${num}"
        return
    fi
@@ -203,99 +153,21 @@ cmd_delegate() {
    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"
+        cmd_start "$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
+    local pm_session=$(get_pm_agent_session_id)
+    if [ -z "$pm_session" ] || [ "$pm_session" = "null" ] || [ "$pm_session" = "None" ]; then
+        echo "Error: PM agent 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 &
-    rm -f "$msg_file"
-    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_json=$(opencode session list --format=json 2>/dev/null)
-    local before_ids=$(echo "$before_json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); print(' '.join(s['id'] for s in sessions))" 2>/dev/null || echo "")
-    
-    opencode run --fork --session "$base_session" "new session" 2>/dev/null
-    
-    local after_json=$(opencode session list --format=json 2>/dev/null)
-    local after_ids=$(echo "$after_json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); print(' '.join(s['id'] for s in sessions))" 2>/dev/null || echo "")
-    
-    local new_session_id=""
-    for sess in $after_ids; do
-        if [[ ! " $before_ids " =~ " $sess " ]] && [[ "$sess" != "$base_session" ]]; then
-            new_session_id="$sess"
-            break
-        fi
-    done
-    
-    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 base_message="You are assigned to work on $issue_ref.
-
-Workflow:
-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
-   - 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
-
-Work directory: $worktree_path"
-    
-    if [ -n "$user_message" ]; then
-        echo "$base_message
-
-Additional instructions from delegator:
-$user_message"
-    else
-        echo "$base_message"
-    fi
+    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '$message' --continue --session '$pm_session' >> '$log_file' 2>&1" > /dev/null 2>&1 &
+    disown
+    echo "Delegated to PM agent (logged to $(basename "$log_file"))"
 }

 cmd_start() {
@@ -316,36 +188,15 @@ cmd_start() {
        exit 1
    fi
    
-    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"; then
-        worktree_exists=true
-    fi
-    
-    local session_exists=false
-    if [ -f "$session_path" ]; then
-        session_exists=true
-    fi
-    
-    if $worktree_exists && $session_exists; then
-        echo "Issue '$issue_ref' already has a worktree and session." >&2
-        echo "Use 'kugetsu continue $issue_ref' to continue work." >&2
+    local pm_agent_session_id=$(get_pm_agent_session_id)
+    if [ -z "$pm_agent_session_id" ] || [ "$pm_agent_session_id" = "null" ]; then
+        echo "Error: PM agent session not found. Run 'kugetsu init' first." >&2
        exit 1
    fi
    
-    if $worktree_exists && ! $session_exists; then
-        echo "Warning: Worktree exists but session is missing. Removing worktree to recreate both..." >&2
-        remove_worktree_for_issue "$issue_ref"
-        worktree_exists=false
-    fi
-    
-    if ! $worktree_exists && $session_exists; then
-        echo "Warning: Session exists but worktree is missing. Removing stale session to recreate both..." >&2
-        rm -f "$session_path"
-        remove_issue_from_index "$issue_ref"
-        session_exists=false
+    if worktree_exists "$issue_ref"; then
+        echo "Issue '$issue_ref' already has a worktree. Use 'kugetsu continue' instead."
+        exit 1
    fi
    
    local active_count=$(count_active_dev_sessions)
@@ -354,12 +205,31 @@ cmd_start() {
        exit 1
    fi
    
-    create_worktree "$issue_ref" "$WORKTREES_DIR"
+    local session_file=$(issue_ref_to_filename "$issue_ref")
+    local session_path="$SESSIONS_DIR/$session_file"
    
-    local new_session_id=$(create_session "$base_session_id")
+    if [ -f "$session_path" ]; then
+        echo "Session file already exists: $session_file"
+        echo "Use 'kugetsu continue $issue_ref' to continue work."
+        exit 1
+    fi
+    
+    local before_sessions=$(opencode session list 2>/dev/null | grep -oP '^ses_\w+' | sort)
+    local before_set="|$before_sessions|"
+    
+    create_worktree "$issue_ref"
+    
+    local after_sessions=$(opencode session list 2>/dev/null | grep -oP '^ses_\w+' | sort)
+    local new_session_id=""
+    while IFS= read -r sess; do
+        if [[ ! "$before_set" =~ \|${sess}\| ]] && [[ "$sess" != "$base_session_id" ]] && [[ "$sess" != "$pm_agent_session_id" ]]; then
+            new_session_id="$sess"
+            break
+        fi
+    done <<< "$after_sessions"
    
    if [ -z "$new_session_id" ]; then
-        echo "Error: Could not create session" >&2
+        echo "Error: Could not find newly created session" >&2
        remove_worktree_for_issue "$issue_ref"
        exit 1
    fi
@@ -371,16 +241,6 @@ cmd_start() {
    
    add_issue_to_index "$issue_ref" "$session_file"
    
-    local dev_message=$(build_dev_agent_message "$issue_ref" "$message")
-    
-    load_agent_env "dev"
-    
-    cd "$worktree_path"
-    local msg_file="$LOGS_DIR/msg-$new_session_id.txt"
-    printf '%s' "$dev_message" > "$msg_file"
-    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$new_session_id'" >> "$LOGS_DIR/dev-$new_session_id.log" 2>&1 &
-    rm -f "$msg_file"
-    
    echo "Session started for '$issue_ref': $new_session_id"
    echo "Worktree: $worktree_path"
 }
@@ -426,26 +286,20 @@ cmd_continue() {
    
    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 issue_ref=$(python3 -c "import json; print(json.load(open('$session_path')).get('issue_ref', ''))" 2>/dev/null || echo "")
    
-    if [ -z "$worktree_path" ] || [ ! -d "$worktree_path" ]; then
-        echo "Warning: Worktree is missing for '$session_name'. Recovering..." >&2
-        rm -f "$session_path"
-        remove_issue_from_index "$session_name"
-        echo "Calling cmd_start to create new session and worktree..." >&2
-        cmd_start "$session_name" "$message"
-        return $?
+    if [ -n "$worktree_path" ] && [ -d "$worktree_path" ]; then
+        if [ -n "$message" ]; then
+            (cd "$worktree_path" && opencode run "$message" --continue --session "$opencode_session_id" "$@")
+        else
+            (cd "$worktree_path" && opencode --continue --session "$opencode_session_id" "$@")
+        fi
+    else
+        if [ -n "$message" ]; then
+            opencode run "$message" --continue --session "$opencode_session_id" "$@"
+        else
+            opencode --continue --session "$opencode_session_id" "$@"
        fi
-    
-    if [ -z "$message" ]; then
-        message=$(build_dev_agent_message "$issue_ref" "")
    fi
-    
-    cd "$worktree_path"
-    local msg_file="$LOGS_DIR/msg-$opencode_session_id.txt"
-    printf '%s' "$message" > "$msg_file"
-    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$opencode_session_id'" >> "$LOGS_DIR/dev-$opencode_session_id.log" 2>&1 &
-    rm -f "$msg_file"
 }

 cmd_list() {
@@ -596,7 +450,11 @@ cmd_destroy() {
    local target="${1:-}"
    local force=false
    
-    if [ "${2:-}" = "-y" ]; then
+    if [ "$target" = "--base" ]; then
+        target=""
+    fi
+    
+    if [ "$2" = "-y" ]; then
        force=true
    fi
    
--- a/skills/kugetsu/scripts/kugetsu-worktree.sh
+++ b/skills/kugetsu/scripts/kugetsu-worktree.sh
@@ -10,7 +10,7 @@ issue_ref_to_worktree_path() {
    local issue_ref="$1"
    local parent_dir="${2:-$WORKTREES_DIR}"
    local worktree_name=$(issue_ref_to_worktree_name "$issue_ref")
-    echo "$parent_dir/$worktree_name"
+    echo "$parent_dir/.kugetsu-worktrees/$worktree_name"
 }

 issue_ref_to_branch_name() {
@@ -41,7 +41,7 @@ get_repo_url() {
    fi
    
    local instance=$(echo "$issue_ref" | cut -d'/' -f1 | cut -d'#' -f1)
-    local rest=$(echo "$issue_ref" | sed 's/^[^\/]*\///' | sed 's/#.*//')
+    local rest=$(echo "$issue_ref" | sed 's/.*\///' | sed 's/#.*//')
    
    if [ -n "${GIT_SERVERS[$instance]:-}" ]; then
        echo "${GIT_SERVERS[$instance]}/${rest}.git"
--- a/skills/kugetsu/tests/test-create-session.sh
+++ b/skills/kugetsu/tests/test-create-session.sh
@@ -1,181 +0,0 @@
-#!/bin/bash
-# Tests for create_session function
-#
-# Run with: bash skills/kugetsu/tests/test-create-session.sh
-#
-# NOTE: These tests MUST be run sequentially (not in parallel)
-# to avoid exhausting memory with too many opencode sessions.
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/../scripts/kugetsu-config.sh"
-source "$SCRIPT_DIR/../scripts/kugetsu-index.sh"
-source "$SCRIPT_DIR/../scripts/kugetsu-session.sh"
-
-PASS=0
-FAIL=0
-RUN=0
-
-pass() {
-    echo "PASS: $1"
-    PASS=$((PASS + 1))
-}
-
-fail() {
-    echo "FAIL: $1"
-    echo "  Expected: $2"
-    echo "  Got: $3"
-    FAIL=$((FAIL + 1))
-}
-
-run_test() {
-    local name="$1"
-    local test_func="$2"
-    RUN=$((RUN + 1))
-    echo ""
-    echo "=== Test $RUN: $name ==="
-    echo "--- $name ---"
-    $test_func
-}
-
-echo "=== create_session Test Suite ==="
-echo "NOTE: Running sequentially to avoid memory exhaustion"
-echo ""
-
-# Test 1: create_session requires base session
-test_create_session_requires_base() {
-    local base_id=$(get_base_session_id)
-    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
-        skip "Base session not initialized - run 'kugetsu init' first"
-        return
-    fi
-    
-    local result=$(create_session "$base_id")
-    if [ -n "$result" ] && [[ "$result" =~ ^ses_ ]]; then
-        pass "create_session returns valid session ID"
-    else
-        fail "create_session returns valid session ID" "ses_xxx" "$result"
-    fi
-}
-
-# Test 2: create_session creates a NEW session (different from base)
-test_create_session_is_new() {
-    local base_id=$(get_base_session_id)
-    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
-        skip "Base session not initialized - run 'kugetsu init' first"
-        return
-    fi
-    
-    local new_id=$(create_session "$base_id")
-    if [ "$new_id" != "$base_id" ]; then
-        pass "create_session returns NEW session (not same as base)"
-    else
-        fail "create_session returns NEW session" "different from base_id" "$new_id"
-    fi
-}
-
-# Test 3: create_session can be called multiple times (creates different sessions)
-test_create_session_multiple_calls() {
-    local base_id=$(get_base_session_id)
-    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
-        skip "Base session not initialized - run 'kugetsu init' first"
-        return
-    fi
-    
-    local id1=$(create_session "$base_id")
-    sleep 1
-    local id2=$(create_session "$base_id")
-    
-    if [ "$id1" != "$id2" ]; then
-        pass "create_session creates different sessions on each call"
-    else
-        fail "create_session creates different sessions" "$id1 != $id2" "both equal: $id1"
-    fi
-}
-
-# Test 4: JSON session list parsing
-test_session_json_parsing() {
-    local json='[{"id": "ses_abc123", "title": "test"}, {"id": "ses_def456", "title": "test2"}]'
-    local ids=$(echo "$json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); print(' '.join(s['id'] for s in sessions))" 2>/dev/null)
-    
-    if [ "$ids" = "ses_abc123 ses_def456" ]; then
-        pass "JSON session list parsing extracts IDs correctly"
-    else
-        fail "JSON session list parsing" "ses_abc123 ses_def456" "$ids"
-    fi
-}
-
-# Test 5: Session ID format validation
-test_session_id_format() {
-    local json='[{"id": "ses_2b4814406ffe3AxcpbrP7FknDr", "title": "test"}]'
-    local ids=$(echo "$json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); print(' '.join(s['id'] for s in sessions))" 2>/dev/null)
-    
-    if [[ "$ids" =~ ^ses_ ]]; then
-        pass "Session ID format is valid (starts with ses_)"
-    else
-        fail "Session ID format" "ses_xxx" "$ids"
-    fi
-}
-
-# Test 6: create_session accepts optional base session parameter
-test_create_session_with_param() {
-    local base_id=$(get_base_session_id)
-    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
-        skip "Base session not initialized - run 'kugetsu init' first"
-        return
-    fi
-    
-    local result=$(create_session "$base_id")
-    if [ -n "$result" ] && [[ "$result" =~ ^ses_ ]]; then
-        pass "create_session accepts base session parameter"
-    else
-        fail "create_session accepts base session parameter" "ses_xxx" "$result"
-    fi
-}
-
-# Test 7: Verify session appears in opencode session list after creation
-test_session_visible_in_list() {
-    local base_id=$(get_base_session_id)
-    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
-        skip "Base session not initialized - run 'kugetsu init' first"
-        return
-    fi
-    
-    local new_id=$(create_session "$base_id")
-    sleep 1
-    
-    local all_sessions=$(opencode session list --format=json 2>/dev/null)
-    if echo "$all_sessions" | grep -q "$new_id"; then
-        pass "Created session appears in opencode session list"
-    else
-        fail "Created session appears in session list" "should contain $new_id" "$all_sessions"
-    fi
-}
-
-skip() {
-    echo "SKIP: $1"
-}
-
-# Run tests sequentially
-run_test "create_session requires base session" test_create_session_requires_base
-run_test "create_session creates NEW session" test_create_session_is_new
-run_test "create_session creates different sessions on multiple calls" test_create_session_multiple_calls
-run_test "JSON session list parsing" test_session_json_parsing
-run_test "Session ID format validation" test_session_id_format
-run_test "create_session accepts optional base session parameter" test_create_session_with_param
-run_test "Created session visible in opencode session list" test_session_visible_in_list
-
-echo ""
-echo "=== Test Results ==="
-echo "Passed: $PASS"
-echo "Failed: $FAIL"
-echo "Total: $RUN"
-
-if [ $FAIL -eq 0 ]; then
-    echo "All tests passed!"
-    exit 0
-else
-    echo "Some tests failed!"
-    exit 1
-fi
--- a/skills/kugetsu/tests/test-git-url-parsing.sh
+++ b/skills/kugetsu/tests/test-git-url-parsing.sh
@@ -1,298 +0,0 @@
-#!/bin/bash
-# Git URL Parsing Tests for kugetsu
-# Tests all functions that parse or construct git URLs and issue refs
-#
-# Run with: bash skills/kugetsu/tests/test-git-url-parsing.sh
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/../scripts/kugetsu-config.sh"
-source "$SCRIPT_DIR/../scripts/kugetsu-worktree.sh"
-source "$SCRIPT_DIR/../scripts/kugetsu-session.sh"
-
-PASS=0
-FAIL=0
-
-pass() {
-    echo "PASS: $1"
-    PASS=$((PASS + 1))
-}
-
-fail() {
-    echo "FAIL: $1"
-    echo "  Expected: $2"
-    echo "  Got: $3"
-    FAIL=$((FAIL + 1))
-}
-
-echo "=== Git URL Parsing Test Suite ==="
-echo ""
-
-# Test: get_repo_url with standard GitHub issue ref
-echo "--- Test: get_repo_url with github.com ---"
-result=$(get_repo_url "github.com/shoko/kugetsu#14")
-expected="https://github.com/shoko/kugetsu.git"
-if [ "$result" = "$expected" ]; then
-    pass "get_repo_url standard github issue ref"
-else
-    fail "get_repo_url standard github issue ref" "$expected" "$result"
-fi
-
-# Test: get_repo_url with custom instance
-echo "--- Test: get_repo_url with git.fbrns.co ---"
-result=$(get_repo_url "git.fbrns.co/shoko/kugetsu#158")
-expected="https://git.fbrns.co/shoko/kugetsu.git"
-if [ "$result" = "$expected" ]; then
-    pass "get_repo_url custom instance issue ref (ISSUE #181)"
-else
-    fail "get_repo_url custom instance issue ref (ISSUE #181)" "$expected" "$result"
-fi
-
-# Test: get_repo_url with gitlab.com (if configured)
-echo "--- Test: get_repo_url with gitlab.com ---"
-if [ -n "${GIT_SERVERS[gitlab.com]:-}" ]; then
-    result=$(get_repo_url "gitlab.com/someuser/somerepo#42")
-    expected="https://gitlab.com/someuser/somerepo.git"
-    if [ "$result" = "$expected" ]; then
-        pass "get_repo_url gitlab.com issue ref"
-    else
-        fail "get_repo_url gitlab.com issue ref" "$expected" "$result"
-    fi
-else
-    echo "SKIP: get_repo_url gitlab.com (not configured in GIT_SERVERS)"
-fi
-
-# Test: get_repo_url with bitbucket.org (if configured)
-echo "--- Test: get_repo_url with bitbucket.org ---"
-if [ -n "${GIT_SERVERS[bitbucket.org]:-}" ]; then
-    result=$(get_repo_url "bitbucket.org/myteam/myproject#7")
-    expected="https://bitbucket.org/myteam/myproject.git"
-    if [ "$result" = "$expected" ]; then
-        pass "get_repo_url bitbucket.org issue ref"
-    else
-        fail "get_repo_url bitbucket.org issue ref" "$expected" "$result"
-    fi
-else
-    echo "SKIP: get_repo_url bitbucket.org (not configured in GIT_SERVERS)"
-fi
-
-# Test: get_repo_url with large issue number
-echo "--- Test: get_repo_url with large issue number ---"
-result=$(get_repo_url "github.com/shoko/kugetsu#999999")
-expected="https://github.com/shoko/kugetsu.git"
-if [ "$result" = "$expected" ]; then
-    pass "get_repo_url with large issue number"
-else
-    fail "get_repo_url with large issue number" "$expected" "$result"
-fi
-
-# Test: issue_ref_to_worktree_name standard
-echo "--- Test: issue_ref_to_worktree_name standard ---"
-result=$(issue_ref_to_worktree_name "github.com/shoko/kugetsu#14")
-expected="github.com-shoko-kugetsu-14"
-if [ "$result" = "$expected" ]; then
-    pass "issue_ref_to_worktree_name standard"
-else
-    fail "issue_ref_to_worktree_name standard" "$expected" "$result"
-fi
-
-# Test: issue_ref_to_worktree_name with custom instance
-echo "--- Test: issue_ref_to_worktree_name custom instance ---"
-result=$(issue_ref_to_worktree_name "git.fbrns.co/shoko/kugetsu#158")
-expected="git.fbrns.co-shoko-kugetsu-158"
-if [ "$result" = "$expected" ]; then
-    pass "issue_ref_to_worktree_name custom instance"
-else
-    fail "issue_ref_to_worktree_name custom instance" "$expected" "$result"
-fi
-
-# Test: issue_ref_to_branch_name with number
-echo "--- Test: issue_ref_to_branch_name with number ---"
-result=$(issue_ref_to_branch_name "github.com/shoko/kugetsu#14")
-expected="fix/issue-14"
-if [ "$result" = "$expected" ]; then
-    pass "issue_ref_to_branch_name with number"
-else
-    fail "issue_ref_to_branch_name with number" "$expected" "$result"
-fi
-
-# Test: issue_ref_to_branch_name with discuss suffix
-# Note: #-discuss falls through to fix/issue-temp because #[^-]+$ doesn't match #-<text-with-hyphens>
-echo "--- Test: issue_ref_to_branch_name with discuss suffix ---"
-result=$(issue_ref_to_branch_name "github.com/shoko/kugetsu#-discuss")
-expected="fix/issue-temp"
-if [ "$result" = "$expected" ]; then
-    pass "issue_ref_to_branch_name with discuss suffix"
-else
-    fail "issue_ref_to_branch_name with discuss suffix" "$expected" "$result"
-fi
-
-# Test: issue_ref_to_branch_name with identifier that has no hyphens
-echo "--- Test: issue_ref_to_branch_name with pure identifier ---"
-result=$(issue_ref_to_branch_name "github.com/shoko/kugetsu#someid")
-expected="fix/someid"
-if [ "$result" = "$expected" ]; then
-    pass "issue_ref_to_branch_name with pure identifier"
-else
-    fail "issue_ref_to_branch_name with pure identifier" "$expected" "$result"
-fi
-
-# Test: issue_ref_to_branch_name without number
-echo "--- Test: issue_ref_to_branch_name without number ---"
-result=$(issue_ref_to_branch_name "github.com/shoko/kugetsu#abc")
-expected="fix/abc"
-if [ "$result" = "$expected" ]; then
-    pass "issue_ref_to_branch_name without number"
-else
-    fail "issue_ref_to_branch_name without number" "$expected" "$result"
-fi
-
-# Test: extract_issue_ref_from_message with short form
-echo "--- Test: extract_issue_ref_from_message short form ---"
-result=$(extract_issue_ref_from_message "github.com/shoko/kugetsu#14")
-expected="github.com/shoko/kugetsu#14"
-if [ "$result" = "$expected" ]; then
-    pass "extract_issue_ref_from_message short form"
-else
-    fail "extract_issue_ref_from_message short form" "$expected" "$result"
-fi
-
-# Test: extract_issue_ref_from_message with https URL
-echo "--- Test: extract_issue_ref_from_message with https URL ---"
-result=$(extract_issue_ref_from_message "https://github.com/shoko/kugetsu/issues/14")
-expected="github.com/shoko/kugetsu#14"
-if [ "$result" = "$expected" ]; then
-    pass "extract_issue_ref_from_message with https URL"
-else
-    fail "extract_issue_ref_from_message with https URL" "$expected" "$result"
-fi
-
-# Test: extract_issue_ref_from_message with custom instance
-echo "--- Test: extract_issue_ref_from_message custom instance ---"
-result=$(extract_issue_ref_from_message "https://git.fbrns.co/shoko/kugetsu/issues/158")
-expected="git.fbrns.co/shoko/kugetsu#158"
-if [ "$result" = "$expected" ]; then
-    pass "extract_issue_ref_from_message custom instance"
-else
-    fail "extract_issue_ref_from_message custom instance" "$expected" "$result"
-fi
-
-# Test: extract_issue_ref_from_message with empty message
-echo "--- Test: extract_issue_ref_from_message empty message ---"
-result=$(extract_issue_ref_from_message "")
-expected=""
-if [ "$result" = "$expected" ]; then
-    pass "extract_issue_ref_from_message empty message"
-else
-    fail "extract_issue_ref_from_message empty message" "$expected" "$result"
-fi
-
-# Test: extract_issue_ref_from_message with no issue ref
-echo "--- Test: extract_issue_ref_from_message no issue ref ---"
-result=$(extract_issue_ref_from_message "Just a regular message without any issue reference")
-expected=""
-if [ "$result" = "$expected" ]; then
-    pass "extract_issue_ref_from_message no issue ref"
-else
-    fail "extract_issue_ref_from_message no issue ref" "$expected" "$result"
-fi
-
-# Test: extract_issue_ref_from_message with gitlab URL
-echo "--- Test: extract_issue_ref_from_message gitlab URL ---"
-result=$(extract_issue_ref_from_message "https://gitlab.com/someuser/somerepo/issues/42")
-expected="gitlab.com/someuser/somerepo#42"
-if [ "$result" = "$expected" ]; then
-    pass "extract_issue_ref_from_message gitlab URL"
-else
-    fail "extract_issue_ref_from_message gitlab URL" "$expected" "$result"
-fi
-
-# Test: validate_issue_ref valid format
-echo "--- Test: validate_issue_ref valid format ---"
-if validate_issue_ref "github.com/shoko/kugetsu#14" 2>/dev/null; then
-    pass "validate_issue_ref valid format"
-else
-    fail "validate_issue_ref valid format" "exit 0" "exit non-zero"
-fi
-
-# Test: validate_issue_ref invalid format (missing parts)
-echo "--- Test: validate_issue_ref invalid format ---"
-if ! validate_issue_ref "invalid-ref" 2>/dev/null; then
-    pass "validate_issue_ref invalid format"
-else
-    fail "validate_issue_ref invalid format" "exit non-zero" "exit 0"
-fi
-
-# Test: issue_ref_to_filename
-echo "--- Test: issue_ref_to_filename ---"
-result=$(issue_ref_to_filename "github.com/shoko/kugetsu#14")
-expected="github.com-shoko-kugetsu-14.json"
-if [ "$result" = "$expected" ]; then
-    pass "issue_ref_to_filename"
-else
-    fail "issue_ref_to_filename" "$expected" "$result"
-fi
-
-# Test: filename_to_issue_ref
-echo "--- Test: filename_to_issue_ref ---"
-result=$(filename_to_issue_ref "github.com-shoko-kugetsu-14.json")
-expected="github.com/shoko/kugetsu#14"
-if [ "$result" = "$expected" ]; then
-    pass "filename_to_issue_ref"
-else
-    fail "filename_to_issue_ref" "$expected" "$result"
-fi
-
-# Test: get_repo_url with org having hyphen
-echo "--- Test: get_repo_url with hyphenated org ---"
-result=$(get_repo_url "github.com/my-org/my-repo#1")
-expected="https://github.com/my-org/my-repo.git"
-if [ "$result" = "$expected" ]; then
-    pass "get_repo_url with hyphenated org"
-else
-    fail "get_repo_url with hyphenated org" "$expected" "$result"
-fi
-
-# Test: get_repo_url with repo having dots
-echo "--- Test: get_repo_url with dotted repo ---"
-result=$(get_repo_url "github.com/shoko/kugetsu.utils#5")
-expected="https://github.com/shoko/kugetsu.utils.git"
-if [ "$result" = "$expected" ]; then
-    pass "get_repo_url with dotted repo"
-else
-    fail "get_repo_url with dotted repo" "$expected" "$result"
-fi
-
-# Test: get_repo_url with underscore in username
-echo "--- Test: get_repo_url with underscore in user ---"
-result=$(get_repo_url "github.com/my_user/my_repo#10")
-expected="https://github.com/my_user/my_repo.git"
-if [ "$result" = "$expected" ]; then
-    pass "get_repo_url with underscore in user"
-else
-    fail "get_repo_url with underscore in user" "$expected" "$result"
-fi
-
-# Test: get_repo_url with instance not in GIT_SERVERS (fallback)
-echo "--- Test: get_repo_url with unknown instance ---"
-result=$(get_repo_url "unknown.example.com/owner/repo#1")
-expected="https://unknown.example.com/owner/repo.git"
-if [ "$result" = "$expected" ]; then
-    pass "get_repo_url with unknown instance"
-else
-    fail "get_repo_url with unknown instance" "$expected" "$result"
-fi
-
-echo ""
-echo "=== Test Results ==="
-echo "Passed: $PASS"
-echo "Failed: $FAIL"
-
-if [ $FAIL -eq 0 ]; then
-    echo "All tests passed!"
-    exit 0
-else
-    echo "Some tests failed!"
-    exit 1
-fi
--- a/skills/kugetsu/tests/test-kugetsu-v2.sh
+++ b/skills/kugetsu/tests/test-kugetsu-v2.sh
@@ -7,8 +7,6 @@
 set -euo pipefail

 KUGETSU="./skills/kugetsu/scripts/kugetsu"
-TEST_KUGETSU_DIR="/tmp/test-kugetsu-$$"
-export KUGETSU_DIR="$TEST_KUGETSU_DIR"
 TEST_ISSUE_REF="github.com/shoko/kugetsu#14"
 TEST_DISCUSS_REF="github.com/shoko/kugetsu#-discuss"
 TEST_BASE_SESSION_ID="ses_test_base_123"
@@ -20,28 +18,28 @@ PASS=0
 FAIL=0

 cleanup() {
-    rm -rf "$TEST_KUGETSU_DIR" 2>/dev/null || true
+    rm -rf ~/.kugetsu/sessions/* ~/.kugetsu/worktrees/* ~/.kugetsu/index.json 2>/dev/null || true
 }

 setup_mock_base() {
-    mkdir -p "$TEST_KUGETSU_DIR/sessions" "$TEST_KUGETSU_DIR/worktrees"
-    cat > "$TEST_KUGETSU_DIR/index.json" << EOF
+    mkdir -p ~/.kugetsu/sessions ~/.kugetsu/worktrees
+    cat > ~/.kugetsu/index.json << EOF
 {
  "base": "$TEST_BASE_SESSION_ID",
  "pm_agent": "$TEST_PM_AGENT_SESSION_ID",
  "issues": {}
 }
 EOF
-    cat > "$TEST_KUGETSU_DIR/sessions/$TEST_BASE_SESSION_FILE" << EOF
+    cat > ~/.kugetsu/sessions/$TEST_BASE_SESSION_FILE << EOF
 {"type": "base", "opencode_session_id": "$TEST_BASE_SESSION_ID", "created_at": "2026-03-29T18:00:00+02:00", "state": "idle"}
 EOF
-    cat > "$TEST_KUGETSU_DIR/sessions/$TEST_PM_AGENT_SESSION_FILE" << EOF
+    cat > ~/.kugetsu/sessions/$TEST_PM_AGENT_SESSION_FILE << EOF
 {"type": "pm_agent", "opencode_session_id": "$TEST_PM_AGENT_SESSION_ID", "created_at": "2026-03-29T18:00:00+02:00", "state": "idle"}
 EOF
 }

 setup_mock_forked() {
-    cat > "$TEST_KUGETSU_DIR/index.json" << EOF
+    cat > ~/.kugetsu/index.json << EOF
 {
  "base": "$TEST_BASE_SESSION_ID",
  "pm_agent": "$TEST_PM_AGENT_SESSION_ID",
@@ -50,7 +48,7 @@ setup_mock_forked() {
  }
 }
 EOF
-    cat > "$TEST_KUGETSU_DIR/sessions/$TEST_FORKED_SESSION_FILE" << EOF
+    cat > ~/.kugetsu/sessions/$TEST_FORKED_SESSION_FILE << EOF
 {"type": "forked", "issue_ref": "$TEST_ISSUE_REF", "opencode_session_id": "ses_forked_789", "worktree_path": "/tmp/test-worktree", "created_at": "2026-03-29T18:00:00+02:00", "state": "idle"}
 EOF
 }
@@ -114,16 +112,16 @@ echo ""

 # Test 3b: start fails without pm-agent
 echo "--- Test: start without pm-agent session ---"
-rm -f $TEST_KUGETSU_DIR/index.json $TEST_KUGETSU_DIR/sessions/*
-mkdir -p $TEST_KUGETSU_DIR/sessions
-cat > $TEST_KUGETSU_DIR/index.json << EOF
+rm -f ~/.kugetsu/index.json ~/.kugetsu/sessions/*
+mkdir -p ~/.kugetsu/sessions
+cat > ~/.kugetsu/index.json << EOF
 {
  "base": "$TEST_BASE_SESSION_ID",
  "pm_agent": null,
  "issues": {}
 }
 EOF
-cat > $TEST_KUGETSU_DIR/sessions/$TEST_BASE_SESSION_FILE << EOF
+cat > ~/.kugetsu/sessions/$TEST_BASE_SESSION_FILE << EOF
 {"type": "base", "opencode_session_id": "$TEST_BASE_SESSION_ID", "created_at": "2026-03-29T18:00:00+02:00", "state": "idle"}
 EOF
 OUTPUT=$($KUGETSU start github.com/shoko/kugetsu#14 "test" 2>&1 || true)
@@ -178,7 +176,7 @@ echo ""

 # Test 6c: index.json has pm_agent field
 echo "--- Test: index.json has pm_agent field ---"
-if grep -q '"pm_agent"' $TEST_KUGETSU_DIR/index.json; then
+if grep -q '"pm_agent"' ~/.kugetsu/index.json; then
    pass "index.json has pm_agent field"
 else
    fail "index.json missing pm_agent field"
@@ -229,12 +227,12 @@ echo ""
 echo "--- Test: destroy --pm-agent -y ---"
 setup_mock_base
 OUTPUT=$($KUGETSU destroy --pm-agent -y 2>&1 || true)
-if [ -f $TEST_KUGETSU_DIR/sessions/$TEST_PM_AGENT_SESSION_FILE ]; then
+if [ -f ~/.kugetsu/sessions/$TEST_PM_AGENT_SESSION_FILE ]; then
    fail "destroy --pm-agent -y removes pm-agent file"
 else
    pass "destroy --pm-agent -y removes pm-agent file"
 fi
-if grep -q '"pm_agent": null' $TEST_KUGETSU_DIR/index.json; then
+if grep -q '"pm_agent": null' ~/.kugetsu/index.json; then
    pass "destroy --pm-agent -y sets pm_agent to null in index"
 else
    fail "destroy --pm-agent -y should set pm_agent to null"
@@ -245,7 +243,7 @@ echo ""
 echo "--- Test: destroy --base -y ---"
 setup_mock_base
 OUTPUT=$($KUGETSU destroy --base -y 2>&1 || true)
-if [ -f $TEST_KUGETSU_DIR/sessions/$TEST_BASE_SESSION_FILE ]; then
+if [ -f ~/.kugetsu/sessions/$TEST_BASE_SESSION_FILE ]; then
    fail "destroy --base -y removes base file"
 else
    pass "destroy --base -y removes base file"
@@ -294,7 +292,7 @@ echo ""

 # Test 15: worktree path in session file
 echo "--- Test: worktree_path in session file ---"
-if grep -q "worktree_path" $TEST_KUGETSU_DIR/sessions/$TEST_FORKED_SESSION_FILE; then
+if grep -q "worktree_path" ~/.kugetsu/sessions/$TEST_FORKED_SESSION_FILE; then
    pass "session file contains worktree_path"
 else
    fail "session file missing worktree_path"
@@ -305,7 +303,7 @@ echo ""
 echo "--- Test: prune with orphaned worktree ---"
 cleanup
 setup_mock_base
-mkdir -p $TEST_KUGETSU_DIR/worktrees/orphaned-worktree
+mkdir -p ~/.kugetsu/worktrees/orphaned-worktree
 OUTPUT=$($KUGETSU prune 2>&1 || true)
 if echo "$OUTPUT" | grep -q "orphaned worktree"; then
    pass "prune detects orphaned worktree"
@@ -317,7 +315,7 @@ echo ""
 # Test 17: prune --force removes orphaned worktrees
 echo "--- Test: prune --force removes orphaned worktrees ---"
 OUTPUT=$($KUGETSU prune --force 2>&1 || true)
-if [ -d $TEST_KUGETSU_DIR/worktrees/orphaned-worktree ]; then
+if [ -d ~/.kugetsu/worktrees/orphaned-worktree ]; then
    fail "prune --force should remove orphaned worktree"
 else
    pass "prune --force removes orphaned worktree"
@@ -334,10 +332,10 @@ echo ""
 echo "--- Test: destroy removes worktree ---"
 cleanup
 setup_mock_forked
-# remove_worktree_for_issue derives path from issue ref: $TEST_KUGETSU_DIR/worktrees/github.com-shoko-kugetsu-14
-mkdir -p $TEST_KUGETSU_DIR/worktrees/github.com-shoko-kugetsu-14
+# remove_worktree_for_issue derives path from issue ref: ~/.kugetsu/worktrees/github.com-shoko-kugetsu-14
+mkdir -p ~/.kugetsu/worktrees/github.com-shoko-kugetsu-14
 OUTPUT=$($KUGETSU destroy github.com/shoko/kugetsu#14 -y 2>&1 || true)
-if [ -d $TEST_KUGETSU_DIR/worktrees/github.com-shoko-kugetsu-14 ]; then
+if [ -d ~/.kugetsu/worktrees/github.com-shoko-kugetsu-14 ]; then
    fail "destroy should remove worktree"
 else
    pass "destroy removes worktree"
@@ -347,7 +345,7 @@ echo ""
 # Test 20: session file properly formatted for v2.2
 echo "--- Test: session file format v2.2 ---"
 setup_mock_forked
-SESSION_CONTENT=$(cat $TEST_KUGETSU_DIR/sessions/$TEST_FORKED_SESSION_FILE)
+SESSION_CONTENT=$(cat ~/.kugetsu/sessions/$TEST_FORKED_SESSION_FILE)
 if echo "$SESSION_CONTENT" | grep -q '"type": "forked"' && \
   echo "$SESSION_CONTENT" | grep -q '"worktree_path"'; then
    pass "session file has v2.2 format"
@@ -369,8 +367,8 @@ echo ""

 # Test 22: status when base missing
 echo "--- Test: status (base missing) ---"
-mkdir -p $TEST_KUGETSU_DIR/sessions
-cat > $TEST_KUGETSU_DIR/index.json << EOF
+mkdir -p ~/.kugetsu/sessions
+cat > ~/.kugetsu/index.json << EOF
 {
  "base": null,
  "pm_agent": "$TEST_PM_AGENT_SESSION_ID",
@@ -387,7 +385,7 @@ echo ""

 # Test 23: status when pm-agent missing
 echo "--- Test: status (pm-agent missing) ---"
-cat > $TEST_KUGETSU_DIR/index.json << EOF
+cat > ~/.kugetsu/index.json << EOF
 {
  "base": "$TEST_BASE_SESSION_ID",
  "pm_agent": null,
@@ -404,7 +402,7 @@ echo ""

 # Test 24: status when pm-agent is "None" (Python None output)
 echo "--- Test: status (pm-agent is Python None) ---"
-cat > $TEST_KUGETSU_DIR/index.json << EOF
+cat > ~/.kugetsu/index.json << EOF
 {
  "base": "$TEST_BASE_SESSION_ID",
  "pm_agent": "None",
@@ -447,8 +445,8 @@ echo ""
 # Test 27: delegate when pm-agent missing
 echo "--- Test: delegate (pm-agent missing) ---"
 cleanup
-mkdir -p $TEST_KUGETSU_DIR/sessions $TEST_KUGETSU_DIR/worktrees
-cat > $TEST_KUGETSU_DIR/index.json << EOF
+mkdir -p ~/.kugetsu/sessions ~/.kugetsu/worktrees
+cat > ~/.kugetsu/index.json << EOF
 {
  "base": "$TEST_BASE_SESSION_ID",
  "pm_agent": null,
@@ -510,7 +508,7 @@ echo ""
 # Test 32: delegate is fire-and-forget (returns immediately)
 echo "--- Test: delegate is fire-and-forget ---"
 setup_mock_base
-mkdir -p $TEST_KUGETSU_DIR/logs
+mkdir -p ~/.kugetsu/logs
 START=$(date +%s)
 OUTPUT=$($KUGETSU delegate "test fire-and-forget" 2>&1 || true)
 END=$(date +%s)
@@ -529,10 +527,10 @@ echo ""
 # Test 33: delegate creates log file
 echo "--- Test: delegate creates log file ---"
 setup_mock_base
-LOG_COUNT_BEFORE=$(ls $TEST_KUGETSU_DIR/logs/*.log 2>/dev/null | wc -l)
+LOG_COUNT_BEFORE=$(ls ~/.kugetsu/logs/*.log 2>/dev/null | wc -l)
 $KUGETSU delegate "test log file" 2>&1 || true
 sleep 1
-LOG_COUNT_AFTER=$(ls $TEST_KUGETSU_DIR/logs/*.log 2>/dev/null | wc -l)
+LOG_COUNT_AFTER=$(ls ~/.kugetsu/logs/*.log 2>/dev/null | wc -l)
 if [ $LOG_COUNT_AFTER -gt $LOG_COUNT_BEFORE ]; then
    pass "delegate creates log file"
 else
@@ -560,10 +558,10 @@ echo ""

 # Test E2: env set creates file
 echo "--- Test: env set creates env file ---"
-mkdir -p $TEST_KUGETSU_DIR/env
-rm -f $TEST_KUGETSU_DIR/env/pm-agent.env
+mkdir -p ~/.kugetsu/env
+rm -f ~/.kugetsu/env/pm-agent.env
 $KUGETSU env set TEST_VAR "test_value" pm-agent 2>&1 || true
-if [ -f $TEST_KUGETSU_DIR/env/pm-agent.env ]; then
+if [ -f ~/.kugetsu/env/pm-agent.env ]; then
    pass "env set creates pm-agent.env file"
 else
    fail "env set did not create pm-agent.env"
@@ -572,7 +570,7 @@ echo ""

 # Test E3: env show masks sensitive values
 echo "--- Test: env show masks sensitive values ---"
-cat > $TEST_KUGETSU_DIR/env/pm-agent.env << 'ENVEOF'
+cat > ~/.kugetsu/env/pm-agent.env << 'ENVEOF'
 export GITEA_TOKEN="secret_token_123"
 export MY_VAR="visible_value"
 ENVEOF
@@ -586,14 +584,14 @@ echo ""

 # Test E4: Variables exported to child processes via set -a
 echo "--- Test: set -a exports variables to children ---"
-mkdir -p $TEST_KUGETSU_DIR/env
-cat > $TEST_KUGETSU_DIR/env/test.env << 'ENVEOF'
+mkdir -p ~/.kugetsu/env
+cat > ~/.kugetsu/env/test.env << 'ENVEOF'
 export EXPORT_TEST="exported_value"
 SIMPLE_TEST="not_exported"
 ENVEOF

 # Simulate what cmd_delegate does
-ENV_FILE="$TEST_KUGETSU_DIR/env/test.env"
+ENV_FILE="~/.kugetsu/env/test.env"
 env_sh="set -a; source '$ENV_FILE'; set +a; "
 result=$(bash -c "${env_sh}bash -c 'echo \$EXPORT_TEST'")

@@ -606,11 +604,11 @@ echo ""

 # Test E5: pm-agent.env takes precedence
 echo "--- Test: pm-agent.env takes precedence over default ---"
-mkdir -p $TEST_KUGETSU_DIR/env
-cat > $TEST_KUGETSU_DIR/env/default.env << 'ENVEOF'
+mkdir -p ~/.kugetsu/env
+cat > ~/.kugetsu/env/default.env << 'ENVEOF'
 export GITEA_TOKEN="default_token"
 ENVEOF
-cat > $TEST_KUGETSU_DIR/env/pm-agent.env << 'ENVEOF'
+cat > ~/.kugetsu/env/pm-agent.env << 'ENVEOF'
 export GITEA_TOKEN="pm_agent_token"
 ENVEOF

@@ -646,7 +644,7 @@ fi
 echo ""

 # Cleanup env files
-rm -rf $TEST_KUGETSU_DIR/env 2>/dev/null || true
+rm -rf ~/.kugetsu/env 2>/dev/null || true

 # Test E7: fix_session_permissions function exists
 echo "--- Test: fix_session_permissions function exists ---"
@@ -738,7 +736,7 @@ PASS=0
 FAIL=0

 test_cleanup() {
-    rm -rf $TEST_KUGETSU_DIR/sessions/* $TEST_KUGETSU_DIR/worktrees/* $TEST_KUGETSU_DIR/index.json $TEST_KUGETSU_DIR/logs/* $TEST_KUGETSU_DIR/.agent_count $TEST_KUGETSU_DIR/.agent_lock 2>/dev/null || true
+    rm -rf ~/.kugetsu/sessions/* ~/.kugetsu/worktrees/* ~/.kugetsu/index.json ~/.kugetsu/logs/* ~/.kugetsu/.agent_count ~/.kugetsu/.agent_lock 2>/dev/null || true
 }

 pass() {
@@ -752,25 +750,25 @@ fail() {
 }

 setup_mock_sessions() {
-    mkdir -p $TEST_KUGETSU_DIR/sessions $TEST_KUGETSU_DIR/worktrees $TEST_KUGETSU_DIR/logs
-    cat > $TEST_KUGETSU_DIR/index.json << INDEX
+    mkdir -p ~/.kugetsu/sessions ~/.kugetsu/worktrees ~/.kugetsu/logs
+    cat > ~/.kugetsu/index.json << INDEX
 {
  "base": "ses_test_base_123",
  "pm_agent": "ses_test_pm_456",
  "issues": {}
 }
 INDEX
-    echo '{"type": "base", "opencode_session_id": "ses_test_base_123", "created_at": "2026-03-29T18:00:00+02:00", "state": "idle"}' > $TEST_KUGETSU_DIR/sessions/base.json
-    echo '{"type": "pm_agent", "opencode_session_id": "ses_test_pm_456", "created_at": "2026-03-29T18:00:00+02:00", "state": "idle"}' > $TEST_KUGETSU_DIR/sessions/pm-agent.json
+    echo '{"type": "base", "opencode_session_id": "ses_test_base_123", "created_at": "2026-03-29T18:00:00+02:00", "state": "idle"}' > ~/.kugetsu/sessions/base.json
+    echo '{"type": "pm_agent", "opencode_session_id": "ses_test_pm_456", "created_at": "2026-03-29T18:00:00+02:00", "state": "idle"}' > ~/.kugetsu/sessions/pm-agent.json
 }

 # Test C1: Agent count file is initialized to 0
 echo "--- Test: agent count file initialized ---"
 test_cleanup
-mkdir -p $TEST_KUGETSU_DIR/sessions $TEST_KUGETSU_DIR/worktrees
+mkdir -p ~/.kugetsu/sessions ~/.kugetsu/worktrees
 $KUGETSU list > /dev/null 2>&1 || true
-if [ -f $TEST_KUGETSU_DIR/.agent_count ]; then
-    COUNT=$(cat $TEST_KUGETSU_DIR/.agent_count)
+if [ -f ~/.kugetsu/.agent_count ]; then
+    COUNT=$(cat ~/.kugetsu/.agent_count)
    if [ "$COUNT" = "0" ]; then
        pass "agent count file initialized to 0"
    else
@@ -797,10 +795,10 @@ test_cleanup
 setup_mock_sessions

 # Initialize count to 0
-echo 0 > $TEST_KUGETSU_DIR/.agent_count
+echo 0 > ~/.kugetsu/.agent_count

 # Verify initial state
-INITIAL=$(cat $TEST_KUGETSU_DIR/.agent_count)
+INITIAL=$(cat ~/.kugetsu/.agent_count)
 if [ "$INITIAL" = "0" ]; then
    pass "agent count starts at 0"
 else
@@ -811,7 +809,7 @@ fi
 $KUGETSU list > /dev/null 2>&1

 # Verify count is still 0 (no slot leak)
-AFTER=$(cat $TEST_KUGETSU_DIR/.agent_count)
+AFTER=$(cat ~/.kugetsu/.agent_count)
 if [ "$AFTER" = "0" ]; then
    pass "agent count stays 0 after list (no leak)"
 else