loki-mode 6.67.2 → 6.68.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.67.2
+# Loki Mode v6.68.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -268,4 +268,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.67.2 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.68.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.67.2
+6.68.0

package/autonomy/loki

@@ -398,6 +398,7 @@ show_help() {
     echo "  run <issue>      Issue-driven engineering (v6.0.0) - GitHub/GitLab/Jira/Azure DevOps"
     echo "  start [PRD]      Start Loki Mode (optionally with PRD file)"
     echo "  quick \"task\"     Quick single-task mode (lightweight, 3 iterations max)"
+    echo "  monitor [path]   Monitor Docker Compose services with auto-fix (v6.67.0)"
     echo "  demo             Run interactive demo (~60s simulated session)"
     echo "  init [name]      Project scaffolding with 22 PRD templates"
     echo "  issue <url|num>  [DEPRECATED] Use 'loki run' instead"
@@ -6987,11 +6988,12 @@ cmd_quick() {
 
     local task_desc="$*"
     local version=$(get_version)
+    local max_iter="${LOKI_MAX_ITERATIONS:-3}"
 
     echo -e "${BOLD}Loki Mode v$version - Quick Mode${NC}"
     echo ""
     echo -e "${CYAN}Task:${NC} $task_desc"
-    echo -e "${DIM}Running lightweight execution (3 iterations max, no quality council)${NC}"
+    echo -e "${DIM}Running lightweight execution ($max_iter iterations max, no quality council)${NC}"
     echo ""
 
     # Create quick PRD from task description
@@ -7028,7 +7030,7 @@ QPRDEOF
     echo ""
 
     # Set lightweight execution environment
-    export LOKI_MAX_ITERATIONS=3
+    export LOKI_MAX_ITERATIONS="$max_iter"
     export LOKI_COMPLEXITY=simple
     export LOKI_COUNCIL_ENABLED=false
     export LOKI_PHASE_CODE_REVIEW=false
@@ -7048,6 +7050,198 @@ QPRDEOF
     exec "$RUN_SH" "$quick_prd"
 }
 
+# Docker Compose monitoring with auto-fix (v6.67.0)
+cmd_monitor() {
+    local project_dir="${1:-.}"
+
+    # Resolve to absolute path
+    if [[ ! "$project_dir" = /* ]]; then
+        project_dir="$(cd "$project_dir" 2>/dev/null && pwd)" || {
+            echo -e "${RED}Error: directory not found: $1${NC}"
+            return 1
+        }
+    fi
+
+    if [[ ! -f "$project_dir/docker-compose.yml" ]] && [[ ! -f "$project_dir/docker-compose.yaml" ]]; then
+        echo -e "${RED}No docker-compose.yml found in $project_dir${NC}"
+        return 1
+    fi
+
+    echo -e "${CYAN}AI-Powered Docker Monitor${NC}"
+    echo -e "Project: ${BOLD}$project_dir${NC}"
+    echo -e "Provider: ${GREEN}${LOKI_PROVIDER:-claude}${NC}"
+    echo "Press Ctrl+C to stop."
+    echo ""
+
+    local fix_count=0
+    local max_fixes="${LOKI_MONITOR_MAX_FIXES:-10}"
+    local poll_interval="${LOKI_MONITOR_INTERVAL:-10}"
+    local consecutive_healthy=0
+
+    trap 'echo ""; echo -e "${CYAN}Monitor stopped.${NC}"; return 0' INT TERM
+
+    while true; do
+        # 1. CAPTURE: Get service status (all services including stopped)
+        local ps_output
+        ps_output=$(cd "$project_dir" && docker compose ps -a --format json 2>/dev/null)
+
+        if [[ -z "$ps_output" ]]; then
+            echo -e "${YELLOW}No services found. Waiting...${NC}"
+            sleep "$poll_interval"
+            continue
+        fi
+
+        # Parse services and find failures
+        local failed_services=""
+        local all_healthy=true
+        local service_summary=""
+
+        while IFS= read -r line; do
+            [[ -z "$line" ]] && continue
+            local svc_name svc_state svc_exit
+            svc_name=$(echo "$line" | python3 -c "import json,sys; d=json.loads(sys.stdin.read()); print(d.get('Service',d.get('Name','')))" 2>/dev/null || echo "unknown")
+            svc_state=$(echo "$line" | python3 -c "import json,sys; d=json.loads(sys.stdin.read()); print(d.get('State','unknown'))" 2>/dev/null || echo "unknown")
+            svc_exit=$(echo "$line" | python3 -c "import json,sys; d=json.loads(sys.stdin.read()); print(d.get('ExitCode',0))" 2>/dev/null || echo "0")
+
+            service_summary="${service_summary}${svc_name}=${svc_state} "
+
+            if [[ "$svc_state" == "exited" ]] || [[ "$svc_state" == "dead" ]]; then
+                all_healthy=false
+                failed_services="${failed_services} ${svc_name}"
+            fi
+        done <<< "$ps_output"
+
+        if [[ "$all_healthy" == "true" ]]; then
+            consecutive_healthy=$((consecutive_healthy + 1))
+            printf "\r${GREEN}[healthy]${NC} %s (%s)   " "$service_summary" "$(date +%H:%M:%S)"
+            sleep "$poll_interval"
+            continue
+        fi
+
+        consecutive_healthy=0
+
+        # 2. CAPTURE LOGS and CONTEXT for each failed service, then feed to AI
+        for svc_name in $failed_services; do
+            if [[ $fix_count -ge $max_fixes ]]; then
+                echo -e "\n${RED}Max fix attempts ($max_fixes) reached for this session.${NC}"
+                echo "Manual intervention needed. Check: cd $project_dir && docker compose logs $svc_name"
+                sleep "$poll_interval"
+                continue 2
+            fi
+
+            echo -e "\n${RED}[FAILURE] $svc_name is down${NC}"
+
+            local logs
+            logs=$(cd "$project_dir" && docker compose logs --tail 50 "$svc_name" 2>/dev/null | head -c 3000)
+
+            # Gather docker-compose.yml for AI context (truncated to avoid ARG_MAX)
+            local compose_content=""
+            if [[ -f "$project_dir/docker-compose.yml" ]]; then
+                compose_content=$(head -c 5000 "$project_dir/docker-compose.yml")
+            elif [[ -f "$project_dir/docker-compose.yaml" ]]; then
+                compose_content=$(head -c 5000 "$project_dir/docker-compose.yaml")
+            fi
+
+            # Gather Dockerfile for the failing service (truncated)
+            local dockerfile_content=""
+            for df_path in "$project_dir/$svc_name/Dockerfile" "$project_dir/Dockerfile" "$project_dir/Dockerfile.$svc_name"; do
+                if [[ -f "$df_path" ]]; then
+                    dockerfile_content=$(head -c 3000 "$df_path")
+                    break
+                fi
+            done
+
+            # 3. FEED TO AI: Construct a rich prompt with all context
+            local ai_prompt="You are debugging a Docker Compose service that has failed.
+
+SERVICE: $svc_name
+STATUS: exited/dead
+
+DOCKER COMPOSE LOGS (last 50 lines):
+$logs
+
+DOCKER-COMPOSE.YML:
+$compose_content"
+
+            if [[ -n "$dockerfile_content" ]]; then
+                ai_prompt="${ai_prompt}
+
+DOCKERFILE ($svc_name/Dockerfile):
+$dockerfile_content"
+            fi
+
+            ai_prompt="${ai_prompt}
+
+INSTRUCTIONS:
+1. Analyze the error in the logs above
+2. Identify the root cause
+3. Fix the issue by editing the necessary files (docker-compose.yml, Dockerfile, source code, package.json, requirements.txt, etc.)
+4. Make sure the fix works on any platform (Docker Desktop, Linux, Docker-in-Docker, Kubernetes)
+5. Do NOT just restart -- actually fix the underlying code/config problem
+6. After fixing, the system will rebuild with 'docker compose up --build'
+7. Common issues: named volumes for node_modules (use anonymous), missing dependencies, port conflicts, wrong commands"
+
+            echo -e "${CYAN}[AI] Analyzing $svc_name failure with ${LOKI_PROVIDER:-claude}...${NC}"
+
+            # 4. LET AI FIX: Run loki quick with the AI prompt
+            # The AI provider (claude/codex/gemini/ollama) decides what to fix
+            fix_count=$((fix_count + 1))
+            echo -e "${CYAN}[FIX] Attempt $fix_count/$max_fixes${NC}"
+
+            (
+                cd "$project_dir"
+                LOKI_MAX_ITERATIONS=5 LOKI_AUTO_FIX=true \
+                "$0" quick "$ai_prompt" 2>&1 | while IFS= read -r fline; do
+                    echo "  $fline"
+                done
+            )
+
+            # 5. REBUILD: Docker compose up --build for the fixed service
+            echo -e "${CYAN}[REBUILD] Rebuilding $svc_name...${NC}"
+            (cd "$project_dir" && docker compose up -d --build --no-deps "$svc_name" 2>&1) | while IFS= read -r fline; do
+                echo "  $fline"
+            done
+
+            # 6. VERIFY: Wait and check if the fix worked
+            echo -e "${CYAN}[VERIFY] Waiting 15s for $svc_name to stabilize...${NC}"
+            sleep 15
+
+            local verify_state
+            verify_state=$(cd "$project_dir" && docker compose ps -a --format json 2>/dev/null | VERIFY_SVC="$svc_name" python3 -c "
+import json, sys, os
+svc = os.environ['VERIFY_SVC']
+raw = sys.stdin.read().strip()
+if not raw:
+    print('unknown')
+    sys.exit(0)
+# Handle both JSON array (v2.21+) and NDJSON formats
+try:
+    parsed = json.loads(raw)
+    services = parsed if isinstance(parsed, list) else [parsed]
+except json.JSONDecodeError:
+    services = []
+    for line in raw.split(chr(10)):
+        try: services.append(json.loads(line))
+        except: pass
+for s in services:
+    if not isinstance(s, dict): continue
+    if s.get('Service', s.get('Name','')) == svc:
+        print(s.get('State','unknown'))
+        sys.exit(0)
+print('unknown')
+" 2>/dev/null || echo "unknown")
+
+            if [[ "$verify_state" == "running" ]]; then
+                echo -e "${GREEN}[SUCCESS] $svc_name is now running!${NC}"
+            else
+                echo -e "${YELLOW}[RETRY] $svc_name still not healthy (state: $verify_state). Will retry on next poll.${NC}"
+            fi
+        done
+
+        sleep "$poll_interval"
+    done
+}
+
 # Project scaffolding (v6.28.0)
 cmd_init() {
     # Guard: check if .loki/ already exists to avoid overwriting active session
@@ -10487,6 +10681,9 @@ main() {
         quick)
             cmd_quick "$@"
             ;;
+        monitor)
+            cmd_monitor "$@"
+            ;;
         demo)
             cmd_demo "$@"
             ;;

package/autonomy/run.sh

@@ -580,6 +580,11 @@ PHASE_UAT=${LOKI_PHASE_UAT:-true}
 COMPLETION_PROMISE=${LOKI_COMPLETION_PROMISE:-""}
 MAX_ITERATIONS=${LOKI_MAX_ITERATIONS:-1000}
 ITERATION_COUNT=0
+
+# If this is an auto-fix task, allow more iterations
+if [[ "${LOKI_AUTO_FIX:-}" == "true" ]]; then
+    MAX_ITERATIONS="${LOKI_MAX_ITERATIONS:-5}"
+fi
 # Perpetual mode: never stop unless max iterations (ignores all completion signals)
 PERPETUAL_MODE=${LOKI_PERPETUAL_MODE:-false}
 
@@ -625,6 +630,8 @@ if [ -f "$TELEMETRY_SCRIPT" ]; then
     source "$TELEMETRY_SCRIPT"
 fi
 
+
+
 # 2026 Research Enhancements (minimal additions)
 PROMPT_REPETITION=${LOKI_PROMPT_REPETITION:-true}
 CONFIDENCE_ROUTING=${LOKI_CONFIDENCE_ROUTING:-true}

package/completions/_loki

@@ -91,6 +91,9 @@ function _loki {
                 completions)
                     _arguments '1:shell:(bash zsh)'
                     ;;
+                monitor)
+                    _directories
+                    ;;
                 context|ctx)
                     _loki_context
                     ;;
@@ -107,6 +110,7 @@ function _loki_commands {
     commands=(
         'start:Start Loki Mode'
         'quick:Quick single-task mode'
+        'monitor:Monitor Docker Compose services with auto-fix'
         'demo:Interactive 60-second demo'
         'init:Interactive PRD builder'
         'stop:Stop execution'

package/completions/loki.bash

@@ -5,7 +5,7 @@ _loki_completion() {
     _init_completion || return
 
     # Main subcommands (must match autonomy/loki main case statement)
-    local main_commands="start quick demo init stop pause resume status dashboard logs serve api sandbox notify import github issue config provider reset memory compound checkpoint council dogfood projects enterprise secrets doctor watchdog audit metrics syslog onboard share explain plan report test ci watch telemetry agent context code run export review optimize heal migrate cluster worktree trigger failover remote version completions help"
+    local main_commands="start quick monitor demo init stop pause resume status dashboard logs serve api sandbox notify import github issue config provider reset memory compound checkpoint council dogfood projects enterprise secrets doctor watchdog audit metrics syslog onboard share explain plan report test ci watch telemetry agent context code run export review optimize heal migrate cluster worktree trigger failover remote version completions help"
 
     # 1. If we are on the first argument (subcommand)
     if [[ $cword -eq 1 ]]; then
@@ -178,6 +178,11 @@ _loki_completion() {
             fi
             ;;
 
+        monitor)
+            # Complete with directories
+            _filedir -d
+            ;;
+
         completions)
             COMPREPLY=( $(compgen -W "bash zsh" -- "$cur") )
             ;;

package/dashboard/__init__.py

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

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:** v6.67.2
+**Version:** v6.68.0
 
 ---
 

package/mcp/__init__.py

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

package/package.json

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

package/web-app/server.py

@@ -1454,9 +1454,10 @@ class DevServerManager:
             except Exception:
                 logger.debug("Docker context gathering for auto-fix failed", exc_info=True)
 
-        # Save original command and multi_service flag before stop() removes the info dict
+        # Save original command, framework, and multi_service flag before stop() removes the info dict
         cmd = info.get("original_command")
         is_multi_service = info.get("multi_service", False)
+        framework = info.get("framework")
 
         try:
             auto_fix_env = {**os.environ}
@@ -1475,6 +1476,14 @@ class DevServerManager:
             )
             if result.returncode == 0:
                 logger.info("Auto-fix succeeded for session %s, restarting dev server", session_id)
+                # For Docker projects, rebuild images before restarting
+                # (fix may have changed Dockerfile, package.json, requirements.txt, etc.)
+                if framework == "docker":
+                    await asyncio.to_thread(
+                        subprocess.run,
+                        ["docker", "compose", "up", "-d", "--build", "--no-deps"],
+                        capture_output=True, cwd=str(target), timeout=120
+                    )
                 # Restart the dev server
                 await self.stop(session_id)
                 await asyncio.sleep(1)
@@ -1723,7 +1732,17 @@ class DevServerManager:
                 was_running = prev.get("status") in ("running", None)
                 now_failed = svc["state"] in ("exited", "dead")
 
-                if was_running and now_failed:
+                # Detect services that need fixing:
+                # 1. was_running and now_failed: service transitioned from running to exited
+                # 2. Persistently failed: service is exited AND has never been successfully fixed
+                #    (fix_attempts == 0 or fix_status != "fixed")
+                persistently_failed = (
+                    now_failed
+                    and prev.get("fix_status") != "fixed"
+                    and prev.get("status") in ("exited", "dead", None)
+                )
+
+                if (was_running and now_failed) or persistently_failed:
                     svc_health["restarts"] = prev.get("restarts", 0) + 1
                     logger.warning("Docker service '%s' failed (exit %s)", name, svc.get("exit_code"))
 
@@ -1747,14 +1766,51 @@ class DevServerManager:
 
                         info["_auto_fixing"] = True
                         svc_logs = docker_ctx.get("service_logs", {}).get(name, "")
-                        diagnoses = _diagnose_errors(svc_logs)
-                        diag_text = "\n".join(f"- {d['diagnosis']}: {d['suggestion']}" for d in diagnoses)
 
-                        fix_prompt = f"The '{name}' Docker service crashed (exit code {svc.get('exit_code', 1)}).\n"
-                        if diag_text:
-                            fix_prompt += f"\nDiagnosis:\n{diag_text}\n"
-                        fix_prompt += f"\nService logs:\n{svc_logs[:2000]}\n"
-                        fix_prompt += "\nFix the issue and ensure the service starts correctly."
+                        # Read compose file for AI context
+                        compose_content = ""
+                        compose_file = project_dir / "docker-compose.yml"
+                        if not compose_file.exists():
+                            compose_file = project_dir / "docker-compose.yaml"
+                        if compose_file.exists():
+                            try:
+                                compose_content = compose_file.read_text(errors="replace")[:5000]
+                            except OSError:
+                                pass
+
+                        # Read service Dockerfile for AI context
+                        dockerfile_content = ""
+                        for df_path in [project_dir / name / "Dockerfile", project_dir / "Dockerfile"]:
+                            if df_path.exists():
+                                try:
+                                    dockerfile_content = df_path.read_text(errors="replace")[:3000]
+                                    break
+                                except OSError:
+                                    pass
+
+                        fix_prompt = f"""You are debugging a Docker Compose service that has failed.
+
+SERVICE: {name}
+STATUS: exited/dead (exit code {svc.get('exit_code', 1)})
+
+DOCKER COMPOSE LOGS (last 50 lines):
+{svc_logs[:3000]}
+
+DOCKER-COMPOSE.YML:
+{compose_content}
+"""
+                        if dockerfile_content:
+                            fix_prompt += f"\nDOCKERFILE ({name}/Dockerfile):\n{dockerfile_content}\n"
+
+                        fix_prompt += """
+INSTRUCTIONS:
+1. Analyze the error in the logs above
+2. Identify the root cause
+3. Fix the issue by editing the necessary files (docker-compose.yml, Dockerfile, source code, package.json, requirements.txt, etc.)
+4. Make sure the fix works on any platform (Docker Desktop, Linux, Docker-in-Docker, Kubernetes)
+5. Do NOT just restart -- actually fix the underlying code/config problem
+6. After fixing, the system will rebuild with 'docker compose up --build'
+7. Common issues: named volumes for node_modules (use anonymous), missing dependencies, port conflicts, wrong commands"""
 
                         svc_health["fix_attempts"] += 1
                         svc_health["fix_timestamps"] = recent_fixes + [now]
@@ -1794,24 +1850,70 @@ class DevServerManager:
             return
 
         try:
+            fix_env = {**os.environ, **_load_secrets()}
+            fix_env["LOKI_MAX_ITERATIONS"] = "5"  # More iterations for complex Docker fixes
+
             proc = await asyncio.to_thread(
                 subprocess.run,
                 [loki, "quick", fix_prompt],
                 capture_output=True, text=True, cwd=project_dir, timeout=300,
-                env={**os.environ, **_load_secrets()}
+                env=fix_env
             )
 
-            # After fix, restart the specific service
+            # Rebuild the image (fix may have changed Dockerfile or package.json)
+            # --no-deps prevents restarting healthy services, --build rebuilds with the fix
             await asyncio.to_thread(
                 subprocess.run,
-                ["docker", "compose", "restart", service_name],
-                capture_output=True, cwd=project_dir, timeout=30
+                ["docker", "compose", "up", "-d", "--build", "--no-deps", service_name],
+                capture_output=True, cwd=project_dir, timeout=120
             )
 
+            # Wait for service to stabilize after rebuild
+            await asyncio.sleep(10)
+
+            # Verify the fix actually worked
+            fix_worked = False
+            try:
+                verify_proc = await asyncio.to_thread(
+                    subprocess.run,
+                    ["docker", "compose", "ps", "-a", "--format", "json"],
+                    capture_output=True, text=True, cwd=project_dir, timeout=10
+                )
+                if verify_proc.returncode == 0 and verify_proc.stdout.strip():
+                    raw = verify_proc.stdout.strip()
+                    try:
+                        parsed = json.loads(raw)
+                        if not isinstance(parsed, list):
+                            parsed = [parsed]
+                    except json.JSONDecodeError:
+                        parsed = []
+                        for line in raw.split("\n"):
+                            if line.strip():
+                                try:
+                                    parsed.append(json.loads(line))
+                                except json.JSONDecodeError:
+                                    pass
+                    for svc in parsed:
+                        if isinstance(svc, dict) and svc.get("Name", svc.get("name", "")) == service_name:
+                            state = svc.get("State", svc.get("state", ""))
+                            fix_worked = state == "running"
+                            break
+            except Exception:
+                logger.debug("Post-fix verification failed for service '%s'", service_name, exc_info=True)
+
+            # Determine final fix status
+            if proc.returncode == 0 and fix_worked:
+                final_status = "fixed"
+            elif proc.returncode == 0 and not fix_worked:
+                final_status = "fix_failed"
+                logger.warning("loki quick succeeded but service '%s' still not running", service_name)
+            else:
+                final_status = "fix_failed"
+
             # BUG-V64-005: Re-fetch from live info dict to avoid writing to detached dict
             info = self.servers.get(session_id)
             if info and "docker_service_health" in info and service_name in info["docker_service_health"]:
-                info["docker_service_health"][service_name]["fix_status"] = "fixed" if proc.returncode == 0 else "fix_failed"
+                info["docker_service_health"][service_name]["fix_status"] = final_status
         except Exception as exc:
             logger.error("Auto-fix for service '%s' failed: %s", service_name, exc)
             # BUG-V64-005: Re-fetch from live info dict
@@ -1856,7 +1958,7 @@ async def _gather_docker_context(project_dir: Path) -> dict:
     # Get service status via docker compose ps
     try:
         ps_proc = await loop.run_in_executor(None, lambda: subprocess.run(
-            ["docker", "compose", "ps", "--format", "json"],
+            ["docker", "compose", "ps", "-a", "--format", "json"],
             capture_output=True, text=True, cwd=str(project_dir), timeout=10
         ))
         if ps_proc.returncode == 0 and ps_proc.stdout.strip():