loki-mode 11.4.2 → 11.6.0

package/dashboard/control.py

@@ -1,62 +1,23 @@
 """
-Loki Mode Session Control API
+Loki Mode session-control helpers
 
-FastAPI-based session control endpoints for the Loki Mode dashboard.
-Provides start/stop/pause/resume functionality and real-time status updates.
-
-Usage:
-    uvicorn dashboard.control:app --host 0.0.0.0 --port 57374
-    # Or run with the CLI:
-    loki dashboard start
+Shared helpers for the dashboard: session status, atomic JSON writes, skill-dir
+discovery and the browser-mutation Origin check. The HTTP control routes live
+in dashboard/server.py (the only dashboard app).
 """
 
-import asyncio
 import fcntl
 import json
 import os
-import signal
-import subprocess
 import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 from urllib.parse import urlsplit
 
-from fastapi import Depends, FastAPI, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi import Request
 from pydantic import BaseModel
 
-# Auth gating for the standalone control app.
-#
-# This module also defines a self-contained FastAPI `app` whose own docstring
-# invites operators to expose it via `uvicorn dashboard.control:app`. When that
-# happens the state-mutating endpoints (start/stop/pause/resume) MUST honor the
-# same scope checks as the primary dashboard (dashboard/server.py), otherwise a
-# user who follows the docstring stands up an unauthenticated control plane that
-# can launch arbitrary builds and kill running sessions even when
-# LOKI_ENTERPRISE_AUTH / OIDC are configured.
-#
-# auth.require_scope is a no-op (allows access) when no auth method is enabled,
-# so this import is safe for the default anonymous-localhost workflow and only
-# enforces when the operator has explicitly turned auth on. The import is
-# defensive: if the package context is unavailable (e.g. the file is run from a
-# path where the relative import fails) we fall back to a gate that always
-# allows, preserving the prior behavior rather than crashing import.
-try:
-    from . import auth as _auth
-
-    def _require_control_scope():
-        return Depends(_auth.require_scope("control"))
-except Exception:  # pragma: no cover - defensive fallback for non-package runs
-    def _require_control_scope():
-        async def _noop() -> bool:
-            return True
-
-        return Depends(_noop)
-
-_CONTROL_DEP = _require_control_scope()
-
 
 def _normalized_http_origin(value: str) -> tuple[str, str, int] | None:
     """Return a comparable browser origin, or ``None`` when malformed.
@@ -250,104 +211,6 @@ def atomic_write_json(file_path: Path, data: dict, use_lock: bool = True):
     except Exception as e:
         raise RuntimeError(f"Failed to write {file_path}: {e}")
 
-# FastAPI app
-app = FastAPI(
-    title="Loki Mode Control API",
-    description="Session control endpoints for Loki Mode dashboard",
-    version="1.0.0"
-)
-
-# CORS middleware for dashboard frontend - restricted to localhost by default.
-# Set LOKI_DASHBOARD_CORS to override (comma-separated origins).
-_cors_default = "http://localhost:57374,http://127.0.0.1:57374"
-_cors_raw = os.environ.get("LOKI_DASHBOARD_CORS", _cors_default)
-_cors_origins = [o.strip() for o in _cors_raw.split(",") if o.strip()]
-if "*" in _cors_origins or _cors_raw.strip() == "*":
-    if os.environ.get("LOKI_ENV") == "production":
-        raise RuntimeError(
-            "Wildcard CORS ('*') is not allowed in production. "
-            "Set LOKI_DASHBOARD_CORS to a specific origin list, "
-            "or set LOKI_ENV != production."
-        )
-    import logging
-
-    logging.getLogger(__name__).warning(
-        "LOKI_DASHBOARD_CORS is set to '*' -- all origins are allowed. "
-        "This is insecure for production deployments."
-    )
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=_cors_origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@app.middleware("http")
-async def browser_mutation_boundary(request: Request, call_next):
-    """Refuse cross-origin browser mutations before control side effects."""
-    if request.method in ("POST", "PUT", "PATCH", "DELETE"):
-        if not browser_mutation_origin_allowed(request, _cors_origins):
-            return JSONResponse(
-                status_code=403,
-                content={"detail": "cross-origin mutation refused"},
-            )
-    return await call_next(request)
-
-
-# Request/Response models
-class StartRequest(BaseModel):
-    """Request body for starting a Loki Mode session."""
-    prd: Optional[str] = None
-    provider: str = "claude"
-    parallel: bool = False
-    background: bool = True
-
-    def validate_provider(self) -> None:
-        """Validate provider is from allowed list."""
-        allowed_providers = ["claude", "codex", "gemini", "cline", "aider"]
-        if self.provider not in allowed_providers:
-            raise ValueError(f"Invalid provider: {self.provider}. Must be one of: {', '.join(allowed_providers)}")
-
-    def validate_prd_path(self) -> None:
-        """Validate PRD path is safe and exists."""
-        if not self.prd:
-            return
-
-        # Check for path traversal sequences
-        if ".." in self.prd:
-            raise ValueError("PRD path contains path traversal sequence (..)")
-
-        # Resolve to absolute path and verify it exists
-        prd_path = Path(self.prd).resolve()
-        if not prd_path.exists():
-            raise ValueError(f"PRD file does not exist: {self.prd}")
-
-        # Verify it's a file, not a directory
-        if not prd_path.is_file():
-            raise ValueError(f"PRD path is not a file: {self.prd}")
-
-        # Verify path resolves within CWD or a reasonable parent.
-        # FAIL CLOSED if the cwd is gone: this is a path-confinement check, so
-        # an unresolvable base must reject the path, never skip the comparison.
-        try:
-            cwd = Path.cwd().resolve()
-        except OSError as exc:
-            raise ValueError(
-                "cannot validate PRD path: the working directory no longer "
-                "exists (%s)" % exc
-            ) from exc
-        try:
-            prd_path.relative_to(cwd)
-        except ValueError:
-            # Not within CWD - check if it's within user's home or project directory
-            home = Path.home().resolve()
-            try:
-                prd_path.relative_to(home)
-            except ValueError:
-                raise ValueError(f"PRD path is outside allowed directories: {self.prd}")
-
 
 class StatusResponse(BaseModel):
     """Current session status."""
@@ -365,13 +228,6 @@ class StatusResponse(BaseModel):
     timestamp: str
 
 
-class ControlResponse(BaseModel):
-    """Generic control operation response."""
-    success: bool
-    message: str
-    pid: Optional[int] = None
-
-
 # Utility functions
 def read_file_safe(filepath: Path) -> str:
     """Read file contents safely, returning empty string on error."""
@@ -520,289 +376,3 @@ def get_status() -> StatusResponse:
         complexity=complexity,
         timestamp=datetime.now(timezone.utc).isoformat()
     )
-
-
-# API Endpoints
-@app.get("/api/control/health")
-async def health_check():
-    """Health check endpoint."""
-    return {"status": "ok", "version": get_version()}
-
-
-@app.get("/api/control/status", response_model=StatusResponse)
-async def get_session_status():
-    """Get current session status."""
-    return get_status()
-
-
-@app.post("/api/control/start", response_model=ControlResponse, dependencies=[_CONTROL_DEP])
-async def start_session(request: StartRequest):
-    """
-    Start a Loki Mode session.
-
-    Args:
-        request: Start request with PRD path, provider, and options
-
-    Returns:
-        ControlResponse with success status and PID
-    """
-    # Validate input
-    try:
-        request.validate_provider()
-        request.validate_prd_path()
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-    # Check if already running
-    status = get_status()
-    if status.state == "running":
-        raise HTTPException(
-            status_code=409,
-            detail=f"Session already running with PID {status.pid}"
-        )
-
-    # Verify run.sh exists
-    if not RUN_SH.exists():
-        raise HTTPException(
-            status_code=500,
-            detail=f"run.sh not found at {RUN_SH}"
-        )
-
-    # Build command arguments
-    args = [str(RUN_SH), "--provider", request.provider]
-    if request.parallel:
-        args.append("--parallel")
-    if request.background:
-        args.append("--bg")
-    if request.prd:
-        args.append(request.prd)
-
-    try:
-        # Start the process
-        # RUN_SH is a trusted fixed path; provider and PRD were validated above,
-        # and argv is passed directly without a command shell.
-        process = subprocess.Popen(
-            args,  # lgtm[py/command-line-injection]
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            start_new_session=True,
-            # A deleted cwd would make Popen itself raise; fall back to the
-            # skill tree rather than failing to launch the run at all.
-            cwd=str(_cwd_or_skill_dir()),
-            shell=False,
-        )
-
-        # Save provider for status tracking
-        (STATE_DIR / "provider").write_text(request.provider)
-
-        # Emit start event
-        emit_event("session_start", {
-            "pid": process.pid,
-            "provider": request.provider,
-            "prd": request.prd,
-            "parallel": request.parallel
-        })
-
-        return ControlResponse(
-            success=True,
-            message=f"Session started with provider {request.provider}",
-            pid=process.pid
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/api/control/stop", response_model=ControlResponse, dependencies=[_CONTROL_DEP])
-async def stop_session():
-    """
-    Stop the current Loki Mode session.
-
-    Creates a STOP file to signal graceful shutdown and attempts
-    to terminate the process directly.
-    """
-    stop_file = LOKI_DIR / "STOP"
-    pid_file = LOKI_DIR / "loki.pid"
-
-    # Create STOP file for graceful shutdown
-    stop_file.parent.mkdir(parents=True, exist_ok=True)
-    stop_file.write_text(datetime.now(timezone.utc).isoformat())
-
-    # Also try to terminate process directly
-    pid_str = read_file_safe(pid_file)
-    pid = None
-    if pid_str.isdigit():
-        pid = int(pid_str)
-        if is_process_running(pid):
-            try:
-                os.kill(pid, signal.SIGTERM)
-            except (OSError, ProcessLookupError):
-                pass
-
-    # Mark session.json as stopped (skill-invoked sessions)
-    session_file = LOKI_DIR / "session.json"
-    if session_file.exists():
-        try:
-            # Read current session data
-            session_data = json.loads(session_file.read_text())
-            session_data["status"] = "stopped"
-
-            # Atomic write with file locking to prevent race conditions
-            atomic_write_json(session_file, session_data, use_lock=True)
-        except (json.JSONDecodeError, OSError, KeyError, RuntimeError):
-            pass
-
-    # Emit stop event
-    emit_event("session_stop", {"pid": pid, "reason": "user_request"})
-
-    return ControlResponse(
-        success=True,
-        message="Stop signal sent",
-        pid=pid
-    )
-
-
-@app.post("/api/control/pause", response_model=ControlResponse, dependencies=[_CONTROL_DEP])
-async def pause_session():
-    """
-    Pause the current Loki Mode session.
-
-    Creates a PAUSE file that signals the runner to pause
-    after completing the current task.
-    """
-    pause_file = LOKI_DIR / "PAUSE"
-
-    # Create PAUSE file
-    pause_file.parent.mkdir(parents=True, exist_ok=True)
-    pause_file.write_text(datetime.now(timezone.utc).isoformat())
-
-    # Get current PID for response
-    pid_file = LOKI_DIR / "loki.pid"
-    pid_str = read_file_safe(pid_file)
-    pid = int(pid_str) if pid_str.isdigit() else None
-
-    # Emit pause event
-    emit_event("session_pause", {"pid": pid})
-
-    return ControlResponse(
-        success=True,
-        message="Pause signal sent - session will pause after current task",
-        pid=pid
-    )
-
-
-@app.post("/api/control/resume", response_model=ControlResponse, dependencies=[_CONTROL_DEP])
-async def resume_session():
-    """
-    Resume a paused Loki Mode session.
-
-    Removes the PAUSE and STOP files to allow the session to continue.
-    """
-    pause_file = LOKI_DIR / "PAUSE"
-    stop_file = LOKI_DIR / "STOP"
-
-    # Remove control files
-    try:
-        pause_file.unlink(missing_ok=True)
-    except Exception:
-        pass
-
-    try:
-        stop_file.unlink(missing_ok=True)
-    except Exception:
-        pass
-
-    # Get current PID for response
-    pid_file = LOKI_DIR / "loki.pid"
-    pid_str = read_file_safe(pid_file)
-    pid = int(pid_str) if pid_str.isdigit() else None
-
-    # Emit resume event
-    emit_event("session_resume", {"pid": pid})
-
-    return ControlResponse(
-        success=True,
-        message="Session resumed",
-        pid=pid
-    )
-
-
-@app.get("/api/control/events")
-async def stream_events():
-    """
-    Stream events as Server-Sent Events (SSE).
-
-    Provides real-time updates to the dashboard frontend.
-    """
-    async def event_generator():
-        # Send initial status
-        status = get_status()
-        yield f"data: {json.dumps(status.model_dump())}\n\n"
-
-        # Track file position for incremental reads
-        last_position = 0
-        if EVENTS_FILE.exists():
-            last_position = EVENTS_FILE.stat().st_size
-
-        # Stream updates
-        while True:
-            # Send status update every 2 seconds
-            status = get_status()
-            yield f"event: status\ndata: {json.dumps(status.model_dump())}\n\n"
-
-            # Check for new events
-            if EVENTS_FILE.exists():
-                current_size = EVENTS_FILE.stat().st_size
-                if current_size > last_position:
-                    with open(EVENTS_FILE, "r") as f:
-                        f.seek(last_position)
-                        for line in f:
-                            line = line.strip()
-                            if line:
-                                yield f"event: log\ndata: {line}\n\n"
-                    last_position = current_size
-
-            await asyncio_sleep(2)
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive"
-        }
-    )
-
-
-@app.get("/api/control/logs")
-async def get_logs(lines: int = 50):
-    """
-    Get recent log lines from the session log.
-
-    Args:
-        lines: Number of lines to return (default 50, max 10000)
-    """
-    lines = min(max(lines, 1), 10000)
-    log_file = LOG_DIR / "session.log"
-
-    if not log_file.exists():
-        return {"logs": [], "total": 0}
-
-    content = log_file.read_text()
-    all_lines = [line for line in content.split("\n") if line.strip()]
-    recent_lines = all_lines[-lines:]
-
-    return {"logs": recent_lines, "total": len(all_lines)}
-
-
-# Helper for async sleep
-async def asyncio_sleep(seconds: float):
-    """Async sleep helper."""
-    await asyncio.sleep(seconds)
-
-
-# Run with uvicorn if executed directly
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("LOKI_DASHBOARD_PORT", "57374"))
-    host = os.environ.get("LOKI_DASHBOARD_HOST", "127.0.0.1")
-    uvicorn.run(app, host=host, port=port)

package/docs/ARCHITECTURE.md

@@ -215,8 +215,7 @@ memory/                    Memory system (Python package, ~19 modules)
 
 mcp/                       Model Context Protocol server
   server.py                MCP server (tools + resources + prompts)
-  tools.py / magic_tools.py / managed_tools.py  Tool registries
-  resources.py             MCP resources
+  magic_tools.py / managed_tools.py  Tool registries
   lsp_proxy.py             LSP proxy (references, definitions, symbols)
 
 dashboard/                 FastAPI control-plane backend

package/docs/CLI-CORE-VERBS.md

@@ -98,12 +98,8 @@ The process exit code equals `exit_code`.
 | 3 | Missing component, or verifier error |
 | 64 | Usage error for `verify`, `quick` and `start` (unknown option, missing task) |
 
-Severity rises with the code. `loki verify` exits 0 VERIFIED, 1 CONCERNS, 2
-BLOCKED or not a git directory, 3 verifier error or empty diff, 64 usage error.
-Gate CI with `loki verify || fail` and treat any code of 2 or higher as worse
-than CONCERNS. From 11.4.0 this is a breaking change for scripts that tested
-`rc == 1` on an empty diff or a non-git directory. Per-command detail:
-`docs/exit-codes.md`.
+Severity rises with the code. `loki verify` codes and the CI-gate guidance are
+in `docs/exit-codes.md`.
 
 ## Unknown commands
 

package/docs/CLI-REFERENCE.md

@@ -1,6 +1,6 @@
 # CLI reference
 
-Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.4.2. Do not edit by hand.
+Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.6.0. Do not edit by hand.
 Hidden and legacy-only commands are omitted; see `docs/v10/CLI-MODERN.md` for the full inventory.
 
 | Command | Description |
@@ -12,6 +12,8 @@ Hidden and legacy-only commands are omitted; see `docs/v10/CLI-MODERN.md` for th
 | `loki provider show` | Show current provider |
 | `loki provider list` | List providers and install status |
 | `loki provider set` | Switch the active provider |
+| `loki provider info` | Provider details; --json prints the capability contract |
+| `loki provider matrix` | Capability matrix per provider and engine |
 | `loki memory` | Cross-project learnings |
 | `loki memory list` | All learnings |
 | `loki memory index` | Show or rebuild the memory index |

package/docs/COMPONENTS.md

@@ -249,13 +249,11 @@ search) to MCP clients.
 **Key files:**
 - `server.py` - MCP server (47 tools: 31 in-file + magic + gated managed + 8 cp; plus
   3 resources, 2 prompts).
-- `tools.py` - Core tool implementations.
 - `magic_tools.py` - Magic Modules tools.
 - `cp_tools.py` - Read-only Control Plane data tools (`cp_*`, GET only; the CP URL
   and token come from the MCP child env and are never returned).
 - `managed_tools.py` - Managed-memory tool (`loki_memory_redact`, gated on
   `LOKI_MANAGED_AGENTS=true` and `LOKI_MANAGED_MEMORY=true`).
-- `resources.py` - MCP resources.
 - `lsp_proxy.py` - LSP proxy (find references, go to definition, symbol lookup).
 - `learning_collector.py` - Learning signal collection.
 - `_sdk_loader.py` - Bootstraps the Python MCP SDK on first run.

package/docs/EVALUATING.md

@@ -184,6 +184,33 @@ per-call cost was not recorded.
 
 ---
 
+## 8. Harness attribution: what Loki adds to the same model
+
+Question: what does Loki add to the same underlying coding agent, and is the benefit worth its cost? Status: pilot. Six tasks, small n. A pilot reports variance; it is not proof of superiority. Running it is a separate, paid step.
+
+```bash
+loki bench attribution --dry-run                       # validate task set, print plan, no model call
+loki bench attribution --model <model-id> --execute    # run, spends API budget
+loki bench attribution --report <result.json>          # re-render the markdown report
+```
+
+Source checkout only. Implementation: `benchmarks/bench/attribution.py`, reusing `runner._apply_overlay`, `report._median` and `benchmarks/bench/adapters` (process-tree reaping, the Claude JSON parser, the Loki adapter and its cost collection). Options: `--tasks id,id`, `--repeats N` (default 1), `--model ID` (default `claude-sonnet-5`, or `LOKI_BENCH_MODEL`), `--budget-usd X` (default 5), `--timeout SECONDS` (default 900, capped by each task's `agent_timeout_s`), `--out-dir DIR`, `--tasks-dir DIR`. Without `--execute` it only prints the plan and never spawns `claude` or `loki`.
+
+Arms and controls: `raw_claude` runs `claude -p <prompt> --output-format json --model M --dangerously-skip-permissions --max-budget-usd B`; `loki` runs `loki start <prompt-file> --provider claude --no-dashboard --yes` with `LOKI_SESSION_MODEL=M` and `LOKI_BUDGET_LIMIT=B`. Both get a byte-identical seed in a fresh git repo with one fixed "seed" commit, the same prompt text (the PRD file for Loki is kept outside the workspace), the same wall-clock cap with the process tree reaped on timeout, separate scratch directories, a scoped child environment and `LOKI_NO_BROWSER=1`. The arm that goes first alternates per task and repeat. Every result JSON pins `claude --version`, `loki version`, the Loki commit SHA, Python version, model, budget, timeout, repeats, and per task the sha256 of the seed tree, acceptance tree and prompt. Disclosed difference: Loki runs its own planning, review and verification loop; that overhead is what is measured. Provider comparisons are out of scope so model and harness effects are not mixed.
+
+Tasks live under `benchmarks/attribution/tasks/<id>/` (2 bug fixes, 2 features, 1 refactor, 1 integration): `task.json`, `prompt.md` (the only instruction either arm sees), `seed/` (workspace), `acceptance/` (hidden test, copied in only after the run, overwriting same-named files) and `reference/` (known-good overlay, used only by tests). Exit code 0 from `acceptance.cmd` means accepted. The loader rejects a task whose acceptance test also appears in the seed. Neither arm grades itself: no council, RARV-C or LLM judge takes part in scoring.
+
+Metrics, per arm and per task class, computed by `compute_metrics`; failures, timeouts and harness errors stay in every denominator:
+
+- Acceptance rate: accepted / assigned, with a 95% Wilson interval.
+- False-completion rate: (reported success and not accepted) / reported success; null when nothing reported success. Reported success means `claude -p` exits 0 with `is_error` false, or `loki start` exits 0.
+- Cost per accepted task: total measured spend across all attempts / accepted. Null (`undefined_no_accepted`) when none accepted. A run with no cost figure is `unmeasured`, never zero: some unmeasured gives `partial_lower_bound` (per-accepted null, lower bound only), all unmeasured gives `unmeasured`. Cost is API-dollar accounting; subscription use is not converted.
+- Elapsed time: median over accepted runs, with completion rate, timeout count and error count; median over all runs is also given.
+
+Not measured: human effort, recovery success, review quality. Output: `--out-dir` (default `benchmarks/attribution/results/`) receives `attribution-<UTC stamp>.json` and the matching `.md`. Publish failures, timeouts and exclusions with the report; do not drop rows. Do not claim superiority from overlapping intervals on a handful of runs; use the pilot to size a larger run with `--repeats` above 1. Tests: `python3 benchmarks/bench/tests/test_attribution.py` (no model call).
+
+---
+
 ## What we do not have
 
 Stating this plainly, because you will find it out anyway and it is cheaper for

package/docs/HARNESS-INTELLIGENCE-PLAN.md

@@ -133,6 +133,26 @@ Cap overrides (only meaningful when feature 8 is on):
 Profile knobs: `LOKI_REPO_PROFILE_TTL_SECONDS` (86400),
 `LOKI_REPO_PROFILE_MAX_CHARS` (2000).
 
+## Repo commands and baseline (REPOMEM, same module)
+
+`loki-ts/src/runner/repo_profile.ts` also owns the commands profile the engine10 path uses (`loki start`). The goal: the user never explains how the repo builds and tests, and a failure that was already there never blocks the run. It is not gated by `LOKI_REPO_PROFILE`; disable it with `LOKI_REPO_BASELINE=0`. Both profiles share one manifest hash (`manifestHash`: sha256 over name and content of package.json, requirements.txt, Makefile, pyproject.toml, tox.ini, pytest.ini, setup.cfg, go.mod, Cargo.toml and `.github/workflows/*.yml`).
+
+Artifact: `.loki/state/repo-profile.json` (version 1, `CommandProfile`), written by engine10 intake.
+
+- `revision`: HEAD the baseline ran on. `manifest_hash`: as above.
+- `commands[]`: `{kind: test|lint|typecheck|build, cmd, source, validated, exit_code, duration_s, failing_ids}`. `validated` is true only when the command ran to completion on the untouched tree, false when it could not run (missing, timed out), null when discovered but not executed. Only the first test command is executed.
+- `baseline`: `{ran, command, exit_code, duration_s, timed_out, failing_ids, attributable, reason?}`. `attributable` means exit 0, or non-zero with parseable failing ids (`failIds`).
+
+Lifecycle:
+
+1. Intake (after the dirty-tree refusal and the `.loki/` exclude, before any agent edit): same manifest hash and HEAD reuses the file; same hash and a new HEAD keeps the commands and re-runs only the baseline; a changed hash rediscovers and re-runs (`ensureProfile`).
+2. Baseline: `sh -c <test cmd>` in the repo, 60s timeout (SIGKILL), scoped env (`plainTestEnv`, `PYTHONDONTWRITEBYTECODE=1`, `CI=1`). Untracked files the run created are removed so the diff stays the agent's.
+3. Implementer brief (`briefContext`, e10ext/context.ts): a "Repo commands" block and the known-red test ids (`profileBrief`). Bytes depend only on the profile content (no timestamps).
+4. Verify (`verifyStage`): `attribute()` marks a failing check pre-existing only when the profile revision equals the run base sha, the baseline was attributable, the check is neither a Wall/task-named target nor in a file the diff touched, and every one of its failing ids is in the baseline. Those join `pre_red` and `pre_red_checks`. Everything else that fails is introduced and blocks as before; a check with no parsed ids is introduced. Verify data gains `baseline_line` (`baseline: N pre-existing failing check(s) (not blocking), M introduced (blocking)`) and `introduced_checks`; seal lists the line under NOT PROVEN only when a baseline failure was excused.
+5. Surface: `loki doctor --repo` (and `--repo --json`) prints the profile, read-only, from the current directory.
+
+`e10ext/repomemory.ts` still holds the last verified command, flaky list and failure causes (dynamic per-repo cache data, not discovery).
+
 ## Acceptance
 
 1. With all flags unset, `bun test tests/parity/` stays 60/60 byte-exact.

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 Loki Mode, by [Autonomi](https://www.autonomi.dev/), turns a spec or an issue into a verified pull request with a receipt you can check. This page covers installing it, a first run, and the options around it.
 
-**Version:** v11.4.2
+**Version:** v11.6.0
 
 **Engine note:** `loki start` is the primary command. `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` all run the Loki 10 engine, whatever the flag order or input form (PRD file, issue ref, task or one-word brief). The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, or for one call when a flag Loki 10 cannot honor is present. See the [user guide](v10/GUIDE.md) and the [5-minute quickstart](QUICKSTART.md).
 

package/docs/KNOWN-ISSUES.md

@@ -4,4 +4,13 @@ Issues in the current release that are known and not yet fixed. Report new ones
 
 ## Which engine runs
 
-From 11.4.0, `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` run the Loki 10 engine whatever the flag order or input form. The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, or for one call when a flag Loki 10 cannot honor is present (`--simple`, `--parallel`, `--sandbox`, ...). Check with `loki route start <args>`.
+From 11.4.0, `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` run the Loki 10 engine whatever the flag order or input form. The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, for a provider with no Loki 10 invoker, for a PRD over 100000 bytes, or for one call when a flag Loki 10 cannot honor is present (`--simple`, `--parallel`, `--sandbox`, ...). Check with `loki route start <args> --json`: it reports `engine`, `adapter`, `reason` and `capability_differences`. The full table is in the Routing contract section of `docs/exit-codes.md`.
+
+## Exit codes
+
+The exit code of every command is listed in `docs/exit-codes.md`. Two things are kept as they are for compatibility:
+
+- `loki run` (deprecated alias of `loki start <issue-ref>`) exits 1 on an unknown option, not 64.
+- `loki start` without `LOKI_DURABLE_STATE=1` has no finer run-outcome signal than 0 versus nonzero.
+
+An empty diff has a distinct exit code only for `loki verify` (3). `loki quick`, `loki start` and `loki run` do not define one.