loki-mode 5.57.0 → 5.58.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 v5.57.0
+# Loki Mode v5.58.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 |
 
-**v5.57.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v5.58.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-5.57.0
+5.58.0

package/autonomy/loki

@@ -4854,7 +4854,7 @@ cmd_migrate_help() {
 }
 
 cmd_migrate_list() {
-    python3 -c "
+    PYTHONPATH="${SKILL_DIR:-.}" python3 -c "
 import sys
 sys.path.insert(0, '.')
 from dashboard.migration_engine import list_migrations
@@ -4900,7 +4900,7 @@ cmd_migrate_status() {
         return 1
     fi
 
-    python3 -c "
+    PYTHONPATH="${SKILL_DIR:-.}" python3 -c "
 import json, sys
 sys.path.insert(0, '.')
 from dashboard.migration_engine import MigrationPipeline
@@ -4955,7 +4955,7 @@ print(data.get('id', ''))
 " "$plan_file" 2>/dev/null || echo "")
 
     if [ -n "$migration_id_for_plan" ]; then
-        python3 -c "
+        PYTHONPATH="${SKILL_DIR:-.}" python3 -c "
 import sys
 sys.path.insert(0, '.')
 from dashboard.migration_engine import MigrationPipeline
@@ -5121,7 +5121,7 @@ if manifests:
 
     # Create migration via engine
     local create_result
-    create_result=$(python3 -c "
+    create_result=$(PYTHONPATH="${SKILL_DIR:-.}" python3 -c "
 import json, sys
 sys.path.insert(0, '.')
 from dashboard.migration_engine import MigrationPipeline
@@ -5215,7 +5215,7 @@ print(json.dumps({'id': manifest.id, 'dir': str(pipeline.migration_dir)}))
         echo -e "${CYAN}[Phase: ${p}]${NC} Starting..."
 
         # Start phase via engine
-        python3 -c "
+        PYTHONPATH="${SKILL_DIR:-.}" python3 -c "
 import sys
 sys.path.insert(0, '.')
 from dashboard.migration_engine import MigrationPipeline
@@ -5226,31 +5226,140 @@ pipeline.start_phase(sys.argv[2])
             return 1
         }
 
-        # Phase-specific logic
+        # Phase-specific logic -- invoke Claude to do real work
+        local phase_prompt=""
         case "$p" in
             understand)
                 echo -e "  ${DIM}Analyzing codebase structure...${NC}"
-                echo -e "  ${DIM}Detecting languages, frameworks, dependencies...${NC}"
-                echo -e "  ${DIM}Building dependency graph...${NC}"
+                phase_prompt="You are performing the UNDERSTAND phase of a codebase migration.
+Target: ${target}
+Codebase: ${codebase_path}
+
+Tasks:
+1. Analyze the full codebase structure (languages, frameworks, dependencies, architecture)
+2. Create the docs directory: mkdir -p ${migration_dir}/docs
+3. Write analysis documentation to ${migration_dir}/docs/analysis.md
+3. Identify migration seams (logical boundaries for incremental migration) and write them to ${migration_dir}/seams.json as a JSON array of objects with fields: id, name, description, files (array of file paths), dependencies (array of seam ids), priority (high/medium/low)
+
+You MUST create both files. The migration cannot proceed without them.
+Write the analysis doc first, then the seams.json."
                 ;;
             guardrail)
-                echo -e "  ${DIM}Identifying existing tests...${NC}"
-                echo -e "  ${DIM}Creating rollback checkpoints...${NC}"
-                echo -e "  ${DIM}Setting up safety nets...${NC}"
+                echo -e "  ${DIM}Setting up safety nets and characterization tests...${NC}"
+                phase_prompt="You are performing the GUARDRAIL phase of a codebase migration.
+Target: ${target}
+Codebase: ${codebase_path}
+Migration dir: ${migration_dir}
+
+Read ${migration_dir}/docs/analysis.md and ${migration_dir}/seams.json for context.
+
+Tasks:
+1. Identify existing tests and create characterization tests that capture current behavior
+2. Write ${migration_dir}/features.json as a JSON array of objects with fields: id, name, description, test_command (shell command to verify), passes (boolean, set to true for existing passing behavior)
+3. Create a git checkpoint: cd ${codebase_path} && git stash || true
+
+All features in features.json must have passes: true for the gate to pass."
                 ;;
             migrate)
-                echo -e "  ${DIM}Executing migration transforms (${parallel} parallel agents)...${NC}"
-                echo -e "  ${DIM}Applying incremental changes...${NC}"
+                echo -e "  ${DIM}Executing migration transforms...${NC}"
+                phase_prompt="You are performing the MIGRATE phase of a codebase migration.
+Target: ${target}
+Codebase: ${codebase_path}
+Migration dir: ${migration_dir}
+
+Read ${migration_dir}/docs/analysis.md, ${migration_dir}/seams.json, and ${migration_dir}/features.json for context.
+
+Tasks:
+1. Create a migration plan and write it to ${migration_dir}/migration-plan.json with fields: target, source_path, steps (array of objects with: id, name, description, status set to 'completed' after you do the step)
+2. Execute the actual code migration transforms in ${codebase_path} -- convert code from the current framework/language to ${target}
+3. Update each step status to 'completed' as you finish it
+4. Work incrementally seam by seam from ${migration_dir}/seams.json
+
+All steps must have status: completed for the gate to pass."
                 ;;
             verify)
                 echo -e "  ${DIM}Running verification suite...${NC}"
-                echo -e "  ${DIM}Checking regression tests...${NC}"
-                echo -e "  ${DIM}Validating build output...${NC}"
+                phase_prompt="You are performing the VERIFY phase of a codebase migration.
+Target: ${target}
+Codebase: ${codebase_path}
+Migration dir: ${migration_dir}
+
+Tasks:
+1. Run syntax validation on all migrated files
+2. Run any test commands from ${migration_dir}/features.json to verify behavior is preserved
+3. Check for common migration issues (missing imports, broken references, etc.)
+4. Write a verification report to ${migration_dir}/docs/verification-report.md
+5. Summarize what was migrated, what works, and any remaining issues"
                 ;;
         esac
 
+        # Invoke Claude to execute the phase
+        local phase_exit=0
+        if [ -n "$phase_prompt" ]; then
+            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) | \
+                        while IFS= read -r line; do
+                            # Extract text from stream-json
+                            if echo "$line" | python3 -c "
+import sys, json
+try:
+    d = json.loads(sys.stdin.read())
+    if d.get('type') == 'assistant':
+        for item in d.get('message', {}).get('content', []):
+            if item.get('type') == 'text':
+                print(item.get('text', ''), end='')
+except Exception: pass
+" 2>/dev/null; then
+                                true
+                            fi
+                        done
+                    phase_exit=${PIPESTATUS[0]}
+                    ;;
+                codex)
+                    (cd "$codebase_path" && codex exec --full-auto "$phase_prompt" 2>&1) || phase_exit=$?
+                    ;;
+                gemini)
+                    (cd "$codebase_path" && gemini --approval-mode=yolo "$phase_prompt" 2>&1) || phase_exit=$?
+                    ;;
+            esac
+        fi
+
+        # Verify phase gate artifacts exist before advancing
+        local gate_ok=true
+        case "$p" in
+            understand)
+                if [ ! -f "${migration_dir}/docs/analysis.md" ] || [ ! -f "${migration_dir}/seams.json" ]; then
+                    echo -e "${RED}Error: Phase 'understand' did not produce required artifacts${NC}"
+                    echo -e "${DIM}  Expected: docs/analysis.md, seams.json${NC}"
+                    gate_ok=false
+                fi
+                ;;
+            guardrail)
+                if [ ! -f "${migration_dir}/features.json" ]; then
+                    echo -e "${RED}Error: Phase 'guardrail' did not produce required artifacts${NC}"
+                    echo -e "${DIM}  Expected: features.json${NC}"
+                    gate_ok=false
+                fi
+                ;;
+            migrate)
+                if [ ! -f "${migration_dir}/migration-plan.json" ]; then
+                    echo -e "${RED}Error: Phase 'migrate' did not produce required artifacts${NC}"
+                    echo -e "${DIM}  Expected: migration-plan.json${NC}"
+                    gate_ok=false
+                fi
+                ;;
+        esac
+
+        if [ "$gate_ok" != "true" ]; then
+            echo -e "${YELLOW}Phase '$p' artifacts missing. Migration halted.${NC}"
+            echo -e "${DIM}Re-run with: loki migrate <path> --target ${target} --phase ${p} --resume${NC}"
+            return 1
+        fi
+
         # Complete phase via engine
-        python3 -c "
+        PYTHONPATH="${SKILL_DIR:-.}" python3 -c "
 import sys
 sys.path.insert(0, '.')
 from dashboard.migration_engine import MigrationPipeline

package/autonomy/run.sh

@@ -5556,6 +5556,76 @@ stop_dashboard() {
     fi
 }
 
+# Handle dashboard crash: restart silently without triggering pause handler
+# This prevents a killed dashboard from being misinterpreted as a user interrupt
+handle_dashboard_crash() {
+    if [[ "${ENABLE_DASHBOARD:-true}" != "true" ]]; then
+        return 0
+    fi
+
+    local dashboard_pid_file=".loki/dashboard/dashboard.pid"
+    if [[ ! -f "$dashboard_pid_file" ]]; then
+        return 0
+    fi
+
+    local dpid
+    dpid=$(cat "$dashboard_pid_file" 2>/dev/null)
+    if [[ -z "$dpid" ]]; then
+        return 0
+    fi
+
+    # Dashboard is still alive, nothing to do
+    if kill -0 "$dpid" 2>/dev/null; then
+        return 0
+    fi
+
+    # Dashboard is dead -- restart it silently (with throttle)
+    DASHBOARD_RESTART_COUNT=${DASHBOARD_RESTART_COUNT:-0}
+    local max_restarts=${DASHBOARD_MAX_RESTARTS:-3}
+
+    if [ "$DASHBOARD_RESTART_COUNT" -ge "$max_restarts" ]; then
+        log_warn "Dashboard restart limit reached ($max_restarts) - disabling dashboard for this session"
+        ENABLE_DASHBOARD=false
+        return 1
+    fi
+
+    DASHBOARD_RESTART_COUNT=$((DASHBOARD_RESTART_COUNT + 1))
+    log_info "Dashboard process $dpid exited, restarting silently (attempt $DASHBOARD_RESTART_COUNT/$max_restarts)..."
+    emit_event_json "dashboard_crash" \
+        "pid=$dpid" \
+        "action=auto_restart" \
+        "attempt=$DASHBOARD_RESTART_COUNT" \
+        "autonomy_mode=$AUTONOMY_MODE"
+    DASHBOARD_PID=""
+    rm -f "$dashboard_pid_file"
+    start_dashboard
+    return 0
+}
+
+# Check if a signal was caused by a child process dying (e.g., dashboard)
+# rather than an actual user interrupt. Returns 0 if it was a child crash
+# (handled silently), 1 if it was a real interrupt.
+is_child_process_signal() {
+    # If dashboard PID is set and dashboard is now dead, this signal
+    # was likely caused by the dashboard process exiting
+    if [ -n "$DASHBOARD_PID" ] && ! kill -0 "$DASHBOARD_PID" 2>/dev/null; then
+        handle_dashboard_crash
+        return 0
+    fi
+
+    # Check PID file as fallback
+    if [ -f ".loki/dashboard/dashboard.pid" ]; then
+        local dpid
+        dpid=$(cat ".loki/dashboard/dashboard.pid" 2>/dev/null)
+        if [ -n "$dpid" ] && ! kill -0 "$dpid" 2>/dev/null; then
+            handle_dashboard_crash
+            return 0
+        fi
+    fi
+
+    return 1
+}
+
 #===============================================================================
 # Calculate Exponential Backoff
 #===============================================================================
@@ -7171,6 +7241,9 @@ if __name__ == "__main__":
         # Update session continuity file for next iteration / agent handoff
         update_continuity
 
+        # Checkpoint after each iteration (v5.57.0)
+        create_checkpoint "iteration-${ITERATION_COUNT} complete" "iteration-${ITERATION_COUNT}"
+
         # Code review gate (v5.35.0)
         if [ "$PHASE_CODE_REVIEW" = "true" ] && [ "$ITERATION_COUNT" -gt 0 ]; then
             run_code_review || log_warn "Code review found issues - check .loki/quality/reviews/"
@@ -7240,6 +7313,9 @@ if __name__ == "__main__":
         local goal_desc="${prd_path:-codebase-analysis}"
         store_episode_trace "$task_id" "failure" "iteration" "$goal_desc" "$duration"
 
+        # Checkpoint failed iteration state (v5.57.0)
+        create_checkpoint "iteration-${ITERATION_COUNT} failed (exit=$exit_code)" "iteration-${ITERATION_COUNT}-fail"
+
         # Handle retry - check for rate limit first
         local rate_limit_wait=$(detect_rate_limit "$log_file")
         local wait_time
@@ -7299,6 +7375,15 @@ check_human_intervention() {
     # handle_pause returns 1 if STOP was requested during the pause, so we must
     # propagate that as return 2 (stop) instead of always returning 1 (continue).
     if [ -f "$loki_dir/PAUSE" ]; then
+        # In perpetual mode: auto-clear PAUSE files and continue without waiting
+        if [ "$AUTONOMY_MODE" = "perpetual" ] || [ "$PERPETUAL_MODE" = "true" ]; then
+            log_warn "PAUSE file detected but autonomy mode is perpetual - auto-clearing"
+            notify_intervention_needed "PAUSE file auto-cleared in perpetual mode" 2>/dev/null || true
+            rm -f "$loki_dir/PAUSE" "$loki_dir/PAUSED.md"
+            # Restart dashboard if it crashed (likely cause of the PAUSE)
+            handle_dashboard_crash
+            return 0
+        fi
         log_warn "PAUSE file detected - pausing execution"
         notify_intervention_needed "Execution paused via PAUSE file"
         handle_pause
@@ -7311,6 +7396,26 @@ check_human_intervention() {
         return 1
     fi
 
+    # Check for PAUSE_AT_CHECKPOINT (checkpoint mode deferred pause)
+    if [ -f "$loki_dir/PAUSE_AT_CHECKPOINT" ]; then
+        if [ "$AUTONOMY_MODE" = "checkpoint" ]; then
+            log_warn "Checkpoint pause requested - pausing now"
+            rm -f "$loki_dir/PAUSE_AT_CHECKPOINT"
+            notify_intervention_needed "Execution paused at checkpoint"
+            touch "$loki_dir/PAUSE"
+            handle_pause
+            local pause_result=$?
+            rm -f "$loki_dir/PAUSE"
+            if [ "$pause_result" -eq 1 ]; then
+                return 2
+            fi
+            return 1
+        else
+            # Clean up stale checkpoint pause file
+            rm -f "$loki_dir/PAUSE_AT_CHECKPOINT"
+        fi
+    fi
+
     # Check for HUMAN_INPUT.md (prompt injection)
     # Security: Check it's a regular file (not symlink) to prevent symlink attacks
     if [ -f "$loki_dir/HUMAN_INPUT.md" ] && [ ! -L "$loki_dir/HUMAN_INPUT.md" ]; then
@@ -7516,7 +7621,46 @@ except (json.JSONDecodeError, OSError): pass
     # Re-enable signals for pause mode
     trap cleanup INT TERM
 
-    # First Ctrl+C - pause and show options
+    # Check if this signal was caused by a child process dying (e.g., dashboard)
+    # rather than an actual user interrupt. In that case, handle silently.
+    if is_child_process_signal; then
+        log_info "Child process exit detected, handled silently"
+        INTERRUPT_COUNT=0
+        return
+    fi
+
+    # In perpetual/autonomous mode: NEVER pause, NEVER wait for input
+    # Log the interrupt but continue the iteration loop immediately
+    if [ "$AUTONOMY_MODE" = "perpetual" ] || [ "$PERPETUAL_MODE" = "true" ]; then
+        INTERRUPT_COUNT=$((INTERRUPT_COUNT + 1))
+        INTERRUPT_LAST_TIME=$current_time
+        echo ""
+        log_warn "Interrupt received in perpetual mode - ignoring (not pausing)"
+        log_info "To stop: touch .loki/STOP or press Ctrl+C twice within 2 seconds"
+        echo ""
+        # Check and restart dashboard if it died
+        handle_dashboard_crash
+        # Do NOT reset INTERRUPT_COUNT -- let it accumulate so double-Ctrl+C escape works
+        return
+    fi
+
+    # In checkpoint mode: only pause at explicit checkpoint boundaries, not on
+    # random signals. A signal during normal execution is treated as noise.
+    if [ "$AUTONOMY_MODE" = "checkpoint" ]; then
+        INTERRUPT_COUNT=$((INTERRUPT_COUNT + 1))
+        INTERRUPT_LAST_TIME=$current_time
+        echo ""
+        log_warn "Interrupt received in checkpoint mode - will pause at next checkpoint"
+        log_info "To stop immediately: press Ctrl+C again within 2 seconds"
+        echo ""
+        # Mark that a pause was requested for the next checkpoint
+        touch "${TARGET_DIR:-.}/.loki/PAUSE_AT_CHECKPOINT"
+        handle_dashboard_crash
+        # Do NOT reset INTERRUPT_COUNT -- let it accumulate so double-Ctrl+C escape works
+        return
+    fi
+
+    # Supervised mode (or unrecognized): original behavior - pause and show options
     INTERRUPT_COUNT=$((INTERRUPT_COUNT + 1))
     INTERRUPT_LAST_TIME=$current_time
 
@@ -7937,6 +8081,10 @@ main() {
     # Compound learnings into structured solution files (v5.30.0)
     compound_session_to_solutions
 
+    # Log checkpoint count before final checkpoint (v5.57.0)
+    local cp_count=$(find .loki/state/checkpoints -maxdepth 1 -type d -name "cp-*" 2>/dev/null | wc -l | tr -d ' ')
+    log_info "Session checkpoints: ${cp_count}"
+
     # Create session-end checkpoint (v5.34.0)
     create_checkpoint "session end (iterations=$ITERATION_COUNT)" "session-end"
 

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "5.57.0"
+__version__ = "5.58.0"
 
 # Expose the control app for easy import
 try:

package/dashboard/migration_engine.py

@@ -307,12 +307,14 @@ class MigrationPipeline:
         return phase_data.get("status", "pending")
 
     def start_phase(self, phase: str) -> None:
-        """Start a phase (transition from pending to in_progress)."""
+        """Start a phase (transition from pending to in_progress). Idempotent if already in_progress."""
         if phase not in PHASE_ORDER:
             raise ValueError(f"Unknown phase: {phase}")
         with self._lock:
             manifest = self._load_manifest_unlocked()
             current_status = manifest.phases[phase]["status"]
+            if current_status == "in_progress":
+                return  # Already started, idempotent
             if current_status != "pending":
                 raise RuntimeError(
                     f"Cannot start phase '{phase}': status is '{current_status}', expected 'pending'"

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v5.57.0
+**Version:** v5.58.0
 
 ---
 

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '5.57.0'
+__version__ = '5.58.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "5.57.0",
+  "version": "5.58.0",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",