loki-mode 6.3.1 → 6.5.0

package/README.md

@@ -9,7 +9,7 @@
 [![Agent Types](https://img.shields.io/badge/Agent%20Types-41-blue)]()
 [![Autonomi](https://img.shields.io/badge/Autonomi-autonomi.dev-5B4EEA)](https://www.autonomi.dev/)
 
-**Current Version: v6.2.1**
+**Current Version: v6.5.0**
 
 ---
 

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.3.1
+# Loki Mode v6.5.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -263,4 +263,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.3.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.5.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.3.1
+6.5.0

package/autonomy/hooks/migration-hooks.sh

@@ -52,7 +52,7 @@ load_migration_hook_config() {
         # Parse YAML config safely using read/declare instead of eval
         while IFS='=' read -r key val; do
             case "$key" in
-                HOOK_*) declare -g "$key=$val" ;;
+                HOOK_*) printf -v "$key" '%s' "$val" ;;
             esac
         done < <(python3 -c "
 import sys
@@ -224,7 +224,7 @@ try:
     print(len([s for s in steps if s.get('status') != 'completed']))
 except: print(-1)
 " 2>/dev/null || echo -1)
-            [[ "$pending" -gt 0 ]] && echo "GATE_BLOCKED: ${pending} steps still pending" && return 1
+            [[ "$pending" -ne 0 ]] && echo "GATE_BLOCKED: ${pending} steps still pending (or plan missing)" && return 1
             ;;
     esac
 
@@ -236,6 +236,10 @@ hook_on_agent_stop() {
     local features_path="${LOKI_FEATURES_PATH:-}"
 
     [[ "$HOOK_ON_AGENT_STOP_ENABLED" != "true" ]] && return 0
+    if [[ -z "$features_path" ]]; then
+        echo "HOOK_BLOCKED: LOKI_FEATURES_PATH not set. Cannot verify features."
+        return 1
+    fi
     [[ ! -f "$features_path" ]] && return 0
 
     local failing

package/autonomy/loki

@@ -806,8 +806,35 @@ cmd_start() {
 }
 
 # Check if session is running
+# Usage: is_session_running [session_id]
+# Without args: returns true if ANY session (global or per-session) is running
+# With session_id: returns true only if that specific session is running
 is_session_running() {
-    # Check both possible PID files (loki.pid from run.sh, run.pid legacy)
+    local target_session="${1:-}"
+
+    if [ -n "$target_session" ]; then
+        # Check specific session
+        local session_pid_file="$LOKI_DIR/sessions/$target_session/loki.pid"
+        if [ -f "$session_pid_file" ]; then
+            local pid
+            pid=$(cat "$session_pid_file" 2>/dev/null)
+            if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                return 0
+            fi
+        fi
+        # Also check legacy per-run PID file (run-<number>.pid)
+        local run_pid_file="$LOKI_DIR/run-${target_session}.pid"
+        if [ -f "$run_pid_file" ]; then
+            local pid
+            pid=$(cat "$run_pid_file" 2>/dev/null)
+            if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                return 0
+            fi
+        fi
+        return 1
+    fi
+
+    # Check global PID files (loki.pid from run.sh, run.pid legacy)
     local pid_files=("$LOKI_DIR/loki.pid" "$LOKI_DIR/run.pid")
     for pid_file in "${pid_files[@]}"; do
         if [ -f "$pid_file" ]; then
@@ -818,15 +845,151 @@ is_session_running() {
             fi
         fi
     done
+
+    # Check per-session PIDs
+    if [ -d "$LOKI_DIR/sessions" ]; then
+        for session_dir in "$LOKI_DIR/sessions"/*/; do
+            [ -d "$session_dir" ] || continue
+            local pid_file="${session_dir}loki.pid"
+            if [ -f "$pid_file" ]; then
+                local pid
+                pid=$(cat "$pid_file" 2>/dev/null)
+                if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                    return 0
+                fi
+            fi
+        done
+    fi
     return 1
 }
 
-# Stop execution immediately
+# List all running session IDs
+list_running_sessions() {
+    local sessions=()
+    # Check global session
+    if [ -f "$LOKI_DIR/loki.pid" ]; then
+        local pid
+        pid=$(cat "$LOKI_DIR/loki.pid" 2>/dev/null)
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            sessions+=("global:$pid")
+        fi
+    fi
+    # Check per-session PIDs
+    if [ -d "$LOKI_DIR/sessions" ]; then
+        for session_dir in "$LOKI_DIR/sessions"/*/; do
+            [ -d "$session_dir" ] || continue
+            local sid pid_file pid
+            sid=$(basename "$session_dir")
+            pid_file="${session_dir}loki.pid"
+            if [ -f "$pid_file" ]; then
+                pid=$(cat "$pid_file" 2>/dev/null)
+                if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                    sessions+=("$sid:$pid")
+                fi
+            fi
+        done
+    fi
+    # Check legacy run-*.pid files
+    for run_pid_file in "$LOKI_DIR"/run-*.pid; do
+        [ -f "$run_pid_file" ] || continue
+        local sid pid
+        sid=$(basename "$run_pid_file" .pid)
+        sid="${sid#run-}"
+        pid=$(cat "$run_pid_file" 2>/dev/null)
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            # Avoid duplicates (if also in sessions/)
+            local dup=false
+            for s in "${sessions[@]}"; do
+                if [[ "$s" == "$sid:"* ]]; then dup=true; break; fi
+            done
+            if ! $dup; then
+                sessions+=("$sid:$pid")
+            fi
+        fi
+    done
+    printf '%s\n' "${sessions[@]}"
+}
+
+# Kill a PID with SIGTERM, wait, then SIGKILL if needed
+_kill_pid() {
+    local pid="$1"
+    pkill -P "$pid" 2>/dev/null || true
+    kill "$pid" 2>/dev/null || true
+    sleep 1
+    if kill -0 "$pid" 2>/dev/null; then
+        pkill -9 -P "$pid" 2>/dev/null || true
+        kill -9 "$pid" 2>/dev/null || true
+    fi
+}
+
+# Stop a specific session by its session ID
+_stop_session_by_id() {
+    local sid="$1"
+    local session_dir="$LOKI_DIR/sessions/$sid"
+    local pid_file="$session_dir/loki.pid"
+
+    if [ -f "$pid_file" ]; then
+        local pid
+        pid=$(cat "$pid_file" 2>/dev/null)
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            _kill_pid "$pid"
+            echo -e "${RED}Stopped session $sid (PID: $pid)${NC}"
+        fi
+        rm -f "$pid_file"
+    fi
+
+    # Also check legacy run-<id>.pid
+    local run_pid_file="$LOKI_DIR/run-${sid}.pid"
+    if [ -f "$run_pid_file" ]; then
+        local pid
+        pid=$(cat "$run_pid_file" 2>/dev/null)
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            _kill_pid "$pid"
+        fi
+        rm -f "$run_pid_file"
+    fi
+
+    # Clean up session lock file
+    rm -f "$session_dir/session.lock" 2>/dev/null
+}
+
+# Stop a specific session or all sessions
+# Usage: loki stop [session_id]
+# Without args: stops all running sessions
+# With session_id: stops only that specific session
 cmd_stop() {
+    local target_session=""
+
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                echo -e "${BOLD}loki stop${NC} - Stop running sessions (v6.4.0)"
+                echo ""
+                echo "Usage: loki stop [session-id]"
+                echo ""
+                echo "  loki stop          Stop all running sessions"
+                echo "  loki stop 52       Stop only session #52"
+                echo "  loki stop 54       Stop only session #54"
+                echo ""
+                echo "Use 'loki status' to see all running sessions."
+                exit 0
+                ;;
+            -*)
+                echo -e "${RED}Unknown option: $1${NC}"
+                echo "Run 'loki stop --help' for usage."
+                exit 1
+                ;;
+            *)
+                target_session="$1"
+                shift
+                ;;
+        esac
+    done
+
     if [ ! -d "$LOKI_DIR" ]; then
         echo -e "${YELLOW}No .loki directory found.${NC}"
         echo "No active session to stop."
-        # Emit error pattern for stop without session (SYN-018)
         emit_learning_signal error_pattern \
             --source cli \
             --action "cmd_stop" \
@@ -837,28 +1000,54 @@ cmd_stop() {
         exit 0
     fi
 
+    # Stop a specific session by ID
+    if [ -n "$target_session" ]; then
+        if is_session_running "$target_session"; then
+            _stop_session_by_id "$target_session"
+        else
+            echo -e "${YELLOW}Session '$target_session' is not running.${NC}"
+        fi
+        return 0
+    fi
+
+    # No session ID given -- stop all running sessions
     if is_session_running; then
+        # Stop per-session PIDs first
+        if [ -d "$LOKI_DIR/sessions" ]; then
+            for session_dir in "$LOKI_DIR/sessions"/*/; do
+                [ -d "$session_dir" ] || continue
+                local sid
+                sid=$(basename "$session_dir")
+                if is_session_running "$sid"; then
+                    _stop_session_by_id "$sid"
+                fi
+            done
+        fi
+        # Stop legacy run-*.pid sessions
+        for run_pid_file in "$LOKI_DIR"/run-*.pid; do
+            [ -f "$run_pid_file" ] || continue
+            local pid
+            pid=$(cat "$run_pid_file" 2>/dev/null)
+            if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                _kill_pid "$pid"
+                local sid
+                sid=$(basename "$run_pid_file" .pid)
+                echo -e "${RED}Stopped session ${sid#run-} (PID: $pid)${NC}"
+            fi
+            rm -f "$run_pid_file"
+        done
+
+        # Stop global session
         touch "$LOKI_DIR/STOP"
 
-        # Kill the background process and all its children
         local killed_pid=""
         for pid_file in "$LOKI_DIR/loki.pid" "$LOKI_DIR/run.pid"; do
             if [ -f "$pid_file" ]; then
                 local pid
                 pid=$(cat "$pid_file" 2>/dev/null)
                 if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
-                    # Kill all child processes first (SIGTERM)
-                    pkill -P "$pid" 2>/dev/null || true
-                    # Then kill the parent (SIGTERM)
-                    kill "$pid" 2>/dev/null || true
+                    _kill_pid "$pid"
                     killed_pid="$pid"
-
-                    # Wait briefly, then SIGKILL if still alive
-                    sleep 1
-                    if kill -0 "$pid" 2>/dev/null; then
-                        pkill -9 -P "$pid" 2>/dev/null || true
-                        kill -9 "$pid" 2>/dev/null || true
-                    fi
                 fi
                 rm -f "$pid_file"
             fi
@@ -871,7 +1060,6 @@ cmd_stop() {
 
         # Mark session.json as stopped (skill-invoked sessions)
         if [ -f "$LOKI_DIR/session.json" ]; then
-            # Use python for reliable JSON update, fall back to overwrite
             python3 -c "
 import json, sys, os
 try:
@@ -1162,6 +1350,29 @@ cmd_status() {
     echo -e "${DIM}  Switch with: loki provider set <claude|codex|gemini>${NC}"
     echo ""
 
+    # Show running sessions (v6.4.0 - concurrent session support)
+    local running_sessions=()
+    while IFS= read -r line; do
+        [ -n "$line" ] && running_sessions+=("$line")
+    done < <(list_running_sessions 2>/dev/null)
+
+    if [ ${#running_sessions[@]} -gt 0 ]; then
+        echo -e "${GREEN}Active Sessions: ${#running_sessions[@]}${NC}"
+        for entry in "${running_sessions[@]}"; do
+            local sid="${entry%%:*}"
+            local spid="${entry#*:}"
+            if [ "$sid" = "global" ]; then
+                echo -e "  ${CYAN}[global]${NC} PID $spid"
+            else
+                echo -e "  ${CYAN}[#$sid]${NC} PID $spid"
+            fi
+        done
+        echo ""
+        echo -e "${DIM}  Stop specific: loki stop <session-id>${NC}"
+        echo -e "${DIM}  Stop all:      loki stop${NC}"
+        echo ""
+    fi
+
     # Check for signals first (more prominent)
     if [ -f "$LOKI_DIR/PAUSE" ]; then
         echo -e "${YELLOW}Status: PAUSED${NC}"
@@ -1881,7 +2092,7 @@ cmd_dashboard_stop() {
         local wait_count=0
         while kill -0 "$pid" 2>/dev/null && [ $wait_count -lt 10 ]; do
             sleep 0.5
-            ((wait_count++))
+            wait_count=$((wait_count + 1))
         done
 
         # Force kill if still running
@@ -2663,20 +2874,17 @@ cmd_run() {
             --pr)
                 use_worktree=true
                 create_pr=true
-                start_args+=("--parallel")
                 shift
                 ;;
             --ship)
                 use_worktree=true
                 create_pr=true
                 auto_merge=true
-                start_args+=("--parallel")
                 shift
                 ;;
             --detach|-d)
                 use_worktree=true
                 run_detached=true
-                start_args+=("--parallel")
                 shift
                 ;;
             -*)
@@ -2693,6 +2901,11 @@ cmd_run() {
         esac
     done
 
+    # Add --parallel once if worktree mode is enabled (not per-flag)
+    if $use_worktree; then
+        start_args+=("--parallel")
+    fi
+
     if [[ -z "$issue_ref" ]]; then
         echo -e "${RED}Error: Issue reference required${NC}"
         echo ""
@@ -2740,6 +2953,12 @@ cmd_run() {
     fi
     echo ""
 
+    # Per-session locking (v6.4.0): export session ID so run.sh uses
+    # per-session PID/lock files instead of the global lock. This allows
+    # multiple concurrent `loki run` sessions (e.g., loki run 52 -d && loki run 54 -d).
+    local session_id="${number:-$(date +%s)}"
+    export LOKI_SESSION_ID="$session_id"
+
     # Progressive isolation: set up worktree branch naming
     if $use_worktree; then
         local branch_name="issue/${issue_provider}-${number:-$(date +%s)}"
@@ -2754,6 +2973,13 @@ cmd_run() {
 
     # Detached mode: fork to background
     if $run_detached; then
+        # Guard: prevent launching duplicate session
+        if is_session_running "$session_id"; then
+            echo -e "${RED}Error: Session '$session_id' is already running.${NC}"
+            echo -e "Stop it first with: ${CYAN}loki stop $session_id${NC}"
+            exit 1
+        fi
+
         local log_file="$LOKI_DIR/logs/run-${number:-$(date +%s)}.log"
         mkdir -p "$(dirname "$log_file")"
         echo -e "${GREEN}Running detached. Logs: $log_file${NC}"
@@ -2768,31 +2994,51 @@ cmd_run() {
             branch_name="issue/detach-$(date +%s)"
         fi
 
-        nohup bash -c "
-            cd $(pwd)
-            export LOKI_DETACHED=true
-            export LOKI_PARALLEL_MODE=true
-            export LOKI_WORKTREE_BRANCH=\"$branch_name\"
-            $(command -v loki || echo "$0") start \"$detach_prd\" --parallel ${start_args[*]+"${start_args[*]}"}
-
-            # Post-completion: create PR if requested
-            if [[ \"$create_pr\" == \"true\" ]]; then
-                branch_current=\$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo \"\")
-                if [[ -n \"\$branch_current\" && \"\$branch_current\" != \"main\" && \"\$branch_current\" != \"master\" ]]; then
-                    git push origin \"\$branch_current\" 2>/dev/null || true
-                    gh pr create --title \"${title:-Implementation for issue ${issue_ref}}\" --body \"Implemented by Loki Mode\" --head \"\$branch_current\" 2>/dev/null || true
-                fi
-            fi
-            # Post-completion: auto-merge if requested
-            if [[ \"$auto_merge\" == \"true\" ]]; then
-                branch_current=\$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo \"\")
-                if gh pr merge \"\$branch_current\" --squash --delete-branch 2>/dev/null; then
-                    if [[ -n \"${number:-}\" ]]; then
-                        gh issue close \"$number\" --comment \"Resolved by Loki Mode\" 2>/dev/null || true
-                    fi
-                fi
-            fi
-        " > "$log_file" 2>&1 &
+        # Write a temp script to avoid shell injection via variable interpolation
+        local run_script="$LOKI_DIR/scripts/run-${number:-detached}.sh"
+        mkdir -p "$LOKI_DIR/scripts"
+        local loki_cmd
+        loki_cmd="$(command -v loki || echo "$0")"
+        cat > "$run_script" << 'INNER_SCRIPT_EOF'
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$LOKI_RUN_DIR"
+export LOKI_DETACHED=true
+export LOKI_PARALLEL_MODE=true
+"$LOKI_CMD" start "$LOKI_PRD_PATH" ${LOKI_START_ARGS:-}
+
+# Post-completion: create PR if requested
+if [[ "$LOKI_CREATE_PR" == "true" ]]; then
+    branch_current=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
+    if [[ -n "$branch_current" && "$branch_current" != "main" && "$branch_current" != "master" ]]; then
+        git push origin "$branch_current" 2>/dev/null || true
+        gh pr create --title "$LOKI_PR_TITLE" --body "Implemented by Loki Mode" --head "$branch_current" 2>/dev/null || true
+    fi
+fi
+# Post-completion: auto-merge if requested
+if [[ "$LOKI_AUTO_MERGE" == "true" ]]; then
+    branch_current=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
+    if gh pr merge "$branch_current" --squash --delete-branch 2>/dev/null; then
+        if [[ -n "${LOKI_ISSUE_NUMBER:-}" ]]; then
+            gh issue close "$LOKI_ISSUE_NUMBER" --comment "Resolved by Loki Mode" 2>/dev/null || true
+        fi
+    fi
+fi
+INNER_SCRIPT_EOF
+        chmod +x "$run_script"
+
+        # Pass all variables safely via environment
+        LOKI_RUN_DIR="$(pwd)" \
+        LOKI_CMD="$loki_cmd" \
+        LOKI_SESSION_ID="$session_id" \
+        LOKI_WORKTREE_BRANCH="$branch_name" \
+        LOKI_PRD_PATH="$detach_prd" \
+        LOKI_START_ARGS="${start_args[*]+"${start_args[*]}"}" \
+        LOKI_CREATE_PR="$create_pr" \
+        LOKI_AUTO_MERGE="$auto_merge" \
+        LOKI_PR_TITLE="${title:-Implementation for issue ${issue_ref}}" \
+        LOKI_ISSUE_NUMBER="${number:-}" \
+        nohup bash "$run_script" > "$log_file" 2>&1 &
 
         local bg_pid=$!
         echo "$bg_pid" > "$LOKI_DIR/run-${number:-detached}.pid"
@@ -4728,7 +4974,7 @@ cmd_notify_test() {
             echo -n "  Slack...    "
             if send_slack_notification "$message" "Test"; then
                 echo -e "${GREEN}OK${NC}"
-                ((channels_notified++))
+                channels_notified=$((channels_notified + 1))
             else
                 echo -e "${RED}FAILED${NC}"
             fi
@@ -4741,7 +4987,7 @@ cmd_notify_test() {
             echo -n "  Discord...  "
             if send_discord_notification "$message" "Test"; then
                 echo -e "${GREEN}OK${NC}"
-                ((channels_notified++))
+                channels_notified=$((channels_notified + 1))
             else
                 echo -e "${RED}FAILED${NC}"
             fi
@@ -4754,7 +5000,7 @@ cmd_notify_test() {
             echo -n "  Webhook...  "
             if send_webhook_notification "$message" "Test"; then
                 echo -e "${GREEN}OK${NC}"
-                ((channels_notified++))
+                channels_notified=$((channels_notified + 1))
             else
                 echo -e "${RED}FAILED${NC}"
             fi
@@ -6473,7 +6719,7 @@ Tasks:
             local provider_name="${LOKI_PROVIDER:-claude}"
             case "$provider_name" in
                 claude)
-                    (cd "$codebase_path" && claude --dangerously-skip-permissions -p "$phase_prompt" --output-format stream-json --verbose 2>&1) | \
+                    { (cd "$codebase_path" && claude --dangerously-skip-permissions -p "$phase_prompt" --output-format stream-json --verbose 2>&1) | \
                         while IFS= read -r line; do
                             # Extract text from stream-json
                             if echo "$line" | python3 -c "
@@ -6488,8 +6734,7 @@ except Exception: pass
 " 2>/dev/null; then
                                 true
                             fi
-                        done
-                    phase_exit=${PIPESTATUS[0]}
+                        done; } && phase_exit=0 || phase_exit=$?
                     ;;
                 codex)
                     (cd "$codebase_path" && codex exec --full-auto "$phase_prompt" 2>&1) || phase_exit=$?
@@ -6636,7 +6881,7 @@ IMPORTANT RULES:
         local provider_name="${LOKI_PROVIDER:-claude}"
         case "$provider_name" in
             claude)
-                (cd "$codebase_path" && claude --dangerously-skip-permissions -p "$doc_prompt" --output-format stream-json --verbose 2>&1) | \
+                { (cd "$codebase_path" && claude --dangerously-skip-permissions -p "$doc_prompt" --output-format stream-json --verbose 2>&1) | \
                     while IFS= read -r line; do
                         if echo "$line" | python3 -c "
 import sys, json
@@ -6650,8 +6895,7 @@ except Exception: pass
 " 2>/dev/null; then
                             true
                         fi
-                    done
-                doc_exit=${PIPESTATUS[0]}
+                    done; } && doc_exit=0 || doc_exit=$?
                 ;;
             codex)
                 (cd "$codebase_path" && codex exec --full-auto "$doc_prompt" 2>&1) || doc_exit=$?
@@ -7181,7 +7425,7 @@ main() {
             cmd_init "$@"
             ;;
         stop)
-            cmd_stop
+            cmd_stop "$@"
             ;;
         cleanup)
             cmd_cleanup "$@"