loki-mode 10.6.7 → 10.6.9

package/docs/v10/D63-CARDS.md

@@ -0,0 +1,354 @@
+# D63 remaining slice cards (Architect, main 23298d2eb)
+
+Scope: Control Plane default, Slack, Jira and Linear, multi-repo, MCP, containers, and the stub-provider E2E. Visual and contract flips and the D61 speed slices are carded elsewhere. These cards are a design; nothing here is implemented.
+
+## Findings
+
+Control Plane
+- `loki control` is gated on `LOKI_CONTROL=1` (`loki-ts/src/commands/control.ts:71`).
+- `LOKI_CONTROL_DEFAULT` exists only in bash `cmd_dashboard` (`autonomy/loki:7330`). Bare `loki` still runs `cmd_ui`, which starts the old dashboard.
+- Runs ship only when `LOKI_CONTROL_URL` is set (`engine10/supervisor.ts:189`). The `instance.json` discovery described in `docs/v10/CONTROL-PLANE.md:52` does not exist.
+- The BLOCKED answer UI exists (`packages/control-plane/ui/src/App.tsx:168-216`, `src/server/answer.ts`). It only writes `~/.loki/control/answers/<src>/<run>.answer.txt`; nothing reads that file to resume the run.
+
+Security gap (HIGH)
+- `docs/v10/CONTROL-PLANE.md:43` says a non-loopback bind refuses without `LOKI_CONTROL_TOKEN` and that `/v1` needs a Bearer token. Neither is implemented: `app.ts` has no auth middleware and `serve.ts` binds whatever `LOKI_CONTROL_HOST` says.
+- `Dockerfile.control-plane`, the Helm chart and the ECS task all set `0.0.0.0`, so the shipped container exposes unauthenticated ingest and answer-write on every interface.
+- On loopback there is no Host check (DNS rebinding).
+
+Routing (`bin/loki`)
+- `slack` is missing from the Bun allowlist at `bin/loki:570`, so the documented `loki slack serve` is unreachable from an installed CLI.
+- `jira:PROJ-1` and `linear:ENG-42` are one word and fall to the legacy engine.
+- Linear URLs (`/issue/`, singular) match neither `*/issues/*` nor `*/browse/*` and also go legacy. Only Jira `https://...atlassian.net/browse/` URLs reach v10.
+
+Slack
+- The default launcher spawns `process.execPath process.argv[1] <task>`, which is `cli.ts`, not `bin/loki`; `cli.ts` has no task route, so the launch fails.
+- The launcher passes `SLACK_BOT_TOKEN` and `SLACK_SIGNING_SECRET` into the child run's env.
+- Outbound with no webhook is already a clean no-op (`engine10/adapters/slack.ts:19`).
+
+Jira and Linear
+- Already on with no flag. A missing credential throws an error naming the variable, before any LLM call. Self-hosted Jira URLs are not parsed.
+
+Multi-repo
+- `autonomy/lib/workspace.py` is a 290-line compact version: repos run sequentially; no `show`, `status` or `clean`; no exit code 3; SIGINT not handled. The gate exists twice (`workspace.py:50`, `autonomy/loki:12926`).
+
+MCP
+- The three v10 tools are always registered. `mcp/tests/test_v10_tools.py` is not run by any runner, workflow or local-ci.
+
+Containers
+- Files exist; the only check is `packages/control-plane/test/deploy/container.test.ts`. The Dockerfile comment says "no authentication of its own". The token is optional in Helm.
+
+Stub provider (BUG-2 in E2E-D65.md)
+- A usage gap, not missing code: `LOKI_E10_INVOKER=cli` plus `LOKI_CLAUDE_CLI=<stub>` already drives v10 with a stub (`scripts/first-run-gate.sh:98`, `docs/v10/FIRST-RUN-GATE.md:11`).
+
+## File-set rules for every card
+- CHANGELOG: each card supplies its sentence; the Release Manager writes `CHANGELOG.md` at the train. No card edits it.
+- README: each card edits only the README section it names.
+- Headless tests: `LOKI_NO_BROWSER=1`, a throwaway `HOME`, `--port 0` or a stub server, never a port in 57374-57399. Stop only recorded PIDs; never kill by name or pattern.
+- Every spawn under `loki-ts/src` passes an explicit env. No stored credentials are read.
+- No new `tests/*.sh` except in C5, which owns `tests/run-all-tests.sh` and `tests/shard-durations.tsv`. Other cards extend existing suites.
+- Caps: core engine10 has 64 lines left (D71), e10ext 33 lines left. New code goes in `loki-ts/src/features` or `packages/`.
+
+---
+
+## C1 CP-AUTH: Control Plane auth enforced as documented
+- Tier: HIGH (auth, security). Budget: 30 min.
+- Goal:
+  - With `LOKI_CONTROL_TOKEN` set, every `/v1/*` call needs `Authorization: Bearer <token>`, compared with `timingSafeEqual`. `/health` and `/ready` stay open.
+  - A non-loopback `LOKI_CONTROL_HOST` without a token refuses to start: exit 2 with a line naming `LOKI_CONTROL_TOKEN`. Override: `LOKI_CONTROL_ALLOW_INSECURE_BIND=1`.
+  - On loopback, a request whose Host is not `127.0.0.1`, `localhost` or `[::1]` (any port) gets 403.
+  - The UI accepts `#token=` once, keeps it in sessionStorage and sends it on each call.
+- Files:
+  - `packages/control-plane/src/server/auth.ts` (new), `packages/control-plane/src/server/app.ts`, `packages/control-plane/src/server/serve.ts`
+  - `packages/control-plane/ui/src/api.ts`, `packages/control-plane/ui/dist/**` (rebuild)
+  - `packages/control-plane/test/server/auth.test.ts` (new)
+  - `docs/v10/CONTROL-PLANE.md` (Auth section only)
+- Wall checks:
+  - With a token: no header 401, wrong token 401, right token 200 on GET `/v1/runs`, POST `/v1/ingest`, POST `.../answer`.
+  - No token on loopback: behaviour unchanged, existing tests green.
+  - `serve.ts` with `LOKI_CONTROL_HOST=0.0.0.0` and no token exits 2 without binding (explicit env, port 0).
+  - `Host: evil.example` on loopback gives 403.
+  - Mutation: removing the middleware turns the 401 tests red.
+- Commands: `cd packages/control-plane && bun test ./test/ && bun run typecheck && bun run build:all`
+- CHANGELOG: "The Control Plane now enforces `LOKI_CONTROL_TOKEN` on every API call and refuses to listen on a non-loopback address without one."
+- Docs: `docs/v10/CONTROL-PLANE.md` Auth section.
+- Dependencies: none. Blocks C10.
+
+## C2 CP-DEFAULT: Control Plane on by default; local runs ship to it
+- Tier: MEDIUM. Budget: 30 min.
+- Goal:
+  - `LOKI_CONTROL` defaults on; `LOKI_CONTROL=0` prints one "off" line and exits 0.
+  - `serve` reads the child's "listening on" line and writes `~/.loki/control/instance.json` `{pid, port, url, version, install_path, db}` (mode 0600), removed when the CLI exits.
+  - The ship hook ships when `LOKI_CONTROL_URL` is set, or when `instance.json` names a live pid (`kill -0`) whose `/health` answers `service=loki-control` within 300 ms. It never starts a server. `LOKI_CONTROL=0` disables discovery.
+- Files:
+  - `loki-ts/src/commands/control.ts`
+  - `packages/control-plane/src/shipper/discover.ts` (new)
+  - `loki-ts/src/e10ext/ship_hook.ts` (at most 8 lines)
+  - `loki-ts/src/engine10/supervisor.ts` (line 189 only, 1-line condition change)
+  - `loki-ts/tests/commands/control_default.test.ts` (new)
+  - `tests/test-control-plane.sh` (update the "ungated" assertion)
+  - `docs/v10/CONTROL-PLANE.md` (sections 5 and 6)
+  - README "Control Plane" section
+- Wall checks:
+  - No `instance.json` gives zero fetch calls (injected fetch).
+  - A stale pid is ignored; a live stub `/health` with the wrong service is ignored; a valid instance gives one ship.
+  - `LOKI_CONTROL=0` gives no discovery.
+  - `instance.json` is mode 0600 and gone after serve exits.
+  - `budget.test.ts` passes (core under 5000, e10ext under 1500).
+- Commands: `cd loki-ts && bun test tests/commands/control_default.test.ts tests/engine10/budget.test.ts && bunx tsc --noEmit`; `bash tests/test-control-plane.sh`
+- CHANGELOG: "The Control Plane is on by default: `loki control serve` needs no flag, and runs on this machine appear in it automatically while it is running."
+- Docs: `docs/v10/CONTROL-PLANE.md` sections 5 and 6, README Control Plane section.
+- Dependencies: none. C3 builds against its `instance.json` contract.
+
+## C3 BASH-FLIPS: bare `loki` opens the Control Plane; workspace gate flips
+- Tier: MEDIUM. Budget: 30 min.
+- Goal:
+  - `cmd_ui` (bare `loki`) and `cmd_dashboard ""|start|open` use the Control Plane by default; `LOKI_CONTROL_DEFAULT=0` restores the old dashboard.
+  - Reuse a live `instance.json` URL; otherwise start `loki control serve` detached, record its PID and print the URL.
+  - Headless (`LOKI_HEADLESS=1`, `LOKI_NO_BROWSER=1` or `--no-open`): print only, never open.
+  - No bun: the old dashboard plus one line naming bun.
+  - `cmd_workspace`: the gate becomes "`LOKI_WORKSPACES=0` disables".
+  - Help lines 1633 and 1786 drop "preview" and "needs".
+- Files:
+  - `autonomy/loki` (`cmd_ui`, `cmd_dashboard` head, `cmd_workspace`, the two help lines only)
+  - `tests/test-ui-bare-loki.sh` (pin the legacy leg to `LOKI_CONTROL_DEFAULT=0`; add a Control Plane leg with a python stub answering `/health` with `service=loki-control`)
+  - `docs/dashboard.md` or the nearest dashboard doc (one paragraph)
+- Wall checks:
+  - Control Plane leg: bare `loki` with `LOKI_NO_BROWSER=1` and a stub `instance.json` prints the stub URL; the logging `open` stub has zero calls.
+  - Legacy leg output unchanged.
+  - No port in 57374-57399 bound (lsof on recorded PIDs).
+  - shellcheck on the changed test; `bash -n autonomy/loki`.
+- Commands: `bash tests/test-ui-bare-loki.sh; bash -n autonomy/loki; shellcheck tests/test-ui-bare-loki.sh`
+- CHANGELOG: "`loki` with no arguments now opens the Control Plane (set `LOKI_CONTROL_DEFAULT=0` for the previous dashboard)."
+- Docs: dashboard doc paragraph.
+- Dependencies: merges on the same train as C2 or one later.
+
+## C4 BLOCKED-RESUME: `loki answer` closes the BLOCKED loop
+- Tier: MEDIUM. Budget: 30 min.
+- Goal:
+  - New `loki answer [<run-id>] [--text "..."]`; default run is the newest BLOCKED run.
+  - Reads the run's task and question from events, and the answer from `--text` or the Control Plane answer file.
+  - Launches `bin/loki "<task>\n\nClarification answering \"<q>\": <a>"` with an explicit env (`LOKI_NO_BROWSER=1`; no `SLACK_*` and no `LOKI_CONTROL_TOKEN`) and prints the new run id.
+  - Refuses a run that is not BLOCKED (exit 2, says why).
+  - The Control Plane `writeAnswer` resume string becomes `loki answer <run>`.
+- Files:
+  - `loki-ts/src/features/blocked_answer.ts` (new, at most 120 lines)
+  - `loki-ts/src/cli.ts` (`answer` case plus the `control` help line)
+  - `packages/control-plane/src/server/answer.ts` (resume string only)
+  - `loki-ts/tests/features/blocked_answer.test.ts` (new)
+  - `packages/control-plane/test/server/answer.test.ts` (resume assertion)
+  - `docs/v10/CONTROL-PLANE.md` ("Answering a BLOCKED run" section)
+  - README "Answering a BLOCKED run" paragraph
+- Wall checks:
+  - A fixture BLOCKED run plus an answer file gives a spawn argv containing the task, question and answer (spawn injected).
+  - The env lacks `SLACK_BOT_TOKEN` and has `LOKI_NO_BROWSER=1`.
+  - A non-BLOCKED run gives exit 2.
+  - The features budget test passes.
+- Commands: `cd loki-ts && bun test tests/features/blocked_answer.test.ts tests/engine10/budget.test.ts && bunx tsc --noEmit`; `cd packages/control-plane && bun test test/server/answer.test.ts`
+- CHANGELOG: "`loki answer` resumes a BLOCKED run with the answer typed in the Control Plane (or `--text`)."
+- Docs: CONTROL-PLANE.md section and README paragraph above.
+- Dependencies: CLI reachability via C5 (unit tests independent).
+
+## C5 ROUTING: shim entry points for D65 features
+- Tier: MEDIUM. Budget: 20 min.
+- Goal:
+  - The `bin/loki:570` Bun allowlist gains `slack|answer`.
+  - v10 routing (top level and the `start` case) gains `jira:*|linear:*|https://linear.app/*/issue/*`.
+- Files:
+  - `bin/loki`
+  - `tests/test-d65-routing.sh` (new, `timeout -k`)
+  - `tests/run-all-tests.sh` (one `run_test` row)
+  - `tests/shard-durations.tsv` (one row)
+- Wall checks:
+  - With a probe bun that echoes argv: `loki slack serve` and `loki answer x` reach `cli.ts`; `loki jira:ABC-1`, `loki linear:ENG-2` and a Linear URL reach `engine10`; one-word `loki foo` stays legacy.
+  - Real-CLI leg: `loki jira:ABC-1` with no `JIRA_*` env exits non-zero in under 5 s, names `JIRA_BASE_URL`, and the stub claude logs zero calls.
+  - `tests/test-shard-coverage.sh` and shellcheck pass.
+- Commands: `bash tests/test-d65-routing.sh; bash tests/test-shard-coverage.sh; shellcheck bin/loki tests/test-d65-routing.sh`
+- CHANGELOG: "`loki jira:KEY`, `loki linear:KEY`, Linear issue URLs and `loki slack serve` now reach the Loki 10 engine directly."
+- Docs: none beyond C6 and C7 docs.
+- Dependencies: none. Merge early; C4, C6, C7, C11a, C11b CLI-level checks rely on it.
+
+## C6 SLACK: two-way Slack polished and on by default
+- Tier: MEDIUM. Budget: 25 min.
+- Goal:
+  - Inbound defaults on; `LOKI_SLACK_INBOUND=0` disables.
+  - With no `SLACK_BOT_TOKEN` or `SLACK_SIGNING_SECRET`: one line naming both, exit 2, nothing bound.
+  - The launcher spawns `REPO_ROOT/bin/loki` (not `argv[1]`) with an explicit env that strips both Slack secrets and sets `LOKI_NO_BROWSER=1`.
+  - The poster logs an HTTP failure as one redacted line.
+  - Outbound unchanged: no webhook, no call.
+- Files:
+  - `loki-ts/src/features/slack_inbound.ts`
+  - `loki-ts/tests/features/slack_inbound.test.ts`
+  - `docs/slack.md`
+  - README Slack paragraph (around line 173)
+- Wall checks:
+  - No credentials: exit 2 and `Bun.serve` never called (injected).
+  - Spawn argv[0] ends in `bin/loki`; env lacks both Slack secrets.
+  - Signed `url_verification` returns the challenge; a bad signature returns 401.
+  - BLOCKED (exit 4) posts the question; a thread reply relaunches with the clarification.
+  - `LOKI_SLACK_INBOUND=0` gives exit 2 with the disabled line.
+- Commands: `cd loki-ts && bun test tests/features/slack_inbound.test.ts && bunx tsc --noEmit`
+- CHANGELOG: "Two-way Slack is on by default: with a bot token and signing secret, `@loki <task>` in a thread starts a run and a BLOCKED question is answered in the same thread."
+- Docs: `docs/slack.md`, README Slack paragraph.
+- Dependencies: CLI reachability via C5.
+
+## C7 TRACKERS: Jira and Linear intake polish
+- Tier: MEDIUM. Budget: 20 min.
+- Goal:
+  - `LOKI_TRACKER_INTAKE=0` kill switch (`parseTrackerRef` returns null).
+  - Self-hosted Jira: `<JIRA_BASE_URL>/browse/KEY` parses when its origin equals `JIRA_BASE_URL`.
+  - Error text names the exact variables per tracker (the one fix).
+  - Linear: `errors[]` with no data, or HTTP 401, names `LINEAR_API_KEY`.
+  - Intake only; no sync claims.
+- Files:
+  - `loki-ts/src/features/tracker_intake.ts`
+  - `loki-ts/tests/engine10/tracker_intake.test.ts`
+  - `docs/trackers.md` (new)
+  - README "Issue intake" paragraph
+- Wall checks:
+  - Injected fetch only; zero network.
+  - Self-hosted URL parses only when `JIRA_BASE_URL` matches, else null.
+  - Kill switch gives null.
+  - Missing credentials: message names the variable.
+  - ADF fixture output unchanged.
+- Commands: `cd loki-ts && bun test tests/engine10/tracker_intake.test.ts && bunx tsc --noEmit`
+- CHANGELOG: "Jira (cloud and self-hosted) and Linear issues start a Loki 10 run with `loki jira:KEY` or `loki linear:KEY`, using credentials from the environment only."
+- Docs: `docs/trackers.md`, README Issue intake paragraph.
+- Dependencies: CLI reachability via C5.
+
+## C8 WORKSPACES: multi-repo parity and the flag flipped
+- Tier: MEDIUM. Budget: 30 min.
+- Goal:
+  - `enabled()` defaults on; `LOKI_WORKSPACES=0` disables.
+  - Repos with no pending `after` run in parallel, bounded by `concurrency` (default 2).
+  - Add `show <ws>` and `status [<run>]`, reading `integration.json`.
+  - Exit 3 when the only non-ok outcomes are budget stops (child exit 3); 1 otherwise.
+  - SIGINT handled like SIGTERM (killpg on recorded PIDs).
+- Files:
+  - `autonomy/lib/workspace.py`
+  - `tests/test_workspace.py`
+  - `tests/workspace/50-run.sh` (new part, auto-sourced by the registered `tests/test-workspace.sh`)
+  - `docs/WORKSPACES.md`
+  - `docs/v10/D51-PHASE-B.md` (status block)
+  - `tests/docs-drift-allowlist.tsv` (remove rows 44-46; the commands now exist)
+- Wall checks (stub launcher):
+  - Two independent repos overlap in time (start timestamps).
+  - The `after` dependent starts after its predecessor; a failed predecessor makes it SKIPPED.
+  - All children exiting 3 gives group exit 3.
+  - `status` prints per-repo rows.
+  - `LOKI_WORKSPACES=0` gives exit 2.
+  - The docs drift guard passes.
+- Commands: `python3 -m pytest tests/test_workspace.py -q && bash tests/test-workspace.sh` plus the suite that reads `docs-drift-allowlist.tsv`
+- CHANGELOG: "Multi-repo workspaces are on by default: `loki workspace run <ws> <ref>` runs each repo in parallel, respects `after` ordering and records integration evidence."
+- Docs: `docs/WORKSPACES.md`, `docs/v10/D51-PHASE-B.md`.
+- Dependencies: the bash gate flip is in C3; `workspace.py` is gated independently, so either order works.
+
+## C9 MCP: v10 tools wired into CI and documented
+- Tier: MEDIUM. Budget: 20 min.
+- Goal:
+  - `mcp/tests/test_v10_tools.py` runs in CI through the existing `tests/test-mcp-server.sh` (no new runner row).
+  - `_env()` forces `LOKI_NO_BROWSER=1` and drops `LOKI_CONTROL_TOKEN` and the Slack secrets.
+  - `v10_status` returns `blocked_question` when the verdict is BLOCKED.
+  - `v10_run` passes `jira:` and `linear:` refs through; the leading-dash guard stays.
+- Files:
+  - `mcp/v10_tools.py`
+  - `mcp/tests/test_v10_tools.py`
+  - `tests/test-mcp-server.sh`
+  - `docs/mcp.md` (or the existing MCP doc)
+  - README MCP section (with the `claude mcp add` line)
+- Wall checks:
+  - pytest green.
+  - The suite counts the v10 tests (positive control: one deliberately failing assert, run locally, turns the suite red).
+  - Child env has no secrets.
+  - A BLOCKED fixture returns the question.
+  - `tests/test-mcp-tool-surface-packaged.sh` still lists all three tools.
+- Commands: `python3 -m pytest mcp/tests/test_v10_tools.py -q && bash tests/test-mcp-server.sh && bash tests/test-mcp-tool-surface-packaged.sh`
+- CHANGELOG: "The MCP server's `loki_v10_run`, `loki_v10_status` and `loki_v10_verify` tools are tested in CI and report a BLOCKED run's question."
+- Docs: MCP doc, README MCP section.
+- Dependencies: none.
+
+## C10 CONTAINERS: image, Helm and ECS aligned with token auth
+- Tier: MEDIUM (the reviewer reads C1). Budget: 20 min.
+- Goal:
+  - Dockerfile: drop the "no authentication" comment; document that `LOKI_CONTROL_TOKEN` is required on `0.0.0.0`.
+  - Helm: `controlToken.existingSecret` required, failing at template time when unset (`required`), unless `allowInsecureBind: true` sets `LOKI_CONTROL_ALLOW_INSECURE_BIND=1`.
+  - ECS: already maps the token; README states it.
+- Files:
+  - `Dockerfile.control-plane`
+  - `deploy/helm/control-plane/**`
+  - `deploy/ecs/**`
+  - `docs/control-plane-container.md`
+  - `packages/control-plane/test/deploy/container.test.ts`
+- Wall checks (static, no helm or docker needed):
+  - The deployment template references the `LOKI_CONTROL_TOKEN` `secretKeyRef` and a `required` guard.
+  - The ECS task carries `LOKI_CONTROL_TOKEN` via `valueFrom`.
+  - Dockerfile has `USER loki`, a HEALTHCHECK on `/ready`, and no "no authentication" text.
+  - If `helm` is on PATH: `helm template` without the secret fails and with it succeeds. Otherwise the test prints SKIP (helm absent) and never passes silently.
+- Commands: `cd packages/control-plane && bun test test/deploy/`
+- CHANGELOG: "The Control Plane container, Helm chart and ECS task now require an access token whenever the service is exposed beyond localhost."
+- Docs: `docs/control-plane-container.md`, `deploy/helm/README.md`, `deploy/ecs/README.md`.
+- Dependencies: ships on the same train as C1 or later, never before.
+
+## C11a E2E-HARNESS: hermetic `npm pack` E2E, legs 1-4
+- Tier: MEDIUM. Budget: 30 min.
+- Goal: `scripts/e2e-d65.sh`
+  - `npm pack`, install into a temp prefix under a run-owned dir (`loki_run_tmp_create` pattern) with a throwaway `HOME` and `npm_config_cache`.
+  - Stub `claude` on PATH (reuse the `first-run-gate.sh` stub shape; writes only on a real `-p` call).
+  - `LOKI_E10_INVOKER=cli`, `LOKI_CLAUDE_CLI=<stub>`, `LOKI_NO_BROWSER=1`, `GIT_CONFIG_GLOBAL=/dev/null`; no `*_API_KEY` or `*_TOKEN` (`env -i` plus an allowlist).
+  - Sources `scripts/e2e-d65/legs/*.sh`; prints one `PASS|FAIL|SKIP(<reason>)` per leg; exit 0 if and only if there is no FAIL.
+  - `E2E_FORCE_FAIL=<leg>` is a positive control.
+- Legs:
+  - 1 D61 speed: `LOKI_SPEED=1` on a 2-file fixture task; receipt exists.
+  - 2 Visual evidence: no Playwright gives a NOT PROVEN line, not a failure.
+  - 3 Control Plane: `serve --port 0` (recorded PID); a run ships via `instance.json`; GET `/v1/runs` has at least one row; POST `answer` on the BLOCKED fixture returns 200.
+  - 4 Slack: `serve --port 0` with fake secrets; signed `url_verification` returns the challenge; bad signature returns 401; nothing outbound.
+- Files:
+  - `scripts/e2e-d65.sh` (new)
+  - `scripts/e2e-d65/legs/01-speed.sh`, `02-visual.sh`, `03-control.sh`, `04-slack.sh` (new)
+  - `scripts/e2e-d65/stub-claude.sh` (new)
+- Wall checks:
+  - shellcheck clean.
+  - A run on the current tree exits 0, or each FAIL names a bug.
+  - `E2E_FORCE_FAIL=3` gives exit 1.
+  - Afterwards no recorded PID is alive and the run dir is removed.
+- Commands: `bash scripts/e2e-d65.sh` (timeout 10 min); `shellcheck scripts/e2e-d65.sh scripts/e2e-d65/*.sh scripts/e2e-d65/legs/*.sh`
+- CHANGELOG: none (tooling); C11b documents it in `docs/v10/E2E-D65.md`.
+- Dependencies: final run after C1-C10 merge; leg 3 needs C2, leg 4 needs C5 and C6.
+
+## C11b E2E-LEGS: legs 5-9 and the results doc
+- Tier: MEDIUM. Budget: 30 min.
+- Legs:
+  - 5 Jira: `jira:ABC-1` against a local fake `JIRA_BASE_URL=http://127.0.0.1:<port0>` gives a run whose `issue.json` has `source=jira`; with no credentials it exits fast naming the variable.
+  - 6 Spec to contract: a `.loki/contract.json` fixture gives a receipt containing the contract section.
+  - 7 Multi-repo: two local git repos in `loki.yaml` give two runs plus `integration.json`.
+  - 8 MCP: `python3` imports `mcp.v10_tools` from the installed package; `v10_status` then `v10_verify` on leg 6's repo.
+  - 9 Containers: deploy files exist in the repo; if `docker` is on PATH and the daemon answers, build `Dockerfile.control-plane` and probe `/ready` on a random host port; otherwise SKIP(docker unavailable), never PASS.
+- Results doc: append section 6 "Stub E2E (`scripts/e2e-d65.sh`)" to `docs/v10/E2E-D65.md` with version, date, per-leg table (exit codes, seconds), the note that BUG-2 is resolved by `LOKI_E10_INVOKER=cli`, and which legs SKIP and why.
+- Files:
+  - `scripts/e2e-d65/legs/05-jira.sh`, `06-contract.sh`, `07-workspaces.sh`, `08-mcp.sh`, `09-containers.sh` (new)
+  - `docs/v10/E2E-D65.md`
+- Wall checks: as C11a, plus every leg is cited with its rc line in the doc.
+- Commands: `bash scripts/e2e-d65.sh` (with the C11a harness)
+- CHANGELOG: none (tooling).
+- Docs: `docs/v10/E2E-D65.md`.
+- Dependencies: C11a harness; leg 5 needs C5 and C7, leg 7 needs C8, leg 8 needs C9, leg 9 needs C10.
+
+## C12 STUB-INVOKER (optional; drop if fix-e2e-bugs already owns BUG-2)
+- Tier: MEDIUM. Budget: 15 min.
+- Goal: setting `LOKI_CLAUDE_CLI` implies `LOKI_E10_INVOKER=cli`, so a stub path alone drives v10. Core edit at most 3 lines.
+- Files:
+  - `loki-ts/src/engine10/session.ts` (around line 39 only)
+  - `loki-ts/tests/engine10/session_invoker.test.ts` (new)
+  - `docs/v10/FIRST-RUN-GATE.md` (one line)
+- Wall checks:
+  - `LOKI_CLAUDE_CLI` set: env has no `LOKI_SDK_LOOP`.
+  - Unset: unchanged (`LOKI_SDK_LOOP=1`).
+  - Budget test passes.
+- Commands: `cd loki-ts && bun test tests/engine10/session_invoker.test.ts tests/engine10/budget.test.ts`
+- CHANGELOG: "Setting `LOKI_CLAUDE_CLI` now selects the Claude CLI invoker, so a stub or custom `claude` binary drives Loki 10 directly."
+- Docs: `docs/v10/FIRST-RUN-GATE.md`.
+- Dependencies: none; C11a works without it.
+
+---
+
+## Ordering and parallelism
+All 12 cards can start now; file sets do not overlap. C1 (HIGH, opus reviewer) is the critical path and goes on the first train; C10 ships on the same train or later. C5 merges early because the CLI-level checks of C4, C6, C7 and both E2E cards reach their commands through it. C2 and C3 together make the Control Plane the default; they build in parallel against C2's `instance.json` contract, and C3 merges on the same train as C2 or one later. C11a and C11b start in parallel, but the final E2E runs only on a tree containing C1-C10. C12 goes only if fix-e2e-bugs has not fixed BUG-2. With 8 engineers: C1, C5, C2, C6, C7, C8, C9, C4 first; then C3, C10, C11a, C11b, C12 as seats free. Only C1 needs the HIGH review.

package/docs/v10/DECISIONS.md

@@ -491,3 +491,66 @@ A product feature, not a build-process change: `loki "small task"` should finish
 
 ## D60-5 default cost cap (2026-10-02 23:05Z)
 A Loki 10 run caps priced spend at $20.00 by default. `--max-cost N` beats loki.yaml `budgets.per_run`, which beats the default. The start line prints the cap and its source. Hitting the cap ends the run as BUDGET_STOP with exit 3. Unpriced sessions (no cost event) never count toward the cap, so a subscription or local provider never stops on it.
+
+## D62: resume now, no pause until 2026-10-07 (founder via the autonomi-dev session, 2026-10-03 about 00:05Z)
+Founder: "don't have to pause until wed oct 7th, remove that and resume now". Ends the D59 pause. Pacing follows the usage governor: week at 44% with about 4.6 days to reset, so about 0.5% per hour, seats scaled to live /usage. Trains and the D49 auto-promote continue unchanged. Priorities in order: (1) D61 speed (slice 17 large eval arm, then warm maps, then decomposer, integrator and parallel units, all behind LOKI_SPEED until the eval holds); (2) Vorflux gaps: visual evidence in PRs (local screenshots of changed pages when the repo has Playwright or a web app), multi-repo workspaces (D51 Phase B behind LOKI_WORKSPACES), Jira and Linear issue intake into v10 reusing autonomy/issue-providers.sh (intake only, no sync claims), project memory (D50 item 3); later merge queue, PR review risk score, REST API; (3) small fixes: root action.yml routes to v10 instead of `loki start --simple`, and one real end-to-end BUDGET_STOP exit 3 test. Each release reports its version and what users can now do to the autonomi-dev session.
+
+## D63: industry-standard autonomous software factory roadmap (founder via the autonomi-dev session, 2026-10-03 00:15Z)
+Founder: "I want everything top notch features and UI and connections and updates to make loki mode the industry standard best tool comparable to cognition devin, factory.ai and even 8090.ai and claude code, but fully autonomous super intelligence software factory". Recorded as the roadmap in docs/v10/ROADMAP-D63.md (nine pillars, each with a measurable bar). D50, D51, D56 and D61 slot into it. No row is done without a test or an eval row. User-facing text makes no superintelligence or benchmark claims. Build order this week, under the governor: D61 eval and warm start, visual evidence in PRs, Control Plane default with the BLOCKED answer UI, two-way Slack, Jira and Linear intake, spec to contract, multi-repo, MCP run/verify server, containers.
+
+## D64 (WITHDRAWN 2026-10-03 00:25Z, never acted on): win every Vorflux row, 10/10 ease of use, max pace (founder via the autonomi-dev session, 2026-10-03 00:20Z)
+Founder: "i want to win on all things versus vorflux and rated 10/10 in ease of use for users, anything that says vorflux wins should become loki, complete all releases towards that in fastest way and I want everything done right now". Raises D63 to max pace. The 0.5%/h pacing is lifted: as many parallel builders as the machine and CI allow (sonnet builders, haiku for docs and mechanical work, opus only for moat reviews). One hard floor: no new work starts when live /usage shows the week at 90% or above. CI gates and the two-leg promote stay. Every "Us" row in ~/git/autonomi-dev/research/vorflux/docs-teardown.md section 6 becomes a local, free Loki win, each on its own train: visual evidence (local Playwright screenshots, trace or video, in the PR and the receipt); browser testing in verify (Playwright or Cypress when present; mobile only when an emulator or simulator is already installed, said plainly otherwise; never claim coverage that did not run); D61 parallel units; triggers (`loki serve` webhooks for GitHub, Linear, Jira, plus cron); multi-repo (D51-B); merge queue (`loki merge`); PR review with a deterministic risk score (`loki review <pr>`); plan mode (`loki plan`); project memory; Jira, Linear and Sentry intake plus two-way Slack; Control Plane default with mobile layout and a REST API for runs. Ease of use is measured and gated: fresh machine to first merge-ready PR under 5 minutes, zero config with at most one decision, `loki` with no args opens the UI with guided onboarding, every error names the one fix, and an "ease" row in the first-run gate (time to first PR, prompt count) is published.
+
+D64 withdrawn (founder via the autonomi-dev session, 00:25Z): "I think your build order is better, just follow that, ignore my last message". Recorded only; no D64 builder was started. Pacing and order return to D63: about 0.5% of the week per hour at a staffing of 4, order as in docs/v10/ROADMAP-D63.md. The Vorflux section 6 rows remain a reference for later D63 items.
+
+## D65: build all nine D63 items today, then one end-to-end pass (founder via the autonomi-dev session, 2026-10-03 00:35Z)
+Founder: "this looks amazing ... i want everything done today, no testing required, first develop and complete all releases, then do one end to end testing of all things and fix bugs and make improvements". Phase 1: build all nine D63 items in D63 order, in parallel; builder-side test runs and review rounds are off (builders run typecheck and the structural dash check only, because a red train is dropped, not waited on); each slice merges and ships on trains as built. CI and the release gates are unchanged (required-ci, Tests, Bun Parity, Coverage, Security Audit, two-leg promote). The 0.5%/h pace is lifted for today; hard floor: no new work starts once live /usage shows the week at 85%, and the autonomi-dev session is told. Phase 2: from a clean `npm i -g loki-mode@latest` in a throwaway HOME, exercise every D63 feature on real push-disabled clones (augmentiq#52 plus two public eval repos), record pass or fail with evidence in docs/v10/E2E-D65.md, then fix bugs in priority order on trains. Phase 2 real-repo runs need provider auth present in the session environment; stored keys are never read.
+
+## D66: D65 feature code lives in loki-ts/src/features/ under its own cap (CTO call, 2026-10-03 02:00Z)
+The D61 decomposer (125 lines) does not fit: engine10 core is at 4,993 of its 5,000-line cap (D29, D33, never raised) and e10ext at 1,490 of 1,500 (D42). New D65 modules (decomposer, warm start, visual evidence, contract, Slack inbound, Jira/Linear fetch) go in loki-ts/src/features/, with its own 3,000-line cap and the D42 import rules (no import of stages/, seal, verify, wall or verify_cmd except whole-statement `import type`), enforced in budget.test.ts. Core and e10ext caps are unchanged; each slice's edit to engine10 or e10ext is a hook of at most a few lines, and a slice that pushes core or e10ext over its cap is trimmed or dropped at the train.
+
+## D67: authored speed tier is separate from the D34 large tier (CTO, 2026-10-03, on the Chief of Staff's request)
+- D61 slice 17 added 8 authored tasks under the lg- name with tier "large" and excluded lg-* from the D34 size gate. Rejected: the real D34/D38 large tasks are also named lg-<repo>-<issue> (EV-12F, EV-12G), so the exclusion would have exempted them on merge, and D34 already closed synthetic lg-* tasks.
+- Authored decomposition tasks are a separate tier: id prefix spd-, "tier": "speed", a boolean "decomposable", and D38 hidden-test provenance, sha256 freeze and a requirements map. No refdiff and no size gate. validate enforces the prefix and the tier in both directions.
+- D34 and D38 are unchanged. lg- and tier "large" mean only real upstream PR tasks. measure-size.py runs over every task with no name exclusion, and a test proves an unsized lg- task fails it.
+- Speed-tier results measure decomposer choice and wall-time ratio only. They are never published as large-tier, "any size" or completion-at-scale claims.
+- The LOKI_SPEED default flips only when D61 section 5 B and 5 C hold on the speed tier and LOKI_SPEED=1 is no worse than LOKI_SPEED=0 on completion, p50 wall and tokens per completed across the real medium tasks and any D34 large tasks on main, at 2 runs per arm. A loss on any axis keeps the default off.
+
+## D68: D65 12-hour mandate (founder, about 03:00Z 2026-10-03, relayed by autonomi-dev-76)
+- Founder's words: "steer with highest velocity for releasing asap everything to complete all implementation roadmap within this time.. no excuses". Deadline 15:00Z 2026-10-03; work continues after it.
+- Goal: every D63 item released to npm latest with flags ON and documented. An item whose opus D12 review has not passed ships flags-off and is named in the handoff.
+- The per-hour governor pace is lifted for 12 hours. The only usage floor is 85% of the week on live /usage (03:01Z reading: 46%). Builders scale with CI and machine load. train-cycle runs every 10 to 15 minutes; red slices are dropped, never held.
+- Unchanged: CI gates (no waivers), no stored credentials read (real-model E2E legs stay parked), P9 rerun once in full with the new diagnostics, never added to pending.txt.
+- Every release carries a CHANGELOG sentence, README and docs in the same slice, and a version report to the peer. docs/v10/MORNING-BRIEF-1003.md is written at 14:30Z (60 lines max).
+
+## D69: no founder waits (founder, about 03:05Z 2026-10-03, relayed by autonomi-dev-76)
+- Founder's words: "lokimode session should never prompt me or wait for me for anything ... complete all work with chief of staff and software factory it is".
+- The Chief of Staff and the CTO role decide every call that would go to the founder: product, scope, ordering, D12 sign-offs through the opus reviewer, and flag flips. Each decision is logged here with its rationale so the founder can reverse it.
+- Anything only the founder can physically do (credentials, licensing, external accounts, posting as himself) becomes a non-blocking FOUNDER-QUEUE.md row; work goes around it.
+- Safety rules are not founder waits and still hold: CI gates, no stored keys read, never kill by pattern, the Never list, and repo configuration (CLAUDE.md, .claude/settings.json) is not edited on a relayed request.
+
+## D70: contract and visual evidence default ON (Chief of Staff and CTO role, 03:08Z 2026-10-03, under D68 and D69)
+- The opus D12 HIGH re-review (af6ddde5) approved both after reproducing C1 and B1-B3 on the pre-fix parent and showing them fixed. D68 asks for flags on once D12 passes.
+- LOKI_CONTRACT and LOKI_VISUAL_EVIDENCE default to on; `=0` turns each off. Contract only acts when .loki/contract.json exists. Visual evidence only acts when Playwright is present and pages changed, inside its 25s budget, and otherwise writes a NOT PROVEN line, never a failure.
+- Rationale: both fail closed or advisory (neither can raise a verdict to VERIFIED); the remaining should-fixes (D65-SPEC-F1, D62-VIS-F1, D65-SPEC-F2) are non-blocking and build in parallel. Reverse by setting the defaults back to off.
+
+## D71: D61 parallel-units code lives under loki-ts/src/features/speed (CTO role, 03:08Z 2026-10-03)
+- Core engine10 measures 4936 lines against the 5000 cap (D29, D33, D42), so 64 lines remain. The cap is a gate and is not raised.
+- New D61 modules (decompose check, unit mode, integrator, group seal helpers, group output) go under loki-ts/src/features/speed/ (features budget 3000, 993 used). Each slice may add at most 10 lines of hook code to core engine10; the wave's total stays under 60, and structural-checks.sh must pass on every merge.
+- engine10/decompose.ts (slice 8) stays where it is.
+
+## D72: drop D63-C12 (stub invoker via LOKI_CLAUDE_CLI alone) (CoS with CTO, 04:13Z 2026-10-03)
+- Opus HIGH review blocked 7a83f2fa8: setting LOKI_CLAUDE_CLI alone switches to the CLI invoker, so a paid run records $0 with source "cli-invoker-unmetered", and supervisor.ts disagrees with the receipt. That breaks cost honesty in the receipt.
+- The card marked C12 optional, and an explicit LOKI_E10_INVOKER=cli already selects the CLI invoker for the stub-provider gate. Dropping it costs no user capability.
+- C11b and the D65 stub E2E use LOKI_E10_INVOKER=cli explicitly. Row set to rejected; no founder input needed (D69).
+
+
+## D60-5 addendum: INTEL-2 closed (visible cost cap)
+The $20.00 default per-run cap stays. It is a hard stop on priced sessions only; lower it with one line in loki.yaml (`budgets.per_run`) or `--max-cost`. Every v10 start line shows the cap and its source (`--max-cost`, `loki.yaml` or `default`). A run that reaches it ends BUDGET_STOP with exit 3. Unpriced sessions (subscription or local providers) never count, so the cap never fires on a guess. Proven end to end through the CLI for the flag, the yaml key and flag-over-yaml precedence (loki-ts/tests/engine10/budget_stop_e2e.test.ts, commit 0cc189106). The typical cost of a fast run has not been measured yet; the default is not justified by a run-cost figure.
+
+## D73: drop D61-12 (integrator) from the 10-03 window (CoS with CTO, 04:47Z 2026-10-03, under D68 and D69)
+- Round 8 opus review of 35a7b0c32 reproduced four cases (C1-C4) and one regression (S3) where a unit's change is missing from HEAD while the group reports merged and ready, plus a false failure on a mode-only change (E6). Probe: scratchpad rev-d61-12-r8/r8.test.ts.
+- Round 8 was declared final. Eight rounds on a HIGH Seal-adjacent surface without convergence means the per-path containment design needs rework, not another patch.
+- D61-12 is parked. D61 ships without an integrator: parallel units stay behind their flag and the integrator is not in the shipped feature set. Named in the handoff as not shipped.
+- Next window: redesign around per-resolution-commit containment (B at R^1, X at R, H at HEAD) and a revert guard for covered units, as the reviewer proposed.
+

package/docs/v10/DEPS.md

@@ -261,6 +261,8 @@ Node.js current stable: 26.10.0 (cycle 26); Python current stable: 3.14.7 (cycle
 | File | Name | Current | Latest stable | Bump | Note |
 |---|---|---|---|---|---|
 | `Dockerfile` | `ubuntu:24.04` | `ubuntu:24.04` | `24.04.5 (newest line 26.04.1)` | MAJOR | EOL 2029-05-31 (not yet); patch in line; MAJOR to newest line |
+| `Dockerfile.control-plane` | `oven/bun:1.4.2` | `oven/bun:1.4.2` | `-` | unknown | floating/arbitrary registry tag, see Docker section for endoflife-mapped images |
+| `Dockerfile.control-plane` | `oven/bun:1.4.2-slim` | `oven/bun:1.4.2-slim` | `-` | unknown | floating/arbitrary registry tag, see Docker section for endoflife-mapped images |
 | `Dockerfile.purplelab-test` | `node:22-slim` | `node:22-slim` | `22.23.3 (newest line 26.10.0)` | MAJOR | EOL 2027-04-30 (not yet); minor in line; MAJOR to newest line |
 | `Dockerfile.sandbox` | `debian:bookworm-slim` | `debian:bookworm-slim` | `12.15 (newest line 13.7)` | MAJOR | EOL 2028-06-30 (not yet); minor in line; MAJOR to newest line |
 | `Dockerfile.sandbox` | `debian:bookworm-slim` | `debian:bookworm-slim` | `12.15 (newest line 13.7)` | MAJOR | EOL 2028-06-30 (not yet); minor in line; MAJOR to newest line |
@@ -293,6 +295,8 @@ Node.js current stable: 26.10.0 (cycle 26); Python current stable: 3.14.7 (cycle
 | `deploy/helm/autonomi/tests/test-health.yaml` | `curlimages/curl:8.5.0` | `curlimages/curl:8.5.0` | `-` | unknown | floating/arbitrary registry tag, see Docker section for endoflife-mapped images |
 | `deploy/helm/autonomi/values.yaml` | `alpine/git:latest` | `alpine/git:latest` | `-` | unknown | floating/arbitrary registry tag, see Docker section for endoflife-mapped images |
 | `deploy/helm/autonomi/values.yaml` | `image.repository` | `asklokesh/loki-mode:(defaults to appVersion)` | `-` | n/a | own product image, tracked via VERSION not a third-party dep |
+| `deploy/helm/control-plane/Chart.yaml` | `appVersion` | `10.6.7` | `10.6.7` | up-to-date | repo VERSION file is 10.6.7 |
+| `deploy/helm/control-plane/Chart.yaml` | `chart dependencies` | `(none declared)` | `-` | n/a |  |
 | `helm/loki-mode/Chart.yaml` | `appVersion` | `9.19.1` | `10.2.1` | drifted | DRIFTED: chart appVersion does not track the product VERSION file (10.2.1) |
 | `helm/loki-mode/Chart.yaml` | `chart dependencies` | `(none declared)` | `-` | n/a |  |
 | `helm/loki-mode/values.yaml` | `redis:7-alpine` | `redis:7-alpine` | `-` | unknown | floating/arbitrary registry tag, see Docker section for endoflife-mapped images |
@@ -372,8 +376,8 @@ Counts are all from the single `Bump` column (current line vs newest line in the
 | Python (pyproject) | 0 | 1 | 1 | 1 | 0 | 0 | 1 | 0 | 0 |
 | GitHub Actions | 1 | 0 | 0 | 75 | 0 | 0 | 2 | 13 | 2 |
 | Runtimes | 0 | 5 | 0 | 2 | 1 | 0 | 1 | 0 | 0 |
-| Docker/Compose | 0 | 3 | 0 | 8 | 1 | 0 | 8 | 0 | 1 |
-| Helm | 0 | 0 | 0 | 0 | 0 | 2 | 5 | 0 | 34 |
+| Docker/Compose | 0 | 3 | 0 | 8 | 1 | 0 | 10 | 0 | 1 |
+| Helm | 0 | 0 | 0 | 0 | 0 | 2 | 5 | 1 | 35 |
 | Terraform | 0 | 0 | 0 | 4 | 0 | 0 | 0 | 0 | 15 |
 | Homebrew | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
 

package/docs/v10/E2E-D65.md

@@ -0,0 +1,87 @@
+# D65 Phase 2 end-to-end pass: plan, stub-leg results, bugs, operator commands
+
+Status: stub legs run 2026-10-02 (loki-mode 10.6.7 from npm `latest`, macOS arm64, bun 1.x on PATH).
+Real-provider legs are PENDING: they need `~/.config/loki/e2e.env`, which this document's author
+never read or loaded. No leg here used real provider auth.
+
+## 1. Plan
+
+Every leg starts from a clean install and never touches the operator's real HOME or any remote.
+
+1. Clean install: `npm i -g --prefix <run>/p loki-mode@<version>` with `HOME=<run>/home`,
+   `npm_config_cache=<run>/npmcache`. Record install seconds and `loki version`.
+2. Three repos:
+   - `asklokesh/augmentiq#52` (private, expected ALREADY_SATISFIED, needs gh token and provider auth: PENDING auth).
+   - `octocat/Hello-World` (tiny public repo, stub leg 1).
+   - `sindresorhus/is-plain-obj` (small public repo, stub leg 2).
+   - The gate proper (`scripts/real-repo-gate.sh`) also runs the two corpus rows (humanize-333, click) from `scripts/real-repo-gate.repos`.
+3. Push disabled: shallow clone (`--depth 1`), `git remote set-url --push origin no-push`, `GIT_CONFIG_GLOBAL=/dev/null`, `--no-pr`. Gate clones additionally set `remote.origin.pushurl=invalid://push-disabled-by-real-repo-gate`.
+4. Stub legs: a stub `claude` on PATH, `LOKI_NO_BROWSER=1`, `LOKI_DASHBOARD=false`, no API key variables. Real legs: credentials only through `LOKI_E2E_ENV_FILE` (below).
+5. Evidence per leg: exit codes, wall seconds, receipt presence, `loki verify` verdict, `loki proof verify`, diff.
+
+## 2. Stub-leg results (loki-mode 10.6.7)
+
+Install: `npm i -g --prefix ... loki-mode@latest` rc=0, 5 s (warm npm cache directory was empty, so a cold fetch), `loki version` = `Loki Mode v10.6.7`.
+
+| Leg | Repo @ SHA | Command | Exit | Wall | Receipt | `loki verify` | Notes |
+|---|---|---|---|---|---|---|---|
+| A | octocat/Hello-World @ 7fd1a60b01f91b314f59955a4e4d4e80d8edf11d | `loki start ./task.md --no-pr` (file task, exactly what the gate runs for corpus rows) | 1 | 1 s | none | rc=1, CONCERNS (empty diff) | `Unknown option: --no-pr` (BUG-1) |
+| B | octocat/Hello-World @ 7fd1a60b | `loki start "Add a short Contributing note to the README" --no-pr` (v10 route) | 1 | 4 s | yes, `.loki/runs/e10-20261003T020630Z-9ab3/receipt.json` (sha256:321a4232...) | rc=4, `NOT VERIFIED (run outcome FAILED; receipt integrity intact)` | `Not logged in` from the SDK loop; stub `claude` on PATH ignored by the v10 engine (BUG-2, BUG-3). Outcome FAILED, no diff |
+| C | sindresorhus/is-plain-obj @ 666df7c10035f7e26f27ec214fe5ae3173435f34 | `LOKI_ENGINE=legacy LOKI_MAX_ITERATIONS=1 LOKI_SDK_MODE=off LOKI_SKIP_AUTH_PREFLIGHT=1 loki start ./task.md` | 0 | 71 s | yes, `.loki/proofs/run-20261003020703-25030-19911` | rc=0, `VERDICT: VERIFIED` (2 files, +122) | `loki proof verify` rc=0 (hash_ok, headline_consistent); receipt body says `quality_gate:code_review: failed` (BUG-4) |
+| C0 | is-plain-obj @ 666df7c1 | same as C without `LOKI_SKIP_AUTH_PREFLIGHT=1` | 1 | 1 s | none | CONCERNS | Legacy auth preflight stops with `Claude Code is installed but not logged in`; correct behaviour |
+
+Push check: after every leg `git remote get-url --push origin` = `no-push`; nothing left the machine.
+
+## 3. Bugs
+
+BUG-1 (gate blocker, P1): `loki start <file> --no-pr` is rejected by the legacy parser.
+`bin/loki` routes `start` to the v10 engine only for issue refs, issue URLs and multi-word tasks (`bin/loki` start case); a path to a file stays legacy, and the legacy `cmd_start` has no `--no-pr`. `scripts/real-repo-gate.sh` runs corpus rows as `loki start <T>/issue-NAME.md --no-pr`, so both corpus rows (humanize-333, click) die in 1 s with `Unknown option: --no-pr` on a real install. The stub-`loki` test hides it because the stub accepts anything.
+Repro: `loki start ./task.md --no-pr` in any git clone; exit 1.
+Fix options: route `start <file>.md --no-pr` to v10, or accept and ignore `--no-pr` in legacy `cmd_start`, or have the gate pass the issue text as a multi-word task. Add a gate test that uses the real routing.
+
+BUG-2 (P2): the v10 engine does not use a `claude` found on PATH, so a stub provider cannot drive it.
+The SDK loop spawns its own Claude Code and reports `Not logged in` even with a stub first on PATH. The legacy engine does honor PATH `claude`. Result: v10 stub legs are impossible, so no hermetic v10 e2e exists beyond unit tests. Suggest an env override (an executable path for the SDK loop) for tests.
+Repro: Leg B.
+
+BUG-3 (P2): an unauthenticated provider is reported as a generic failure by v10.
+`loki-ts/src/engine10/machine.ts` matches only `Failed to authenticate|API key is invalid` and the credit-balance wording. The SDK's `Not logged in - Please run /login` is not matched, so the run ends `Outcome: FAILED  Reason: exit 1 (general error)` plus four NOT PROVEN items, with no pointer to the login fix. Legacy prints an actionable message.
+Repro: Leg B stderr log `.loki/runs/*/..-impl.stderr.log` contains `[sdk-loop error: Claude Code returned an error result: Not logged in ...]`.
+
+BUG-4 (P3, wording): after a legacy run whose receipt lists `quality_gate:code_review: failed` under "Not yet verified", bare `loki verify` prints `VERDICT: VERIFIED`, because it is the diff-scope deterministic verify, while the receipt headline is not a full pass. Two commands, two meanings of VERIFIED. Operators should read the receipt headline, not only `loki verify`. Repro: Leg C.
+
+Observation, not a Loki bug: my first stub appended to `README.md` on every invocation, including the auth probe, so the stub must only write on a real `-p` call.
+
+## 4. Gate script change (this commit)
+
+`scripts/real-repo-gate.sh` accepts `LOKI_E2E_ENV_FILE` (default unset, behaviour unchanged when unset). When set it requires a regular non-symlink file owned by the current user with mode 0600 (refuses with exit 2 otherwise), then loads it with `set -a; . file; set +a` inside the gate process only, output discarded, never echoed. Tested in `tests/test-real-repo-gate.sh` (0644 refused, 0600 loads, dummy value absent from stdout, stderr and logs). Caveat: the gate's per-repo log captures `loki` output, so a provider that echoes its own key would land in the log; the gate itself never writes values.
+
+## 5. Operator commands once `~/.config/loki/e2e.env` exists
+
+Create it with `umask 077` and put only the provider variables in it (`ANTHROPIC_API_KEY` or `CLAUDE_CODE_OAUTH_TOKEN`; `GH_TOKEN` for the private augmentiq repo, or rely on `gh auth login`).
+
+```bash
+chmod 600 ~/.config/loki/e2e.env
+stat -f '%Lp %Su' ~/.config/loki/e2e.env        # expect: 600 <you>
+
+# 0. Do not run until BUG-1 is fixed, or the two corpus rows fail on the file-task route.
+cd <loki-mode checkout>
+
+# 1. Local gate on the published latest (clean install, throwaway HOME, push disabled, all three repos)
+LOKI_E2E_ENV_FILE=$HOME/.config/loki/e2e.env \
+  bash scripts/real-repo-gate.sh --version "$(npm view loki-mode version)" \
+  --results "$HOME/loki-ci-logs/real-repo-gate-e2e.results"
+echo "gate exit: $?"        # 0 pass, 1 repo failed or nothing ran, 2 setup error
+
+# 2. augmentiq#52 alone, for a clearer log
+LOKI_E2E_ENV_FILE=$HOME/.config/loki/e2e.env \
+  bash scripts/real-repo-gate.sh --version "$(npm view loki-mode version)" --repo 'asklokesh/augmentiq#52'
+
+# 3. Inspect: results table and per-repo logs (logs are in the .logs dir next to the results file)
+cat "$HOME/loki-ci-logs/real-repo-gate-e2e.results"
+ls "$HOME/loki-ci-logs/real-repo-gate-e2e.logs"
+
+# 4. Confirm no push happened and nothing leaked
+grep -rIl -E 'sk-ant-|oat01-' "$HOME/loki-ci-logs/real-repo-gate-e2e.logs" || echo "no key material in logs"
+```
+
+Pass criteria per repo are in `scripts/real-repo-gate.repos` (expected outcome, allowed diff paths, max seconds); evidence to record for the log: exit code, wall seconds, Outcome line, receipt path, `loki verify` verdict.

package/docs/v10/HANDOFF-NEXT-WEEK.md

@@ -1,8 +1,7 @@
-# Handoff to next week (D59, written 2026-10-01; resume Wednesday 2026-10-07)
+# Handoff state (D59 pause ended early by D62 on 2026-10-03 about 00:05Z; work resumed, see DECISIONS D62)
 
-## On npm now
-- latest: 10.6.6 (moved by the D49 auto-promote after post-release smoke passed, seen 20:28Z; the D58 real-repo gate is not wired into promote yet).
-- next: 10.6.6 (Release run succeeded 20:12Z; npm can lag about 30 minutes, check `npm view loki-mode dist-tags`). 
+## On npm now (updated 2026-10-02T23:52Z after the D60 sprint)
+- latest and next: 10.6.7 (`npm view loki-mode dist-tags` gave latest 10.6.7, next 10.6.7 at 23:51Z; moved by the D49 auto-promote after Post-Release Smoke passed on bfce1db12; the D58 real-repo gate is still not wired into promote).
 
 ## Releases this window and their CI
 - 10.6.0 (9f9569c35, tree d922ef170): Tests, Bun Parity, Coverage, Security Audit all green on train/72 and on main. Published.
@@ -13,6 +12,13 @@
 - 10.6.5 (0472f306a): Moat suite red, P9 injection-cannot-reach-token regressed by the minimal `loki start <ref>` route (b2e3afc43): the P9 probe drives `loki start <issue>` and expects a provider session; engine10 exited rc=2 first. Not published; start route reverted (621437c0a).
 - 10.6.6 (456058bae): scope control, Control Plane v0, train-cycle fix, docs. Tests, Bun Parity, Coverage, Security Audit all green; Release succeeded. Published.
 
+## D60 sprint (2026-10-02, one hour, all five slices in 10.6.7)
+- 10.6.7 (bfce1db12, train/79 1917333e1): Tests, Bun Parity, Coverage, Security Audit, First-run gate, SBOM, Release, Post-Release Smoke, Promote all success.
+- Shipped: `loki start` runs Loki 10 (moat P9 probe ported, moat rc=0); dashboard prints the bound port (LEAK3, test-ui-bare-loki rc=0); reviewer-first PR body; issue-to-PR Action on Loki 10 plus nightly `loki backlog` example; visible cost cap ($20 default, `--max-cost`, loki.yaml `budgets.per_run`, BUDGET_STOP exit 3).
+- Open: no real end-to-end exit 3 run of the cost cap yet; root action.yml still uses `loki start --simple`.
+- D61 (speed, docs/v10/D61-SPEED.md) resumed under D62. Worktree agent-ad890c5afa3648ae6 held no saved slice 17 work (clean, no commits), so slice 17 restarts. Peer GO covers slices 1, 2, 7, 8, 17 behind LOKI_SPEED=1.
+- D58 basics 1 and 2 below are superseded by 10.6.7 (now PASS on CI; still unproven on a real repo).
+
 ## D58 basics
 1. `loki start` runs v10: FAIL. Both the minimal route (b2e3afc43, a 7-line bin/loki start arm) and the full re-route regress moat P9, because tests/moat P9 drives `loki start <issue>` through the legacy path; port that probe to the v10 issue path first, then re-land b2e3afc43. The full re-route W1-ROUTE is built (branch slice-D57-W1-ROUTE, commit a8ed5461a, which is based on the old main that still has the CP-00 JWT commits, so cherry-pick it, never merge it) but turned Tests red as listed above. Its docs follow-up is f001bc0f1.
 2. Dashboard: FAIL. LEAK3 (bound URL, scoped reuse, 57374-57399 guard; branch slice-P0-DASH-LEAK3, ceba8a6de) failed `test-ui-bare-loki` in CI and was reverted. The Control Plane v0 live view (CP-RELAND) ships in 10.6.6, off unless LOKI_CONTROL_URL is set.