fix(shell): address shellcheck warnings, standardize error handling, add retry logic

- Fix shellcheck SC2155 (separate variable assignment from declaration)
- Replace ! bool && bool pattern with [ "$bool" = true ] && [ "$bool2" = true ]
- Add retry logic for git clone with configurable attempts
- Add retry logic for opencode session fork
- Add NETWORK_RETRY_ATTEMPTS and NETWORK_RETRY_DELAY_SECONDS config vars
- Add retry_with_backoff helper function in kugetsu-config.sh
- Replace subshell cd with git -C for safer directory handling

.gitignore

@@ -4,3 +4,4 @@ results/
 */results/
 *.pyc
 
+.kugetsu/

skills/kugetsu/scripts/kugetsu-config.sh

@@ -26,6 +26,9 @@ QUEUE_DAEMON_INTERVAL_MINUTES="${QUEUE_DAEMON_INTERVAL_MINUTES:-5}"
 QUEUE_CLEANUP_AGE_DAYS="${QUEUE_CLEANUP_AGE_DAYS:-7}"
 TASK_TIMEOUT_HOURS="${TASK_TIMEOUT_HOURS:-1}"
 
+NETWORK_RETRY_ATTEMPTS="${NETWORK_RETRY_ATTEMPTS:-3}"
+NETWORK_RETRY_DELAY_SECONDS="${NETWORK_RETRY_DELAY_SECONDS:-5}"
+
 # Load user config overrides (~/.kugetsu/config)
 if [ -f "$KUGETSU_DIR/config" ]; then
     source "$KUGETSU_DIR/config"
@@ -87,3 +90,24 @@ set_debug_mode() {
     
     echo "${filtered_args[@]}"
 }
+
+retry_with_backoff() {
+    local max_attempts="${1:-$NETWORK_RETRY_ATTEMPTS}"
+    local delay_seconds="${2:-$NETWORK_RETRY_DELAY_SECONDS}"
+    local command="$3"
+    local remaining_attempts=$max_attempts
+    
+    while [ $remaining_attempts -gt 0 ]; do
+        if eval "$command"; then
+            return 0
+        fi
+        remaining_attempts=$((remaining_attempts - 1))
+        if [ $remaining_attempts -gt 0 ]; then
+            log "warn" "retry_with_backoff" "Command failed, $remaining_attempts retries remaining. Waiting ${delay_seconds}s..."
+            sleep "$delay_seconds"
+            delay_seconds=$((delay_seconds * 2))
+        fi
+    done
+    log "error" "retry_with_backoff" "Command failed after $max_attempts attempts"
+    return 1
+}

skills/kugetsu/scripts/kugetsu-index.sh

@@ -139,6 +139,77 @@ validate_issue_ref() {
     fi
 }
 
+read_json_file() {
+    local file_path="$1"
+    if [ -f "$file_path" ]; then
+        cat "$file_path"
+    else
+        echo "{}"
+    fi
+}
+
+write_json_file() {
+    local file_path="$1"
+    local json_content="$2"
+    local temp_file="$file_path.tmp.$$"
+    
+    printf '%s' "$json_content" > "$temp_file"
+    
+    if ! python3 -c "import json; json.load(open('$temp_file'))" 2>/dev/null; then
+        echo "Error: write_json_file would create malformed JSON: $file_path" >&2
+        rm -f "$temp_file"
+        return 1
+    fi
+    
+    mv "$temp_file" "$file_path"
+}
+
+get_json_value() {
+    local file_path="$1"
+    local key="$2"
+    local default="${3:-}"
+    
+    if [ ! -f "$file_path" ]; then
+        echo "$default"
+        return
+    fi
+    
+    python3 -c "import json; print(json.load(open('$file_path')).get('$key', '$default'))" 2>/dev/null || echo "$default"
+}
+
+set_json_value() {
+    local file_path="$1"
+    local key="$2"
+    local value="$3"
+    
+    if [ ! -f "$file_path" ]; then
+        printf '{"%s": "%s"}\n' "$key" "$value" > "$file_path"
+        return
+    fi
+    
+    python3 << PYEOF
+import json
+import sys
+
+file_path = "$file_path"
+key = "$key"
+value = "$value"
+
+try:
+    with open(file_path, 'r') as f:
+        data = json.load(f)
+except:
+    data = {}
+
+data[key] = value
+
+with open(file_path, 'w') as f:
+    json.dump(data, f, indent=2)
+
+print(f"Set $key = $value in $file_path")
+PYEOF
+}
+
 update_session_pr_url() {
     local issue_ref="$1"
     local pr_url="$2"

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

@@ -34,6 +34,8 @@ release_lock() {
 check_task_completion() {
     local item="$1"
     local queue_id=$(basename "$item" .json)
+    
+    local item_data=$(read_json_file "$item")
     local state=$(python3 -c "import json; print(json.load(open('$item')).get('state', ''))" 2>/dev/null)
 
     [ "$state" = "notified" ] || return 0
@@ -41,6 +43,31 @@ check_task_completion() {
     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)
+    local notified_at=$(python3 -c "import json; print(json.load(open('$item')).get('notified_at', ''))" 2>/dev/null)
+
+    local timed_out=false
+    if [ -n "$notified_at" ]; then
+        local notified_epoch=$(date -d "$notified_at" +%s 2>/dev/null || echo "0")
+        local now_epoch=$(date +%s)
+        local hours_elapsed=$(( (now_epoch - notified_epoch) / 3600 ))
+        if [ "$hours_elapsed" -ge "${TASK_TIMEOUT_HOURS:-1}" ]; then
+            timed_out=true
+            log_warn "queue-daemon" "Task $queue_id ($issue_ref) timed out after ${hours_elapsed}h"
+        fi
+    fi
+
+    if [ "$timed_out" = true ]; then
+        if [ -n "$pid" ] && [ "$pid" != "None" ]; then
+            kill "$pid" 2>/dev/null || true
+        fi
+        if [ -n "$session_id" ]; then
+            opencode session stop "$session_id" 2>/dev/null || true
+        fi
+        update_queue_item_state "$queue_id" "error"
+        log_error "queue-daemon" "Task $queue_id ($issue_ref) marked error — timeout after ${hours_elapsed}h"
+        release_lock "$issue_ref"
+        return
+    fi
 
     if [ -n "$pid" ] && [ "$pid" != "None" ]; then
         if ! kill -0 "$pid" 2>/dev/null; then

skills/kugetsu/scripts/kugetsu-session.sh

@@ -13,7 +13,8 @@ count_active_dev_sessions() {
     if [ -d "$SESSIONS_DIR" ]; then
         for session_file in "$SESSIONS_DIR"/*.json; do
             if [ -f "$session_file" ]; then
-                local filename=$(basename "$session_file")
+                local filename
+                filename=$(basename "$session_file")
                 if [ "$filename" != "base.json" ] && [ "$filename" != "pm-agent.json" ]; then
                     count=$((count + 1))
                 fi
@@ -239,23 +240,55 @@ create_session() {
         return 1
     fi
     
-    local before_json=$(opencode session list --format=json 2>/dev/null)
+    local before_file
-    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 "|")
+    before_file="$KUGETSU_DIR/sessions/before$$.json"
+    local after_file
+    after_file="$KUGETSU_DIR/sessions/after$$.json"
     
-    opencode run --fork --session "$base_session" "new session" >/dev/null 2>&1
+    opencode session list --format=json > "$before_file" 2>/dev/null || printf '{}' > "$before_file"
+    
+    local fork_success=false
+    local attempt=0
+    local max_attempts="${NETWORK_RETRY_ATTEMPTS:-3}"
+    
+    while [ $attempt -lt $max_attempts ] && [ "$fork_success" = false ]; do
+        attempt=$((attempt + 1))
+        if opencode run --fork --session "$base_session" "new session" >/dev/null 2>&1; then
+            fork_success=true
+        elif [ $attempt -lt $max_attempts ]; then
+            log "warn" "create_session" "Fork attempt $attempt failed, retrying..."
+            sleep "$((attempt * 2))"
+        fi
+    done
+    
+    if [ "$fork_success" = false ]; then
+        log "error" "create_session" "Failed to fork session after $max_attempts attempts"
+        rm -f "$before_file" "$after_file"
+        return 1
+    fi
     
     sleep 1
     
-    local after_json=$(opencode session list --format=json 2>/dev/null)
+    opencode session list --format=json > "$after_file" 2>/dev/null || printf '{}' > "$after_file"
-    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=""
+    local new_session_id
-    while IFS= read -r sess; do
+    new_session_id=$(python3 << PYEOF
-        if [[ -n "$sess" ]] && [[ ! "$before_set" =~ \|${sess}\| ]]; then
+import json
-            new_session_id="$sess"
+
+with open("$before_file", 'r') as f:
+    before = json.load(f)
+with open("$after_file", 'r') as f:
+    after = json.load(f)
+
+before_ids = set(s['id'] for s in before)
+for s in after:
+    if s['id'] not in before_ids:
+        print(s['id'])
         break
-        fi
+PYEOF
-    done <<< "$after_sessions"
+)
+    
+    rm -f "$before_file" "$after_file"
     
     echo "$new_session_id"
 }
@@ -378,20 +411,20 @@ ensure_session() {
         session_exists=true
     fi
     
-    if $worktree_exists && $session_exists; then
+    if [ "$worktree_exists" = true ] && [ "$session_exists" = true ]; then
         log "info" "ensure_session" "Session already exists for $issue_ref"
         echo "continued"
         return 0
     fi
     
-    if ! $worktree_exists && $session_exists; then
+    if [ "$worktree_exists" = false ] && [ "$session_exists" = true ]; then
         log "warn" "ensure_session" "Session exists but worktree is missing. Removing stale session..."
         rm -f "$session_path"
         remove_issue_from_index "$issue_ref"
         session_exists=false
     fi
     
-    if ! $worktree_exists; then
+    if [ "$worktree_exists" = false ]; then
         local wt_status=$(ensure_worktree "$issue_ref")
         if [ "$wt_status" != "created" ] && [ "$wt_status" != "existed" ]; then
             log "error" "ensure_session" "Failed to ensure worktree for $issue_ref"
@@ -489,6 +522,8 @@ cmd_continue() {
         exit 1
     fi
     
+    kugetsu_context_dump "$issue_ref" "$message" "$(issue_ref_to_branch_name "$issue_ref")"
+    
     local session_file=$(issue_ref_to_filename "$issue_ref")
     local session_path="$SESSIONS_DIR/$session_file"
     local opencode_session_id=$(python3 -c "import json; print(json.load(open('$session_path')).get('opencode_session_id', ''))" 2>/dev/null || echo "")

skills/kugetsu/scripts/kugetsu-worktree.sh

@@ -76,7 +76,8 @@ create_worktree() {
         exit 1
     fi
     
-    local worktree_parent_dir=$(dirname "$worktree_path")
+    local worktree_parent_dir
+    worktree_parent_dir=$(dirname "$worktree_path")
     mkdir -p "$worktree_parent_dir"
     
     if worktree_exists "$issue_ref" "$parent_dir"; then
@@ -85,15 +86,36 @@ create_worktree() {
     fi
     
     echo "Creating worktree at '$worktree_path'..."
-    git clone "$repo_url" "$worktree_path" 2>/dev/null || {
+    
-        echo "Error: Failed to clone repository" >&2
+    local clone_success=false
+    local attempt=0
+    local max_attempts="${NETWORK_RETRY_ATTEMPTS:-3}"
+    
+    while [ $attempt -lt $max_attempts ] && [ "$clone_success" = false ]; do
+        attempt=$((attempt + 1))
+        if [ $attempt -gt 1 ]; then
+            echo "Clone attempt $attempt of $max_attempts..."
+            sleep "$((attempt * 2))"
+        fi
+        
+        if git clone "$repo_url" "$worktree_path" 2>/dev/null; then
+            clone_success=true
+        fi
+    done
+    
+    if [ "$clone_success" = false ]; then
+        echo "Error: Failed to clone repository after $max_attempts attempts" >&2
         exit 1
-    }
+    fi
     
     echo "Creating branch '$branch_name'..."
-    (cd "$worktree_path" && git checkout -b "$branch_name" origin/main 2>/dev/null || git checkout -b "$branch_name" main 2>/dev/null) || {
+    if git -C "$worktree_path" checkout -b "$branch_name" origin/main 2>/dev/null; then
+        :
+    elif git -C "$worktree_path" checkout -b "$branch_name" main 2>/dev/null; then
+        :
+    else
         echo "Warning: Could not checkout branch (may need to run from within worktree after session)" >&2
-    }
+    fi
     
     echo "Worktree created at: $worktree_path"
 }
@@ -145,15 +167,17 @@ check_pr_status() {
         token="${GITEA_TOKEN:-}"
     fi
     
-    local response
+    local response_file="$KUGETSU_DIR/.pr_status_response_$$.json"
     if [ -n "$token" ]; then
-        response=$(curl -s -H "Authorization: token $token" "$api_url" 2>/dev/null || echo "{}")
+        curl -s -H "Authorization: token $token" "$api_url" > "$response_file" 2>/dev/null || printf '{}' > "$response_file"
     else
-        response=$(curl -s "$api_url" 2>/dev/null || echo "{}")
+        curl -s "$api_url" > "$response_file" 2>/dev/null || printf '{}' > "$response_file"
     fi
     
-    local state=$(echo "$response" | python3 -c "import json, sys; d=json.load(sys.stdin); print(d.get('state', 'unknown'))" 2>/dev/null || echo "unknown")
+    local state=$(python3 -c "import json; print(json.load(open('$response_file')).get('state', 'unknown'))" 2>/dev/null || echo "unknown")
-    local merged=$(echo "$response" | python3 -c "import json, sys; d=json.load(sys.stdin); print('true' if d.get('merged', False) else 'false')" 2>/dev/null || echo "false")
+    local merged=$(python3 -c "import json; print('true' if json.load(open('$response_file')).get('merged', False) else 'false')" 2>/dev/null || echo "false")
+    
+    rm -f "$response_file"
     
     if [ "$merged" = "true" ]; then
         echo "merged"