loki-mode 5.58.1 → 5.59.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.58.1
+# Loki Mode v5.59.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.58.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v5.59.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-5.58.1
+5.59.0

package/autonomy/loki

@@ -4839,6 +4839,8 @@ cmd_migrate_help() {
     echo "  --resume                         Resume from last checkpoint"
     echo "  --multi-repo <glob>              Multiple repository paths (glob pattern)"
     echo "  --export-report                  Export migration report to file"
+    echo "  --no-dashboard                   Disable web dashboard during migration"
+    echo "  --no-docs                        Skip migration_docs/ generation"
     echo "  --list                           List all migrations"
     echo "  --status [migration-id]          Show migration status"
     echo ""
@@ -4994,6 +4996,8 @@ cmd_migrate_start() {
     local resume="$8"
     local multi_repo="$9"
     local export_report="${10}"
+    local no_dashboard="${11:-false}"
+    local no_docs="${12:-false}"
 
     local migrations_dir="${HOME}/.loki/migrations"
     local migration_id=""
@@ -5118,9 +5122,18 @@ if manifests:
         echo ""
     fi
 
-    # Create migration via engine
-    local create_result
-    create_result=$(PYTHONPATH="${SKILL_DIR:-.}" python3 -c "
+    local migration_dir
+    if [ -n "$migration_id" ]; then
+        # Resume: load existing migration directory
+        migration_dir="${migrations_dir}/${migration_id}"
+        if [ ! -d "$migration_dir" ]; then
+            echo -e "${RED}Error: Migration directory not found: ${migration_dir}${NC}"
+            return 1
+        fi
+    else
+        # Create new migration via engine
+        local create_result
+        create_result=$(PYTHONPATH="${SKILL_DIR:-.}" python3 -c "
 import json, sys
 sys.path.insert(0, '.')
 from dashboard.migration_engine import MigrationPipeline
@@ -5128,13 +5141,13 @@ pipeline = MigrationPipeline(sys.argv[1], sys.argv[2])
 manifest = pipeline.create_manifest()
 print(json.dumps({'id': manifest.id, 'dir': str(pipeline.migration_dir)}))
 " "$codebase_path" "$target" 2>&1) || {
-        echo -e "${RED}Error: Failed to create migration${NC}"
-        echo "$create_result"
-        return 1
-    }
-    migration_id=$(echo "$create_result" | python3 -c "import json,sys; print(json.load(sys.stdin)['id'])")
-    local migration_dir
-    migration_dir=$(echo "$create_result" | python3 -c "import json,sys; print(json.load(sys.stdin)['dir'])")
+            echo -e "${RED}Error: Failed to create migration${NC}"
+            echo "$create_result"
+            return 1
+        }
+        migration_id=$(echo "$create_result" | python3 -c "import json,sys; print(json.load(sys.stdin)['id'])")
+        migration_dir=$(echo "$create_result" | python3 -c "import json,sys; print(json.load(sys.stdin)['dir'])")
+    fi
 
     # Security scan (first step of understand phase)
     echo -e "${BOLD}[Security] Scanning for secrets...${NC}"
@@ -5190,6 +5203,79 @@ print(json.dumps({'id': manifest.id, 'dir': str(pipeline.migration_dir)}))
     [ -n "$compliance" ] && echo -e "  Compliance:  ${compliance}"
     echo ""
 
+    # Dashboard cleanup trap for error paths
+    local migrate_dashboard_pid=""
+    _migrate_cleanup_dashboard() {
+        if [ -n "$migrate_dashboard_pid" ]; then
+            kill "$migrate_dashboard_pid" 2>/dev/null || true
+            wait "$migrate_dashboard_pid" 2>/dev/null || true
+            rm -f "${codebase_path}/.loki/dashboard/dashboard.pid" 2>/dev/null || true
+        fi
+    }
+    trap '_migrate_cleanup_dashboard' RETURN
+
+    # Start dashboard for migration monitoring (unless --no-dashboard)
+    if [ "$no_dashboard" != "true" ]; then
+        local dashboard_port="${LOKI_DASHBOARD_PORT:-57374}"
+        local skill_dir="${SKILL_DIR:-.}"
+        local dashboard_venv="$HOME/.loki/dashboard-venv"
+        local python_cmd="python3"
+        local url_scheme="http"
+
+        # Use venv python if available
+        if [ -x "${dashboard_venv}/bin/python3" ]; then
+            python_cmd="${dashboard_venv}/bin/python3"
+        fi
+
+        # Check if dashboard deps are available
+        if "$python_cmd" -c "import fastapi" 2>/dev/null; then
+            # Find available port (increment until a free port is found)
+            local port_attempts=0
+            while lsof -i :"$dashboard_port" &>/dev/null && [ $port_attempts -lt 10 ]; do
+                dashboard_port=$((dashboard_port + 1))
+                port_attempts=$((port_attempts + 1))
+            done
+
+            if [ $port_attempts -lt 10 ]; then
+                # Determine TLS
+                if [ -n "${LOKI_TLS_CERT:-}" ] && [ -n "${LOKI_TLS_KEY:-}" ]; then
+                    url_scheme="https"
+                fi
+
+                if ! mkdir -p "${codebase_path}/.loki/dashboard/logs" 2>/dev/null; then
+                    echo -e "  ${YELLOW}Dashboard skipped (cannot create log directory)${NC}"
+                else
+                    local log_file="${codebase_path}/.loki/dashboard/logs/dashboard.log"
+
+                    LOKI_DASHBOARD_PORT="$dashboard_port" \
+                    LOKI_DASHBOARD_HOST="127.0.0.1" \
+                    LOKI_PROJECT_PATH="$codebase_path" \
+                    LOKI_SKILL_DIR="$skill_dir" \
+                    LOKI_TLS_CERT="${LOKI_TLS_CERT:-}" \
+                    LOKI_TLS_KEY="${LOKI_TLS_KEY:-}" \
+                    PYTHONPATH="$skill_dir" \
+                        nohup "$python_cmd" -m dashboard.server > "$log_file" 2>&1 &
+                    migrate_dashboard_pid=$!
+
+                    echo "$migrate_dashboard_pid" > "${codebase_path}/.loki/dashboard/dashboard.pid"
+
+                    sleep 2
+                    if kill -0 "$migrate_dashboard_pid" 2>/dev/null; then
+                        echo -e "  Dashboard:   ${CYAN}${url_scheme}://127.0.0.1:${dashboard_port}/${NC}"
+                        if [[ "$OSTYPE" == "darwin"* ]]; then
+                            open "${url_scheme}://127.0.0.1:${dashboard_port}/" 2>/dev/null || true
+                        fi
+                        echo ""
+                    else
+                        echo -e "  ${YELLOW}Dashboard failed to start (check logs)${NC}"
+                        migrate_dashboard_pid=""
+                        echo ""
+                    fi
+                fi
+            fi
+        fi
+    fi
+
     # Determine which phases to run
     local phases_to_run=()
     if [ -n "$phase" ]; then
@@ -5238,7 +5324,7 @@ 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)
+4. 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 (string, e.g. 'seam-01'), name (string), description (string), type (string: 'module'/'api'/'config'/'adapter'), files (array of file paths), dependencies (array of seam ids), priority (string: 'high'/'medium'/'low')
 
 You MUST create both files. The migration cannot proceed without them.
 Write the analysis doc first, then the seams.json."
@@ -5254,7 +5340,7 @@ Read ${migration_dir}/docs/analysis.md and ${migration_dir}/seams.json for conte
 
 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)
+2. Write ${migration_dir}/features.json as a JSON array of objects with fields: id (string, e.g. 'F01'), category (string, e.g. 'core'), description (string), characterization_test (string, shell command to verify), passes (boolean, set to true for existing passing behavior), risk (string: 'low'/'medium'/'high')
 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."
@@ -5269,7 +5355,7 @@ 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)
+1. Create a migration plan and write it to ${migration_dir}/migration-plan.json as a JSON object with fields: version (integer, default 1), strategy (string: 'incremental' or 'big_bang'), steps (array of objects with: id (string), description (string), type (string: 'refactor'/'rewrite'/'config'/'test'), status (string, 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
@@ -5383,6 +5469,119 @@ pipeline.advance_phase(sys.argv[2])
         echo ""
     done
 
+    # Generate migration_docs/ in the codebase (unless --no-docs or --plan-only)
+    if [ "$plan_only" != "true" ] && [ "$no_docs" != "true" ]; then
+        echo -e "${CYAN}[Phase: document]${NC} Generating migration documentation..."
+
+        local doc_prompt="You are generating comprehensive migration documentation for a completed codebase migration.
+
+Target: ${target}
+Codebase: ${codebase_path}
+Migration dir: ${migration_dir}
+
+Read the following files for context:
+- ${migration_dir}/docs/analysis.md (original codebase analysis)
+- ${migration_dir}/docs/verification-report.md (verification results)
+- ${migration_dir}/features.json (feature tracking)
+- ${migration_dir}/seams.json (migration boundaries)
+- ${migration_dir}/migration-plan.json (migration steps)
+
+Create a directory called migration_docs/ in the codebase root (${codebase_path}/migration_docs/) with the following files:
+
+1. **README.md** - Executive summary of the migration:
+   - What the codebase was before (source language/framework/architecture)
+   - What it is now (target: ${target})
+   - High-level summary of changes made
+   - Link to other docs in migration_docs/
+
+2. **USAGE.md** - How to use the migrated codebase:
+   - Getting started / quick start
+   - Key commands and workflows
+   - Configuration options
+   - Environment variables
+
+3. **INSTALLATION.md** - Installation and setup:
+   - Prerequisites and dependencies
+   - Step-by-step installation
+   - Build instructions
+   - Development environment setup
+
+4. **TESTING.md** - Testing the migrated codebase:
+   - How to run tests
+   - Test coverage status
+   - Known test gaps
+   - How to add new tests
+
+5. **WHAT-CHANGED.md** - Detailed migration changelog:
+   - Files added, modified, and removed
+   - Architecture changes
+   - API changes (if any)
+   - Configuration changes
+   - Dependency changes
+
+6. **WHAT-WORKS.md** - Current status:
+   - Features confirmed working (from verification)
+   - Features that need manual testing
+   - Known limitations
+
+7. **WHAT-PENDING.md** - Remaining work:
+   - Items flagged during verification
+   - Manual steps required
+   - Recommended follow-up tasks
+   - Security items to address
+
+8. **DEPLOYMENT.md** - Deployment guide (if applicable):
+   - How to deploy the migrated application
+   - CI/CD considerations
+   - Infrastructure changes needed
+   - Rollback instructions
+
+IMPORTANT RULES:
+- Only document what is TRUE and VERIFIED - never fabricate features or capabilities
+- Reference actual files and test results from the migration artifacts
+- If something was not tested or verified, say so explicitly
+- Mark uncertain items with 'NEEDS VERIFICATION' tags
+- Do NOT use emojis anywhere in the documentation"
+
+        local doc_exit=0
+        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) | \
+                    while IFS= read -r line; do
+                        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
+                doc_exit=${PIPESTATUS[0]}
+                ;;
+            codex)
+                (cd "$codebase_path" && codex exec --full-auto "$doc_prompt" 2>&1) || doc_exit=$?
+                ;;
+            gemini)
+                (cd "$codebase_path" && gemini --approval-mode=yolo "$doc_prompt" 2>&1) || doc_exit=$?
+                ;;
+        esac
+
+        if [ "$doc_exit" -eq 0 ] && [ -d "${codebase_path}/migration_docs" ]; then
+            local doc_count
+            doc_count=$(find "${codebase_path}/migration_docs" -name "*.md" -type f 2>/dev/null | wc -l | tr -d ' ')
+            echo -e "${GREEN}  [Phase: document] Complete (${doc_count} docs generated)${NC}"
+        else
+            echo -e "${YELLOW}  [Phase: document] Warning: Documentation may be incomplete${NC}"
+        fi
+        echo ""
+    fi
+
     # Plan-only: generate plan file and stop
     if [ "$plan_only" = "true" ]; then
         echo -e "${BOLD}Migration plan generated.${NC}"
@@ -5471,6 +5670,8 @@ cmd_migrate() {
     local do_list="false"
     local do_status="false"
     local status_id=""
+    local no_dashboard="false"
+    local no_docs="false"
 
     if [ $# -eq 0 ]; then
         cmd_migrate_help
@@ -5575,6 +5776,14 @@ cmd_migrate() {
                 export_report="true"
                 shift
                 ;;
+            --no-dashboard)
+                no_dashboard="true"
+                shift
+                ;;
+            --no-docs)
+                no_docs="true"
+                shift
+                ;;
             -*)
                 echo -e "${RED}Unknown option: $1${NC}"
                 echo "Run 'loki migrate --help' for usage."
@@ -5618,7 +5827,7 @@ cmd_migrate() {
         return 1
     fi
 
-    cmd_migrate_start "$codebase_path" "$target" "$plan_only" "$phase" "$parallel" "$compliance" "$dry_run" "$do_resume" "$multi_repo" "$export_report"
+    cmd_migrate_start "$codebase_path" "$target" "$plan_only" "$phase" "$parallel" "$compliance" "$dry_run" "$do_resume" "$multi_repo" "$export_report" "$no_dashboard" "$no_docs"
 }
 
 # Main command dispatcher

package/dashboard/__init__.py

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

package/dashboard/migration_engine.py

@@ -14,7 +14,7 @@ import re
 import subprocess
 import tempfile
 import threading
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict, dataclass, field, fields
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Optional
@@ -38,8 +38,8 @@ class Feature:
     """Individual feature tracked during migration."""
 
     id: str
-    category: str
-    description: str
+    category: str = ""
+    description: str = ""
     verification_steps: list[str] = field(default_factory=list)
     passes: bool = False
     characterization_test: str = ""
@@ -52,8 +52,8 @@ class MigrationStep:
     """Single step in a migration plan."""
 
     id: str
-    description: str
-    type: str  # e.g. "refactor", "rewrite", "config", "test"
+    description: str = ""
+    type: str = ""  # e.g. "refactor", "rewrite", "config", "test"
     files: list[str] = field(default_factory=list)
     tests_required: list[str] = field(default_factory=list)
     estimated_tokens: int = 0
@@ -81,9 +81,14 @@ class SeamInfo:
     """Detected seam (boundary/interface) in the codebase."""
 
     id: str
-    type: str  # e.g. "api", "module", "database", "config"
-    location: str
-    description: str
+    description: str = ""
+    type: str = ""  # e.g. "api", "module", "database", "config"
+    location: str = ""
+    name: str = ""
+    priority: str = "medium"
+    files: list[str] = field(default_factory=list)
+    dependencies: list[str] = field(default_factory=list)
+    complexity: str = ""
     confidence: float = 0.0
     suggested_interface: str = ""
 
@@ -121,6 +126,10 @@ class MigrationManifest:
     feature_list_path: str = ""
     migration_plan_path: str = ""
     checkpoints: list[str] = field(default_factory=list)
+    status: str = "pending"
+    progress_pct: int = 0
+    updated_at: str = ""
+    source_path: str = ""
 
 
 # ---------------------------------------------------------------------------
@@ -144,7 +153,7 @@ def _atomic_write(path: Path, content: str) -> None:
             os.fsync(fd)
         finally:
             os.close(fd)
-        os.rename(tmp_path, str(path))
+        os.replace(tmp_path, str(path))
     except OSError as exc:
         logger.error("Failed to write %s: %s", path, exc)
         # Clean up temp file on failure
@@ -307,20 +316,23 @@ class MigrationPipeline:
         return phase_data.get("status", "pending")
 
     def start_phase(self, phase: str) -> None:
-        """Start a phase (transition from pending to in_progress). Idempotent if already in_progress."""
+        """Start a phase (transition to in_progress).
+
+        Idempotent if already in_progress. Also allows restarting completed or
+        failed phases (e.g., when using --resume --phase <phase>).
+        """
         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 phase not in manifest.phases:
+                manifest.phases[phase] = {"status": "pending", "started_at": "", "completed_at": ""}
+            current_status = manifest.phases[phase].get("status", "pending")
             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'"
-                )
             manifest.phases[phase]["status"] = "in_progress"
             manifest.phases[phase]["started_at"] = datetime.now(timezone.utc).isoformat()
+            manifest.phases[phase]["completed_at"] = ""
             self._save_manifest_unlocked(manifest)
 
     def _check_phase_gate_unlocked(self, from_phase: str, to_phase: str) -> tuple[bool, str]:
@@ -353,7 +365,12 @@ class MigrationPipeline:
             features_path = self.migration_dir / "features.json"
             try:
                 data = json.loads(features_path.read_text(encoding="utf-8"))
-                features = [Feature(**f) for f in data]
+                # Handle both flat list and {"features": [...]} wrapper
+                if isinstance(data, dict):
+                    data = data.get("features", [])
+                # Filter to known Feature fields to tolerate extra keys
+                _feature_fields = {f.name for f in fields(Feature)}
+                features = [Feature(**{k: v for k, v in f.items() if k in _feature_fields}) for f in data]
             except FileNotFoundError:
                 return False, "Phase gate failed: features.json not found"
             except (json.JSONDecodeError, TypeError) as exc:
@@ -372,9 +389,11 @@ class MigrationPipeline:
             try:
                 data = json.loads(plan_path.read_text(encoding="utf-8"))
                 steps_data = data.get("steps", [])
-                plan_data = {k: v for k, v in data.items() if k != "steps"}
+                _plan_fields = {f.name for f in fields(MigrationPlan)}
+                _step_fields = {f.name for f in fields(MigrationStep)}
+                plan_data = {k: v for k, v in data.items() if k in _plan_fields and k != "steps"}
                 plan = MigrationPlan(**plan_data)
-                plan.steps = [MigrationStep(**s) for s in steps_data]
+                plan.steps = [MigrationStep(**{k: v for k, v in s.items() if k in _step_fields}) for s in steps_data]
             except FileNotFoundError:
                 return False, "Phase gate failed: migration-plan.json not found"
             except (json.JSONDecodeError, TypeError) as exc:
@@ -390,55 +409,13 @@ class MigrationPipeline:
     def check_phase_gate(self, from_phase: str, to_phase: str) -> tuple[bool, str]:
         """Validate whether transition from from_phase to to_phase is allowed.
 
+        Thread-safe wrapper that delegates to _check_phase_gate_unlocked under lock.
+
         Returns:
             Tuple of (allowed, reason). If allowed is False, reason explains why.
         """
-        if from_phase not in PHASE_ORDER or to_phase not in PHASE_ORDER:
-            return False, f"Unknown phase: {from_phase} or {to_phase}"
-
-        from_idx = PHASE_ORDER.index(from_phase)
-        to_idx = PHASE_ORDER.index(to_phase)
-        if to_idx != from_idx + 1:
-            return False, f"Cannot jump from {from_phase} to {to_phase}"
-
-        # Gate: understand -> guardrail
-        if from_phase == "understand" and to_phase == "guardrail":
-            docs_dir = self.migration_dir / "docs"
-            has_docs = any(docs_dir.iterdir()) if docs_dir.exists() else False
-            if not has_docs:
-                return False, "Phase gate failed: no documentation generated in docs/"
-            seams_path = self.migration_dir / "seams.json"
-            if not seams_path.exists():
-                return False, "Phase gate failed: seams.json does not exist"
-            return True, "Gate passed: docs generated and seams.json exists"
-
-        # Gate: guardrail -> migrate
-        if from_phase == "guardrail" and to_phase == "migrate":
-            try:
-                features = self.load_features()
-            except FileNotFoundError:
-                return False, "Phase gate failed: features.json not found"
-            if not features:
-                return False, "No features defined"
-            failing = [f for f in features if not f.passes]
-            if failing:
-                ids = ", ".join(f.id for f in failing[:5])
-                return False, f"Phase gate failed: {len(failing)} characterization tests not passing ({ids})"
-            return True, "Gate passed: all characterization tests pass"
-
-        # Gate: migrate -> verify
-        if from_phase == "migrate" and to_phase == "verify":
-            try:
-                plan = self.load_plan()
-            except FileNotFoundError:
-                return False, "Phase gate failed: migration-plan.json not found"
-            incomplete = [s for s in plan.steps if s.status != "completed"]
-            if incomplete:
-                ids = ", ".join(s.id for s in incomplete[:5])
-                return False, f"Phase gate failed: {len(incomplete)} steps not completed ({ids})"
-            return True, "Gate passed: all migration steps completed"
-
-        return True, "Gate passed"
+        with self._lock:
+            return self._check_phase_gate_unlocked(from_phase, to_phase)
 
     def advance_phase(self, phase: str) -> PhaseResult:
         """Mark the current phase as complete and start the next one.
@@ -480,6 +457,8 @@ class MigrationPipeline:
 
             # Start next phase if there is one
             if next_phase is not None:
+                if next_phase not in manifest.phases:
+                    manifest.phases[next_phase] = {"status": "pending", "started_at": "", "completed_at": ""}
                 manifest.phases[next_phase]["status"] = "in_progress"
                 manifest.phases[next_phase]["started_at"] = now
 
@@ -501,7 +480,12 @@ class MigrationPipeline:
         with self._lock:
             try:
                 data = json.loads(features_path.read_text(encoding="utf-8"))
-                return [Feature(**f) for f in data]
+                # Handle both flat list and {"features": [...]} wrapper
+                if isinstance(data, dict):
+                    data = data.get("features", [])
+                # Filter to known Feature fields to tolerate extra keys
+                _feature_fields = {f.name for f in fields(Feature)}
+                return [Feature(**{k: v for k, v in f.items() if k in _feature_fields}) for f in data]
             except FileNotFoundError:
                 logger.warning("Features file not found: %s", features_path)
                 raise
@@ -528,9 +512,12 @@ class MigrationPipeline:
             try:
                 data = json.loads(plan_path.read_text(encoding="utf-8"))
                 # Reconstruct nested MigrationStep objects
-                steps_data = data.pop("steps", [])
-                plan = MigrationPlan(**data)
-                plan.steps = [MigrationStep(**s) for s in steps_data]
+                steps_data = data.get("steps", [])
+                _plan_fields = {f.name for f in fields(MigrationPlan)}
+                _step_fields = {f.name for f in fields(MigrationStep)}
+                plan_data = {k: v for k, v in data.items() if k in _plan_fields and k != "steps"}
+                plan = MigrationPlan(**plan_data)
+                plan.steps = [MigrationStep(**{k: v for k, v in s.items() if k in _step_fields}) for s in steps_data]
                 return plan
             except FileNotFoundError:
                 logger.warning("Plan file not found: %s", plan_path)
@@ -555,7 +542,11 @@ class MigrationPipeline:
         with self._lock:
             try:
                 data = json.loads(seams_path.read_text(encoding="utf-8"))
-                return [SeamInfo(**s) for s in data]
+                # Handle both flat list and {"seams": [...]} wrapper
+                if isinstance(data, dict):
+                    data = data.get("seams", [])
+                _seam_fields = {f.name for f in fields(SeamInfo)}
+                return [SeamInfo(**{k: v for k, v in s.items() if k in _seam_fields}) for s in data]
             except FileNotFoundError:
                 logger.warning("Seams file not found: %s", seams_path)
                 raise
@@ -681,7 +672,7 @@ class MigrationPipeline:
             if status == "completed":
                 current_phase = phase
                 completed_phases.append(phase)
-                overall_status = "completed"
+                overall_status = "in_progress"  # partial completion
 
         # Feature stats
         features_total = 0
@@ -730,19 +721,47 @@ class MigrationPipeline:
                 except (FileNotFoundError, json.JSONDecodeError):
                     last_checkpoint_data = {"tag": last_tag, "step_id": "", "timestamp": ""}
 
+        # Check if all phases are completed
+        if len(completed_phases) == len(PHASE_ORDER):
+            overall_status = "completed"
+
+        # Seam stats
+        seams_data: Optional[dict[str, Any]] = None
+        try:
+            seams = self.load_seams()
+            seams_high = sum(1 for s in seams if getattr(s, "priority", "medium") == "high")
+            seams_medium = sum(1 for s in seams if getattr(s, "priority", "medium") == "medium")
+            seams_low = sum(1 for s in seams if getattr(s, "priority", "medium") == "low")
+            seams_data = {"total": len(seams), "high": seams_high, "medium": seams_medium, "low": seams_low}
+        except (FileNotFoundError, json.JSONDecodeError, TypeError):
+            pass
+
+        # Flatten source/target to strings for UI consumption
+        source_path = ""
+        target_name = ""
+        if isinstance(manifest.source_info, dict):
+            source_path = manifest.source_info.get("path", "")
+        elif isinstance(manifest.source_info, str):
+            source_path = manifest.source_info
+        if isinstance(manifest.target_info, dict):
+            target_name = manifest.target_info.get("target", "")
+        elif isinstance(manifest.target_info, str):
+            target_name = manifest.target_info
+
         return {
             "migration_id": self.migration_id,
             "status": overall_status,
             "current_phase": current_phase,
             "phases": manifest.phases,
             "completed_phases": completed_phases,
-            "source": manifest.source_info,
-            "target": manifest.target_info,
+            "source": source_path,
+            "target": target_name,
             "current_step": current_step,
             "features": {"passing": features_passing, "total": features_total},
             "steps": {"current": current_step_index, "completed": steps_completed, "total": steps_total},
             "last_checkpoint": last_checkpoint_data,
             "checkpoints_count": len(manifest.checkpoints),
+            "seams": seams_data,
         }
 
     def generate_plan_summary(self) -> str:
@@ -869,21 +888,34 @@ def list_migrations() -> list[dict[str, Any]]:
             # Determine overall status from phases (clean string, no parenthesized phase)
             phases = data.get("phases", {})
             status = "pending"
+            all_completed = True
             for phase in PHASE_ORDER:
                 phase_status = phases.get(phase, {}).get("status", "pending")
+                if phase_status == "failed":
+                    status = "failed"
+                    all_completed = False
+                    break
                 if phase_status == "in_progress":
                     status = "in_progress"
+                    all_completed = False
                     break
                 if phase_status == "completed":
-                    status = "completed"
+                    status = "in_progress"  # partial completion
+                else:
+                    all_completed = False
+            if all_completed:
+                status = "completed"
 
             source_info = data.get("source_info", {})
+            source_path = source_info.get("path", "") if isinstance(source_info, dict) else str(source_info)
+            target_info = data.get("target_info", {})
+            target_name = target_info.get("target", "") if isinstance(target_info, dict) else str(target_info)
             results.append({
                 "id": data.get("id", entry.name),
                 "created_at": data.get("created_at", ""),
-                "source": source_info,
-                "source_path": source_info.get("path", ""),
-                "target": data.get("target_info", {}).get("target", ""),
+                "source": source_path,
+                "source_path": source_path,
+                "target": target_name,
                 "status": status,
             })
         except (json.JSONDecodeError, OSError) as exc:

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.58.1
+**Version:** v5.59.0
 
 ---
 

package/mcp/__init__.py

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

package/package.json

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