loki-mode 10.5.35 → 10.6.6

package/README.md

@@ -24,7 +24,6 @@ Before a build counts as done, a review council selects reviewers from a special
 - [loki doctor](#loki-doctor)
 - [Modernization: status of loki modernize](#modernization-status-of-loki-modernize)
 - [Providers](#providers)
-- [Legacy engine reference](#legacy-engine-reference) (the engine `loki` runs by default today)
 
 ## Install
 
@@ -72,19 +71,21 @@ loki-seal is a Claude Code Stop hook that runs your repo's real test suite when
 
 ## Loki 10 engine
 
-Default: Loki 10 engine for `loki "<task>"`, `loki owner/repo#N` and `loki quick "<task>"`. Set LOKI_ENGINE=legacy or run `loki legacy <args>` for the previous engine. <!-- loki10-default -->
+Loki Mode now runs the v10 engine for all commands. <!-- loki10-default -->
 
-Loki 10 is the rewritten engine and the default for tasks, issue mode and `quick`; `status`, `verify` and `dashboard` use it when `LOKI_ENGINE=v10` is set. Guide, provider table and summary format: [docs/v10/GUIDE.md](docs/v10/GUIDE.md).
+Guide, provider table and summary format: [docs/v10/GUIDE.md](docs/v10/GUIDE.md).
 
 ```
-LOKI_ENGINE=v10 loki "fix the login redirect loop" --no-pr
+loki "fix the login redirect loop" --no-pr
 ```
 
 ```
-LOKI_ENGINE=v10 loki owner/repo#123
+loki owner/repo#123
 ```
 
-The router sends a quoted multi-word task, a GitHub, GitLab or Jira issue reference, and the `status`, `verify` and `dashboard` subcommands to the v10 engine. A one-word argument that is not an issue ref, or any first argument starting with `-`, stays on the legacy CLI. Flags (`loki-ts/src/engine10/cli.ts` USAGE): `--no-pr` builds and verifies without opening a pull request, `--deep` requests the deep verify pass and a longer implement budget, `--provider <name>` picks the coding provider (`--json` and `--verbose` are also parsed by the supervisor, see [Quiet output](#quiet-output)). The v10 engine needs Bun; without it the command exits 1 with a message.
+The v10 engine accepts a quoted multi-word task, a GitHub, GitLab or Jira issue reference, `status`, `verify`, `dashboard`, and other subcommands. Flags (`loki-ts/src/engine10/cli.ts` USAGE): `--no-pr` builds and verifies without opening a pull request, `--deep` requests the deep verify pass and a longer implement budget, `--provider <name>` picks the coding provider (`--json` and `--verbose` are also parsed by the supervisor, see [Quiet output](#quiet-output)). The engine needs Bun; without it the command exits 1 with a message and installation instructions.
+
+Migration note: Legacy engine removed in 10.6.0; use `loki "<task>"`, `loki owner/repo#N`, or `loki backlog` instead.
 
 ### The state machine
 
@@ -148,10 +149,10 @@ Every sealed v10 run writes a receipt to `.loki/runs/<run-id>/receipt.json`. `re
 Receipts are signed by default. On the first run Loki generates an Ed25519 key at `~/.loki/keys/receipt-ed25519.pem` (mode 0600, directory 0700), or you supply your own with `LOKI_RECEIPT_SIGNING_KEY` or `LOKI_RECEIPT_SIGNING_KEY_FILE`. See [docs/SIGNED-RECEIPTS.md](docs/SIGNED-RECEIPTS.md).
 
 ```
-LOKI_ENGINE=v10 loki verify
+loki verify
 ```
 
-`loki verify [run-id]` (latest run by default) re-hashes the receipt, checks the signature against your local key (and retired keys listed in `LOKI_RECEIPT_RETIRED_PUBKEYS`), and checks the receipt against the event log. Verdicts and exit codes on the v10 path (`loki-ts/src/engine10/verify_cmd.ts`):
+`loki verify [run-id]` (latest run by default) re-hashes the receipt, checks the signature against your local key (and retired keys listed in `LOKI_RECEIPT_RETIRED_PUBKEYS`), and checks the receipt against the event log. Verdicts and exit codes (`loki-ts/src/engine10/verify_cmd.ts`):
 
 | Verdict | Exit | Meaning |
 |---------|------|---------|
@@ -163,8 +164,6 @@ LOKI_ENGINE=v10 loki verify
 
 A verified receipt is bound to the run's event log, so a receipt lifted out of its run, or a log edited after sealing, does not verify. Signing proves the receipt came from the key holder; it does not prove the generated code is bug-free. A receipt only claims what its checks ran, and states what they did not.
 
-On the legacy engine, receipts live under `.loki/proofs/<run_id>/` and are inspected with `loki proof list`, `loki proof show <id>` and `loki proof verify <id>` (exit 0 clean, 1 on tamper or drift, 2 could not check).
-
 ## Quiet output
 
 The v10 run is quiet by default: no stage chatter, only the final summary. `--verbose` tails the event stream live (one line per finished stage and a heartbeat with elapsed time and the running diff size). `--json` prints one JSON object (`ok`, `outcome`, `stop`, `run_id`, `receipt_sha256`) instead of text.
@@ -213,10 +212,7 @@ Exit 0 when every required check passes; optional warnings (an absent provider C
 
 ## Modernization: status of loki modernize
 
-There are two different things behind the name today.
-
-- `loki modernize heal <path>` and `loki modernize migrate <path>` are the shipped legacy commands (agent-driven phases). `loki modernize heal <path> --assess` is read-only. See [Already have a codebase](#already-have-a-codebase-start-read-only).
-- `loki modernize <repo> --to <target>` is the new v10 command with behavior-captured equivalence. It is routed to the v10 engine whatever `LOKI_ENGINE` says, but it is not finished: only the `--dry-run` estimate works (inventory, dependency graph, unit clustering, cost, time and risk estimate, no model spend). A real run stops after the estimate and prints `modernize: oracle capture and execution are not built yet; use --dry-run`. Targets `python3` and `java21` exist; the Java dependency graph is not wired in yet. Nothing in v10 modernize claims a unit is proven equivalent today. Design: [docs/v10/MODERNIZE.md](docs/v10/MODERNIZE.md), user summary: [docs/v10/GUIDE-MODERNIZE.md](docs/v10/GUIDE-MODERNIZE.md).
+Migration: `loki modernize heal <repo> --assess` was a legacy command for read-only analysis. The v10 path `loki modernize <repo> --to <target>` is not yet finished: only `--dry-run` works (inventory, dependency graph, unit clustering, cost, time and risk estimate). A real run stops after the estimate and prints `modernize: oracle capture and execution are not built yet; use --dry-run`. Targets `python3` and `java21` exist; the Java dependency graph is not wired in yet. Design: [docs/v10/MODERNIZE.md](docs/v10/MODERNIZE.md), user summary: [docs/v10/GUIDE-MODERNIZE.md](docs/v10/GUIDE-MODERNIZE.md).
 
 ## Providers
 
@@ -234,98 +230,6 @@ Claude Code is the provider Loki is built for and the one that is run end to end
 
 ---
 
-# Legacy engine reference
-
-Everything below describes the legacy engine, which `loki` still runs by default (and which stays reachable when Loki 10 is made the default). The long-form commands, `loki start`, `loki quick`, `loki quickstart` and `loki proof` all live here.
-
-## Use it
-
-```bash
-loki quickstart                   # guided first build: asks a few questions, quotes cost, builds
-```
-
-That is the whole happy path. It asks for a one-line idea, picks a template,
-shows the real cost and time estimate before spending anything, then builds.
-Press Enter through every step and you get a sample Todo app.
-
-One command, no prompts (CI, scripts, containers, any shell without a terminal):
-
-```bash
-loki quickstart "a todo app with user accounts" --yes
-```
-
-Both halves are required with no terminal: an idea (or a path to a PRD file)
-and an explicit `--yes`. Given both, Loki picks the top-ranked template
-automatically, prints the same honest cost and time estimate, and starts the
-build without asking anything. Missing either half exits 2 with the
-needs-a-terminal message and writes nothing, so an ambient `LOKI_AUTO_CONFIRM`
-or a stray argument in CI can never start a paid build on its own. Existing
-files are never overwritten: if `prd.md` is present the PRD lands at
-`prd-quickstart.md`, then numbered suffixes as needed.
-
-Choose an exact shipped starter when the top-ranked match is not the one you
-want:
-
-```bash
-loki quickstart --list-templates
-loki quickstart --list-templates --json       # schema-v1 automation output
-loki quickstart "an internal reporting workspace" --template dashboard --yes
-```
-
-Template discovery works without a terminal or provider and lists every shipped
-starter's stable name and purpose in catalog order. It returns before estimation,
-consent, PRD writes, or build execution. Positional input and execution/preview
-flags are intentionally incompatible; `--json` is the only optional modifier.
-
-`--template` accepts an exact template name for idea inputs and works the same
-way with interactive use or `--dry-run` (including JSON preview). Unknown
-templates, duplicate flags, and combinations with a PRD path refuse before
-provider discovery, estimation, writes, or build execution.
-
-Preview the same deterministic template choice and estimator-backed plan with
-zero writes or execution:
-
-```bash
-loki quickstart "a todo app with user accounts" --dry-run
-```
-
-Preview requires an idea or readable PRD path, works without a terminal or AI
-provider, and exits before creating a PRD or starting a build. `--dry-run` and
-`--yes` are mutually exclusive so execution intent is never ambiguous.
-
-For scripts and local dashboards, add `--json` to receive one versioned JSON
-object instead of terminal text:
-
-```bash
-loki quickstart "a todo app with user accounts" --dry-run --json > preview.json
-loki quickstart --verify-preview preview.json --json
-loki quickstart --from-preview preview.json --yes
-```
-
-The object contains the input kind, deterministic selected template (or `null`
-for an existing PRD), the exact estimator response under `plan`, and a bounded
-continuation containing the exact idea/template or the PRD path and SHA-256.
-`--verify-preview` validates the same bounded duplicate-key-rejecting schema and
-requires either a currently shipped idea template or the unchanged digest-bound
-PRD, while emitting no idea or PRD path. It accepts a file or piped stdin and
-returns before provider discovery, estimation, writes, or build execution.
-`--from-preview` requires explicit argv `--yes`, rejects malformed, conflicting,
-symlinked, or changed inputs before provider and build boundaries, then uses the
-existing no-clobber quickstart path. The saved plan is evidence rather than
-execution authority: Loki recomputes and displays the current estimate before
-starting. `--json` requires `--dry-run`; invalid input or estimator failure
-writes no JSON, and preview still exits before provider discovery, file writes,
-or build execution.
-
-Or go straight at it:
-
-```bash
-loki quick "build a landing page with a signup form"     # one-shot task
-loki start prd.md                                        # build from a spec you wrote
-loki modernize heal ./your-repo --assess                 # existing codebase, read-only
-```
-
-
 ## Try it first, without installing
 
 ```bash
@@ -346,121 +250,7 @@ Headline: VERIFIED WITH GAPS
 | Cost          | $10.3218                                 |
 ```
 
-**"WITH GAPS" is the point.** Build was not run, security has findings, and the
-receipt says so on its own front page. Recompute the diff hash yourself and
-check it matches -- you are not asked to trust the agent's self-report.
-
-## How the legacy engine works
-
-Drop a spec: a PRD, GitHub issue, OpenAPI/JSON/YAML, or a one-line brief. Loki Mode classifies complexity (`run.sh:detect_complexity()`), selects reviewers from a specialist pool (`agents/types.json` ships the role definitions; 10 are keyword-scored by the review selector at `run.sh:FOCUS_KEYWORDS`, alongside the mandatory reviewers, and the rest are role descriptions in `references/agents.md` that the orchestrator adopts per phase rather than separate processes), with a blind review council and optional git-worktree streams on Claude Code, sequential on most other providers, and runs autonomous RARV cycles (Reason, Act, Reflect, Verify; see `run.sh:run_autonomous()`) with 8 quality gates (see `skills/quality-gates.md`). Code is not "done" until it passes automated verification. Output is a Git repo with source, tests, configs and audit logs.
-
-**Why verified completion matters.** Self-reported completion is the failure users actually hit: the agent says it is done and the work is not. Loki treats "done" as a claim to be checked. [docs/EVALUATING.md](docs/EVALUATING.md) puts a runnable command next to every claim we make, and states plainly what we do not have (no enterprise case studies, no independent benchmark placement, and generation is not air-gapped). `bash tests/test-competitor-verify-surface.sh` reruns our check of which local agent CLIs expose a command that verifies their own output.
-
-## Already have a codebase? Start read-only.
-
-Most agents are built to create new apps. The harder, more valuable problem is
-the ten-year-old repo that pays the bills. Loki works on both, and on an
-existing codebase it starts by **changing nothing**:
-
-```bash
-loki modernize heal ./your-repo --assess          # read-only. no writes, no commits.
-loki modernize heal ./your-repo --assess --json   # same, machine-readable
-```
-
-You get a modernization readiness report: language mix, a 4-level maturity
-rating, technical-debt signals (test coverage, TODO density, oversized files,
-dependency staleness), and a **ranked list of where to start** -- ordered by
-blast radius, so the first change is the one least likely to break something.
-
-Then, if you want it to act:
-
-```bash
-loki modernize heal ./your-repo --strict          # block ALL behavioral change without approval
-loki modernize heal ./your-repo --phase archaeology   # extract knowledge only
-loki modernize heal ./your-repo --compliance healthcare   # preset flag: healthcare, fintech or government (not a certification)
-```
-
-The healing pipeline runs in phases -- archaeology, stabilize, isolate,
-modernize, validate -- and the validate phase checks **behavioral equivalence
-against the pre-change baseline**, not just that the tests are green. Friction
-points (the weird code that exists for a reason nobody remembers) are cataloged
-before anything touches them, because in a legacy system the strange code is
-usually load-bearing.
-
-## The Evidence Receipt: don't trust the agent, check it
-
-Every coding agent tells you it finished. Loki hands you something you can
-check yourself.
-
-**We are not the only tool that checks its own work, and you should be
-suspicious of anyone who claims to be.** Lovable runs a security scan on every
-publish and can block the publish outright. Claude Code's review has a step that
-checks findings against actual code behavior. Replit says its agent tests its
-own work.
-
-The difference is what you are left holding. Their output lives in their
-dashboard: a findings count in a dialog, a check run that by design never blocks
-a merge. Ours is a **file**. It is bound to a specific diff by `diff_sha256`, it
-records what was NOT proven as prominently as what was, and someone who has
-never installed Loki can re-verify it from the repository alone. Commit it,
-attach it to the PR, hand it to an auditor.
-
-Portable, diff-bound, and honest about its gaps -- that is the claim, and it is
-the one worth checking.
-
-Each run writes a receipt to `.loki/proofs/<run_id>/` that separates
-**deterministic FACTS** (the git diff with base and head SHAs plus a
-`diff_sha256`, the test command and its exit code, the build command and its
-exit code, each gate verdict) from **AI ASSESSMENTS** (the council verdict,
-labeled as judgment, never as proof). The headline is computed from the facts
-alone:
-
-| Headline | Means |
-|---|---|
-| VERIFIED | tests ran a real command and exited 0, diff non-empty, nothing skipped |
-| VERIFIED WITH GAPS | each gap listed by name |
-| NOT VERIFIED | a check ran and failed |
-
-```bash
-loki proof list            # every receipt from this project
-loki proof show <id>       # the facts, the assessments, and the headline
-loki proof verify <id>     # re-hash the receipt and re-derive the diff
-```
-
-`loki proof verify` exits 0 clean, 1 on tamper or drift, 2 when it could not check
-(full table: [docs/exit-codes.md](docs/exit-codes.md)). Receipts are attached
-to pull requests automatically (`LOKI_PROVEN_PR=0` to opt out), so a reviewer
-sees the evidence next to the code.
-
-**What the receipt does NOT claim.** On the unsigned path the generator is
-trusted: someone who rewrites both the facts and the headline into a mutually
-consistent lie and recomputes the hash will still pass verification. That is
-defense-in-depth, not non-forgeability, and neutral non-forgeability needs the
-signed record. We tested for exactly this and locked the limitation into the
-suite (`tests/test-proof-forgery-defense.sh`), and in v7.111.0 we removed our
-own earlier "non-forgeable" claim once we found it was false on that path. An
-honest boundary you can verify beats a marketing claim you cannot.
-
-To close that gap, receipts are signed automatically with an Ed25519 key
-generated on first run (or your own via `LOKI_RECEIPT_SIGNING_KEY_FILE`; this needs the
-Python `cryptography` package, otherwise the receipt stays unsigned). See [docs/SIGNED-RECEIPTS.md](docs/SIGNED-RECEIPTS.md).
-
-## What the legacy engine guarantees
-
-- **Verified completion** - the evidence gate (`skills/quality-gates.md`) refuses a "done" claim on an empty git diff against the run-start commit, blocks completion when tests run red, blocks when a serveable app is confirmed unhealthy (opt out `LOKI_EVIDENCE_BOOT_GATE=0`) or a credential is detected in the changed files (opt out `LOKI_EVIDENCE_SECRET_GATE=0`).
-- **An honest checklist verifier** - each completion checklist item is checked deterministically before the completion council accepts "done". A check that cannot be established is reported as inconclusive (pending), never as a false pass or a false failure. `rc == 0` alone is not a pass: a test check goes green only on a real "N passed" signal from the runner.
-- **Quality gates and review** - 8 quality gates (`skills/quality-gates.md`), blind 3-reviewer code review (`run.sh:run_code_review()`), anti-sycophancy checks.
-- **Standalone verification: `loki verify`** - runs the deterministic gates (build, tests, static analysis, secret scan, dependency audit) against any branch or PR diff, including code written by other agents or humans. Exit codes 0 VERIFIED, 1 CONCERNS, 2 BLOCKED, 3 verifier error; machine-readable evidence at `.loki/verify/evidence.json`. Inconclusive evidence is reported as CONCERNS; see [docs/exit-codes.md](docs/exit-codes.md) for the known gaps, including `--fast`, which can exit 0 when nothing was scanned.
-- **Living spec and pre-build interrogation** - `loki spec` locks a spec and detects drift; `loki grill` runs a Devil's-Advocate interrogation of the spec before you build.
-- **Confidence is not evidence** - when the agent's self-reported confidence spikes to near-certainty, Loki forces an extra verification pass (opt out `LOKI_CONFIDENCE_SPIKE=0`).
-- **Stops paying for failures that cannot succeed** - a positively identified permanent failure (bad credentials, unknown model, exhausted quota) exits instead of burning the retry budget; an unrecognized error still retries (opt out `LOKI_SMART_RETRY=0`).
-- **Cross-project memory** - episodic, semantic and procedural memory with optional vector search (`memory/engine.py`).
-- **Guided first build** - `loki quickstart` quotes the real cost and time estimate before anything is spent. `loki preview` prints the running app URL.
-- **MCP server** - 36 tools plus 3 resources and 2 prompts (`mcp/server.py`, magic tools from `mcp/magic_tools.py`, the managed-memory tool from `mcp/managed_tools.py`). Of the 36, 35 are always available; `loki_memory_redact` only succeeds when `LOKI_MANAGED_AGENTS=true` and `LOKI_MANAGED_MEMORY=true`. Launch with `loki mcp`.
-- **Legacy system healing** - `loki modernize heal` runs archaeology, stabilize, isolate, modernize and validate phases (`skills/healing.md`).
-- **Self-hosted and source-available (BUSL-1.1)** - your keys, your infrastructure. Free for personal, internal and academic use.
-
----
+**"WITH GAPS" is the point.** Build was not run, security has findings, and the receipt says so on its own front page. Recompute the diff hash yourself and check it matches.
 
 ## Loki does not lie about "done"
 
@@ -493,81 +283,6 @@ This is honesty-of-done, not a claim of perfection. The receipt proves the
 completion claim is backed by deterministic evidence and is independently
 re-checkable; it does not claim the generated code is bug-free.
 
-<details>
-<summary><strong>Verify a receipt yourself -- <code>loki proof</code> commands, tamper/drift checks, proven PRs (advanced)</strong></summary>
-
-### Verify it yourself
-
-Receipts are written to `.loki/proofs/<run_id>/` automatically at run completion
-(opt out with `LOKI_PROOF=0`). Inspect and re-check them with `loki proof`
-(aliased as `loki receipt`):
-
-```bash
-loki proof list              # every receipt: run id, time, council verdict, cost, files
-loki proof show <id>         # the full proof.json (facts, assessments, honesty)
-loki proof verify <id>       # re-check the receipt against the repo (exit 0 clean, 1 tamper/drift, 2 could not check)
-```
-
-`loki proof verify` does two independent checks and prints the result as JSON:
-
-- **Tamper check** -- recomputes the receipt's integrity hash and compares it to
-  the recorded one. If anyone edited the receipt after it was written, `hash_ok`
-  is `false`.
-- **Drift check** -- re-runs the diff from the recorded base SHA against the
-  current repo and compares the file/insertion/deletion counts and `diff_sha256`
-  to what the receipt recorded. If the repo no longer matches, `diff_drift` is
-  `true`.
-
-A clean receipt prints `"ok": true` and exits 0. A tampered or drifted receipt
-exits 1. When a check cannot run (for example a receipt with no recorded base
-SHA), the verifier reports it as unverifiable rather than passing it silently.
-
-```json
-{
-  "hash_ok": true,
-  "diff_drift": false,
-  "gpg_ok": "n/a",
-  "degraded": [],
-  "reason": "",
-  "ok": true
-}
-```
-
-You can share a receipt as a self-contained HTML page (`loki proof open <id>`),
-or publish it as a GitHub Gist with `loki proof share <id>` (opt-in; the page is
-redacted before it leaves your machine). Receipts carry an Ed25519
-attestation (`LOKI_RECEIPT_SIGNING_KEY_FILE` to use your own key).
-
-### Proven PR
-
-When Loki opens a pull request, the PR body includes the Evidence Receipt
-summary, so a reviewer does not have to take the agent on faith. It shows the
-honest verdict (VERIFIED / VERIFIED WITH GAPS / NOT VERIFIED), the key facts
-(diff hash, tests, secure-gate, cost), and a "verify this yourself" line:
-`loki proof verify <id>` against the recorded base SHA. A green claim appears
-only when the receipt's own headline is VERIFIED. This is on by default whenever
-Loki opens or advises a PR; opt out with `LOKI_PROVEN_PR=0`.
-
-For a review-before-publish workflow, preparation and GitHub mutation are two
-explicit steps:
-
-```bash
-loki start owner/repo#42 --prepare-pr  # builds and writes exact title/body locally
-loki ship --publish                    # pushes that issue branch and opens the PR
-```
-
-The second command consumes `.loki/state/pr-title.txt` and
-`.loki/state/pr-body.md` byte-for-byte. Plain `loki ship`, previews, and default
-start paths remain non-publishing. A failed PR creation preserves both files and
-prints the exact remote-branch rollback command.
-
-An optional advisory status check (`loki: verified-completion`) maps the verdict
-to a GitHub check-run. It is opt-in (`LOKI_PROVEN_PR_CHECK=1`) and can never block
-a merge on its own. To make verified-completion blocking, add it as a required
-status check in your repository's branch-protection settings.
-
-</details>
-
 <details>
 <summary><b>Setup details: providers, other models, what loki doctor checks</b></summary>
 
@@ -701,11 +416,11 @@ See the [Installation Guide](docs/INSTALLATION.md) for the long form.
 <details>
 <summary><strong>Runtime architecture: dual Bash/Bun runtime and the rollback flag</strong></summary>
 
-Loki Mode runs a dual runtime by design: the Bash engine is the stable core (the autonomous loop, quality gates and completion council), and newer product surfaces are TypeScript/Bun modules that wrap it. Bash support is not going away.
+Loki Mode v10 runs on the Bun runtime by default, which hosts the autonomous build engine. Bash is used for system integration where needed.
 
-- Commands routed to the Bun runtime when `bun` is on `PATH` (the router is `bin/loki`): `version`, `--version`, `-v`, `status`, `stats`, `doctor`, `provider`, `memory`, `rollback`, `kpis`, `trust`, `proof`, `receipt`, `wiki`, `crash`, `internal`, and `report kpis`. Every other command runs on the Bash CLI (`autonomy/loki`), including the autonomous `loki start` loop (`autonomy/run.sh`), unless `LOKI_SDK_LOOP` or `LOKI_SDK_MODE=full` selects the Bun loop.
-- If `bun` is not on `PATH`, the shim falls through to Bash silently.
-- Force every command onto the Bash path with `LOKI_LEGACY_BASH=1 loki <cmd>`. This is a rollback flag for the Bun route; it is not the same as the legacy engine switch.
+- Commands that require Bun: `version`, `--version`, `-v`, `status`, `stats`, `doctor`, `provider`, `memory`, `rollback`, `kpis`, `trust`, `wiki`, `crash`, `internal`, and `report kpis`.
+- If `bun` is not on `PATH`, commands exit 1 with installation instructions.
+- For troubleshooting, force commands onto alternate paths with environment variables; see `loki doctor` for available options.
 
 See [UPGRADING.md](UPGRADING.md) and [ADR-001: Runtime Migration](docs/architecture/ADR-001-runtime-migration.md).
 
@@ -736,14 +451,6 @@ All formats land in the same RARV pipeline and pass the same 8 quality gates (`s
 
 ---
 
-## Internal architecture (legacy engine)
-
-- **RARV cycle** - every iteration: Reason (read state), Act (execute, commit), Reflect (update context), Verify (run tests, check spec). Failures trigger self-correction. [Core Workflow](references/core-workflow.md)
-- **8 quality gates** - static analysis, test suite (pass/fail), blind 3-reviewer code review with severity blocking, anti-sycophancy Devil's Advocate, mock-integrity detection, test-mutation detection, documentation coverage, and Magic Modules debate. Backward compatibility is a conditional healing-mode auditor, not one of the 8. [Quality Gates](skills/quality-gates.md)
-- **Memory** - episodic (interaction traces), semantic (generalized patterns), procedural (learned skills). Vector search optional. [Memory Architecture](references/memory-system.md)
-- **Dashboard** - real-time monitoring, task queue, WebSocket streaming and a Live App Preview. Starts at `localhost:57374`. [Dashboard Guide](docs/dashboard-guide.md)
-- **Enterprise layer** - TLS, OIDC bearer-token validation (the foundation for SSO; browser SAML login is roadmap), scoped RBAC, OTEL tracing and audit logs, activated via env vars. See [Enterprise Identity Roadmap](docs/ENTERPRISE-IDENTITY-ROADMAP.md) and [Enterprise Guide](docs/enterprise/architecture.md).
-
 For how Loki compares with other tools, see [docs/COMPARISON.md](docs/COMPARISON.md) and [docs/EVALUATING.md](docs/EVALUATING.md).
 
 ---

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: An autonomous software factory that knows what it is supposed to deliver, and proves it did. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v10.5.35
+# Loki Mode v10.6.6
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -470,4 +470,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v10.5.35 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v10.6.6 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-10.5.35
+10.6.6

package/autonomy/loki

@@ -1782,6 +1782,7 @@ show_help() {
     echo "  syslog telemetry template test tour trigger trust trust-metrics"
     echo "  ultracode update verify version voice watch watchdog web welcome why"
     echo "  wiki worktree (wt)"
+    echo "  control (preview, needs LOKI_CONTROL=1)"
     echo ""
     echo "Any command: loki <command> --help"
     echo ""
@@ -21581,7 +21582,7 @@ status stop pause resume monitor watch watchdog dashboard web open preview share
 memory context ctx checkpoint state report kpis cost metrics stats logs otel \
 syslog telemetry crash config provider doctor setup-skill onboard quickstart \
 welcome update self-update rollback failover cluster enterprise remote deploy docker \
-sandbox api mcp magic compound assets export wiki docs explain why audit compliance \
+sandbox api mcp magic compound assets export wiki control docs explain why audit compliance \
 secrets analyze optimize bench ci reset cleanup notify trigger voice sentrux \
 worktree wt projects cp rc trust-metrics serve agent code self_update test help version"
     local best
@@ -22072,6 +22073,9 @@ main() {
         wiki)
             cmd_wiki "$@"
             ;;
+        control)
+            cmd_control "$@"
+            ;;
         magic)
             cmd_magic "$@"
             ;;
@@ -33803,6 +33807,35 @@ cmd_outcomes() {
     LOKI_DIR="${LOKI_DIR:-.loki}" python3 "$lib" "$@"
 }
 
+# loki control -- D56 control plane (preview). The live route is the Bun CLI
+# (loki-ts/src/commands/control.ts); this is the LOKI_LEGACY_BASH / no-shim
+# fallback. It keeps the gate and help in bash and hands the work to Bun.
+cmd_control() {
+    local sub="${1:-}"
+    case "$sub" in
+        ""|-h|--help|help)
+            echo "Usage: loki control <command> [options]   (preview, requires LOKI_CONTROL=1)"
+            echo ""
+            echo "Commands:"
+            echo "  serve [--port N] [--db PATH]   Run the control plane + UI on 127.0.0.1"
+            echo "  backfill [DIR]                 Ship DIR/.loki/runs to the control plane"
+            echo "  status                         Show whether the control plane is reachable"
+            return 0
+            ;;
+    esac
+    if [ "${LOKI_CONTROL:-}" != "1" ]; then
+        echo "loki control is in preview. Enable it with: export LOKI_CONTROL=1"
+        return 0
+    fi
+    local cli="$SKILL_DIR/loki-ts/dist/loki.js"
+    if ! command -v bun >/dev/null 2>&1; then
+        echo "loki control requires bun (https://bun.sh)" >&2
+        return 1
+    fi
+    [ -f "$cli" ] || cli="$SKILL_DIR/loki-ts/src/cli.ts"
+    exec bun "$cli" control "$@"
+}
+
 cmd_wiki() {
     local subcmd="${1:-}"
     shift 2>/dev/null || true

package/autonomy/telemetry.sh

@@ -168,7 +168,7 @@ _loki_known_command() {
     case "${1:-}" in
         --help|--version|-h|-v|agent|analyze|api|assets\
         |audit|bench|checkpoint|ci|cleanup|cluster|cockpit|code\
-        |completions|compliance|compound|config|context|cost|council|cp\
+        |completions|compliance|compound|config|context|control|cost|council|cp\
         |crash|ctx|dashboard|demo|deploy|docker|docs|doctor\
         |dogfood|enterprise|explain|export|failover|github|grill|handoff\
         |heal|help|import|init|internal|issue|kpis|logs\

package/bin/loki

@@ -244,8 +244,8 @@ if [ "${LOKI_LEGACY_BASH:-0}" = "1" ] || [ "${LOKI_LEGACY_BASH:-}" = "true" ]; t
 fi
 
 # Loki 10 bun resolver: bun on PATH, then an npm-installed @oven/bun-* optional
-# dependency under REPO_ROOT (postinstall moves it to node_modules/bun/bin/bun.exe;
-# under --ignore-scripts it stays in @oven/bun-<os>-<arch>). A candidate counts only if `--version` exits 0
+# dependency under REPO_ROOT (the per-platform packages ship the binary and have no
+# install scripts; node_modules/bun/bin/bun.exe is a legacy fallback). A candidate counts only if `--version` exits 0
 # within 2s. Prints the path, or nothing.
 _loki_bun_probe() {
     local c="$1" t p w rc
@@ -263,7 +263,7 @@ _loki_bun() {
     local c
     c=$(command -v bun 2>/dev/null || true)
     if [ -n "$c" ] && _loki_bun_probe "$c"; then printf '%s\n' "$c"; return 0; fi
-    for c in "$REPO_ROOT/node_modules/bun/bin/bun.exe" "$REPO_ROOT"/node_modules/@oven/bun-*/bin/bun; do
+    for c in "$REPO_ROOT"/node_modules/@oven/bun-*/bin/bun "$REPO_ROOT"/node_modules/@oven/bun-*/bin/bun.exe "$REPO_ROOT/node_modules/bun/bin/bun.exe"; do
         [ -x "$c" ] && _loki_bun_probe "$c" && { printf '%s\n' "$c"; return 0; }
     done
     return 0
@@ -271,7 +271,7 @@ _loki_bun() {
 # Reason text for the fallback notice: missing, or failed to start, exit N.
 _loki_bun_why() {
     local c rc
-    for c in "$REPO_ROOT/node_modules/bun/bin/bun.exe" "$REPO_ROOT"/node_modules/@oven/bun-*/bin/bun; do
+    for c in "$REPO_ROOT"/node_modules/@oven/bun-*/bin/bun "$REPO_ROOT"/node_modules/@oven/bun-*/bin/bun.exe "$REPO_ROOT/node_modules/bun/bin/bun.exe"; do
         [ -x "$c" ] || continue
         _loki_bun_probe "$c"; rc=$?
         echo "failed to start, exit $rc"; return 0
@@ -559,7 +559,7 @@ fi
 # Two-token routes (provider show/list, memory list/index) match on the first
 # token only; the Bun dispatcher handles subcommand routing internally.
 case "${1:-}" in
-    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|trust|proof|receipt|wiki|crash)
+    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|trust|proof|receipt|wiki|crash|control)
         # v7.5.2: rollback added (wires loki-ts/src/commands/rollback.ts).
         # v7.5.3: internal added for autonomy/run.sh phase1-hooks calls.
         # v7.5.28: kpis added (Phase K MVP: read-only KPI snapshot).

package/completions/_loki

@@ -206,6 +206,7 @@ function _loki_commands {
         'crash:Crash report management'
         'otel:OpenTelemetry management'
         'wiki:Wiki commands'
+        'control:Control plane (preview, LOKI_CONTROL=1)'
         'backlog:Run every matching open issue, N in parallel'
         'explain:Explain Loki concepts'
         'optimize:Optimization commands'

package/completions/loki.bash

@@ -5,8 +5,8 @@ _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 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 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"
-    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 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 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"
+    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 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 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"
+    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 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 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"
 
     # 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.5.35"
+__version__ = "10.6.6"
 
 # Expose the control app for easy import
 try:

package/docs/INSTALLATION.md

@@ -2,7 +2,9 @@
 
 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.5.35
+**Version:** v10.6.6
+
+**Migration Note:** Legacy engine removed in 10.6.0. Use `loki "<task>"`, `loki owner/repo#N`, or `loki backlog` instead.
 
 ---
 
@@ -149,10 +151,9 @@ Install Loki Mode without the bundled bun binary. This reduces the package size
 - OpenTelemetry instrumentation packages
 
 **What happens:**
-- The legacy bash engine runs when loki is invoked
-- Each `loki` command that would use the Loki 10 engine prints this as the first line on stderr: "loki: the Loki 10 engine cannot run on this machine: no working bun (none on PATH, and the bundled bun for darwin-aarch64 is missing). Running the legacy engine instead. To fix: install bun from https://bun.sh, or reinstall loki-mode without --omit=optional."
+- Loki 10 requires Bun. Each `loki` command prints an error on stderr if Bun is not found: "loki: the Loki 10 engine cannot run on this machine: no working bun (none on PATH, and the bundled bun for darwin-aarch64 is missing). To fix: install bun from https://bun.sh, or reinstall loki-mode without --omit=optional."
 
-**To restore Loki 10 engine access:**
+**To restore Loki access:**
 - Install bun: `curl -fsSL https://bun.sh/install | bash` or `brew install oven-sh/bun/bun`
 - Or reinstall loki-mode without the flag: `npm install -g loki-mode`
 
@@ -164,7 +165,7 @@ Install Loki Mode without the bundled bun binary. This reduces the package size
 brew tap asklokesh/tap && brew install loki-mode
 ```
 
-Installs the `loki` CLI. For the Loki 10 default engine the formula in `asklokesh/tap` needs bun; if bun is not installed, run `brew install oven-sh/bun/bun`. Without bun, each Loki 10 command prints the "no working bun" line and runs the legacy engine (see Slim install above).
+Installs the `loki` CLI. Loki 10 requires Bun; if bun is not installed, run `brew install oven-sh/bun/bun`. Without bun, each command exits 1 with an error message.
 
 To also install the skill for interactive use with all providers:
 

package/docs/v10/BOARD.md

@@ -618,6 +618,7 @@ Source: ~/git/autonomi-dev/research/2026-09-30-adoption/SWARM-PROMPT-ADOPTION.md
 | D50-F2r | D50-F2 rework, honest label only: label a test value change only on the expected side of an assert comparison or a parametrize expected value, only when the old or new value appears in the task text; wording 'assertion value changed (not shown to be required by the task): file:line old -> new' and keep the 'weakened test' line beside it; exclude control flow, range, tolerances, approx kwargs, decorators | loki-ts/src/e10ext classifier, engine10 verify and seal wiring, tests, dist | probes C D E F G H K from the F2 review all keep 'weakened test'; A labelled only when 5 appears in the task; verdict PARTIAL in every case | HIGH | building@2026-10-01T13:50Z r3 (r2 38d8ffe7 REJECTED: tolerance column never read in the body passes as expected; token boundaries let -25 match 25; required: seal re-check on the committed blob with verify counts) | none |
 | D50-F2-S3 | humanize-174 lift: let the implement brief edit an existing assertion only when the task text states the new expected value; verdict stays PARTIAL, never VERIFIED (moat). CTO call needed first: does a PARTIAL spec-required test edit count as the right outcome, and does the brief license weaken the append-only rule (context.ts:23) | loki-ts/src/e10ext/context.ts, verify and wall policy, eval fixture through implement | humanize-174 fixture through implement ends with code fixed and the spec value assertion changed, PARTIAL with an honest note | HIGH | ready (D53 ruled 12:39Z: VERIFIED allowed when the new literal is verbatim in the issue, the edit changes only that literal in an existing assert, and Wall plus other tests pass; PARTIAL never scores completed; red bypass tests for tolerance, if True to False, deleted assert, literal not in issue) | needs D50-F2r |
 | D50-F4b | D50-F4 hardening from the opus review (non-blocking): validate base from the worker-written event log as ^[0-9a-f]{40,64}$ before any git call, and skip the backstop when log.verify() fails | loki-ts/src/engine10/supervisor.ts or e10ext/commit_filter.ts, tests | a base of --output=x is refused with no git call; a tampered log runs no backstop | MEDIUM | ready@2026-10-01T13:50Z | none |
+| NPM-LAG | CORRECTED 16:14Z: v10.5.34 (ceb6942a) was accepted by npm at 15:37Z with the notice that it was being processed, and appeared in the registry only at 16:05:58Z (about 29 min; gitHead ceb6942a correct). Not a lost publish, a long npm processing delay, while the Release run already showed success. Guard: publish-npm, post-release-smoke and promote wait up to 45 min for the version (registry, no cache) before declaring it missing, and promote re-triggers when it appears, so a delay is never read as a failure or a pass (10.5.34 smoke failed ETARGET during the lag and skipped promote; rerun 16:30Z); train-cycle merges origin/main back into local main after each release (it stalled at 16:20Z with local main behind its own release) and waits on previous version visible; the release captain (train-cycle.sh) refuses the next release while the previous version is missing from npm | .github/workflows/release.yml publish-npm, scripts/train-cycle.sh, tests | a stubbed npm that never lists the version fails the step; train-cycle logs PREV_NOT_ON_NPM and waits | MEDIUM | ready@2026-10-01T16:14Z | none |
 | D53-Q1 | CTO call before D50-F2-S3: under D53(a) a bug-report task ('Expected 200, got 404') lets a test change to the buggy value pass the literal-only gate; only Wall coverage of that behaviour stops it. Options: require the new literal to sit on the expected side of an expected/should phrase in the task, or require Wall coverage of the edited assertion | docs/v10/DECISIONS.md D53 | ruling recorded | HIGH | released@2026-10-01T14:20Z (ruled in DECISIONS D53 amendment: literal must be the EXPECTED value in the acceptance criteria with a source span; Wall must cover the behaviour; unclassifiable stays PARTIAL) | none |
 | D50-F4 | aiq-52 diagnosis: on FAILED, backstopCommit runs git add -A and re-stages the commit stage's exclusions (pre-existing dirt, Wall files, stray lockfiles), so a PR with only setup dirt is pushed. Backstop applies the same exclusions; nothing left means no commit and no PR | loki-ts/src/engine10/supervisor.ts, e10ext helper, tests, dist | preexisting-dirty fixture with FAILED: HEAD equals base and no PR; with a run edit the backstop commit holds only that edit; Wall and stray lockfile never committed | HIGH | merged@2026-10-01T13:50Z 8364a03e (ed8caedf, opus APPROVE r2: filter fixture shows no token, hooks, fsmonitor, textconv or ext-diff with the supervisor env; train/61) | none |
 | D50-F5 | aiq-52 lift: already_done.ts findEvidence misses compound task keywords (searchbar vs search-command); add deterministic compound-token matching and a same-stem source plus referencing-test category pair; confirmation still must cite a real hit | loki-ts/src/e10ext/already_done.ts, tests, dist | aiq-52-shaped fixture yields a candidate; unrelated keyword, source without referencing test and short prefix yield none | HIGH | building@2026-10-01T13:50Z r3 (r2 f4aa8cc9 REJECTED: derivational suffixes, authorization vs author.ts, productivity vs product.ts; import detection counts strings, comments and docstrings) | none |