loki-mode 10.6.13 → 10.7.0

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 backlog quick monitor demo tour welcome init stop pause resume steer status next ship dashboard web serve api sandbox notify import github issue intent config provider reset memory compound checkpoint council dogfood projects enterprise secrets cockpit secure own handoff doctor watchdog audit metrics syslog onboard share proof receipt outcomes explain plan report cost estimate kpis stats test ci watch telemetry agent context ctx code run export review optimize heal modernize migrate cluster worktree wt trigger failover remote deploy docker mcp magic assets analyze compliance crash control workspace open otel preview quickstart rc rollback self-update sentrux setup-skill spec state template trust trust-metrics ultracode update verify voice why wiki bench cleanup logs grill docs cp version completions help keys answer"
+    local main_commands="start backlog quick monitor demo tour welcome init stop pause resume steer status next ship dashboard web serve api sandbox notify import github issue intent config provider reset memory compound checkpoint council dogfood projects enterprise secrets cockpit secure own handoff doctor watchdog audit metrics syslog onboard share proof receipt outcomes explain plan report cost estimate kpis stats test ci watch telemetry agent context ctx code run export review optimize heal modernize migrate cluster worktree wt trigger failover remote deploy docker mcp magic assets analyze compliance crash control workspace open otel preview quickstart rc rollback merge self-update sentrux setup-skill spec state template trust trust-metrics ultracode update verify voice why wiki bench cleanup logs grill docs cp version completions help keys answer acp"
 
     # 1. If we are on the first argument (subcommand)
     if [[ $cword -eq 1 ]]; then

package/dashboard/__init__.py

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

package/dashboard/api_runs_v1.py

@@ -0,0 +1,80 @@
+"""REST API for runs: /api/v1/runs.
+
+A thin, stable surface over code that already exists:
+  GET  /api/v1/runs            -> api_runs.list_runs (envelope kept intact)
+  GET  /api/v1/runs/{id}       -> api_runs.get_run (404 when the run is unknown)
+  POST /api/v1/runs            -> the existing /api/control/start handler
+  POST /api/v1/runs/{id}/stop  -> the existing /api/control/stop handler,
+                                  only when {id} is the current run
+
+Auth is the dashboard's own scope check: "read" for GETs, "control" for POSTs.
+The dashboard binds loopback by default; nothing here opens a listener.
+"""
+import os
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel, Field
+
+from . import auth
+
+router = APIRouter(prefix="/api/v1/runs", tags=["runs-v1"])
+_READ = [Depends(auth.require_scope("read"))]
+_CONTROL = [Depends(auth.require_scope("control"))]
+
+
+def _loki_dir() -> str:
+    try:
+        from . import server
+        return str(server._get_loki_dir())
+    except Exception:
+        return os.environ.get("LOKI_DIR") or os.path.join(os.getcwd(), ".loki")
+
+
+class RunStartIn(BaseModel):
+    prd_text: Optional[str] = Field(default=None, max_length=1_048_576)
+    prd_path: Optional[str] = None
+    provider: str = "claude"
+    parallel: bool = False
+
+
+async def _start_impl(request: Request, body: RunStartIn):
+    from . import server
+    return await server.start_build(request, server.StartBuildRequest(**body.model_dump()))
+
+
+async def _stop_impl(request: Request):
+    from . import server
+    return await server.stop_session(request)
+
+
+@router.get("", dependencies=_READ)
+def list_runs_v1():
+    from . import api_runs
+    return api_runs.list_runs(_loki_dir())
+
+
+@router.get("/{run_id}", dependencies=_READ)
+def get_run_v1(run_id: str):
+    from . import api_runs
+    env = api_runs.get_run(_loki_dir(), run_id)
+    if env.get("run") is None:
+        raise HTTPException(status_code=404, detail=env.get("reason") or "run not found")
+    return env
+
+
+@router.post("", dependencies=_CONTROL)
+async def start_run_v1(request: Request, body: RunStartIn):
+    return await _start_impl(request, body)
+
+
+@router.post("/{run_id}/stop", dependencies=_CONTROL)
+async def stop_run_v1(run_id: str, request: Request):
+    from . import api_runs
+    env = api_runs.get_run(_loki_dir(), run_id)
+    row = env.get("run")
+    if row is None:
+        raise HTTPException(status_code=404, detail=env.get("reason") or "run not found")
+    if not row.get("current"):
+        raise HTTPException(status_code=409, detail="only the current run can be stopped")
+    return await _stop_impl(request)

package/dashboard/server.py

@@ -1362,6 +1362,8 @@ else:
 # D51 Phase A: first-run onboarding + backlog API and its /start page.
 from .api_start import router as api_start_router, START_HTML as _START_HTML
 app.include_router(api_start_router)
+from .api_runs_v1 import router as api_runs_v1_router
+app.include_router(api_runs_v1_router)
 
 
 @app.get("/start", include_in_schema=False, dependencies=[Depends(auth.require_scope("read"))])

package/docs/COMPETITOR-DEPLOYMENT-MODELS.md

@@ -213,10 +213,10 @@ verbatim:
 MCP server, https://docs.replit.com/platforms/mcp-server (accessed 2026-08-08).
 This is the programmatic trigger. Documented tools:
 
-- `create_app_from_prompt` — "Create a new Replit App from a natural language
+- `create_app_from_prompt` - "Create a new Replit App from a natural language
   description. Replit Agent immediately starts building the app."
-- `update_app_using_prompt` — "Make changes to an existing Replit App."
-- `ask_question` — "Ask Replit Agent about the current app."
+- `update_app_using_prompt` - "Make changes to an existing Replit App."
+- `ask_question` - "Ask Replit Agent about the current app."
 
 An Enterprise Admin API exists
 (https://docs.replit.com/teams/admin-api) but is scoped to account usage,

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Loki Mode is a spec-driven autonomous builder with a built-in trust layer that takes any spec to a deployed product and verifies completion with evidence (quality gates plus a completion council), not just a "done" claim. Complete installation instructions for all platforms and use cases.
 
-**Version:** v10.6.13
+**Version:** v10.7.0
 
 **Engine note:** `loki "<task>"`, `loki owner/repo#N` and `loki quick` run the Loki 10 engine. `loki start` still routes to the legacy engine, which is being removed (planned work resumes 2026-10-07); prefer `loki owner/repo#N`. See [docs/v10/GUIDE.md](v10/GUIDE.md).
 
@@ -434,11 +434,15 @@ runs any loki command inside the published `asklokesh/loki-mode` image with zero
 config:
 
 ```bash
+loki docker start owner/repo#17      # work a GitHub issue or PR in Docker (primary path)
 loki docker start prd.md             # full local experience in Docker
 loki docker status                   # any loki command works
 loki docker --dry-run start prd.md   # print the docker command, do not run
 ```
 
+On macOS, pass your GitHub login for PRs with
+`GH_TOKEN=$(gh auth token) loki docker start owner/repo#17`.
+
 It bind-mounts the current folder to `/workspace`, so `.loki/` state (memory,
 session, queue, checkpoints) persists on the host and resume and continuity
 behave exactly like the local `loki` CLI. Auth is auto-detected:

package/docs/acp-editors.md

@@ -0,0 +1,29 @@
+# Loki in VS Code and JetBrains via ACP
+
+`loki acp` speaks the Agent Client Protocol (newline-delimited JSON-RPC over
+stdio). It supports `initialize`, `session/new`, `session/prompt` and
+`session/cancel`. Each prompt runs `loki quick "<prompt>"` in the session's
+working directory and streams the output back. A non-zero exit is reported as
+"NOT VERIFIED"; nothing is claimed that did not run. Loki never receives editor
+credentials, and no network listener is opened.
+
+## JetBrains (AI Assistant with ACP support)
+
+Edit `~/.jetbrains/acp.json`:
+
+    {"agent_servers": {"Loki": {"command": "loki", "args": ["acp"]}}}
+
+## Zed
+
+In settings.json:
+
+    {"agent_servers": {"Loki": {"command": "loki", "args": ["acp"]}}}
+
+## VS Code
+
+Use any ACP client extension and register a custom agent with command `loki`
+and args `acp`.
+
+## Smoke test
+
+    printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":1}}' | loki acp

package/docs/api-runs-v1.md

@@ -0,0 +1,12 @@
+# Runs REST API (/api/v1/runs)
+
+Served by the local dashboard (loopback by default). Auth reuses the dashboard
+scopes: "read" for GET, "control" for POST. With auth off (default local mode)
+no token is needed; with it on, send `Authorization: Bearer <token>`.
+
+- `GET /api/v1/runs` - envelope `{runs, source, freshness_s, reason}`, newest first.
+- `GET /api/v1/runs/{id}` - one run plus per-iteration detail (current run only); 404 if unknown.
+- `POST /api/v1/runs` - start a run. Body: `{"prd_text": "..."}` or `{"prd_path": "..."}`, optional `provider`, `parallel`. Same behavior as `POST /api/control/start` (single-flight, 409 if busy).
+- `POST /api/v1/runs/{id}/stop` - stop the run. Only the current run can be stopped (409 otherwise, 404 if unknown).
+
+Cost and status fields come from measured records only; unmeasured values are null, never 0.

package/docs/architecture/ADR-001-runtime-migration.md

@@ -81,9 +81,9 @@ User constraint: "people use npm, I want to keep it the same way."
 | **Bash** (today) | `package.json` `bin` field points to shell script | Trivial; current state |
 | **Bun runtime** | `npm install -g loki-mode` ships TS, requires Bun installed via `npm install -g bun` (peer) OR Bun standalone in postinstall | Medium; peer dependency convention |
 | **Bun compiled binary** | `bun build --compile` → 60 MB binary per platform; npm postinstall downloads correct binary (esbuild model) | Medium; per-platform binaries |
-| **Go binary** | Same model as Bun compiled — npm postinstall downloads platform binary (esbuild, biome, vite-rust, swc all use this) | Medium; mature pattern |
-| **Python** | npm postinstall would shell out to `pip install` or bundle Python — fragile, two package managers | High; do not recommend |
-| **Node.js** | Native — no postinstall needed | Trivial; but Node is 10x slower than bash on cold start |
+| **Go binary** | Same model as Bun compiled - npm postinstall downloads platform binary (esbuild, biome, vite-rust, swc all use this) | Medium; mature pattern |
+| **Python** | npm postinstall would shell out to `pip install` or bundle Python - fragile, two package managers | High; do not recommend |
+| **Node.js** | Native - no postinstall needed | Trivial; but Node is 10x slower than bash on cold start |
 
 All three viable options (Bun runtime, Bun compiled, Go binary) keep the `npm install -g loki-mode` UX. Users see no change.
 
@@ -104,17 +104,17 @@ All three viable options (Bun runtime, Bun compiled, Go binary) keep the `npm in
 - Rewriting 33,000+ lines of bash to idiomatic Go is a 3-6 month effort.
 - Goroutines/channels are different mental model than bash + Python orchestration.
 
-**Distribution via npm:** Same pattern as esbuild — npm postinstall downloads the right platform binary. Mature, ~5 MB compressed per arch.
+**Distribution via npm:** Same pattern as esbuild - npm postinstall downloads the right platform binary. Mature, ~5 MB compressed per arch.
 
 ### Option B: Bun runtime + TypeScript
 
 **Pro:**
 - **Anthropic owns Bun.** Strategic alignment with the company that owns the model we depend on.
-- Native shell built in (`Bun.$\`echo hello\``) — minimal friction porting bash idioms.
-- Bun's `npm install` is 20-40x faster than npm — every CI run faster.
+- Native shell built in (`Bun.$\`echo hello\``) - minimal friction porting bash idioms.
+- Bun's `npm install` is 20-40x faster than npm - every CI run faster.
 - TypeScript: types catch bugs bash can't.
 - Anthropic-funded development means Bun improvements specifically target AI agent workloads.
-- 98% Node.js compatibility — npm packages work directly.
+- 98% Node.js compatibility - npm packages work directly.
 
 **Con:**
 - **1.7x SLOWER than bash on trivial cold-start** (7.6 ms vs 4.5 ms). The user explicitly said "no speed compromise". This is a genuine compromise, even if 3 ms is humanly invisible.
@@ -127,20 +127,20 @@ All three viable options (Bun runtime, Bun compiled, Go binary) keep the `npm in
 
 **Pro:**
 - Keep tiny scripts in bash (where it wins by 3 ms): `loki version`, `loki status`, anything <100 LOC.
-- Migrate the 11k-line orchestrator (`run.sh`) and 22k-line CLI (`autonomy/loki`) to Bun TypeScript — where compiled+typed wins.
-- Keep `memory/`, `providers/`, `mcp/` in Python — they're already mature, no reason to rewrite.
+- Migrate the 11k-line orchestrator (`run.sh`) and 22k-line CLI (`autonomy/loki`) to Bun TypeScript - where compiled+typed wins.
+- Keep `memory/`, `providers/`, `mcp/` in Python - they're already mature, no reason to rewrite.
 - Anthropic alignment via Bun for the parts that matter.
 - No speed regression for trivial commands; large gains for orchestrator.
 
 **Con:**
-- Three runtimes in the codebase (bash + Bun + Python) — operational complexity.
+- Three runtimes in the codebase (bash + Bun + Python) - operational complexity.
 - Cross-runtime debugging harder than monorepo.
 
 **Distribution:** Bun shipped via npm postinstall as compiled binary; bash remains as-is; Python unchanged.
 
 ## Recommendation
 
-**Option B (Bun runtime + TypeScript) — full migration, not hybrid.**
+**Option B (Bun runtime + TypeScript) - full migration, not hybrid.**
 
 Reasons:
 
@@ -148,7 +148,7 @@ Reasons:
 2. **Anthropic strategic alignment.** Anthropic owns Bun. Loki uses Claude. Aligning runtime and model owner reduces dependency-versioning friction over time.
 3. **TypeScript pays the maintainability dividend** that 33k lines of bash will never deliver. Type checking catches whole classes of bugs (the kind we hit in v6.81-v7.2 cycles).
 4. **Hybrid is now harder to justify.** When bash loses by 8.6x on the actual workload, keeping it for 3 ms theoretical wins on hello-world is bad engineering.
-5. **Go would still be 2-4x faster than Bun** in absolute cold-start, but: zero existing Go in the codebase, no Anthropic alignment, larger rewrite cost, no JS ecosystem reuse. Unless Loki specifically targets the sub-millisecond CLI category (which it doesn't — every command runs in a multi-second/minute autonomous loop), the absolute speed delta doesn't justify the strategic cost.
+5. **Go would still be 2-4x faster than Bun** in absolute cold-start, but: zero existing Go in the codebase, no Anthropic alignment, larger rewrite cost, no JS ecosystem reuse. Unless Loki specifically targets the sub-millisecond CLI category (which it doesn't - every command runs in a multi-second/minute autonomous loop), the absolute speed delta doesn't justify the strategic cost.
 
 **If user explicitly wants the absolute fastest:** Go (Option A) is 2.5x faster than Bun. But for orchestrator-heavy work where most time is spent waiting on Claude API calls, the difference is invisible.
 
@@ -214,7 +214,7 @@ Reasons:
 2. Port `cmd_version` to `loki-ts/src/commands/version.ts` (proof of concept)
 3. Add `bun-test.yml` GitHub workflow alongside existing `test.yml`
 4. Set acceptance criteria: every Phase 2+ command must benchmark within 2x of bash cold-start AND be type-checked via `bun typecheck`
-5. Ship Phase 1 as v8.0.0-alpha.1 (pre-release, opt-in) — does not affect default users
+5. Ship Phase 1 as v8.0.0-alpha.1 (pre-release, opt-in) - does not affect default users
 
 ---
 

package/docs/dev/architecture-reference.md

@@ -25,10 +25,10 @@ model explicitly rather than inherit the session model.
 - **Inspired by**: Amazon AGI Lab's "How Agentic AI Helps Heal Systems We Can't Replace"
 - **CLI**: `loki heal <path> [--phase archaeology|stabilize|isolate|modernize|validate]` (`autonomy/loki` `cmd_heal`)
 - **Principles**: Friction-as-semantics, failure-first learning, universal adapters, incremental healing, institutional knowledge preservation
-- **Artifacts**: `.loki/healing/` (friction-map.json, failure-modes.json, institutional-knowledge.md)
+- **Artifacts**: `.loki/healing/` (friction-map.json, failure-modes.json, institutional-knowledge.md). `loki heal` seeds failure-modes.json as `{"modes":[]}` and the prompt asks the agent to fill it; no code appends to it (NOT WIRED, issue #200)
 - **Review**: `legacy-healing-auditor` specialist added to code review pool (gated)
 - **Gate**: backward-compatibility / legacy-healing auditor (healing mode; not one of the 8 numbered gates) blocks removal of unclassified friction
-- **Hooks**: `hook_pre_healing_modify()` (`autonomy/hooks/migration-hooks.sh:283`), `hook_post_healing_modify()` (`:328`), `hook_healing_phase_gate()` (`:386`)
+- **Hooks**: `hook_pre_healing_modify()` (`autonomy/hooks/migration-hooks.sh:348`), `hook_post_healing_modify()` (`:576`), `hook_healing_phase_gate()`. NOT WIRED (issue #200): the pre/post modify hooks are defined and unit-tested but have no production caller, so the snapshot/revert pairing contract and the failure-modes.json append inside them are not enforced in a real heal run
 - **Memory**: `FrictionPoint` and `FailureMode` schemas for healing-specific memory entries
 - **Skill**: `skills/healing.md` | **Reference**: `references/legacy-healing-patterns.md`
 
@@ -101,3 +101,7 @@ These knobs together implement the RARV-C (closure) loop: findings -> override c
 ## Worktree substrate (autonomy/lib/worktree_prep.py)
 
 `prepare_worktree(source_repo, dest, branch, setup=None, base=None)` creates an isolated git worktree and returns `{path, base_sha, deps, left_out_changes}`. The start point is `origin/HEAD` after a fetch (when a remote exists), else HEAD. Uncommitted edits in the source checkout are never carried or stashed; their count is reported as `left_out_changes`. An fcntl lock at `~/.loki/repos/<slug>.lock` covers fetch and worktree add. Dependencies: a `setup` command run in the worktree, else a copy-on-write copy of ignored top-level `node_modules`, `.venv`, `venv`, `vendor` (refused as "copy unsafe, declare setup" if it holds absolute symlinks or editable finders), else `none`. CLI: `python3 autonomy/lib/worktree_prep.py SRC DEST BRANCH [--setup CMD] [--base REF]` prints the result as JSON. Not yet wired into backlog or the UI.
+
+## Project memory across runs
+
+extract_learnings_from_session (autonomy/run.sh) mirrors learnings and decisions into .loki/memory/learnings/project-*.jsonl. get_relevant_learnings adds a bounded newest-first project_memory list (15 entries, LOKI_PROJECT_MEMORY_MAX_CHARS, default 2000) to .loki/state/relevant-learnings.json at run start. LOKI_PROJECT_MEMORY=0 disables both. Test: tests/test-project-memory.sh.

package/docs/merge-queue.md

@@ -0,0 +1,13 @@
+# loki merge
+
+Serial PR merge queue (requires the `gh` CLI, authenticated).
+
+    loki merge add 101 102 103   # queue PRs (stored in .loki/merge-queue)
+    loki merge run --dry-run     # list what would happen, change nothing
+    loki merge run               # merge one at a time
+
+Rules: a PR merges (squash) only when `gh pr checks` exits 0. Pending checks are
+polled (LOKI_MERGE_POLL_S, default 20s; LOKI_MERGE_MAX_POLLS, default 90). After
+each merge the next PR is rebased onto the new base and must pass checks again.
+PRs that are red, time out, or fail to rebase stay in the queue; the command
+exits nonzero. Nothing is force-pushed and no check is bypassed.

package/docs/mobile-verify.md

@@ -0,0 +1,11 @@
+# Mobile emulator tests
+
+`bash autonomy/mobile-verify.sh [project_dir]`
+
+Detects React Native/Expo (package.json) or Flutter (pubspec.yaml). Looks for a booted Android emulator (`adb devices`) or iOS simulator (`xcrun simctl list devices booted`).
+
+Test command: `LOKI_MOBILE_TEST_CMD`, else `flutter test [integration_test]`, else `npm run test:e2e` / `npm run e2e`.
+
+Exit codes: 0 ran and passed (or not a mobile project, stated); 1 ran and failed; 3 NOT VERIFIED (no device or no e2e script). A NOT VERIFIED result must never be reported as a pass.
+
+Timeout: `LOKI_MOBILE_TIMEOUT` seconds (default 600).

package/docs/sentry-intake.md

@@ -0,0 +1,13 @@
+# Sentry intake
+
+`loki start` turns a Sentry issue into a task spec (error, stack trace, breadcrumbs, acceptance criteria).
+
+Offline, from an exported JSON file (issue export, event, or `{issue, event}`):
+
+    loki start ./sentry-issue.json
+
+From a URL (needs `SENTRY_AUTH_TOKEN`; without it nothing is fetched):
+
+    SENTRY_AUTH_TOKEN=... loki start https://sentry.io/organizations/acme/issues/4001/
+
+The token is sent only to the Sentry host through a curl config on stdin, never on argv, and is never printed. Implementation: `autonomy/issue-providers.sh` (`normalize_sentry_json`).