fix(kugetsu): update forked session permissions after detection

Previously we only fixed base session permissions before forking.
But permissions are NOT inherited from parent to child.

Now we update the newly created session's permissions immediately
after detection, ensuring the forked session can access external
directories like ~/.kugetsu/worktrees/.

docs/kugetsu-architecture.md

@@ -326,7 +326,7 @@ When a Coding Agent starts, it:
 | Phase 1 | ✅ Complete | SSH + Tailscale remote access |
 | Phase 1b | ✅ Complete | Tailscale VPN setup |
 | Phase 2 | 📋 Planned | API Interface |
-| Phase 3 | 🔄 In Progress | Chat Integration (Telegram) |
+| Phase 3 | ✅ Implemented | Chat Integration (Telegram) |
 | Phase 4 | 📋 Planned | Web Dashboard |
 
 ### 6.2 Current Implementation

skills/kugetsu/SKILL.md

@@ -47,6 +47,8 @@ A default config file is created during `kugetsu init` with commented examples:
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `MAX_CONCURRENT_AGENTS` | 3 | Maximum number of concurrent dev agents |
+| `KUGETSU_TEMP_DIR` | `~/.local/share/opencode/tool-output` | Temp directory for subagent tool output (useful in headless environments where /tmp is restricted) |
+| `KUGETSU_VERBOSITY` | `default` | PM agent verbosity level: `verbose`, `default`, or `quiet` |
 
 ### Environment Variables for Agents
 
@@ -254,6 +256,90 @@ kugetsu destroy --base -y
 
 **Note**: Destroying base also destroys PM agent since PM depends on base.
 
+### kugetsu delegate `<message>`
+
+Send a message to the PM agent for task coordination (fire-and-forget):
+```bash
+kugetsu delegate "work on issue #14"
+kugetsu delegate "review PR #92"
+```
+
+- Non-blocking: returns immediately, runs in background
+- PM agent processes the message asynchronously
+- Uses `KUGETSU_VERBOSITY` env var to control PM agent output verbosity
+- Log output stored in `~/.kugetsu/logs/delegate-<timestamp>.log`
+
+### kugetsu logs [n]
+
+Show recent delegation logs:
+```bash
+kugetsu logs           # Show last 10 logs
+kugetsu logs 20       # Show last 20 logs
+```
+
+- Logs are stored in `~/.kugetsu/logs/`
+- Automatically deletes logs older than 7 days
+
+### kugetsu status
+
+Check if kugetsu is properly initialized:
+```bash
+kugetsu status
+```
+
+Output:
+- `kugetsu_not_initialized` - No index file
+- `base_session_missing` - Base session not found
+- `pm_agent_missing` - PM agent not found
+- `ok` - Everything is initialized
+
+### kugetsu doctor [--fix]
+
+Diagnose and fix kugetsu issues:
+```bash
+kugetsu doctor              # Show diagnostic info
+kugetsu doctor --fix        # Attempt automatic repairs
+```
+
+- Checks index file existence
+- Validates base and PM agent sessions
+- With `--fix`: recreates PM agent if missing
+- With `--fix-permissions`: fixes session permissions in opencode database
+
+### kugetsu notify [list|clear]
+
+Show or clear notifications from PM agent:
+```bash
+kugetsu notify list         # Show unread notifications (default)
+kugetsu notify clear       # Mark all as read
+```
+
+- PM agent writes task completion notifications to `~/.kugetsu/notifications.json`
+- Shows timestamp, type, message, and issue ref for each notification
+
+### kugetsu server <list|add|remove|default|get>
+
+Manage git server configurations:
+```bash
+kugetsu server list              # List all configured servers
+kugetsu server add github https://github.com    # Add a server
+kugetsu server remove gitlab    # Remove a server
+kugetsu server default github   # Set default server
+kugetsu server get github       # Get server URL
+```
+
+### kugetsu queue <list|enqueue|dequeue|clear>
+
+Manage task queue for autonomous PM operation:
+```bash
+kugetsu queue list              # Show queued tasks
+kugetsu queue enqueue "task"   # Add task to queue
+kugetsu queue dequeue          # Remove next task from queue
+kugetsu queue clear            # Clear all queued tasks
+```
+
+- Queue stored in `~/.kugetsu/queue.json`
+
 ## Workflow Example
 
 ```bash

skills/kugetsu/scripts/kugetsu

@@ -9,7 +9,10 @@ INDEX_FILE="$KUGETSU_DIR/index.json"
 NOTIFICATIONS_FILE="$KUGETSU_DIR/notifications.json"
 LOGS_DIR="$KUGETSU_DIR/logs"
 ENV_DIR="${ENV_DIR:-$KUGETSU_DIR/env}"
+VERBOSITY_DIR="$KUGETSU_DIR/verbosity"
+
 MAX_CONCURRENT_AGENTS="${MAX_CONCURRENT_AGENTS:-3}"
+KUGETSU_VERBOSITY="${KUGETSU_VERBOSITY:-default}"
 
 # Load user config overrides (~/.kugetsu/config)
 if [ -f "$KUGETSU_DIR/config" ]; then
@@ -143,8 +146,9 @@ issue_ref_to_worktree_name() {
 
 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 "$WORKTREES_DIR/$worktree_name"
+    echo "$parent_dir/.kugetsu-worktrees/$worktree_name"
 }
 
 issue_ref_to_branch_name() {
@@ -192,13 +196,15 @@ get_repo_url() {
 
 worktree_exists() {
     local issue_ref="$1"
-    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref")
+    local parent_dir="${2:-$PWD}"
+    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$parent_dir")
     [ -d "$worktree_path" ]
 }
 
 create_worktree() {
     local issue_ref="$1"
-    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref")
+    local parent_dir="${2:-$PWD}"
+    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$parent_dir")
     local branch_name=$(issue_ref_to_branch_name "$issue_ref")
     local repo_url=$(get_repo_url "$issue_ref")
     
@@ -208,9 +214,10 @@ create_worktree() {
         exit 1
     fi
     
-    ensure_worktree_dir
+    local worktree_parent_dir=$(dirname "$worktree_path")
+    mkdir -p "$worktree_parent_dir"
     
-    if worktree_exists "$issue_ref"; then
+    if worktree_exists "$issue_ref" "$parent_dir"; then
         echo "Removing existing worktree at '$worktree_path'..."
         git worktree remove "$worktree_path" 2>/dev/null || rm -rf "$worktree_path"
     fi
@@ -231,9 +238,10 @@ create_worktree() {
 
 remove_worktree_for_issue() {
     local issue_ref="$1"
-    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref")
+    local parent_dir="${2:-$PWD}"
+    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$parent_dir")
     
-    if worktree_exists "$issue_ref"; then
+    if worktree_exists "$issue_ref" "$parent_dir"; then
         echo "Removing worktree at '$worktree_path'..."
         git worktree remove "$worktree_path" 2>/dev/null || rm -rf "$worktree_path"
     fi
@@ -545,8 +553,62 @@ cmd_status() {
     echo "ok"
 }
 
+get_verbosity_context() {
+    local verbosity="${KUGETSU_VERBOSITY:-default}"
+    local verbosity_file="$VERBOSITY_DIR/${verbosity}.md"
+    
+    if [ -f "$verbosity_file" ]; then
+        cat "$verbosity_file"
+    else
+        echo "## Verbosity: $verbosity"
+    fi
+}
+
+init_verbosity_templates() {
+    mkdir -p "$VERBOSITY_DIR"
+    
+    if [ ! -f "$VERBOSITY_DIR/verbose.md" ]; then
+        cat > "$VERBOSITY_DIR/verbose.md" << 'EOF'
+## Verbosity: Verbose
+
+You are operating in HIGH verbosity mode. Include ALL available context:
+- Full command outputs and their results
+- Detailed reasoning and thinking process
+- All file changes with diffs when relevant
+- Complete log excerpts
+- Comprehensive status updates
+- Ask clarifying questions when uncertain
+EOF
+    fi
+    
+    if [ ! -f "$VERBOSITY_DIR/default.md" ]; then
+        cat > "$VERBOSITY_DIR/default.md" << 'EOF'
+## Verbosity: Default
+
+You are operating in NORMAL verbosity mode. Provide balanced output:
+- Standard command outputs and key results
+- Moderate reasoning detail
+- Important file changes summarized
+- Regular status updates
+EOF
+    fi
+    
+    if [ ! -f "$VERBOSITY_DIR/quiet.md" ]; then
+        cat > "$VERBOSITY_DIR/quiet.md" << 'EOF'
+## Verbosity: Quiet
+
+You are operating in QUIET verbosity mode. Keep output minimal:
+- Only essential information
+- Brief status updates (1-2 sentences)
+- Final decisions only
+- Yes/No answers when appropriate
+EOF
+    fi
+}
+
 cmd_delegate() {
     local message="${1:-}"
+    local verbosity="${KUGETSU_VERBOSITY:-default}"
     
     if [ -z "$message" ]; then
         echo "Error: message is required" >&2
@@ -563,8 +625,10 @@ cmd_delegate() {
     mkdir -p "$LOGS_DIR"
     local log_file="$LOGS_DIR/delegate-$(date +%s).log"
     
+    local temp_dir="${KUGETSU_TEMP_DIR:-$HOME/.local/share/opencode/tool-output}"
+    
     mkdir -p "$ENV_DIR"
-    local env_sh="set -a; "
+    local env_sh="set -a; export KUGETSU_TEMP_DIR='$temp_dir'; export KUGETSU_VERBOSITY='$verbosity'; "
     if [ -f "$ENV_DIR/pm-agent.env" ]; then
         env_sh="${env_sh}source '$ENV_DIR/pm-agent.env'; "
     elif [ -f "$ENV_DIR/default.env" ]; then
@@ -575,6 +639,7 @@ cmd_delegate() {
     nohup sh -c "${env_sh}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"))"
+    echo "Verbosity: $verbosity"
 }
 
 cmd_logs() {
@@ -675,7 +740,7 @@ cmd_env() {
             fi
             local file="$ENV_DIR/${target}.env"
             if [ -f "$file" ]; then
-                sed -i "/^${key}=/d" "$file"
+                grep -v "^${key}=" "$file" > "$file.tmp" && mv "$file.tmp" "$file"
                 echo "Removed $key from ${target}.env"
             fi
             ;;
@@ -695,12 +760,16 @@ cmd_env() {
 
 cmd_doctor() {
     local fix=false
+    local fix_permissions=false
     
     while [ $# -gt 0 ]; do
         case "$1" in
             --fix)
                 fix=true
                 ;;
+            --fix-permissions)
+                fix_permissions=true
+                ;;
             *)
                 ;;
         esac
@@ -798,6 +867,52 @@ cmd_doctor() {
             fi
         fi
     fi
+    
+    if [ "$fix_permissions" = true ]; then
+        echo ""
+        echo "Fixing session permissions..."
+        fix_session_permissions
+    fi
+}
+
+fix_session_permissions() {
+    local opencode_db="${OPENCODE_DB:-$HOME/.opencode/opencode.db}"
+    
+    if [ ! -f "$opencode_db" ]; then
+        echo "[ERROR] opencode database not found: $opencode_db"
+        return 1
+    fi
+    
+    local base_session_id=$(get_base_session_id)
+    local pm_agent_session_id=$(get_pm_agent_session_id)
+    
+    local PERMISSION_JSON='[{"permission":"question","pattern":"*","action":"deny"},{"permission":"plan_enter","pattern":"*","action":"deny"},{"permission":"plan_exit","pattern":"*","action":"deny"},{"permission":"external_directory","pattern":"*","action":"allow"}]'
+    
+    if [ -n "$base_session_id" ] && [ "$base_session_id" != "null" ]; then
+        echo "Updating base session permissions: $base_session_id"
+        python3 -c "
+import sqlite3
+conn = sqlite3.connect('$opencode_db')
+cursor = conn.cursor()
+cursor.execute(\"UPDATE session SET permission = ? WHERE id = ?\", ('$PERMISSION_JSON', '$base_session_id'))
+conn.commit()
+print('[OK] Base session permissions updated')
+"
+    fi
+    
+    if [ -n "$pm_agent_session_id" ] && [ "$pm_agent_session_id" != "null" ] && [ "$pm_agent_session_id" != "None" ]; then
+        echo "Updating PM agent session permissions: $pm_agent_session_id"
+        python3 -c "
+import sqlite3
+conn = sqlite3.connect('$opencode_db')
+cursor = conn.cursor()
+cursor.execute(\"UPDATE session SET permission = ? WHERE id = ?\", ('$PERMISSION_JSON', '$pm_agent_session_id'))
+conn.commit()
+print('[OK] PM agent session permissions updated')
+"
+    fi
+    
+    echo "Session permissions fix complete"
 }
 
 DEBUG_MODE=false
@@ -938,6 +1053,9 @@ cmd_init() {
 # Max concurrent dev agents (default: 3)
 # MAX_CONCURRENT_AGENTS=5
 
+# Verbosity level for PM agent output (verbose, default, or quiet)
+# KUGETSU_VERBOSITY=default
+
 # Git server configurations
 # Format: GIT_SERVERS["hostname"]="https://hostname"
 # Add servers with: kugetsu server add <name> <url>
@@ -993,7 +1111,11 @@ EOF
     echo "Press Ctrl+C to cancel or wait for session to be created"
     sleep 2
 
-    opencode
+    if ! opencode; then
+        echo "Error: opencode TUI failed to start" >&2
+        echo "Please ensure opencode is installed and accessible" >&2
+        exit 1
+    fi
 
     local session_ids=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' | tail -1)
     if [ -z "$session_ids" ]; then
@@ -1052,6 +1174,8 @@ EOF
     echo "Initialization complete!"
     echo "- Base session: $new_session_id"
     echo "- PM agent: ${new_pm_session_id:-created by hermes}"
+    
+    fix_session_permissions
 }
 
 cmd_start() {
@@ -1096,8 +1220,9 @@ cmd_start() {
         exit 1
     fi
 
-    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref")
+    local parent_dir="$PWD"
-    create_worktree "$issue_ref"
+    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$parent_dir")
+    create_worktree "$issue_ref" "$parent_dir"
 
     local session_file="$(issue_ref_to_filename "$issue_ref").json"
 
@@ -1114,28 +1239,35 @@ cmd_start() {
     if [ "$active_count" -ge "$MAX_CONCURRENT_AGENTS" ]; then
         echo "Error: Max concurrent agents ($MAX_CONCURRENT_AGENTS) reached" >&2
         echo "Active sessions: $active_count" >&2
-        remove_worktree_for_issue "$issue_ref"
+        remove_worktree_for_issue "$issue_ref" "$parent_dir"
         exit 1
     fi
     
+    local fork_log="$SESSIONS_DIR/$session_file.fork.log"
+    local opencode_db="${OPENCODE_DB:-$HOME/.local/share/opencode/opencode.db}"
+    
+    fix_session_permissions
+    
     if [ "$DEBUG_MODE" = true ]; then
-        opencode run "$message" --fork --session "$base_session_id" --dir "$worktree_path" 2>&1 | tee "$SESSIONS_DIR/$session_file.debug.log" &
+        (cd "$worktree_path" && opencode run "$message" --fork --session "$base_session_id" 2>&1) | tee "$fork_log" &
     else
-        opencode run "$message" --fork --session "$base_session_id" --dir "$worktree_path" 2>&1 &
+        (cd "$worktree_path" && opencode run "$message" --fork --session "$base_session_id" 2>&1) >> "$fork_log" &
     fi
 
-    # Wait briefly for session to be created
+    local fork_pid=$!
+    
+    local max_attempts=10
+    local attempt=1
+    local new_session_id=""
+    local fork_log_output=""
+    
+    while [ $attempt -le $max_attempts ]; do
         sleep 1
         
-    # Find the new session by comparing before/after lists
-    # Skip any session that existed before the fork and skip base/pm-agent
-    local new_session_id=""
         while IFS= read -r sess; do
-        # Skip base and pm-agent
             [ "$sess" = "$base_session_id" ] && continue
             [ "$sess" = "$pm_agent_session_id" ] && continue
             
-        # Check if this session existed before
             local existed_before=false
             for before_sess in "${before_sessions[@]}"; do
                 if [ "$sess" = "$before_sess" ]; then
@@ -1150,12 +1282,68 @@ cmd_start() {
             fi
         done < <(opencode session list 2>/dev/null | grep -oP '^ses_\w+')
         
+        if [ -n "$new_session_id" ]; then
+            break
+        fi
+        
+        if ! kill -0 $fork_pid 2>/dev/null; then
+            fork_log_output=$(tail -20 "$fork_log" 2>/dev/null || echo "(log empty or unavailable)")
+            break
+        fi
+        
+        attempt=$((attempt + 1))
+    done
+
     if [ -z "$new_session_id" ]; then
-        echo "Error: Could not find newly created session" >&2
+        if [ -f "$opencode_db" ]; then
+            local db_sessions=$(python3 -c "
+import sqlite3
+conn = sqlite3.connect('$opencode_db')
+cursor = conn.cursor()
+cursor.execute(\"SELECT id FROM session WHERE parent_id IS NOT NULL ORDER BY time_created DESC LIMIT 5\")
+for row in cursor.fetchall():
+    print(row[0])
+" 2>/dev/null || echo "")
+            if [ -n "$db_sessions" ]; then
+                echo "Recent forked sessions in DB:" >&2
+                echo "$db_sessions" >&2
+            fi
+        fi
+        
+        echo "Error: Could not find newly created session after ${max_attempts}s" >&2
+        if [ -n "$fork_log_output" ]; then
+            echo "Fork log output:" >&2
+            echo "$fork_log_output" >&2
+        fi
         remove_worktree_for_issue "$issue_ref"
         exit 1
     fi
 
+    echo "Updating permissions for new session: $new_session_id"
+    python3 -c "
+import sqlite3
+conn = sqlite3.connect('$opencode_db')
+cursor = conn.cursor()
+PERMISSION_JSON = '[{\"permission\":\"question\",\"pattern\":\"*\",\"action\":\"deny\"},{\"permission\":\"plan_enter\",\"pattern\":\"*\",\"action\":\"deny\"},{\"permission\":\"plan_exit\",\"pattern\":\"*\",\"action\":\"deny\"},{\"permission\":\"external_directory\",\"pattern\":\"*\",\"action\":\"allow\"}]'
+cursor.execute('UPDATE session SET permission = ? WHERE id = ?', (PERMISSION_JSON, '$new_session_id'))
+conn.commit()
+print('[OK] Session permissions updated')
+"
+
+    if [ "$DEBUG_MODE" = true ]; then
+        echo "[DEBUG] Forked session permissions check:"
+        python3 -c "
+import sqlite3
+conn = sqlite3.connect('$opencode_db')
+cursor = conn.cursor()
+cursor.execute(\"SELECT id, directory, permission FROM session WHERE id = '$new_session_id'\")
+for row in cursor.fetchall():
+    print('  ID:', row[0])
+    print('  Directory:', row[1])
+    print('  Permission:', row[2])
+" 2>/dev/null || echo "  (failed to query DB)"
+    fi
+
     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"
 
@@ -1212,9 +1400,9 @@ cmd_continue() {
     if [ -n "$worktree_path" ] && [ -d "$worktree_path" ]; then
         echo "Using worktree: $worktree_path"
         if [ "$DEBUG_MODE" = true ]; then
-            opencode run "$message" --continue --session "$opencode_session_id" --dir "$worktree_path" 2>&1 | tee "$session_path.debug.log" &
+            (cd "$worktree_path" && opencode run "$message" --continue --session "$opencode_session_id" 2>&1) | tee "$session_path.debug.log" &
         else
-            opencode run "$message" --continue --session "$opencode_session_id" --dir "$worktree_path" 2>&1 &
+            (cd "$worktree_path" && opencode run "$message" --continue --session "$opencode_session_id" 2>&1) &
         fi
     else
         if [ "$DEBUG_MODE" = true ]; then

skills/kugetsu/tests/test-kugetsu-v2.sh

@@ -634,9 +634,70 @@ else
 fi
 echo ""
 
+# Test E7: KUGETSU_TEMP_DIR is exported in cmd_delegate
+echo "--- Test: KUGETSU_TEMP_DIR export in cmd_delegate ---"
+if grep -q "KUGETSU_TEMP_DIR" "$KUGETSU" && grep -q "export KUGETSU_TEMP_DIR" "$KUGETSU"; then
+    pass "KUGETSU_TEMP_DIR is exported to delegated agents"
+else
+    fail "KUGETSU_TEMP_DIR not found in cmd_delegate export"
+fi
+echo ""
+
 # Cleanup env files
 rm -rf ~/.kugetsu/env 2>/dev/null || true
 
+# Test E7: fix_session_permissions function exists
+echo "--- Test: fix_session_permissions function exists ---"
+if grep -q "fix_session_permissions()" "$KUGETSU"; then
+    pass "fix_session_permissions function exists"
+else
+    fail "fix_session_permissions function not found"
+fi
+echo ""
+
+# Test E8: cmd_doctor --fix-permissions flag is recognized
+echo "--- Test: cmd_doctor --fix-permissions flag ---"
+OUTPUT=$($KUGETSU doctor --fix-permissions 2>&1 || true)
+if echo "$OUTPUT" | grep -q -E "(Fixing session permissions|Session permissions fix complete|opencode database not found)"; then
+    pass "cmd_doctor --fix-permissions flag is recognized"
+else
+    fail "cmd_doctor --fix-permissions not recognized: $OUTPUT"
+fi
+echo ""
+
+# Test E9: fix_session_permissions has valid permission JSON
+echo "--- Test: fix_session_permissions has valid permission JSON ---"
+PERMISSION_JSON='[{"permission":"question","pattern":"*","action":"deny"},{"permission":"plan_enter","pattern":"*","action":"deny"},{"permission":"plan_exit","pattern":"*","action":"deny"},{"permission":"external_directory","pattern":"*","action":"allow"}]'
+if python3 -c "import json; json.loads('$PERMISSION_JSON')" 2>/dev/null; then
+    pass "fix_session_permissions has valid permission JSON"
+else
+    fail "fix_session_permissions permission JSON is invalid"
+fi
+echo ""
+
+# Test E10: fix_session_permissions SQL UPDATE syntax is valid
+echo "--- Test: fix_session_permissions SQL UPDATE syntax ---"
+if python3 -c "
+import sqlite3
+conn = sqlite3.connect(':memory:')
+cursor = conn.cursor()
+cursor.execute('CREATE TABLE session (id TEXT, permission TEXT)')
+cursor.execute('INSERT INTO session (id, permission) VALUES (?, ?)', ('test_id', 'original'))
+cursor.execute('UPDATE session SET permission = ? WHERE id = ?', ('$PERMISSION_JSON', 'test_id'))
+conn.commit()
+cursor.execute('SELECT permission FROM session WHERE id = ?', ('test_id',))
+result = cursor.fetchone()
+if result and 'external_directory' in result[0]:
+    print('OK')
+else:
+    print('FAIL')
+" 2>/dev/null | grep -q OK; then
+    pass "fix_session_permissions SQL UPDATE syntax is valid"
+else
+    fail "fix_session_permissions SQL UPDATE syntax failed"
+fi
+echo ""
+
 # Cleanup
 cleanup
 

skills/kugetsu/tests/test-kugetsu.sh

@@ -1,277 +0,0 @@
-#!/bin/bash
-# kugetsu test suite
-# Run with: bash skills/kugetsu/tests/test-kugetsu.sh
-#
-# Memory management approach:
-# - Sequential test execution (no parallel)
-# - Cleanup between tests that spawn opencode
-# - No hard memory cap (ulimit -v breaks Bun/opencode)
-# - If OOM occurs, it is a known failure mode
-
-set -euo pipefail
-
-KUGETSU="./skills/kugetsu/scripts/kugetsu"
-TEST_SESSION_PREFIX="kugetsu-test-"
-PASS=0
-FAIL=0
-
-cleanup_sessions() {
-    for dir in ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}*; do
-        [ -d "$dir" ] && rm -rf "$dir" 2>/dev/null || true
-    done
-}
-
-cleanup_opencode() {
-    pkill -f "opencode.*${TEST_SESSION_PREFIX}" 2>/dev/null || true
-    pkill -f "kugetsu.*${TEST_SESSION_PREFIX}" 2>/dev/null || true
-    sleep 0.5
-}
-
-cleanup() {
-    cleanup_sessions
-    cleanup_opencode
-}
-
-pass() {
-    echo "✅ PASS: $1"
-    PASS=$((PASS + 1))
-}
-
-fail() {
-    echo "❌ FAIL: $1"
-    FAIL=$((FAIL + 1))
-}
-
-cleanup
-
-echo "=== kugetsu Test Suite ==="
-echo ""
-
-# Test 1: Help
-echo "--- Test: help ---"
-if $KUGETSU help 2>&1 | grep -q "kugetsu - OpenCode Session Manager"; then
-    pass "help displays usage"
-else
-    fail "help displays usage"
-fi
-echo ""
-
-# Test 2: List empty
-echo "--- Test: list (empty) ---"
-if $KUGETSU list 2>&1 | grep -q "SESSION_ID"; then
-    pass "list shows header even when empty"
-else
-    fail "list shows header even when empty"
-fi
-echo ""
-
-# Test 3: List --all empty
-echo "--- Test: list --all (empty) ---"
-if $KUGETSU list --all 2>&1 | grep -q "SESSION_ID"; then
-    pass "list --all shows header even when empty"
-else
-    fail "list --all shows header even when empty"
-fi
-echo ""
-
-# Test 4: Start session (quick exit)
-echo "--- Test: start session ---"
-if timeout 15 bash -c "$KUGETSU start ${TEST_SESSION_PREFIX}start-test 'echo hello'" 2>&1; then
-    if [ -d ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}start-test ]; then
-        pass "start creates session directory"
-    else
-        fail "start creates session directory"
-    fi
-else
-    fail "start runs successfully"
-fi
-echo ""
-
-# Test 5: List shows only left by default
-echo "--- Test: list default filters non-left ---"
-if ! $KUGETSU list 2>&1 | grep -q "${TEST_SESSION_PREFIX}start-test"; then
-    pass "list default hides idle sessions"
-else
-    fail "list default hides idle sessions"
-fi
-echo ""
-
-# Test 6: List --all shows all
-echo "--- Test: list --all shows all states ---"
-if $KUGETSU list --all 2>&1 | grep -q "${TEST_SESSION_PREFIX}start-test"; then
-    pass "list --all shows all sessions"
-else
-    fail "list --all shows all sessions"
-fi
-echo ""
-
-# Test 7: Resume with auto-fill
-echo "--- Test: resume auto-fill ---"
-mkdir -p ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}resume-test
-echo "left" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}resume-test/state
-echo "continue this task" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}resume-test/message
-
-OUTPUT=$(timeout 10 bash -c "$KUGETSU resume ${TEST_SESSION_PREFIX}resume-test" 2>&1 || true)
-if echo "$OUTPUT" | grep -q "Auto-filled message: continue this task"; then
-    pass "resume auto-fills stored message"
-else
-    fail "resume auto-fills stored message"
-fi
-cleanup
-echo ""
-
-# Test 8: Resume with provided message overrides
-echo "--- Test: resume with message overrides ---"
-mkdir -p ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}resume-override
-echo "left" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}resume-override/state
-echo "original message" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}resume-override/message
-
-OUTPUT=$(timeout 30 bash -c "$KUGETSU resume ${TEST_SESSION_PREFIX}resume-override 'new message'" 2>&1 || true)
-if echo "$OUTPUT" | grep -q "new message" && ! echo "$OUTPUT" | grep -q "Auto-filled message"; then
-    pass "resume uses provided message over auto-fill"
-else
-    fail "resume uses provided message over auto-fill: $OUTPUT"
-fi
-cleanup
-echo ""
-
-# Test 9: Resume idle session fails
-echo "--- Test: resume idle session fails ---"
-rm -rf ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}idle-test 2>/dev/null
-mkdir -p ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}idle-test
-echo "idle" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}idle-test/state
-
-OUTPUT=$(timeout 5 bash -c "$KUGETSU resume ${TEST_SESSION_PREFIX}idle-test" 2>&1 || true)
-if echo "$OUTPUT" | grep -q "cannot be resumed"; then
-    pass "resume idle session fails with message"
-else
-    echo "DEBUG: $OUTPUT"
-    fail "resume idle session fails with message"
-fi
-echo ""
-
-# Test 10: Resume non-existent session fails
-echo "--- Test: resume non-existent session fails ---"
-rm -rf ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}nonexistent 2>/dev/null
-OUTPUT=$(timeout 5 bash -c "$KUGETSU resume ${TEST_SESSION_PREFIX}nonexistent" 2>&1 || true)
-if echo "$OUTPUT" | grep -q "not found"; then
-    pass "resume non-existent session fails"
-else
-    echo "DEBUG: $OUTPUT"
-    fail "resume non-existent session fails"
-fi
-echo ""
-
-# Test 11: Stop non-used session fails
-echo "--- Test: stop non-used session fails ---"
-rm -rf ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}notused 2>/dev/null
-mkdir -p ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}notused
-echo "idle" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}notused/state
-
-OUTPUT=$(timeout 5 bash -c "$KUGETSU stop ${TEST_SESSION_PREFIX}notused" 2>&1 || true)
-if echo "$OUTPUT" | grep -q "not in use"; then
-    pass "stop non-used session fails"
-else
-    echo "DEBUG: $OUTPUT"
-    fail "stop non-used session fails"
-fi
-echo ""
-
-# Test 12: Start existing left session resumes instead
-echo "--- Test: start on left session resumes ---"
-mkdir -p ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}left-start
-echo "left" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}left-start/state
-echo "original task" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}left-start/message
-
-OUTPUT=$(timeout 10 bash -c "$KUGETSU start ${TEST_SESSION_PREFIX}left-start 'new task'" 2>&1 || true)
-if echo "$OUTPUT" | grep -q "Resuming instead"; then
-    pass "start on left session resumes"
-else
-    fail "start on left session resumes"
-fi
-cleanup
-echo ""
-
-# ============================================================================
-# FLAKY TESTS - Commented out due to timing/process behavior issues
-# ============================================================================
-
-# Test: Stop active session (FLAKY - timing dependent)
-# echo "--- Test: stop active session (FLAKY) ---"
-# (
-#     timeout 20 bash -c "$KUGETSU start ${TEST_SESSION_PREFIX}stop-test 'sleep 30'" 2>&1 &
-#     KUGETSU_PID=$!
-#     sleep 3
-#     
-#     # Check session is in use
-#     if ! $KUGETSU list --all 2>&1 | grep -q "${TEST_SESSION_PREFIX}stop-test.*used"; then
-#         echo "⚠️  SKIP (FLAKY): Could not verify session was used"
-#     elif timeout 5 bash -c "$KUGETSU stop ${TEST_SESSION_PREFIX}stop-test" 2>&1; then
-#         if [ "$(cat ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}stop-test/state 2>/dev/null)" = "idle" ]; then
-#             echo "✅ PASS (FLAKY): stop transitions to idle"
-#         else
-#             echo "❌ FAIL (FLAKY): stop does not transition to idle"
-#         fi
-#     else
-#         echo "❌ FAIL (FLAKY): stop command failed"
-#     fi
-#     
-#     wait $KUGETSU_PID 2>/dev/null || true
-# ) 2>&1 || true
-
-# Test: Interrupt session leaves state as left (FLAKY - opencode signal handling)
-# echo "--- Test: interrupt session leaves left (FLAKY) ---"
-# (
-#     bash -c "$KUGETSU start ${TEST_SESSION_PREFIX}interrupt-test 'sleep 30'" 2>&1 &
-#     KUGETSU_PID=$!
-#     sleep 3
-#     
-#     # Find and kill opencode process
-#     OPENCODE_PID=$(pgrep -f "opencode.*${TEST_SESSION_PREFIX}interrupt-test" | head -1 || true)
-#     if [ -n "$OPENCODE_PID" ]; then
-#         kill -9 $OPENCODE_PID 2>/dev/null || true
-#     fi
-#     
-#     wait $KUGETSU_PID 2>/dev/null || true
-#     sleep 1
-#     
-#     STATE=$(cat ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}interrupt-test/state 2>/dev/null || echo "unknown")
-#     if [ "$STATE" = "left" ]; then
-#         echo "✅ PASS (FLAKY): interrupt leaves state as left"
-#     else
-#         echo "❌ FAIL (FLAKY): interrupt left state=$STATE (expected left)"
-#     fi
-# ) 2>&1 || true
-
-# Test: Concurrent resume attempts (FLAKY - race condition)
-# echo "--- Test: concurrent resume (FLAKY) ---"
-# mkdir -p ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}concurrent
-# echo "left" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}concurrent/state
-# echo "test task" > ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}concurrent/message
-# 
-# (
-#     timeout 10 bash -c "$KUGETSU resume ${TEST_SESSION_PREFIX}concurrent" 2>&1 &
-#     timeout 10 bash -c "$KUGETSU resume ${TEST_SESSION_PREFIX}concurrent" 2>&1
-# ) 2>&1 || true
-# 
-# echo "⚠️  NOTE (FLAKY): This test is informational only - no assertion"
-# rm -rf ~/.kugetsu/sessions/${TEST_SESSION_PREFIX}concurrent
-
-# ============================================================================
-# Cleanup
-# ============================================================================
-cleanup
-
-echo ""
-echo "=== Test Summary ==="
-echo "Passed: $PASS"
-echo "Failed: $FAIL"
-echo ""
-
-if [ $FAIL -eq 0 ]; then
-    echo "All tests passed!"
-    exit 0
-else
-    echo "Some tests failed."
-    exit 1
-fi