fix: add missing set_debug_mode function to kugetsu-session.sh

The queue daemon crashes with 'set_debug_mode: command not found' because
cmd_continue() calls set_debug_mode(), but that function was only defined
in the main kugetsu script, not in kugetsu-session.sh which the daemon
sources directly.

Fixes #207

skills/kugetsu/scripts/kugetsu

@@ -475,97 +475,6 @@ 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

skills/kugetsu/scripts/kugetsu-config.sh

@@ -32,7 +32,7 @@ if [ -f "$KUGETSU_DIR/config" ]; then
 fi
 
 mask_sensitive_vars() {
-    local line="$1"
+    local line="${1:-}"
     for var in GITEA_TOKEN GITHUB_TOKEN GITLAB_TOKEN API_KEY PASSWORD TOKEN SECRET; do
         if [[ "$line" =~ $var ]]; then
             line=$(echo "$line" | sed -E "s/=.*/=***MASKED***/")
@@ -41,6 +41,11 @@ mask_sensitive_vars() {
     echo "$line"
 }
 
+strip_ansi_codes() {
+    local line="${1:-}"
+    echo "$line" | sed 's/\x1b\[[0-9;]*m//g' | sed 's/\x1b\[[0-9;]*[a-zA-Z]//g'
+}
+
 load_agent_env() {
     local agent_type="${1:-base}"
     local env_file="$ENV_DIR/${agent_type}.env"

skills/kugetsu/scripts/kugetsu-index.sh

@@ -15,6 +15,13 @@ 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"
 }
 
@@ -43,7 +50,11 @@ set_base_in_index() {
     if [ "$session_id" = "null" ]; then
         write_index "null" "$pm_agent" "$issues"
     else
-        write_index "\"$session_id\"" "$pm_agent" "$issues"
+        if [ "$pm_agent" = "null" ]; then
+            write_index "\"$session_id\"" "null" "$issues"
+        else
+            write_index "\"$session_id\"" "\"$pm_agent\"" "$issues"
+        fi
     fi
 }
 
@@ -56,7 +67,11 @@ set_pm_agent_in_index() {
     if [ "$session_id" = "null" ]; then
         write_index "$base" "null" "$issues"
     else
-        write_index "$base" "\"$session_id\"" "$issues"
+        if [ "$base" = "null" ]; then
+            write_index "null" "\"$session_id\"" "$issues"
+        else
+            write_index "\"$base\"" "\"$session_id\"" "$issues"
+        fi
     fi
 }
 
@@ -72,7 +87,19 @@ 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")
     
-    write_index "$base" "$pm_agent" "$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
 }
 
 remove_issue_from_index() {
@@ -86,7 +113,19 @@ 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")
     
-    write_index "$base" "$pm_agent" "$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
 }
 
 validate_issue_ref() {

skills/kugetsu/scripts/kugetsu-log.sh

@@ -24,7 +24,9 @@ cmd_logs() {
             echo ""
             echo "--- $log ---"
             tail -20 "$LOGS_DIR/$log" | while read line; do
-                echo "  $(mask_sensitive_vars "$line")"
+                line=$(strip_ansi_codes "$line")
+                line=$(mask_sensitive_vars "$line")
+                echo "  $line"
             done
         fi
     done

skills/kugetsu/scripts/kugetsu-queue-daemon.sh

@@ -44,7 +44,7 @@ check_task_completion() {
 
     if [ -n "$pid" ] && [ "$pid" != "None" ]; then
         if ! kill -0 "$pid" 2>/dev/null; then
-            local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$HOME/.kugetsu-worktrees")
+            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
@@ -64,7 +64,7 @@ check_task_completion() {
         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" "$HOME/.kugetsu-worktrees")
+            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

skills/kugetsu/scripts/kugetsu-session.sh

@@ -58,12 +58,35 @@ 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
@@ -185,18 +208,57 @@ cmd_delegate() {
         return
     fi
     
-    # No issue ref detected — delegate directly to PM agent (legacy path)
+    # No issue ref detected — fork a new session from base session
-    local pm_session=$(get_pm_agent_session_id)
+    local base_session=$(get_base_session_id)
-    if [ -z "$pm_session" ] || [ "$pm_session" = "null" ] || [ "$pm_session" = "None" ]; then
+    if [ -z "$base_session" ] || [ "$base_session" = "null" ]; then
-        echo "Error: PM agent session not found. Run 'kugetsu init' first." >&2
+        echo "Error: Base session not found. Run 'kugetsu init' first." >&2
         exit 1
     fi
     
     mkdir -p "$LOGS_DIR"
     local log_file="$LOGS_DIR/delegate-$(date +%s).log"
     load_agent_env "pm-agent"
-    nohup sh -c "GITEA_TOKEN='$GITEA_TOKEN' opencode run '$message' --continue --session '$pm_session'" >> "$log_file" 2>&1 &
+    
-    echo "Delegated to PM agent (logged to $(basename "$log_file"))"
+    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_set=$(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" >/dev/null 2>&1
+    
+    sleep 1
+    
+    local after_json=$(opencode session list --format=json 2>/dev/null)
+    local after_sessions=$(echo "$after_json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); [print(s['id']) for s in sessions]" 2>/dev/null || true)
+    
+    local new_session_id=""
+    while IFS= read -r sess; do
+        if [[ -n "$sess" ]] && [[ ! "$before_set" =~ \|${sess}\| ]]; then
+            new_session_id="$sess"
+            break
+        fi
+    done <<< "$after_sessions"
+    
+    echo "$new_session_id"
 }
 
 build_dev_agent_message() {
@@ -256,15 +318,36 @@ cmd_start() {
         exit 1
     fi
     
-    local pm_agent_session_id=$(get_pm_agent_session_id)
+    local session_file=$(issue_ref_to_filename "$issue_ref")
-    if [ -z "$pm_agent_session_id" ] || [ "$pm_agent_session_id" = "null" ]; then
+    local session_path="$SESSIONS_DIR/$session_file"
-        echo "Error: PM agent session not found. Run 'kugetsu init' first." >&2
+    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
         exit 1
     fi
     
-    if worktree_exists "$issue_ref"; then
+    if $worktree_exists && ! $session_exists; then
-        echo "Issue '$issue_ref' already has a worktree. Use 'kugetsu continue' instead."
+        echo "Warning: Worktree exists but session is missing. Removing worktree to recreate both..." >&2
-        exit 1
+        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
     fi
     
     local active_count=$(count_active_dev_sessions)
@@ -273,31 +356,12 @@ cmd_start() {
         exit 1
     fi
     
-    local session_file=$(issue_ref_to_filename "$issue_ref")
-    local session_path="$SESSIONS_DIR/$session_file"
-    
-    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" "$WORKTREES_DIR"
     
-    local after_sessions=$(opencode session list 2>/dev/null | grep -oP '^ses_\w+' | sort)
+    local new_session_id=$(create_session "$base_session_id")
-    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 find newly created session" >&2
+        echo "Error: Could not create session" >&2
         remove_worktree_for_issue "$issue_ref"
         exit 1
     fi
@@ -314,12 +378,38 @@ cmd_start() {
     load_agent_env "dev"
     
     cd "$worktree_path"
-    nohup sh -c "GITEA_TOKEN='$GITEA_TOKEN' opencode run '$dev_message' --continue --session '$new_session_id'" >> "$LOGS_DIR/dev-$new_session_id.log" 2>&1 &
+    local sanitized_id=$(echo "$new_session_id" | sed 's/[^a-zA-Z0-9_-]/_/g')
+    local msg_file="$worktree_path/.kugetsu-msg.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-$sanitized_id.log" 2>&1 &
     
     echo "Session started for '$issue_ref': $new_session_id"
     echo "Worktree: $worktree_path"
 }
 
+set_debug_mode() {
+    local filtered_args=()
+    local debug_mode=false
+    
+    for arg in "$@"; do
+        case "$arg" in
+            --debug)
+                debug_mode=true
+                ;;
+            *)
+                filtered_args+=("$arg")
+                ;;
+        esac
+    done
+    
+    if [ "$debug_mode" = true ]; then
+        export KUGETSU_VERBOSITY="debug"
+        echo "[DEBUG] Debug mode enabled" >&2
+    fi
+    
+    echo "${filtered_args[@]}"
+}
+
 cmd_continue() {
     local session_name=""
     local message=""
@@ -363,16 +453,24 @@ cmd_continue() {
     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 $?
+    fi
+    
     if [ -z "$message" ]; then
         message=$(build_dev_agent_message "$issue_ref" "")
     fi
     
-    if [ -n "$worktree_path" ] && [ -d "$worktree_path" ]; then
+    cd "$worktree_path"
-        cd "$worktree_path"
+    local sanitized_id=$(echo "$opencode_session_id" | sed 's/[^a-zA-Z0-9_-]/_/g')
-        nohup sh -c "GITEA_TOKEN='$GITEA_TOKEN' opencode run '$message' --continue --session '$opencode_session_id'" >> "$LOGS_DIR/dev-$opencode_session_id.log" 2>&1 &
+    local msg_file="$worktree_path/.kugetsu-msg.txt"
-    else
+    printf '%s' "$message" > "$msg_file"
-        nohup sh -c "GITEA_TOKEN='$GITEA_TOKEN' opencode run '$message' --continue --session '$opencode_session_id'" >> "$LOGS_DIR/dev-$opencode_session_id.log" 2>&1 &
+    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$opencode_session_id'" >> "$LOGS_DIR/dev-$sanitized_id.log" 2>&1 &
-    fi
 }
 
 cmd_list() {
@@ -523,7 +621,7 @@ cmd_destroy() {
     local target="${1:-}"
     local force=false
     
-    if [ "$2" = "-y" ]; then
+    if [ "${2:-}" = "-y" ]; then
         force=true
     fi
     

skills/kugetsu/tests/test-create-session.sh

@@ -0,0 +1,181 @@
+#!/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