From b57ac196ea848b13da069056ed3d04b67819f59d Mon Sep 17 00:00:00 2001
From: Paolo Dettori <dettori@us.ibm.com>
Date: Wed, 8 Jul 2026 22:23:08 -0400
Subject: [PATCH] docs: adopt spec/ADR/plan lifecycle + prune coded plans
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adopt an explicit documentation lifecycle and directory convention:
- docs/specs/ — committed, point-in-time design docs (what & why)
- docs/adrs/  — committed, permanent, immutable decision records
- docs/plans/ — local-only, gitignored implementation checklists

Code is the source of truth for *how*; the durable value of docs is the
*why*. Plans go stale the moment code merges, so they are local-only.

Changes:
- Add docs/adrs/ (README + ADR template: Context/Decision/Consequences/Status).
- Document the lifecycle and a Status vocabulary (Proposed → Accepted →
  Implemented → Superseded by <link>) in docs/specs/README.md.
- Gitignore docs/plans/ (keep its README so the dir stays discoverable);
  repoint the writing-plans destination to docs/plans/.
- Remove all 17 now-merged plans from docs/superpowers/plans/ and the
  now-empty docs/superpowers/ tree; the matching specs carry the why.

Merge status confirmed against history — the three "verify before deleting"
plans landed via PRs #5 (m7 cluster experiments), #14/#15 (human-gate),
and #16 (registry hardening hygiene).

Closes #79

Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>
Signed-off-by: Paolo Dettori <dettori@us.ibm.com>
---
 .gitignore                                    |    5 +
 docs/adrs/0000-adr-template.md                |   37 +
 docs/adrs/README.md                           |   46 +
 docs/plans/README.md                          |   30 +
 docs/specs/README.md                          |   33 +-
 .../2026-06-16-m1-redis-session-backend.md    | 1167 --------------
 .../plans/2026-06-17-m2-k8s-sandbox-client.md | 1262 ---------------
 .../plans/2026-06-17-m3-persistent-channel.md | 1027 ------------
 ...026-06-17-m4-knative-serverless-wrapper.md | 1321 ---------------
 .../2026-06-23-m5-compaction-checkpoint.md    |  824 ----------
 .../plans/2026-06-24-m6-experiments.md        | 1018 ------------
 .../2026-06-25-m7-cluster-experiments.md      |  614 -------
 .../2026-06-26-mvp-leaf-session-contract.md   |  793 ---------
 .../plans/2026-06-27-async-leaf-completion.md | 1273 ---------------
 .../plans/2026-06-28-human-gate.md            | 1425 -----------------
 .../2026-06-28-registry-hardening-hygiene.md  |  345 ----
 .../2026-06-28-scheduled-leaf-dispatch.md     |  516 ------
 ...26-07-02-p0prime-ocp-fs-free-deployment.md |  609 -------
 .../plans/2026-07-02-p1-fs-free-harness.md    | 1352 ----------------
 .../2026-07-02-p2-shared-sandbox-pool.md      | 1046 ------------
 ...2026-07-03-e6-workload-parameterization.md |  623 -------
 ...03-p3-sandbox-sharing-ratio-experiments.md | 1125 -------------
 22 files changed, 149 insertions(+), 16342 deletions(-)
 create mode 100644 docs/adrs/0000-adr-template.md
 create mode 100644 docs/adrs/README.md
 create mode 100644 docs/plans/README.md
 delete mode 100644 docs/superpowers/plans/2026-06-16-m1-redis-session-backend.md
 delete mode 100644 docs/superpowers/plans/2026-06-17-m2-k8s-sandbox-client.md
 delete mode 100644 docs/superpowers/plans/2026-06-17-m3-persistent-channel.md
 delete mode 100644 docs/superpowers/plans/2026-06-17-m4-knative-serverless-wrapper.md
 delete mode 100644 docs/superpowers/plans/2026-06-23-m5-compaction-checkpoint.md
 delete mode 100644 docs/superpowers/plans/2026-06-24-m6-experiments.md
 delete mode 100644 docs/superpowers/plans/2026-06-25-m7-cluster-experiments.md
 delete mode 100644 docs/superpowers/plans/2026-06-26-mvp-leaf-session-contract.md
 delete mode 100644 docs/superpowers/plans/2026-06-27-async-leaf-completion.md
 delete mode 100644 docs/superpowers/plans/2026-06-28-human-gate.md
 delete mode 100644 docs/superpowers/plans/2026-06-28-registry-hardening-hygiene.md
 delete mode 100644 docs/superpowers/plans/2026-06-28-scheduled-leaf-dispatch.md
 delete mode 100644 docs/superpowers/plans/2026-07-02-p0prime-ocp-fs-free-deployment.md
 delete mode 100644 docs/superpowers/plans/2026-07-02-p1-fs-free-harness.md
 delete mode 100644 docs/superpowers/plans/2026-07-02-p2-shared-sandbox-pool.md
 delete mode 100644 docs/superpowers/plans/2026-07-03-e6-workload-parameterization.md
 delete mode 100644 docs/superpowers/plans/2026-07-03-p3-sandbox-sharing-ratio-experiments.md

diff --git a/.gitignore b/.gitignore
index 126480d..7f2ae85 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,8 @@ secrets.*
 # OS
 .DS_Store
 Thumbs.db
+
+# Implementation plans are local-only, ephemeral work artifacts (see docs/plans/README.md).
+# They go stale the moment code merges; the durable "why" lives in docs/specs/ + docs/adrs/.
+docs/plans/*
+!docs/plans/README.md
diff --git a/docs/adrs/0000-adr-template.md b/docs/adrs/0000-adr-template.md
new file mode 100644
index 0000000..4ce6a41
--- /dev/null
+++ b/docs/adrs/0000-adr-template.md
@@ -0,0 +1,37 @@
+# ADR-NNNN: <short decision title>
+
+- **Status:** Proposed <!-- Proposed → Accepted → Superseded by ADR-NNNN / Deprecated -->
+- **Date:** YYYY-MM-DD
+- **Deciders:** <who>
+- **Spec:** [`../specs/YYYY-MM-DD-<topic>-design.md`](../specs/YYYY-MM-DD-<topic>-design.md) <!-- the deep-dive this decision came from; omit if none -->
+
+## Context
+
+What forces a decision now? The problem, the constraints, the pressures. State the facts and
+the forces at play — not the answer. Enough that a reader a year from now understands *why this
+was even a question*.
+
+## Decision
+
+The choice, stated in one or two active-voice sentences: "We will …". Name the option picked.
+
+### Alternatives considered
+
+- **<Option A>** — why not (one line).
+- **<Option B>** — why not (one line).
+
+(The full comparison lives in the linked spec; capture just enough here to show the decision
+wasn't made in a vacuum.)
+
+## Consequences
+
+What becomes easier, and what becomes harder or is now owed as follow-up. Include the costs we
+knowingly accepted — the honest ones, not just the upside.
+
+- Positive: …
+- Negative / accepted cost: …
+- Follow-up owed: …
+
+---
+
+*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/adrs/README.md b/docs/adrs/README.md
new file mode 100644
index 0000000..85b302d
--- /dev/null
+++ b/docs/adrs/README.md
@@ -0,0 +1,46 @@
+# Architecture Decision Records (ADRs)
+
+This directory is the **permanent decision spine** of the harness. An ADR captures **one
+significant decision** — the context that forced it, the choice made, and the consequences
+we accepted — in a form that stays true even as the code around it changes.
+
+## What an ADR is (and isn't)
+
+| | ADR | Spec (`../specs/`) | Plan (`../plans/`) |
+|---|---|---|---|
+| Answers | *what we decided & why* | *what & why, in depth* (alternatives, trade-offs, deferred) | *how, in what order* |
+| Size | short (one decision) | long (a whole design) | a checklist |
+| Retention | **permanent, immutable** | committed, point-in-time | **local-only, ephemeral** |
+| On change | write a **new** ADR that supersedes | add a `Status:` header, don't rewrite | delete once coded |
+
+An ADR is deliberately small: it records the *decision*, not the *design*. The full design
+lives in a dated spec under [`../specs/`](../specs/); the ADR links to it. Use an ADR when a
+choice is (a) hard to reverse, (b) cross-cutting, or (c) likely to be questioned later ("why
+Connect instead of raw gRPC?", "why is the harness filesystem-free?").
+
+## Rules
+
+1. **Immutable.** Once accepted, an ADR is never edited except to change its `Status` line
+   (e.g. to `Superseded by ADR-0007`). To change a decision, write a **new** ADR that
+   references and supersedes the old one. The record of *why we once thought otherwise* has
+   value.
+2. **Numbered, monotonic.** Files are `NNNN-kebab-title.md`, zero-padded, next free number.
+   Numbers are never reused.
+3. **One decision per ADR.** If you're recording two, write two.
+4. **Link to the spec.** The ADR states the decision; the spec carries the reasoning.
+
+## Status vocabulary
+
+`Proposed` → `Accepted` → `Superseded by ADR-NNNN` (or `Deprecated`). Same vocabulary as
+specs (see [`../specs/README.md`](../specs/README.md#documentation-lifecycle)).
+
+## Creating one
+
+```sh
+cp docs/adrs/0000-adr-template.md docs/adrs/NNNN-your-decision.md
+# fill in Context / Decision / Consequences; set Status: Accepted; link the spec
+```
+
+---
+
+*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/plans/README.md b/docs/plans/README.md
new file mode 100644
index 0000000..2aba5af
--- /dev/null
+++ b/docs/plans/README.md
@@ -0,0 +1,30 @@
+# Implementation plans (local-only, gitignored)
+
+Plans that describe **how** to build something — ordered steps, checklists, task
+breakdowns — live here **on your machine only**. Everything in this directory except this
+README is gitignored (see the repo `.gitignore`).
+
+## Why plans aren't committed
+
+A plan answers *how, in what order*. The moment the code merges, the code becomes the source
+of truth for *how* — the plan is now a stale, lower-fidelity copy. The durable value of our
+docs is the ***why***: the decisions and rejected alternatives. Those live in:
+
+- **[`../specs/`](../specs/)** — dated design docs (*what & why*, in depth).
+- **[`../adrs/`](../adrs/)** — permanent decision records (*one decision + consequences*).
+
+So a plan's whole life is: write it → execute it → **delete it**. Committing it would just
+create a maintenance burden that goes stale and misleads.
+
+## Workflow
+
+1. Write your plan here: `docs/plans/YYYY-MM-DD-<topic>.md` (named for the spec it implements).
+2. Execute it.
+3. Delete it once the work is coded and merged. The matching spec + the code carry everything
+   that remains true.
+
+New plans authored via the writing-plans workflow land here by convention.
+
+---
+
+*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/specs/README.md b/docs/specs/README.md
index 8c770df..a19a872 100644
--- a/docs/specs/README.md
+++ b/docs/specs/README.md
@@ -135,6 +135,35 @@ live only in identity-keyed egress points. Dependency-ordered:
 
 ---
 
+## Documentation lifecycle
+
+Three artifact types, three lifecycles. Code is the source of truth for *how*; the durable
+value of docs is the *why* — decisions and the alternatives we rejected.
+
+| Artifact | Answers | Retention | Home |
+|---|---|---|---|
+| **Spec** (design doc) | *what & why* — alternatives, trade-offs, deferred work | committed, point-in-time; mark `Superseded by …`, don't delete | `docs/specs/` (here) |
+| **ADR** | one significant decision + context + consequences | committed, **permanent & immutable**, supersession-aware | [`docs/adrs/`](../adrs/) |
+| **Plan** (impl steps) | *how, in what order* | **local-only, ephemeral** — delete once coded; never committed | [`docs/plans/`](../plans/) (gitignored) |
+
+- A **spec** is a dated deep-dive. It's never retro-edited — a superseded spec gets a
+  `Status:` header pointing at its successor and stays in git as the point-in-time record.
+- An **ADR** is the permanent spine: a short, immutable record of a single decision that links
+  out to the spec for the full reasoning. See [`docs/adrs/README.md`](../adrs/README.md).
+- A **plan** is a throwaway checklist, obsolete the moment the code merges — so plans are
+  local-only work artifacts (gitignored). See [`docs/plans/README.md`](../plans/README.md).
+
+### Status vocabulary (specs & ADRs)
+
+Every spec and ADR carries a `Status:` line in its header, drawn from:
+
+> `Proposed` → `Accepted` → `Implemented` → `Superseded by <link>` (or `Deprecated`)
+
+When a design is replaced, set the old spec's status to `Superseded by <link to successor>`
+rather than deleting it — the record of what we once thought, and why we changed, has value.
+(For example, the removed Redis-transport remote-exec design is marked superseded by the
+gRPC/Connect sandbox-transport spec, which records the supersession in its own §12.)
+
 ## Conventions going forward
 
 - **New Phase-2 specs** take the next free **`Zx`** id and record it in this table.
@@ -142,8 +171,8 @@ live only in identity-keyed egress points. Dependency-ordered:
   lives here, not in the filename, to avoid rename churn.
 - Each spec keeps the existing header block (Version / Status / Scope / Builds-on); cross-reference
   by **canonical id** (e.g. "Z3") with the filename in parentheses on first mention.
-- Implementation plans live in `docs/superpowers/plans/` per repo convention, named for the spec
-  they implement.
+- Implementation plans live in [`docs/plans/`](../plans/) (local-only, gitignored), named for the
+  spec they implement, and are deleted once the work is coded and merged.
 
 ---
 
diff --git a/docs/superpowers/plans/2026-06-16-m1-redis-session-backend.md b/docs/superpowers/plans/2026-06-16-m1-redis-session-backend.md
deleted file mode 100644
index 7c81708..0000000
--- a/docs/superpowers/plans/2026-06-16-m1-redis-session-backend.md
+++ /dev/null
@@ -1,1167 +0,0 @@
-# M1: Redis SessionStorageBackend Integration — Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Make Pi persist session state to Redis instead of local JSONL, transparently, so a session can be resumed by a fresh process with no local files — proven by deterministic automated tests plus one real headless smoke.
-
-**Architecture:** Three layers with a one-way dependency arrow. (1) `@sh/session-backend` is a generic, entry-agnostic append-only log store (`LogStore<E>`) with a Redis Streams implementation. (2) `pi-fork` core gains a `SessionStorageBackend` interface (FileEntry-facing, mirrors issue #2032) that `SessionManager` delegates to when injected; the default file path is left untouched. (3) The `harness` package holds a `BufferedRedisBackend` decorator (write-behind queue + `flush()`) that adapts the generic store to Pi's interface, plus the integration tests and the headless smoke entry. **Pi core never imports Redis or `@sh/session-backend`.**
-
-**Tech Stack:** TypeScript (ESM), pnpm workspaces, vitest, Redis (`redis` v6 client, Streams), Pi (`@earendil-works/pi-coding-agent`) pinned at commit `406a2214`.
-
----
-
-## Spec
-
-Implements [`docs/specs/2026-06-16-m1-redis-session-backend-design.md`](../../specs/2026-06-16-m1-redis-session-backend-design.md). Discovery basis: [`packages/session-backend/NOTES-pi-sessionmanager.md`](../../../packages/session-backend/NOTES-pi-sessionmanager.md).
-
-### Planning-time refinements to the spec (read before starting)
-
-These resolve concrete topology issues found while reading Pi source. They preserve the spec's intent (native passthrough, upstreamable seam, one-way dependency):
-
-1. **The interface is split, not shared.** Pi core owns a **FileEntry-facing** `SessionStorageBackend` (this is the #2032 contribution). `@sh/session-backend` stays **entry-agnostic** (`LogStore<E>`, stores opaque JSON) so it needs zero Pi types and avoids cross-submodule build coupling. The `harness` package is where the two meet — `BufferedRedisBackend` implements Pi's interface using a `LogStore`.
-2. **Pi-core injection is a guarded parallel path, not a full file-I/O extraction.** When a backend is injected, `_persist`/load route to it; when absent, the existing file code runs **literally unchanged**. The regression guard is therefore "Pi's existing test suite stays green" (stronger than a new parity test). A full `FileSessionStorageBackend` extraction is deferred to upstreaming time.
-3. **The SDK already injects a `SessionManager`** (`createAgentSession({ sessionManager })`), so the headless smoke needs **no `main.ts` edits** — only Tasks 3–4 touch `pi-fork`.
-
----
-
-## File structure
-
-| File | Responsibility | Task |
-|------|----------------|------|
-| `packages/session-backend/src/entry.ts` | Generic `StoredEntry<E>` envelope + `makeStoredEntry` (rewrite) | 1 |
-| `packages/session-backend/src/backend.ts` | Generic `LogStore<E>` interface (rewrite) | 2 |
-| `packages/session-backend/src/redis-backend.ts` | `RedisSessionBackend<E>` implements `LogStore<E>` (rewrite) | 2 |
-| `packages/session-backend/src/index.ts` | Barrel export (new) | 2 |
-| `pi-fork/.../core/session-storage-backend.ts` | Pi's `SessionStorageBackend` interface (new) | 3 |
-| `pi-fork/.../core/session-manager.ts` | Inject backend into `SessionManager` (modify) | 4 |
-| `pi-fork/.../core/index.ts` + `src/index.ts` | Export the interface + `FileEntry` (modify) | 3 |
-| `pi-fork/.../test/session-backend-seam.test.ts` | Seam test with in-memory fake backend (new) | 4 |
-| `harness/package.json`, `harness/vitest.config.ts` | Package scaffold (new) | 5 |
-| `harness/src/buffered-redis-backend.ts` | `BufferedRedisBackend` decorator (new) | 5 |
-| `harness/test/buffered-redis-backend.test.ts` | Decorator unit tests, fake store (new) | 5 |
-| `harness/test/integration.test.ts` | SessionManager↔Redis parity/mobility/recovery (new) | 6 |
-| `harness/src/flush-extension.ts` | Pi extension: flush on `turn_end`/`session_shutdown` (new) | 7 |
-| `harness/src/cli.ts` | Headless smoke entry (new) | 7 |
-| `harness/README.md`, root `README.md` | Docs (modify) | 8 |
-
----
-
-## Prerequisites (do once, before Task 1)
-
-- [ ] **P1: Create a tracked branch in the Pi fork** (so fork edits are committed, not detached)
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness/pi-fork
-git checkout -b feat/session-storage-backend
-git rev-parse --abbrev-ref HEAD   # expect: feat/session-storage-backend
-cd ..
-```
-
-- [ ] **P2: Start a local Redis** (Tasks 2 and 6 need it)
-
-```bash
-docker run -d --rm --name sh-redis -p 6379:6379 redis:7
-docker exec sh-redis redis-cli ping   # expect: PONG
-```
-
-- [ ] **P3: Confirm the workspace lists the `harness` package**
-
-Run: `grep -A2 packages /Users/paolo/Projects/aiplatform/serverless-harness/pnpm-workspace.yaml`
-Expected: output includes both `"packages/*"` and `"harness"`. (It already does — no edit needed.)
-
----
-
-## Task 1: Generic storage envelope (`@sh/session-backend`)
-
-**Files:**
-- Modify: `packages/session-backend/src/entry.ts`
-- Test: `packages/session-backend/test/entry.test.ts`
-
-- [ ] **Step 1: Replace the test with envelope tests**
-
-Replace the entire contents of `packages/session-backend/test/entry.test.ts`:
-
-```ts
-import { describe, it, expect } from "vitest";
-import { makeStoredEntry } from "../src/entry";
-
-describe("makeStoredEntry", () => {
-  it("wraps an opaque entry and hashes its JSON", () => {
-    const e = makeStoredEntry({
-      position: 1, session_id: "s", piType: "message",
-      entry: { type: "message", x: 1 },
-    });
-    expect(e.position).toBe(1);
-    expect(e.session_id).toBe("s");
-    expect(e.piType).toBe("message");
-    expect(e.entry).toEqual({ type: "message", x: 1 });
-    expect(e.content_sha256).toMatch(/^[0-9a-f]{64}$/);
-    expect(e.timestamp).toBe(0); // default when not provided
-  });
-
-  it("is deterministic: equal entries -> equal hash regardless of envelope fields", () => {
-    const a = makeStoredEntry({ position: 1, session_id: "s", piType: "t", entry: { a: 1 } });
-    const b = makeStoredEntry({ position: 9, session_id: "s2", piType: "t", entry: { a: 1 } });
-    expect(a.content_sha256).toBe(b.content_sha256);
-  });
-
-  it("different entry content -> different hash", () => {
-    const a = makeStoredEntry({ position: 1, session_id: "s", piType: "t", entry: { a: 1 } });
-    const b = makeStoredEntry({ position: 1, session_id: "s", piType: "t", entry: { a: 2 } });
-    expect(a.content_sha256).not.toBe(b.content_sha256);
-  });
-});
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `pnpm -C packages/session-backend exec vitest run test/entry.test.ts`
-Expected: FAIL — `makeStoredEntry` is not exported (current file exports `makeEntry`).
-
-- [ ] **Step 3: Rewrite `entry.ts` with the generic envelope**
-
-Replace the entire contents of `packages/session-backend/src/entry.ts`:
-
-```ts
-// packages/session-backend/src/entry.ts
-import { createHash } from "node:crypto";
-
-/**
- * A stored log record: a thin envelope around an opaque harness-native entry.
- * The store never interprets `entry` except via the denormalized `piType`.
- */
-export interface StoredEntry<E = unknown> {
-  position: number;        // monotonic 1-based offset; powers read(fromPosition)
-  session_id: string;
-  piType: string;          // denormalized copy of the entry's discriminant, for cheap filtering
-  entry: E;                // harness-native entry, stored & returned verbatim
-  content_sha256: string;  // integrity hash of `entry` (canonical JSON)
-  timestamp: number;       // wall-clock ms; audit only, not ordering
-}
-
-export function makeStoredEntry<E>(args: {
-  position: number;
-  session_id: string;
-  piType: string;
-  entry: E;
-  timestamp?: number;
-}): StoredEntry<E> {
-  const payload = JSON.stringify(args.entry ?? null);
-  return {
-    position: args.position,
-    session_id: args.session_id,
-    piType: args.piType,
-    entry: args.entry,
-    content_sha256: createHash("sha256").update(payload).digest("hex"),
-    timestamp: args.timestamp ?? 0, // caller stamps real time; 0 keeps this pure/testable
-  };
-}
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `pnpm -C packages/session-backend exec vitest run test/entry.test.ts`
-Expected: PASS (3 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/session-backend/src/entry.ts packages/session-backend/test/entry.test.ts
-git commit -m "refactor(session-backend): generic StoredEntry envelope (native passthrough)"
-```
-
----
-
-## Task 2: Generic `LogStore` interface + Redis implementation (`@sh/session-backend`)
-
-**Files:**
-- Modify: `packages/session-backend/src/backend.ts`
-- Modify: `packages/session-backend/src/redis-backend.ts`
-- Create: `packages/session-backend/src/index.ts`
-- Modify: `packages/session-backend/package.json` (add `exports`)
-- Test: `packages/session-backend/test/redis-backend.test.ts`
-
-- [ ] **Step 1: Rewrite the Redis test for the new entry-agnostic signature**
-
-Replace the entire contents of `packages/session-backend/test/redis-backend.test.ts`:
-
-```ts
-import { describe, it, expect, beforeEach, afterAll } from "vitest";
-import { RedisSessionBackend } from "../src/redis-backend";
-
-const SID = "test-" + process.pid;
-const b = new RedisSessionBackend<{ type: string; customType?: string; n?: number }>("redis://127.0.0.1:6379");
-
-beforeEach(async () => { await b.reset(SID); });
-afterAll(async () => { await b.reset(SID); await b.close(); });
-
-describe("RedisSessionBackend (LogStore)", () => {
-  it("appends opaque entries and reads them back in order with monotonic positions", async () => {
-    await b.append(SID, { type: "message", n: 1 }, "message");
-    await b.append(SID, { type: "message", n: 2 }, "message");
-    const rows = await b.read(SID);
-    expect(rows.map(r => r.position)).toEqual([1, 2]);
-    expect(rows.map(r => r.entry.n)).toEqual([1, 2]);
-    expect(rows[0].piType).toBe("message");
-  });
-
-  it("read(fromPosition) returns only the tail", async () => {
-    await b.append(SID, { type: "message" }, "message");
-    await b.append(SID, { type: "custom", customType: "checkpoint" }, "custom");
-    await b.append(SID, { type: "message" }, "message");
-    const tail = await b.read(SID, 2);
-    expect(tail.map(r => r.position)).toEqual([2, 3]);
-  });
-
-  it("latestWhere returns the newest matching entry", async () => {
-    await b.append(SID, { type: "custom", customType: "checkpoint" }, "custom"); // pos 1
-    await b.append(SID, { type: "message" }, "message");                          // pos 2
-    await b.append(SID, { type: "custom", customType: "checkpoint" }, "custom"); // pos 3
-    const cp = await b.latestWhere(SID, e => e.type === "custom" && e.customType === "checkpoint");
-    expect(cp?.position).toBe(3);
-  });
-
-  it("returns the entry verbatim (round-trip identity)", async () => {
-    const entry = { type: "custom", customType: "checkpoint", n: 42 };
-    await b.append(SID, entry, "custom");
-    const [row] = await b.read(SID);
-    expect(row.entry).toEqual(entry);
-  });
-});
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `pnpm -C packages/session-backend exec vitest run test/redis-backend.test.ts`
-Expected: FAIL — `append` still has the old `(NewEntry)` signature; `latestWhere`/`close` don't exist.
-
-- [ ] **Step 3: Rewrite `backend.ts` with the generic interface**
-
-Replace the entire contents of `packages/session-backend/src/backend.ts`:
-
-```ts
-// packages/session-backend/src/backend.ts
-import type { StoredEntry } from "./entry";
-
-/**
- * Generic append-only log store. Entry-agnostic: stores opaque `E` records keyed
- * by session_id. Shaped to upstream Pi issue #2032, but kept free of any Pi types
- * so this package has no dependency on the fork.
- */
-export interface LogStore<E = unknown> {
-  /** Append one entry; returns the stored envelope (with assigned position + hash). */
-  append(session_id: string, entry: E, piType: string): Promise<StoredEntry<E>>;
-  /** Read entries in append order, optionally from a 1-based position offset. */
-  read(session_id: string, fromPosition?: number): Promise<StoredEntry<E>[]>;
-  /** Most recent entry whose payload satisfies `predicate`, or null. */
-  latestWhere(session_id: string, predicate: (entry: E) => boolean): Promise<StoredEntry<E> | null>;
-  /** Next position index for a session (1-based; equals current count + 1). */
-  nextPosition(session_id: string): Promise<number>;
-  /** All known session ids. */
-  list(): Promise<string[]>;
-}
-```
-
-- [ ] **Step 4: Rewrite `redis-backend.ts`**
-
-Replace the entire contents of `packages/session-backend/src/redis-backend.ts`:
-
-```ts
-// packages/session-backend/src/redis-backend.ts
-import { createClient, type RedisClientType } from "redis";
-import { makeStoredEntry, type StoredEntry } from "./entry";
-import type { LogStore } from "./backend";
-
-const streamKey = (sid: string) => `session:${sid}`;
-const seqKey = (sid: string) => `session:${sid}:seq`;
-
-/**
- * Redis Streams implementation of LogStore. Single-writer-per-session: a session is
- * owned by one harness instance at a time (mobility is sequential handoff, never
- * concurrent), so INCR(position) then XADD is safe without a transaction.
- */
-export class RedisSessionBackend<E = unknown> implements LogStore<E> {
-  private client: RedisClientType;
-  private ready: Promise<void>;
-  constructor(url = process.env.REDIS_URL ?? "redis://127.0.0.1:6379") {
-    this.client = createClient({ url });
-    this.ready = this.client.connect().then(() => undefined);
-  }
-
-  async nextPosition(sid: string): Promise<number> {
-    await this.ready;
-    return this.client.incr(seqKey(sid));
-  }
-
-  async append(sid: string, entry: E, piType: string): Promise<StoredEntry<E>> {
-    await this.ready;
-    const position = await this.nextPosition(sid);
-    const stored = makeStoredEntry({ position, session_id: sid, piType, entry, timestamp: Date.now() });
-    await this.client.xAdd(streamKey(sid), "*", {
-      position: String(stored.position),
-      timestamp: String(stored.timestamp),
-      piType: stored.piType,
-      entry: JSON.stringify(stored.entry),
-      content_sha256: stored.content_sha256,
-    });
-    return stored;
-  }
-
-  async read(sid: string, fromPosition = 1): Promise<StoredEntry<E>[]> {
-    await this.ready;
-    const rows = await this.client.xRange(streamKey(sid), "-", "+");
-    return rows
-      .map((r): StoredEntry<E> => ({
-        position: Number(r.message.position),
-        timestamp: Number(r.message.timestamp),
-        session_id: sid,
-        piType: r.message.piType,
-        entry: JSON.parse(r.message.entry) as E,
-        content_sha256: r.message.content_sha256,
-      }))
-      .filter((e) => e.position >= fromPosition);
-  }
-
-  async latestWhere(sid: string, predicate: (entry: E) => boolean): Promise<StoredEntry<E> | null> {
-    const all = await this.read(sid);
-    const matches = all.filter((e) => predicate(e.entry));
-    return matches.length ? matches[matches.length - 1] : null;
-  }
-
-  async list(): Promise<string[]> {
-    await this.ready;
-    const keys = await this.client.keys("session:*");
-    return keys.filter((k) => !k.endsWith(":seq")).map((k) => k.slice("session:".length));
-  }
-
-  /** Test helper: delete a session's stream + sequence counter. */
-  async reset(sid: string): Promise<void> {
-    await this.ready;
-    await this.client.del([streamKey(sid), seqKey(sid)]);
-  }
-
-  /** Close the connection (call in test teardown). */
-  async close(): Promise<void> {
-    await this.ready;
-    await this.client.quit();
-  }
-}
-```
-
-- [ ] **Step 5: Create the barrel export `src/index.ts`**
-
-Create `packages/session-backend/src/index.ts`:
-
-```ts
-// packages/session-backend/src/index.ts
-export type { StoredEntry } from "./entry";
-export { makeStoredEntry } from "./entry";
-export type { LogStore } from "./backend";
-export { RedisSessionBackend } from "./redis-backend";
-```
-
-- [ ] **Step 6: Add an `exports` field so the `harness` package can import `@sh/session-backend`**
-
-In `packages/session-backend/package.json`, add a top-level `"exports"` key (sibling of `"version"`):
-
-```json
-  "exports": {
-    ".": "./src/index.ts"
-  },
-```
-
-(Both consumers run under vitest/esbuild, which resolve the `.ts` source directly — no build step for this package.)
-
-- [ ] **Step 7: Run the test to verify it passes** (Redis from P2 must be running)
-
-Run: `pnpm -C packages/session-backend exec vitest run`
-Expected: PASS (entry.test.ts 3 + redis-backend.test.ts 4).
-
-- [ ] **Step 8: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/session-backend
-git commit -m "refactor(session-backend): entry-agnostic LogStore + Redis impl (append/read/latestWhere)"
-```
-
----
-
-## Task 3: Define Pi's `SessionStorageBackend` interface (`pi-fork`)
-
-**Files:**
-- Create: `pi-fork/packages/coding-agent/src/core/session-storage-backend.ts`
-- Modify: `pi-fork/packages/coding-agent/src/index.ts` (export interface + `FileEntry`)
-
-> All `pi-fork` work happens on the `feat/session-storage-backend` branch (P1). Commits in this task and Tasks 4 & 7 are made **inside the submodule**; Task 8 bumps the parent repo's submodule pointer.
-
-- [ ] **Step 1: Create the interface file**
-
-Create `pi-fork/packages/coding-agent/src/core/session-storage-backend.ts`:
-
-```ts
-import type { FileEntry } from "./session-manager.ts";
-
-/**
- * Pluggable storage backend for session persistence (mirrors issue #2032).
- *
- * The default is local-file persistence inside SessionManager. When an instance is
- * injected, SessionManager delegates persistence and load to it, externalizing the
- * session log (e.g. to Redis). The interface deals in Pi's native FileEntry — the
- * backend stores and returns entries verbatim (native passthrough).
- *
- * Writes are fire-and-forget from SessionManager's synchronous append path; the
- * caller (harness) is responsible for awaiting durability at turn boundaries.
- */
-export interface SessionStorageBackend {
-  /** Append one entry to the session's log. */
-  append(sessionId: string, entry: FileEntry): Promise<void>;
-  /** Read entries in append order, optionally from a 1-based position offset. */
-  read(sessionId: string, fromPosition?: number): Promise<FileEntry[]>;
-  /** Most recent checkpoint entry (a custom entry with customType "checkpoint"), or null. */
-  latestCheckpoint(sessionId: string): Promise<FileEntry | null>;
-  /** All known session ids. */
-  list(): Promise<string[]>;
-}
-```
-
-- [ ] **Step 2: Export the interface and `FileEntry` from the package index**
-
-In `pi-fork/packages/coding-agent/src/index.ts`, find the existing block that exports from `./core/session-manager.ts` (around line 217, which already exports `SessionManager`). Immediately after that block, add:
-
-```ts
-export type { FileEntry, SessionEntry, SessionHeader } from "./core/session-manager.ts";
-export type { SessionStorageBackend } from "./core/session-storage-backend.ts";
-```
-
-- [ ] **Step 3: Typecheck the fork builds**
-
-Run: `pnpm -C pi-fork/packages/coding-agent exec tsc --noEmit`
-Expected: PASS (no type errors). If `tsc` is not wired, run `pnpm -C pi-fork install` first, then retry.
-
-- [ ] **Step 4: Commit (inside the submodule)**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness/pi-fork
-git add packages/coding-agent/src/core/session-storage-backend.ts packages/coding-agent/src/index.ts
-git commit -m "feat(coding-agent): add SessionStorageBackend interface (#2032 shape)"
-cd ..
-```
-
----
-
-## Task 4: Inject the backend into `SessionManager` (`pi-fork`)
-
-**Files:**
-- Modify: `pi-fork/packages/coding-agent/src/core/session-manager.ts`
-- Test: `pi-fork/packages/coding-agent/test/session-backend-seam.test.ts`
-
-This task adds a guarded backend path. **The existing file path must remain byte-for-byte behavior-identical** (guarded by `if (this.backend)` / `if (!this.backend)`).
-
-- [ ] **Step 1: Write the failing seam test**
-
-Create `pi-fork/packages/coding-agent/test/session-backend-seam.test.ts`:
-
-```ts
-import { describe, it, expect } from "vitest";
-import { SessionManager } from "../src/core/session-manager.ts";
-import type { SessionStorageBackend } from "../src/core/session-storage-backend.ts";
-import type { FileEntry } from "../src/core/session-manager.ts";
-
-/** In-memory backend that pushes synchronously (so fire-and-forget writes are observable). */
-class FakeBackend implements SessionStorageBackend {
-  store = new Map<string, FileEntry[]>();
-  append(sessionId: string, entry: FileEntry): Promise<void> {
-    const arr = this.store.get(sessionId) ?? [];
-    arr.push(entry);
-    this.store.set(sessionId, arr);
-    return Promise.resolve();
-  }
-  read(sessionId: string, fromPosition = 1): Promise<FileEntry[]> {
-    return Promise.resolve((this.store.get(sessionId) ?? []).slice(fromPosition - 1));
-  }
-  latestCheckpoint(sessionId: string): Promise<FileEntry | null> {
-    const arr = (this.store.get(sessionId) ?? []).filter(
-      (e) => e.type === "custom" && (e as { customType?: string }).customType === "checkpoint",
-    );
-    return Promise.resolve(arr.length ? arr[arr.length - 1] : null);
-  }
-  list(): Promise<string[]> {
-    return Promise.resolve([...this.store.keys()]);
-  }
-}
-
-describe("SessionManager backend seam", () => {
-  it("persists a turn to the backend and resumes an identical tree in a fresh instance", async () => {
-    const backend = new FakeBackend();
-    const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-    const sid = sm.getSessionId();
-
-    sm.appendMessage({ role: "user", content: "hello" } as never);
-    sm.appendMessage({ role: "assistant", content: "hi there" } as never);
-    sm.appendCustomEntry("checkpoint", { ctx: "reconstructed" });
-    sm.appendMessage({ role: "user", content: "again" } as never);
-
-    // Header + 4 entries landed in the backend, in order.
-    const stored = backend.store.get(sid)!;
-    expect(stored[0].type).toBe("session");
-    expect(stored.map((e) => e.type)).toEqual(["session", "message", "message", "custom", "message"]);
-
-    // Fresh instance reconstructs the identical entry list.
-    const resumed = await SessionManager.openFromBackend(sid, backend, process.cwd());
-    expect(resumed.getEntries().map((e) => JSON.stringify(e))).toEqual(
-      sm.getEntries().map((e) => JSON.stringify(e)),
-    );
-
-    // Checkpoint is findable.
-    const cp = await backend.latestCheckpoint(sid);
-    expect((cp as { customType?: string }).customType).toBe("checkpoint");
-  });
-});
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `pnpm -C pi-fork/packages/coding-agent exec vitest run test/session-backend-seam.test.ts`
-Expected: FAIL — `SessionManager.create` takes no 4th arg / `openFromBackend` does not exist.
-
-- [ ] **Step 3: Add the import and the backend field**
-
-In `pi-fork/packages/coding-agent/src/core/session-manager.ts`:
-
-At the top with the other imports, add:
-
-```ts
-import type { SessionStorageBackend } from "./session-storage-backend.ts";
-```
-
-In the class field declarations (just after `private leafId: string | null = null;`), add:
-
-```ts
-	private backend?: SessionStorageBackend;
-```
-
-- [ ] **Step 4: Thread `backend` through the constructor**
-
-Change the private constructor signature to accept a trailing `backend` param, and assign it **before** the `if (sessionFile) … else newSession()` block so `newSession` can use it. Replace:
-
-```ts
-	private constructor(
-		cwd: string,
-		sessionDir: string,
-		sessionFile: string | undefined,
-		persist: boolean,
-		newSessionOptions?: NewSessionOptions,
-	) {
-		this.cwd = resolvePath(cwd);
-		this.sessionDir = normalizePath(sessionDir);
-		this.persist = persist;
-```
-
-with:
-
-```ts
-	private constructor(
-		cwd: string,
-		sessionDir: string,
-		sessionFile: string | undefined,
-		persist: boolean,
-		newSessionOptions?: NewSessionOptions,
-		backend?: SessionStorageBackend,
-	) {
-		this.cwd = resolvePath(cwd);
-		this.sessionDir = normalizePath(sessionDir);
-		this.persist = persist;
-		this.backend = backend;
-```
-
-- [ ] **Step 5: Persist the header through the backend in `newSession`, and skip the file path when a backend is present**
-
-In `newSession`, find the persistence block that begins with `if (this.persist) {` and computes `fileTimestamp` / `this.sessionFile`. Replace its guard so the file-path computation is skipped when a backend is injected, and append the header to the backend instead. Change:
-
-```ts
-		if (this.persist) {
-			const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-```
-
-to:
-
-```ts
-		if (this.persist && this.backend) {
-			void this.backend.append(this.sessionId, header);
-		} else if (this.persist) {
-			const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-```
-
-(The rest of the original `if (this.persist)` body — the `this.sessionFile = join(...)` assignment — now lives under the `else if`, unchanged.)
-
-- [ ] **Step 6: Route `_persist` to the backend when present**
-
-At the very top of `_persist(entry: SessionEntry): void`, before the existing `if (!this.persist || !this.sessionFile) return;` line, add:
-
-```ts
-		if (this.backend) {
-			if (this.persist) void this.backend.append(this.sessionId, entry);
-			return;
-		}
-```
-
-- [ ] **Step 7: Add `loadFromEntries` and the `openFromBackend` factory**
-
-Add this private method (place it next to `setSessionFile`):
-
-```ts
-	/** Populate this manager from a backend-sourced entry list (resume path). */
-	private loadFromEntries(sessionId: string, entries: FileEntry[]): void {
-		this.sessionId = sessionId;
-		this.fileEntries = entries;
-		this.persist = true;
-		this.flushed = true;
-		this._buildIndex(); // rebuilds byId, labels, and leafId (= last entry)
-	}
-```
-
-Add this static factory next to the other factories (`create`/`open`/…):
-
-```ts
-	/**
-	 * Resume a session from an injected storage backend (Redis), keyed by session id.
-	 * Constructed with persist=false so the constructor's newSession() does not append a
-	 * spurious header; loadFromEntries() then re-enables persistence after loading.
-	 */
-	static async openFromBackend(
-		sessionId: string,
-		backend: SessionStorageBackend,
-		cwd: string = process.cwd(),
-	): Promise<SessionManager> {
-		const entries = await backend.read(sessionId);
-		if (entries.length === 0) {
-			throw new Error(`Cannot resume: no session in backend for id ${sessionId}`);
-		}
-		const sm = new SessionManager(cwd, "", undefined, false, undefined, backend);
-		sm.loadFromEntries(sessionId, entries);
-		return sm;
-	}
-```
-
-- [ ] **Step 8: Let `create` accept an injected backend**
-
-Replace the existing `static create(...)`:
-
-```ts
-	static create(cwd: string, sessionDir?: string, options?: NewSessionOptions): SessionManager {
-		const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-		return new SessionManager(cwd, dir, undefined, true, options);
-	}
-```
-
-with:
-
-```ts
-	static create(
-		cwd: string,
-		sessionDir?: string,
-		options?: NewSessionOptions,
-		backend?: SessionStorageBackend,
-	): SessionManager {
-		// With a backend, persistence is external — no session dir needed.
-		const dir = backend ? "" : sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-		return new SessionManager(cwd, dir, undefined, true, options, backend);
-	}
-```
-
-- [ ] **Step 9: Run the seam test to verify it passes**
-
-Run: `pnpm -C pi-fork/packages/coding-agent exec vitest run test/session-backend-seam.test.ts`
-Expected: PASS (1 test).
-
-- [ ] **Step 10: Run the existing SessionManager suite — the regression guard**
-
-Run: `pnpm -C pi-fork/packages/coding-agent exec vitest run test/ > /tmp/sh-pi-suite.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0`. The injected-backend path is additive and guarded, so all pre-existing session-manager / file-persistence tests must stay green. If any fail, inspect `/tmp/sh-pi-suite.log` and confirm the `if (!this.backend)` guards left the file path unchanged.
-
-- [ ] **Step 11: Commit (inside the submodule)**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness/pi-fork
-git add packages/coding-agent/src/core/session-manager.ts packages/coding-agent/test/session-backend-seam.test.ts
-git commit -m "feat(coding-agent): inject SessionStorageBackend into SessionManager (guarded path)"
-cd ..
-```
-
-- [ ] **Step 12: Build the coding-agent package (so the `harness` package can import it in Tasks 5–6)**
-
-Run: `pnpm -C pi-fork install && pnpm -C pi-fork --filter @earendil-works/pi-coding-agent build > /tmp/sh-pi-build.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0` and `pi-fork/packages/coding-agent/dist/index.js` exists. If the filter name differs, run `pnpm -C pi-fork/packages/coding-agent build`.
-
----
-
-## Task 5: `harness` package scaffold + `BufferedRedisBackend` decorator
-
-**Files:**
-- Create: `harness/package.json`
-- Create: `harness/vitest.config.ts`
-- Create: `harness/src/buffered-redis-backend.ts`
-- Test: `harness/test/buffered-redis-backend.test.ts`
-
-- [ ] **Step 1: Create the package scaffold**
-
-Create `harness/package.json`:
-
-```json
-{
-  "name": "@sh/harness",
-  "type": "module",
-  "version": "0.0.0",
-  "scripts": {
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@sh/session-backend": "workspace:*",
-    "@earendil-works/pi-coding-agent": "link:../pi-fork/packages/coding-agent"
-  },
-  "devDependencies": {
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  }
-}
-```
-
-Create `harness/vitest.config.ts`:
-
-```ts
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: { include: ["test/**/*.test.ts"] },
-});
-```
-
-- [ ] **Step 2: Install so the workspace links resolve**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness && pnpm install > /tmp/sh-install.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0`. Confirm `harness/node_modules/@earendil-works/pi-coding-agent` resolves to the submodule package and `@sh/session-backend` is linked.
-
-- [ ] **Step 3: Write the failing decorator unit test**
-
-Create `harness/test/buffered-redis-backend.test.ts`:
-
-```ts
-import { describe, it, expect } from "vitest";
-import { makeStoredEntry, type LogStore, type StoredEntry } from "@sh/session-backend";
-import type { FileEntry } from "@earendil-works/pi-coding-agent";
-import { BufferedRedisBackend } from "../src/buffered-redis-backend";
-
-// The decorator only reads `.type` / `.customType` at runtime, so minimal cast objects
-// stand in for full FileEntry values. Helpers keep the casts in one place.
-const msg = (): FileEntry => ({ type: "message" }) as unknown as FileEntry;
-const custom = (customType: string): FileEntry =>
-  ({ type: "custom", customType }) as unknown as FileEntry;
-const ct = (e: FileEntry): string | undefined => (e as { customType?: string }).customType;
-
-/** In-memory LogStore<FileEntry> with a per-append delay to test ordering/async. */
-class FakeStore implements LogStore<FileEntry> {
-  rows: StoredEntry<FileEntry>[] = [];
-  failNext = false;
-  async append(sid: string, entry: FileEntry, piType: string): Promise<StoredEntry<FileEntry>> {
-    if (this.failNext) { this.failNext = false; throw new Error("boom"); }
-    await new Promise((r) => setTimeout(r, 1));
-    const stored = makeStoredEntry({ position: this.rows.length + 1, session_id: sid, piType, entry });
-    this.rows.push(stored);
-    return stored;
-  }
-  async read(_sid: string, from = 1): Promise<StoredEntry<FileEntry>[]> {
-    return this.rows.filter((r) => r.position >= from);
-  }
-  async latestWhere(_sid: string, p: (e: FileEntry) => boolean): Promise<StoredEntry<FileEntry> | null> {
-    const m = this.rows.filter((r) => p(r.entry)); return m.length ? m[m.length - 1] : null;
-  }
-  async nextPosition(): Promise<number> { return this.rows.length + 1; }
-  async list(): Promise<string[]> { return ["s"]; }
-}
-
-describe("BufferedRedisBackend", () => {
-  it("append is fire-and-forget (resolves before the write completes) and preserves order on flush", async () => {
-    const store = new FakeStore();
-    const b = new BufferedRedisBackend(store);
-    b.append("s", custom("a"));
-    b.append("s", custom("b"));
-    b.append("s", custom("c"));
-    expect(store.rows.length).toBe(0); // nothing drained yet — writes are async
-    await b.flush();
-    expect(store.rows.map((r) => ct(r.entry))).toEqual(["a", "b", "c"]);
-  });
-
-  it("flush surfaces a write error from the queue", async () => {
-    const store = new FakeStore();
-    store.failNext = true;
-    const b = new BufferedRedisBackend(store);
-    b.append("s", msg());
-    await expect(b.flush()).rejects.toThrow("boom");
-  });
-
-  it("read unwraps stored entries; latestCheckpoint finds the checkpoint custom entry", async () => {
-    const store = new FakeStore();
-    const b = new BufferedRedisBackend(store);
-    b.append("s", msg());
-    b.append("s", custom("checkpoint"));
-    await b.flush();
-    const entries = await b.read("s");
-    expect(entries.map((e) => e.type)).toEqual(["message", "custom"]);
-    const cp = await b.latestCheckpoint("s");
-    expect(ct(cp as FileEntry)).toBe("checkpoint");
-  });
-});
-```
-
-- [ ] **Step 4: Run the test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run`
-Expected: FAIL — `BufferedRedisBackend` does not exist.
-
-- [ ] **Step 5: Implement the decorator**
-
-Create `harness/src/buffered-redis-backend.ts`:
-
-```ts
-import type { FileEntry, SessionStorageBackend } from "@earendil-works/pi-coding-agent";
-import type { LogStore } from "@sh/session-backend";
-
-/**
- * Write-behind decorator adapting a generic LogStore to Pi's SessionStorageBackend.
- *
- * append() enqueues and returns immediately (fire-and-forget) so Pi's synchronous
- * _persist path is never blocked. A serial promise chain drains writes to the inner
- * store in append order. The harness calls flush() at turn_end / session_shutdown to
- * make completed turns durable; flush() also surfaces any deferred write error.
- */
-export class BufferedRedisBackend implements SessionStorageBackend {
-  private queue: Promise<unknown> = Promise.resolve();
-  private lastError: unknown = null;
-
-  constructor(private readonly store: LogStore<FileEntry>) {}
-
-  append(sessionId: string, entry: FileEntry): Promise<void> {
-    const piType = entry.type;
-    this.queue = this.queue
-      .then(() => this.store.append(sessionId, entry, piType))
-      .catch((err) => {
-        this.lastError = err;
-      });
-    return Promise.resolve();
-  }
-
-  async flush(): Promise<void> {
-    await this.queue;
-    if (this.lastError) {
-      const err = this.lastError;
-      this.lastError = null;
-      throw err;
-    }
-  }
-
-  async read(sessionId: string, fromPosition?: number): Promise<FileEntry[]> {
-    const rows = await this.store.read(sessionId, fromPosition);
-    return rows.map((r) => r.entry);
-  }
-
-  async latestCheckpoint(sessionId: string): Promise<FileEntry | null> {
-    const row = await this.store.latestWhere(
-      sessionId,
-      (e) => e.type === "custom" && (e as { customType?: string }).customType === "checkpoint",
-    );
-    return row ? row.entry : null;
-  }
-
-  async list(): Promise<string[]> {
-    return this.store.list();
-  }
-}
-```
-
-- [ ] **Step 6: Run the test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run`
-Expected: PASS (3 tests).
-
-- [ ] **Step 7: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add harness/package.json harness/vitest.config.ts harness/src/buffered-redis-backend.ts harness/test/buffered-redis-backend.test.ts pnpm-lock.yaml
-git commit -m "feat(harness): BufferedRedisBackend write-behind decorator"
-```
-
----
-
-## Task 6: SessionManager ↔ Redis integration test (the M1 proof)
-
-**Files:**
-- Test: `harness/test/integration.test.ts`
-
-This is E3 (mobility) and E4 (recovery) in miniature, against real Redis (P2), driving the real (built) `SessionManager` with the Redis-backed decorator.
-
-- [ ] **Step 1: Write the integration test**
-
-Create `harness/test/integration.test.ts`:
-
-```ts
-import { describe, it, expect, afterAll } from "vitest";
-import { SessionManager, type FileEntry } from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { BufferedRedisBackend } from "../src/buffered-redis-backend";
-
-const REDIS = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-const store = new RedisSessionBackend<FileEntry>(REDIS);
-let createdSid: string | undefined;
-
-afterAll(async () => {
-  if (createdSid) await store.reset(createdSid);
-  await store.close();
-});
-
-describe("SessionManager + Redis (parity / mobility / recovery)", () => {
-  it("a completed turn survives process death and a fresh instance resumes it", async () => {
-    const backend = new BufferedRedisBackend(store);
-
-    // Drive a "turn": user -> assistant -> checkpoint -> user.
-    const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-    createdSid = sm.getSessionId();
-    sm.appendMessage({ role: "user", content: "hello" } as never);
-    sm.appendMessage({ role: "assistant", content: "hi there" } as never);
-    sm.appendCustomEntry("checkpoint", { ctx: "reconstructed" });
-    sm.appendMessage({ role: "user", content: "again" } as never);
-
-    // Durability barrier (what the harness calls at turn_end).
-    await backend.flush();
-
-    // Mobility + recovery: a brand-new instance reconstructs from Redis alone.
-    const resumed = await SessionManager.openFromBackend(createdSid, backend, process.cwd());
-
-    expect(resumed.getEntries().map((e) => JSON.stringify(e))).toEqual(
-      sm.getEntries().map((e) => JSON.stringify(e)),
-    );
-
-    // read(fromPosition) tail works (position 1 is the header).
-    const tail = await store.read(createdSid, 4);
-    expect(tail.length).toBeGreaterThan(0);
-
-    // Checkpoint is recoverable through the decorator.
-    const cp = await backend.latestCheckpoint(createdSid);
-    expect((cp as { customType?: string })?.customType).toBe("checkpoint");
-  });
-});
-```
-
-- [ ] **Step 2: Run the integration test (Redis from P2 must be running)**
-
-Run: `pnpm -C harness exec vitest run test/integration.test.ts`
-Expected: PASS (1 test). If it fails to connect, confirm `docker exec sh-redis redis-cli ping` returns `PONG`.
-
-- [ ] **Step 3: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add harness/test/integration.test.ts
-git commit -m "test(harness): SessionManager<->Redis parity/mobility/recovery integration"
-```
-
----
-
-## Task 7: Headless smoke wiring (flush extension + CLI entry)
-
-**Files:**
-- Create: `harness/src/flush-extension.ts`
-- Create: `harness/src/cli.ts`
-
-This discharges the §4.1 "headless one-shot" feasibility gate. It is exercised **manually** against a real model (not in CI). The novel backend/flush wiring is given in full; the prompt-drive loop mirrors Pi's own `print-mode.ts`.
-
-- [ ] **Step 1: Read Pi's print-mode for the exact prompt + exit pattern**
-
-Run: `sed -n '1,90p' pi-fork/packages/coding-agent/src/modes/print-mode.ts`
-Note how it calls `session.prompt(...)` and how it accesses the runtime to register events (`session.on(...)` or a returned runtime). You will mirror that exact call in Step 3. (Reading existing integration glue is expected here — this is a feasibility entry, not an automated unit.)
-
-- [ ] **Step 2: Write the flush extension**
-
-Create `harness/src/flush-extension.ts`:
-
-```ts
-import type { BufferedRedisBackend } from "./buffered-redis-backend";
-
-/**
- * Returns a Pi extension factory that flushes the write-behind buffer at the two
- * durability barriers: after each completed turn, and on session shutdown (the
- * scale-to-zero exit point). Register this with the agent session's runtime.
- */
-export function flushExtension(backend: BufferedRedisBackend) {
-  return (pi: { on: (event: string, handler: () => void | Promise<void>) => void }) => {
-    pi.on("turn_end", () => backend.flush());
-    pi.on("session_shutdown", () => backend.flush());
-  };
-}
-```
-
-- [ ] **Step 3: Write the CLI smoke entry**
-
-Create `harness/src/cli.ts`. The backend construction and flush are concrete; the `createAgentSession` + `prompt` call mirror `print-mode.ts` (Step 1). Adjust the extension-registration call to match the runtime object Pi exposes in your pinned commit.
-
-```ts
-import { getModel } from "@earendil-works/pi-ai";
-import { createAgentSession, SessionManager, type FileEntry } from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { BufferedRedisBackend } from "./buffered-redis-backend";
-import { flushExtension } from "./flush-extension";
-
-async function main() {
-  const prompt = process.argv[2];
-  if (!prompt) throw new Error('usage: cli.ts "<prompt>"   (set PI_SESSION_ID to resume)');
-
-  const store = new RedisSessionBackend<FileEntry>(process.env.REDIS_URL);
-  const backend = new BufferedRedisBackend(store);
-  const cwd = process.cwd();
-  const resumeId = process.env.PI_SESSION_ID;
-
-  const sessionManager = resumeId
-    ? await SessionManager.openFromBackend(resumeId, backend, cwd)
-    : SessionManager.create(cwd, undefined, undefined, backend);
-
-  const model = getModel("anthropic", "claude-opus-4-8");
-  const { session } = await createAgentSession({
-    sessionManager,
-    model,
-    extensionFactories: [flushExtension(backend)],
-  });
-
-  // Mirror print-mode.ts: drive one prompt to completion.
-  await session.prompt(prompt);
-
-  await backend.flush(); // belt-and-suspenders before exit
-  // eslint-disable-next-line no-console
-  console.log(`SESSION_ID=${sessionManager.getSessionId()}`);
-  process.exit(0);
-}
-
-main().catch((err) => {
-  // eslint-disable-next-line no-console
-  console.error(err);
-  process.exit(1);
-});
-```
-
-> If `createAgentSession` in the pinned commit does not accept `extensionFactories`, register the flush handlers directly on the returned `session` runtime (the object `print-mode.ts` uses), using the same `pi.on("turn_end" | "session_shutdown")` events. The flush wiring is the goal; the registration surface is whatever Step 1 reveals.
-
-- [ ] **Step 4: Run the manual headless smoke** (requires a real Anthropic key in Pi's auth + Redis from P2)
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-# Turn 1: new session
-REDIS_URL=redis://127.0.0.1:6379 pnpm -C harness exec tsx src/cli.ts "Remember the number 4242. Reply OK."
-# Capture the printed SESSION_ID, then resume in a FRESH process:
-REDIS_URL=redis://127.0.0.1:6379 PI_SESSION_ID=<printed-id> \
-  pnpm -C harness exec tsx src/cli.ts "What number did I ask you to remember?"
-```
-
-Expected: turn 2 (a fresh process, no local session files) answers `4242`, proving the externalized log round-trips through Redis end-to-end. Confirm no JSONL was written: `find ~/.pi/agent/sessions -newermt '-5 min' 2>/dev/null` returns nothing for this run.
-
-(If `tsx` is not present: `pnpm -C harness add -D tsx`.)
-
-- [ ] **Step 5: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add harness/src/flush-extension.ts harness/src/cli.ts harness/package.json pnpm-lock.yaml
-git commit -m "feat(harness): headless smoke entry + flush-on-turn_end/shutdown extension"
-```
-
----
-
-## Task 8: Docs + final verification + submodule pointer bump
-
-**Files:**
-- Create: `harness/README.md`
-- Modify: `README.md` (root)
-
-- [ ] **Step 1: Write the harness README**
-
-Create `harness/README.md`:
-
-```markdown
-# @sh/harness
-
-Serverless-harness glue: adapts the generic `@sh/session-backend` log store to Pi's
-`SessionStorageBackend`, with write-behind durability.
-
-## Components
-- `BufferedRedisBackend` — write-behind decorator (queue + `flush()`); implements Pi's
-  `SessionStorageBackend` over a `LogStore` (`RedisSessionBackend`).
-- `flushExtension` — flushes at `turn_end` and `session_shutdown`.
-- `cli.ts` — headless one-shot smoke entry (resume via `PI_SESSION_ID`).
-
-## Tests
-- `pnpm -C harness test` — decorator units + the SessionManager↔Redis integration test
-  (needs Redis at `REDIS_URL`, default `redis://127.0.0.1:6379`).
-
-## Dependency direction
-`harness → { pi-fork, @sh/session-backend }`. Pi core never imports Redis or
-`@sh/session-backend`.
-```
-
-- [ ] **Step 2: Add a one-line pointer in the root README**
-
-In `README.md`, append:
-
-```markdown
-
-## Packages
-- `packages/session-backend` — generic append-only `LogStore` + Redis Streams impl.
-- `harness` — Pi `SessionStorageBackend` adapter (write-behind) + headless smoke.
-- `pi-fork` — pinned Pi (commit 406a2214) with the injectable `SessionStorageBackend` seam.
-```
-
-- [ ] **Step 3: Full automated verification (all packages)**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-pnpm -C packages/session-backend exec vitest run > /tmp/sh-v1.log 2>&1; echo "backend EXIT:$?"
-pnpm -C harness exec vitest run > /tmp/sh-v2.log 2>&1; echo "harness EXIT:$?"
-pnpm -C pi-fork/packages/coding-agent exec vitest run test/session-backend-seam.test.ts > /tmp/sh-v3.log 2>&1; echo "seam EXIT:$?"
-```
-
-Expected: three `EXIT:0` lines. If any non-zero, inspect the matching `/tmp/sh-v*.log`.
-
-- [ ] **Step 4: Bump the submodule pointer in the parent repo**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git -C pi-fork log --oneline -3   # confirm the 2 fork commits (Tasks 3, 4) are present
-git add pi-fork                    # records the new submodule SHA
-git status --short                 # expect: modified pi-fork (new commit) + README files
-```
-
-- [ ] **Step 5: Commit docs + submodule bump**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add harness/README.md README.md
-git commit -m "docs: document harness package + bump pi-fork to session-storage-backend branch"
-```
-
-- [ ] **Step 6: Stop the test Redis (cleanup)**
-
-Run: `docker stop sh-redis`
-Expected: `sh-redis`.
-
----
-
-## Self-review notes (coverage check)
-
-- **Spec D1 native passthrough** → Tasks 1–2 store the opaque `entry` verbatim; Task 6 asserts round-trip identity by JSON compare.
-- **Spec D2 upstreamable seam** → Tasks 3–4 add the interface in Pi core; the file path is guarded and the existing suite is the regression guard (Task 4 Step 10).
-- **Spec D3 write-behind + barrier flush** → Task 5 `BufferedRedisBackend`; Task 7 `flushExtension` ties flush to `turn_end`/`session_shutdown`.
-- **Spec D4 envelope** → Task 1 `StoredEntry` (position + content_sha256 retained).
-- **Spec D5 checkpoint = custom entry** → `latestCheckpoint`/`latestWhere` filter `type==="custom" && customType==="checkpoint"` (Tasks 2, 4, 5).
-- **Spec D6 gate** → Tasks 4 (seam, deterministic) + 6 (Redis parity/mobility/recovery) + 7 (manual headless smoke).
-- **Spec D7 one-way dependency** → enforced by topology: `@sh/session-backend` is Pi-free; `harness` depends on both; Pi core depends on neither.
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-17-m2-k8s-sandbox-client.md b/docs/superpowers/plans/2026-06-17-m2-k8s-sandbox-client.md
deleted file mode 100644
index d6ef04f..0000000
--- a/docs/superpowers/plans/2026-06-17-m2-k8s-sandbox-client.md
+++ /dev/null
@@ -1,1262 +0,0 @@
-# M2 K8sSandboxClient Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Route Pi's tool execution (read/write/edit/bash/ls/grep/find) to a remote Kubernetes pod via `kubectl exec`, so the agent's "hands" run in the sandbox rather than on the harness head.
-
-**Architecture:** A new standalone `@sh/k8s-sandbox` package exposes an injectable `execInPod` transport (default = shell out to `kubectl exec -i … -- bash -c <cmd>`), seven pod-backed Pi `Operations` factories, and a Pi extension that registers/overrides the seven built-in tools. The extension is wired into the headless `harness/cli.ts` via `extensionFactories`, env-gated so it is inert unless `KAGENTI_SANDBOX_POD` is set. **No pi-fork change** — Pi's `Operations` seam is native; the one exception is `grep`, whose search hardwires a local `rg`, so its tool gets an `execute` override that runs `rg` in the pod.
-
-**Tech Stack:** TypeScript (ESM), pnpm workspaces, vitest, Pi (`@earendil-works/pi-coding-agent` via `link:`), `kubectl`, a kind cluster for the smoke.
-
----
-
-## Design reference
-
-Spec: [`docs/specs/2026-06-17-m2-k8s-sandbox-client-design.md`](../../specs/2026-06-17-m2-k8s-sandbox-client-design.md)
-
-**Verified facts this plan relies on (from reading pi-fork source at submodule `7acc67a`):**
-
-- `createReadTool` / `createWriteTool` / `createEditTool` / `createBashTool` / `createLsTool` / `createFindTool` / `createGrepTool` are exported from `@earendil-works/pi-coding-agent` and each takes `(cwd, { operations })`. (`packages/coding-agent/src/index.ts`)
-- `ReadOperations`, `WriteOperations`, `EditOperations`, `BashOperations`, `LsOperations`, `FindOperations`, `GrepOperations` are exported types with the shapes used below. (`src/core/tools/*.ts`)
-- `find`'s `execute` **uses `customOps.glob` instead of `fd` when supplied** (`src/core/tools/find.ts:154-164`) → operations route the search to the pod.
-- `grep`'s `execute` **always spawns local `rg`** even when operations are supplied (`src/core/tools/grep.ts:172,221`); operations only cover `isDirectory`/`readFile` for context lines → grep needs an `execute` override. Its success result shape is `{ content: [{ type: "text", text }], details: undefined }` (`grep.ts:311`).
-- The SSH example (`examples/extensions/ssh.ts`) is the delegation template: register a tool, delegate `execute` to a tool built with remote operations; intercept `user_bash` returning `{ operations }`; rewrite the announced cwd in `before_agent_start` returning `{ systemPrompt }`.
-- `ExtensionFactory = (pi: ExtensionAPI) => void | Promise<void>`; `pi.registerTool(tool)` accepts an `AgentTool` (the SSH example passes the object returned by `create*Tool`). (`src/core/extensions/types.ts:1416,1170`)
-- Headless wiring uses `DefaultResourceLoader({ extensionFactories: [...] })` — there are **no CLI flags** on the headless path (`harness/src/cli.ts:54-60`). Config comes from env / factory argument.
-
----
-
-## File structure
-
-```
-packages/k8s-sandbox/
-  package.json          # @sh/k8s-sandbox; links pi-coding-agent; vitest
-  tsconfig.json         # mirrors session-backend if present, else minimal ESM
-  src/
-    index.ts            # public exports
-    paths.ts            # shQuote(), mapPath() — pure helpers
-    config.ts           # K8sSandboxConfig, resolveConfig() (env gate)
-    exec.ts             # ExecInPod type, buildKubectlArgs(), kubectlExecInPod()
-    operations.ts       # createPod{Read,Write,Edit,Bash,Ls,Find}Ops
-    grep-tool.ts        # createPodGrepTool() — execute override (rg in-pod)
-    extension.ts        # k8sSandboxExtension() — registers the 7 tools, gated
-  deploy/
-    sandbox.yaml        # plain Deployment + PVC fixture
-  test/
-    paths.test.ts
-    config.test.ts
-    exec.test.ts
-    operations.test.ts
-harness/
-  package.json          # + "@sh/k8s-sandbox": "workspace:*"
-  src/cli.ts            # + k8sSandboxExtension() in extensionFactories
-```
-
-Unit tests (`paths`, `config`, `exec` argv builder, `operations` with a fake `ExecInPod`) are **cluster-free and build-free** — they import only erased types from Pi. `grep-tool.ts` and `extension.ts` import Pi runtime factories and are exercised by the real kind smoke (Task 11), not unit tests.
-
----
-
-## Task 1: Discovery note — confirm grep/find routing empirically
-
-**Files:**
-- Create: `packages/k8s-sandbox/NOTES-pi-operations.md`
-
-- [ ] **Step 1: Read the two execute paths and confirm the facts**
-
-Run:
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness/pi-fork
-sed -n '150,170p' packages/coding-agent/src/core/tools/find.ts   # custom glob replaces fd
-sed -n '170,225p' packages/coding-agent/src/core/tools/grep.ts   # rg spawned locally regardless
-```
-Expected: `find.ts` shows `if (customOps?.glob) { … return … }` before the `fd` path; `grep.ts` shows `const child = spawn(rgPath, args, …)` with no operations override of the search itself.
-
-- [ ] **Step 2: Write the note**
-
-Create `packages/k8s-sandbox/NOTES-pi-operations.md`:
-```markdown
-# Pi Operations routing — grep/find findings (pi-fork @ 7acc67a)
-
-Confirms the M2 design's §4.1 load-bearing risk.
-
-## find — operations SUFFICE
-`createFindToolDefinition.execute` (src/core/tools/find.ts:154-164): when
-`options.operations.glob` is provided it is used INSTEAD of `fd`. Supplying a
-custom `glob` that shells out in-pod fully routes find's search to the pod.
-Return: array of paths (relative to the search cwd is accepted).
-
-## grep — operations DO NOT suffice
-`createGrepToolDefinition.execute` (src/core/tools/grep.ts): always
-`spawn(rgPath, args)` against the LOCAL filesystem (line ~221). `operations`
-only feeds `isDirectory` (path check) and `readFile` (context lines). So grep's
-search runs on the head regardless of operations.
-Decision: route grep by OVERRIDING the tool's `execute` to run `rg` IN the pod
-via execInPod, and return grep's result shape:
-  { content: [{ type: "text", text }], details: undefined }
-(grep.ts:311 for the success/no-match shape.)
-
-## bash/read/write/edit/ls — operations SUFFICE (standard pattern, per SSH example).
-```
-
-- [ ] **Step 3: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/NOTES-pi-operations.md
-git commit -m "docs(k8s-sandbox): record grep/find Operations routing findings"
-```
-
----
-
-## Task 2: Scaffold the `@sh/k8s-sandbox` package
-
-**Files:**
-- Create: `packages/k8s-sandbox/package.json`
-- Create: `packages/k8s-sandbox/tsconfig.json`
-- Create: `packages/k8s-sandbox/src/index.ts`
-
-- [ ] **Step 1: Write `package.json`**
-
-Create `packages/k8s-sandbox/package.json` (mirrors `@sh/session-backend`, adds the Pi link needed for tool-factory types):
-```json
-{
-  "name": "@sh/k8s-sandbox",
-  "type": "module",
-  "version": "0.0.0",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "scripts": {
-    "test": "vitest run"
-  },
-  "devDependencies": {
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  },
-  "dependencies": {
-    "@earendil-works/pi-coding-agent": "link:../pi-fork/packages/coding-agent"
-  }
-}
-```
-
-- [ ] **Step 2: Write `tsconfig.json`**
-
-Create `packages/k8s-sandbox/tsconfig.json`:
-```json
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "types": ["node"]
-  },
-  "include": ["src", "test"]
-}
-```
-
-- [ ] **Step 3: Write a placeholder `src/index.ts`**
-
-Create `packages/k8s-sandbox/src/index.ts`:
-```ts
-// Public surface — populated by later tasks.
-export {};
-```
-
-- [ ] **Step 4: Install workspace deps**
-
-The workspace already globs `packages/*` (`pnpm-workspace.yaml`), so no edit there.
-Run:
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-pnpm install > /tmp/k8s-sandbox-install.log 2>&1; echo "EXIT:$?"
-```
-Expected: EXIT:0; `packages/k8s-sandbox/node_modules` now exists (symlinked `vitest`, `typescript`, and the linked Pi package).
-
-- [ ] **Step 5: Verify the empty test runner works**
-
-Run:
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm test 2>&1 | tail -5; echo "EXIT:${PIPESTATUS[0]}"
-```
-Expected: vitest reports "No test files found" (exit is non-zero but that's fine — it confirms vitest resolves). Proceed.
-
-- [ ] **Step 6: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/package.json packages/k8s-sandbox/tsconfig.json packages/k8s-sandbox/src/index.ts pnpm-lock.yaml
-git commit -m "chore(k8s-sandbox): scaffold @sh/k8s-sandbox package"
-```
-
----
-
-## Task 3: Path helpers (`paths.ts`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/paths.ts`
-- Test: `packages/k8s-sandbox/test/paths.test.ts`
-
-- [ ] **Step 1: Write the failing test**
-
-Create `packages/k8s-sandbox/test/paths.test.ts`:
-```ts
-import { describe, expect, it } from "vitest";
-import { mapPath, shQuote } from "../src/paths.js";
-
-describe("shQuote", () => {
-  it("wraps a plain path in single quotes", () => {
-    expect(shQuote("/workspace/a.txt")).toBe("'/workspace/a.txt'");
-  });
-  it("escapes embedded single quotes", () => {
-    expect(shQuote("it's")).toBe("'it'\\''s'");
-  });
-});
-
-describe("mapPath", () => {
-  it("rewrites a head-cwd prefix to the pod cwd", () => {
-    expect(mapPath("/Users/dev/proj/src/a.ts", "/Users/dev/proj", "/workspace")).toBe("/workspace/src/a.ts");
-  });
-  it("rewrites the head cwd itself", () => {
-    expect(mapPath("/Users/dev/proj", "/Users/dev/proj", "/workspace")).toBe("/workspace");
-  });
-  it("leaves paths outside the head cwd untouched", () => {
-    expect(mapPath("/etc/hosts", "/Users/dev/proj", "/workspace")).toBe("/etc/hosts");
-  });
-});
-```
-
-- [ ] **Step 2: Run to verify it fails**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec vitest run test/paths.test.ts 2>&1 | tail -8`
-Expected: FAIL — cannot resolve `../src/paths.js`.
-
-- [ ] **Step 3: Implement `paths.ts`**
-
-Create `packages/k8s-sandbox/src/paths.ts`:
-```ts
-/** Single-quote a string for safe interpolation into a `bash -c` command. */
-export function shQuote(s: string): string {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-
-/**
- * Rewrite an absolute head path into the pod's filesystem by swapping the
- * head cwd prefix for the pod cwd. Paths outside the head cwd are returned
- * unchanged (mirrors the SSH example's naive prefix replace).
- */
-export function mapPath(p: string, headCwd: string, podCwd: string): string {
-  if (p === headCwd) return podCwd;
-  if (p.startsWith(headCwd + "/")) return podCwd + p.slice(headCwd.length);
-  return p;
-}
-```
-
-- [ ] **Step 4: Run to verify it passes**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec vitest run test/paths.test.ts 2>&1 | tail -8`
-Expected: PASS (5 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/src/paths.ts packages/k8s-sandbox/test/paths.test.ts
-git commit -m "feat(k8s-sandbox): add shQuote and mapPath helpers"
-```
-
----
-
-## Task 4: Config + env gate (`config.ts`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/config.ts`
-- Test: `packages/k8s-sandbox/test/config.test.ts`
-
-- [ ] **Step 1: Write the failing test**
-
-Create `packages/k8s-sandbox/test/config.test.ts`:
-```ts
-import { describe, expect, it } from "vitest";
-import { resolveConfig } from "../src/config.js";
-
-describe("resolveConfig", () => {
-  it("returns null when KAGENTI_SANDBOX_POD is unset (the off gate)", () => {
-    expect(resolveConfig({}, "/head")).toBeNull();
-  });
-
-  it("applies defaults when only the pod is set", () => {
-    const cfg = resolveConfig({ KAGENTI_SANDBOX_POD: "sbx-0" }, "/head");
-    expect(cfg).toEqual({
-      pod: "sbx-0",
-      namespace: "default",
-      context: undefined,
-      podCwd: "/workspace",
-      headCwd: "/head",
-    });
-  });
-
-  it("honours all overrides", () => {
-    const cfg = resolveConfig(
-      {
-        KAGENTI_SANDBOX_POD: "sbx-0",
-        KAGENTI_SANDBOX_NAMESPACE: "team1",
-        KAGENTI_SANDBOX_CONTEXT: "kind-kagenti",
-        KAGENTI_SANDBOX_CWD: "/repo",
-      },
-      "/head",
-    );
-    expect(cfg).toEqual({
-      pod: "sbx-0",
-      namespace: "team1",
-      context: "kind-kagenti",
-      podCwd: "/repo",
-      headCwd: "/head",
-    });
-  });
-});
-```
-
-- [ ] **Step 2: Run to verify it fails**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec vitest run test/config.test.ts 2>&1 | tail -8`
-Expected: FAIL — cannot resolve `../src/config.js`.
-
-- [ ] **Step 3: Implement `config.ts`**
-
-Create `packages/k8s-sandbox/src/config.ts`:
-```ts
-export interface K8sSandboxConfig {
-  /** Pod name to exec into. */
-  pod: string;
-  /** Kubernetes namespace. */
-  namespace: string;
-  /** kube context, or undefined to use current-context. */
-  context: string | undefined;
-  /** Working directory inside the pod (announced to the model). */
-  podCwd: string;
-  /** The harness process cwd; head paths under it map to podCwd. */
-  headCwd: string;
-}
-
-/**
- * Resolve sandbox config from environment. Returns null when
- * KAGENTI_SANDBOX_POD is unset — the gate that keeps the extension inert
- * (all tools run locally) unless a sandbox pod is explicitly configured.
- */
-export function resolveConfig(env: NodeJS.ProcessEnv, headCwd: string): K8sSandboxConfig | null {
-  const pod = env.KAGENTI_SANDBOX_POD;
-  if (!pod) return null;
-  return {
-    pod,
-    namespace: env.KAGENTI_SANDBOX_NAMESPACE ?? "default",
-    context: env.KAGENTI_SANDBOX_CONTEXT || undefined,
-    podCwd: env.KAGENTI_SANDBOX_CWD ?? "/workspace",
-    headCwd,
-  };
-}
-```
-
-- [ ] **Step 4: Run to verify it passes**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec vitest run test/config.test.ts 2>&1 | tail -8`
-Expected: PASS (3 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/src/config.ts packages/k8s-sandbox/test/config.test.ts
-git commit -m "feat(k8s-sandbox): add config resolution with env gate"
-```
-
----
-
-## Task 5: Transport seam — `buildKubectlArgs` + `ExecInPod` (`exec.ts`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/exec.ts`
-- Test: `packages/k8s-sandbox/test/exec.test.ts`
-
-Only the pure `buildKubectlArgs` is unit-tested; `kubectlExecInPod` (spawns a real process) is exercised by the kind smoke in Task 11.
-
-- [ ] **Step 1: Write the failing test**
-
-Create `packages/k8s-sandbox/test/exec.test.ts`:
-```ts
-import { describe, expect, it } from "vitest";
-import { buildKubectlArgs } from "../src/exec.js";
-import type { K8sSandboxConfig } from "../src/config.js";
-
-const base: K8sSandboxConfig = {
-  pod: "sbx-0",
-  namespace: "team1",
-  context: undefined,
-  podCwd: "/workspace",
-  headCwd: "/head",
-};
-
-describe("buildKubectlArgs", () => {
-  it("builds an interactive exec with namespace and bash -c", () => {
-    expect(buildKubectlArgs(base, "cat '/workspace/a.txt'")).toEqual([
-      "exec", "-i", "-n", "team1", "sbx-0", "--", "bash", "-c", "cat '/workspace/a.txt'",
-    ]);
-  });
-
-  it("includes --context when set", () => {
-    expect(buildKubectlArgs({ ...base, context: "kind-kagenti" }, "true")).toEqual([
-      "exec", "-i", "-n", "team1", "--context", "kind-kagenti", "sbx-0", "--", "bash", "-c", "true",
-    ]);
-  });
-});
-```
-
-- [ ] **Step 2: Run to verify it fails**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec vitest run test/exec.test.ts 2>&1 | tail -8`
-Expected: FAIL — cannot resolve `../src/exec.js`.
-
-- [ ] **Step 3: Implement `exec.ts`**
-
-Create `packages/k8s-sandbox/src/exec.ts`:
-```ts
-import { spawn } from "node:child_process";
-import type { K8sSandboxConfig } from "./config.js";
-
-/**
- * Run one command inside the sandbox pod (as `bash -c <command>`).
- * stdout is collected and returned; stderr is streamed to onData (with stdout)
- * but NOT included in `stdout`, so file ops get clean bytes. Pass `stdin` to
- * feed data (e.g. base64 for writes). `onData` streams output for bash.
- */
-export type ExecInPod = (
-  command: string,
-  opts?: {
-    stdin?: Buffer;
-    onData?: (chunk: Buffer) => void;
-    signal?: AbortSignal;
-    timeout?: number; // seconds
-  },
-) => Promise<{ stdout: Buffer; exitCode: number | null }>;
-
-/** Pure argv builder for `kubectl exec` (unit-tested). */
-export function buildKubectlArgs(config: K8sSandboxConfig, command: string): string[] {
-  const args = ["exec", "-i", "-n", config.namespace];
-  if (config.context) args.push("--context", config.context);
-  args.push(config.pod, "--", "bash", "-c", command);
-  return args;
-}
-
-/** Default transport: shell out to `kubectl exec`. */
-export function kubectlExecInPod(config: K8sSandboxConfig): ExecInPod {
-  return (command, opts = {}) =>
-    new Promise((resolve, reject) => {
-      const child = spawn("kubectl", buildKubectlArgs(config, command), {
-        stdio: ["pipe", "pipe", "pipe"],
-      });
-      const out: Buffer[] = [];
-      let timedOut = false;
-      const timer =
-        opts.timeout && opts.timeout > 0
-          ? setTimeout(() => {
-              timedOut = true;
-              child.kill("SIGKILL");
-            }, opts.timeout * 1000)
-          : undefined;
-
-      child.stdout.on("data", (d: Buffer) => {
-        out.push(d);
-        opts.onData?.(d);
-      });
-      child.stderr.on("data", (d: Buffer) => {
-        opts.onData?.(d);
-      });
-
-      const onAbort = () => child.kill("SIGKILL");
-      opts.signal?.addEventListener("abort", onAbort, { once: true });
-
-      child.on("error", (e) => {
-        if (timer) clearTimeout(timer);
-        reject(e);
-      });
-      child.on("close", (code) => {
-        if (timer) clearTimeout(timer);
-        opts.signal?.removeEventListener("abort", onAbort);
-        if (opts.signal?.aborted) return reject(new Error("aborted"));
-        if (timedOut) return reject(new Error(`timeout:${opts.timeout}`));
-        resolve({ stdout: Buffer.concat(out), exitCode: code });
-      });
-
-      if (opts.stdin) child.stdin.end(opts.stdin);
-      else child.stdin.end();
-    });
-}
-```
-
-- [ ] **Step 4: Run to verify it passes**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec vitest run test/exec.test.ts 2>&1 | tail -8`
-Expected: PASS (2 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/src/exec.ts packages/k8s-sandbox/test/exec.test.ts
-git commit -m "feat(k8s-sandbox): add execInPod transport seam (kubectl exec)"
-```
-
----
-
-## Task 6: The six operations factories (`operations.ts`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/operations.ts`
-- Test: `packages/k8s-sandbox/test/operations.test.ts`
-
-A fake `ExecInPod` records each `(command, opts)` and returns scripted results, so we assert both the exact command built and correct parsing.
-
-- [ ] **Step 1: Write the failing test**
-
-Create `packages/k8s-sandbox/test/operations.test.ts`:
-```ts
-import { describe, expect, it, vi } from "vitest";
-import type { ExecInPod } from "../src/exec.js";
-import type { K8sSandboxConfig } from "../src/config.js";
-import {
-  createPodReadOps,
-  createPodWriteOps,
-  createPodEditOps,
-  createPodBashOps,
-  createPodLsOps,
-  createPodFindOps,
-} from "../src/operations.js";
-
-const cfg: K8sSandboxConfig = {
-  pod: "sbx-0",
-  namespace: "default",
-  context: undefined,
-  podCwd: "/workspace",
-  headCwd: "/head",
-};
-
-/** Build a fake ExecInPod that returns scripted results and records calls. */
-function fakeExec(result: { stdout?: string; exitCode?: number | null }) {
-  const calls: Array<{ command: string; stdin?: string }> = [];
-  const fn: ExecInPod = async (command, opts) => {
-    calls.push({ command, stdin: opts?.stdin?.toString() });
-    return { stdout: Buffer.from(result.stdout ?? ""), exitCode: result.exitCode ?? 0 };
-  };
-  return { fn, calls };
-}
-
-describe("read ops", () => {
-  it("reads a file via cat with the mapped path", async () => {
-    const { fn, calls } = fakeExec({ stdout: "hello" });
-    const ops = createPodReadOps(fn, cfg);
-    const buf = await ops.readFile("/head/a.txt");
-    expect(buf.toString()).toBe("hello");
-    expect(calls[0].command).toBe("cat '/workspace/a.txt'");
-  });
-
-  it("access rejects when test -r exits non-zero", async () => {
-    const { fn } = fakeExec({ exitCode: 1 });
-    const ops = createPodReadOps(fn, cfg);
-    await expect(ops.access("/head/a.txt")).rejects.toThrow();
-  });
-
-  it("detectImageMimeType returns the type for an image, null otherwise", async () => {
-    const img = createPodReadOps(fakeExec({ stdout: "image/png\n" }).fn, cfg);
-    expect(await img.detectImageMimeType!("/head/x.png")).toBe("image/png");
-    const txt = createPodReadOps(fakeExec({ stdout: "text/plain\n" }).fn, cfg);
-    expect(await txt.detectImageMimeType!("/head/x.txt")).toBeNull();
-  });
-});
-
-describe("write ops", () => {
-  it("writes via base64 -d on stdin", async () => {
-    const { fn, calls } = fakeExec({});
-    const ops = createPodWriteOps(fn, cfg);
-    await ops.writeFile("/head/a.txt", "hi");
-    expect(calls[0].command).toBe("base64 -d > '/workspace/a.txt'");
-    expect(calls[0].stdin).toBe(Buffer.from("hi").toString("base64"));
-  });
-
-  it("mkdir -p with the mapped dir", async () => {
-    const { fn, calls } = fakeExec({});
-    await createPodWriteOps(fn, cfg).mkdir("/head/sub");
-    expect(calls[0].command).toBe("mkdir -p '/workspace/sub'");
-  });
-});
-
-describe("edit ops", () => {
-  it("access requires read AND write", async () => {
-    const { fn, calls } = fakeExec({});
-    await createPodEditOps(fn, cfg).access("/head/a.txt");
-    expect(calls[0].command).toBe("test -r '/workspace/a.txt' && test -w '/workspace/a.txt'");
-  });
-});
-
-describe("bash ops", () => {
-  it("cds into the mapped cwd then runs the command, returning exitCode", async () => {
-    const { fn, calls } = fakeExec({ exitCode: 0 });
-    const ops = createPodBashOps(fn, cfg);
-    const onData = vi.fn();
-    const r = await ops.exec("echo hi", "/head", { onData });
-    expect(calls[0].command).toBe("cd '/workspace' && echo hi");
-    expect(r).toEqual({ exitCode: 0 });
-  });
-});
-
-describe("ls ops", () => {
-  it("readdir splits lines and drops blanks", async () => {
-    const { fn, calls } = fakeExec({ stdout: "a.txt\nb\n\n" });
-    const entries = await createPodLsOps(fn, cfg).readdir("/head");
-    expect(entries).toEqual(["a.txt", "b"]);
-    expect(calls[0].command).toBe("ls -1A '/workspace'");
-  });
-
-  it("stat reports directory vs file", async () => {
-    const dir = await createPodLsOps(fakeExec({ stdout: "DIR\n" }).fn, cfg).stat("/head/d");
-    expect((await dir).isDirectory()).toBe(true);
-    const file = await createPodLsOps(fakeExec({ stdout: "FILE\n" }).fn, cfg).stat("/head/f");
-    expect((await file).isDirectory()).toBe(false);
-  });
-});
-
-describe("find ops", () => {
-  it("globs via find -name under the mapped cwd and strips ./", async () => {
-    const { fn, calls } = fakeExec({ stdout: "./src/a.ts\n./b.ts\n" });
-    const ops = createPodFindOps(fn, cfg);
-    const results = await ops.glob("*.ts", "/head", { ignore: [], limit: 100 });
-    expect(results).toEqual(["src/a.ts", "b.ts"]);
-    expect(calls[0].command).toBe("cd '/workspace' && find . -type f -name '*.ts' 2>/dev/null | head -n 100");
-  });
-});
-```
-
-- [ ] **Step 2: Run to verify it fails**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec vitest run test/operations.test.ts 2>&1 | tail -10`
-Expected: FAIL — cannot resolve `../src/operations.js`.
-
-- [ ] **Step 3: Implement `operations.ts`**
-
-Create `packages/k8s-sandbox/src/operations.ts`:
-```ts
-import type {
-  BashOperations,
-  EditOperations,
-  FindOperations,
-  LsOperations,
-  ReadOperations,
-  WriteOperations,
-} from "@earendil-works/pi-coding-agent";
-import type { K8sSandboxConfig } from "./config.js";
-import type { ExecInPod } from "./exec.js";
-import { mapPath, shQuote } from "./paths.js";
-
-const IMAGE_MIMES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
-
-function mapper(cfg: K8sSandboxConfig) {
-  return (p: string) => shQuote(mapPath(p, cfg.headCwd, cfg.podCwd));
-}
-
-export function createPodReadOps(exec: ExecInPod, cfg: K8sSandboxConfig): ReadOperations {
-  const q = mapper(cfg);
-  return {
-    readFile: async (p) => (await exec(`cat ${q(p)}`)).stdout,
-    access: async (p) => {
-      const r = await exec(`test -r ${q(p)}`);
-      if (r.exitCode !== 0) throw new Error(`File not readable in pod: ${p}`);
-    },
-    detectImageMimeType: async (p) => {
-      const r = await exec(`file --mime-type -b ${q(p)}`);
-      const mime = r.stdout.toString().trim();
-      return IMAGE_MIMES.includes(mime) ? mime : null;
-    },
-  };
-}
-
-export function createPodWriteOps(exec: ExecInPod, cfg: K8sSandboxConfig): WriteOperations {
-  const q = mapper(cfg);
-  return {
-    writeFile: async (p, content) => {
-      const b64 = Buffer.from(content).toString("base64");
-      const r = await exec(`base64 -d > ${q(p)}`, { stdin: Buffer.from(b64) });
-      if (r.exitCode !== 0) throw new Error(`Write failed in pod: ${p}`);
-    },
-    mkdir: async (dir) => {
-      const r = await exec(`mkdir -p ${q(dir)}`);
-      if (r.exitCode !== 0) throw new Error(`mkdir failed in pod: ${dir}`);
-    },
-  };
-}
-
-export function createPodEditOps(exec: ExecInPod, cfg: K8sSandboxConfig): EditOperations {
-  const read = createPodReadOps(exec, cfg);
-  const write = createPodWriteOps(exec, cfg);
-  const q = mapper(cfg);
-  return {
-    readFile: read.readFile,
-    writeFile: write.writeFile,
-    access: async (p) => {
-      const r = await exec(`test -r ${q(p)} && test -w ${q(p)}`);
-      if (r.exitCode !== 0) throw new Error(`File not read-writable in pod: ${p}`);
-    },
-  };
-}
-
-export function createPodBashOps(exec: ExecInPod, cfg: K8sSandboxConfig): BashOperations {
-  const q = mapper(cfg);
-  return {
-    exec: async (command, cwd, { onData, signal, timeout }) => {
-      const r = await exec(`cd ${q(cwd)} && ${command}`, { onData, signal, timeout });
-      return { exitCode: r.exitCode };
-    },
-  };
-}
-
-export function createPodLsOps(exec: ExecInPod, cfg: K8sSandboxConfig): LsOperations {
-  const q = mapper(cfg);
-  return {
-    exists: async (p) => (await exec(`test -e ${q(p)}`)).exitCode === 0,
-    stat: async (p) => {
-      const r = await exec(`test -e ${q(p)} && (test -d ${q(p)} && echo DIR || echo FILE)`);
-      if (r.exitCode !== 0) throw new Error(`Path not found in pod: ${p}`);
-      const isDir = r.stdout.toString().trim() === "DIR";
-      return { isDirectory: () => isDir };
-    },
-    readdir: async (p) => {
-      const r = await exec(`ls -1A ${q(p)}`);
-      if (r.exitCode !== 0) throw new Error(`readdir failed in pod: ${p}`);
-      return r.stdout.toString().split("\n").filter((x) => x.length > 0);
-    },
-  };
-}
-
-export function createPodFindOps(exec: ExecInPod, cfg: K8sSandboxConfig): FindOperations {
-  const q = mapper(cfg);
-  return {
-    exists: async (p) => (await exec(`test -e ${q(p)}`)).exitCode === 0,
-    // NOTE: matches basenames via `find -name`; does not honour .gitignore or the
-    // `ignore` list (a known M2 simplification vs Pi's local `fd`). Returns paths
-    // relative to the search cwd (leading "./" stripped).
-    glob: async (pattern, cwd, { limit }) => {
-      const r = await exec(`cd ${q(cwd)} && find . -type f -name ${shQuote(pattern)} 2>/dev/null | head -n ${limit}`);
-      return r.stdout
-        .toString()
-        .split("\n")
-        .filter((x) => x.length > 0)
-        .map((rel) => rel.replace(/^\.\//, ""));
-    },
-  };
-}
-```
-
-- [ ] **Step 4: Run to verify it passes**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec vitest run test/operations.test.ts 2>&1 | tail -12`
-Expected: PASS (all operations tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/src/operations.ts packages/k8s-sandbox/test/operations.test.ts
-git commit -m "feat(k8s-sandbox): add six pod-backed Operations factories"
-```
-
----
-
-## Task 7: Grep tool with in-pod `execute` override (`grep-tool.ts`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/grep-tool.ts`
-
-No unit test: this imports Pi's runtime `createGrepTool` and is covered by the kind smoke (Task 11). The implementation is small and mirrors grep's documented result shape.
-
-- [ ] **Step 1: Implement `grep-tool.ts`**
-
-Create `packages/k8s-sandbox/src/grep-tool.ts`:
-```ts
-import { isAbsolute, resolve as resolvePath } from "node:path";
-import { createGrepTool } from "@earendil-works/pi-coding-agent";
-import type { K8sSandboxConfig } from "./config.js";
-import type { ExecInPod } from "./exec.js";
-import { mapPath, shQuote } from "./paths.js";
-
-/**
- * grep cannot be routed via GrepOperations because Pi's grep always spawns a
- * LOCAL `rg` (see NOTES-pi-operations.md). We reuse the built-in tool's schema,
- * label, and render, but replace `execute` to run `rg` IN the pod and return
- * grep's result shape: { content: [{ type: "text", text }], details: undefined }.
- */
-export function createPodGrepTool(
-  localCwd: string,
-  exec: ExecInPod,
-  cfg: K8sSandboxConfig,
-): ReturnType<typeof createGrepTool> {
-  const base = createGrepTool(localCwd);
-  return {
-    ...base,
-    async execute(_id, params: Record<string, unknown>, signal?: AbortSignal) {
-      const pattern = String(params.pattern ?? "");
-      const searchDir = typeof params.path === "string" ? params.path : ".";
-      const glob = typeof params.glob === "string" ? params.glob : undefined;
-      const ignoreCase = params.ignoreCase === true;
-      const literal = params.literal === true;
-      const context = typeof params.context === "number" ? params.context : 0;
-
-      const headPath = isAbsolute(searchDir) ? searchDir : resolvePath(localCwd, searchDir);
-      const podPath = mapPath(headPath, cfg.headCwd, cfg.podCwd);
-
-      const parts = ["rg", "--line-number", "--no-heading", "--color=never", "--hidden"];
-      if (ignoreCase) parts.push("--ignore-case");
-      if (literal) parts.push("--fixed-strings");
-      if (context > 0) parts.push("--context", String(context));
-      if (glob) parts.push("--glob", shQuote(glob));
-      parts.push("--", shQuote(pattern), shQuote(podPath));
-
-      const r = await exec(parts.join(" "), { signal });
-      const text = r.stdout.toString();
-      // rg exits 1 with no output when there are no matches.
-      if (r.exitCode === 1 && text.trim() === "") {
-        return { content: [{ type: "text" as const, text: "No matches found" }], details: undefined };
-      }
-      return { content: [{ type: "text" as const, text: text.length ? text : "No matches found" }], details: undefined };
-    },
-  } as ReturnType<typeof createGrepTool>;
-}
-```
-
-- [ ] **Step 2: Typecheck the package**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec tsc --noEmit 2>&1 | tail -15; echo "EXIT:${PIPESTATUS[0]}"`
-Expected: EXIT:0 (no type errors). If `pi-coding-agent` types are unresolved, confirm `pnpm install` linked the package (Task 2 Step 4) and that the pi-fork packages are built per the M1 build order — see Task 11 Step 1.
-
-- [ ] **Step 3: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/src/grep-tool.ts
-git commit -m "feat(k8s-sandbox): add grep tool with in-pod execute override"
-```
-
----
-
-## Task 8: The extension + public exports (`extension.ts`, `index.ts`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/extension.ts`
-- Modify: `packages/k8s-sandbox/src/index.ts`
-
-- [ ] **Step 1: Implement `extension.ts`**
-
-Create `packages/k8s-sandbox/src/extension.ts`:
-```ts
-import {
-  createBashTool,
-  createEditTool,
-  createFindTool,
-  createLsTool,
-  createReadTool,
-  createWriteTool,
-  type ExtensionAPI,
-  type ExtensionFactory,
-} from "@earendil-works/pi-coding-agent";
-import { type K8sSandboxConfig, resolveConfig } from "./config.js";
-import { type ExecInPod, kubectlExecInPod } from "./exec.js";
-import {
-  createPodBashOps,
-  createPodEditOps,
-  createPodFindOps,
-  createPodLsOps,
-  createPodReadOps,
-  createPodWriteOps,
-} from "./operations.js";
-import { createPodGrepTool } from "./grep-tool.js";
-
-/**
- * Pi extension that overrides the seven built-in tools so file/search/exec run
- * in a remote Kubernetes pod via `kubectl exec`. Inert (returns immediately,
- * leaving Pi's local tools in place) unless a sandbox is configured.
- *
- * @param opts.config Explicit config; if omitted, resolved from process.env.
- *                    Pass `null` to force-disable.
- * @param opts.exec   Override the transport (used by tests / alternate auth).
- */
-export function k8sSandboxExtension(opts?: {
-  config?: K8sSandboxConfig | null;
-  exec?: ExecInPod;
-}): ExtensionFactory {
-  return (pi: ExtensionAPI) => {
-    const localCwd = process.cwd();
-    const config = opts?.config !== undefined ? opts.config : resolveConfig(process.env, localCwd);
-    if (!config) return; // off gate — local tools stand
-
-    const exec = opts?.exec ?? kubectlExecInPod(config);
-
-    pi.registerTool(createReadTool(localCwd, { operations: createPodReadOps(exec, config) }));
-    pi.registerTool(createWriteTool(localCwd, { operations: createPodWriteOps(exec, config) }));
-    pi.registerTool(createEditTool(localCwd, { operations: createPodEditOps(exec, config) }));
-    pi.registerTool(createBashTool(localCwd, { operations: createPodBashOps(exec, config) }));
-    pi.registerTool(createLsTool(localCwd, { operations: createPodLsOps(exec, config) }));
-    pi.registerTool(createFindTool(localCwd, { operations: createPodFindOps(exec, config) }));
-    pi.registerTool(createPodGrepTool(localCwd, exec, config));
-
-    // User `!` commands also run in the pod.
-    pi.on("user_bash", () => ({ operations: createPodBashOps(exec, config) }));
-
-    // Tell the model its cwd is the pod's, not the head's.
-    pi.on("before_agent_start", (event) => {
-      const modified = event.systemPrompt.replace(
-        `Current working directory: ${localCwd}`,
-        `Current working directory: ${config.podCwd} (sandbox pod ${config.namespace}/${config.pod})`,
-      );
-      return { systemPrompt: modified };
-    });
-  };
-}
-```
-
-- [ ] **Step 2: Update `index.ts` exports**
-
-Replace `packages/k8s-sandbox/src/index.ts` with:
-```ts
-export { k8sSandboxExtension } from "./extension.js";
-export { resolveConfig, type K8sSandboxConfig } from "./config.js";
-export { buildKubectlArgs, kubectlExecInPod, type ExecInPod } from "./exec.js";
-```
-
-- [ ] **Step 3: Typecheck**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm exec tsc --noEmit 2>&1 | tail -15; echo "EXIT:${PIPESTATUS[0]}"`
-Expected: EXIT:0. If `before_agent_start` / `user_bash` event field names mismatch, cross-check against `examples/extensions/ssh.ts` (lines 203-218) and adjust — the SSH example is the source of truth for these hook shapes.
-
-- [ ] **Step 4: Run the full package test suite (regression check)**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox && pnpm test 2>&1 | tail -12`
-Expected: PASS — paths (5) + config (3) + exec (2) + operations (all) green.
-
-- [ ] **Step 5: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/src/extension.ts packages/k8s-sandbox/src/index.ts
-git commit -m "feat(k8s-sandbox): add gated extension wiring the 7 pod tools"
-```
-
----
-
-## Task 9: Wire the extension into the headless harness (`cli.ts`)
-
-**Files:**
-- Modify: `harness/package.json`
-- Modify: `harness/src/cli.ts:54-60`
-
-- [ ] **Step 1: Add the dependency**
-
-In `harness/package.json`, add to `dependencies` (after the `@sh/session-backend` line):
-```json
-    "@sh/k8s-sandbox": "workspace:*",
-```
-So the block reads:
-```json
-  "dependencies": {
-    "@sh/session-backend": "workspace:*",
-    "@sh/k8s-sandbox": "workspace:*",
-    "@earendil-works/pi-ai": "link:../pi-fork/packages/ai",
-    "@earendil-works/pi-coding-agent": "link:../pi-fork/packages/coding-agent"
-  },
-```
-
-- [ ] **Step 2: Install**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness && pnpm install > /tmp/k8s-wire-install.log 2>&1; echo "EXIT:$?"`
-Expected: EXIT:0.
-
-- [ ] **Step 3: Import and register the extension**
-
-In `harness/src/cli.ts`, add the import after the `flushExtension` import (line 24):
-```ts
-import { k8sSandboxExtension } from "@sh/k8s-sandbox";
-```
-Then change the `extensionFactories` array (line 58) from:
-```ts
-    extensionFactories: [flushExtension(backend)],
-```
-to:
-```ts
-    // k8sSandboxExtension() is inert unless KAGENTI_SANDBOX_POD is set, so the
-    // default (Config A, local execution) is unchanged.
-    extensionFactories: [flushExtension(backend), k8sSandboxExtension()],
-```
-
-- [ ] **Step 4: Verify default (no sandbox env) still type-loads**
-
-Run:
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness/harness && pnpm exec tsc --noEmit 2>&1 | tail -15; echo "EXIT:${PIPESTATUS[0]}"
-```
-Expected: EXIT:0. (A full run needs Pi built + Redis + a model gateway; that is the Task 11 smoke. Here we only confirm the wiring typechecks.)
-
-- [ ] **Step 5: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add harness/package.json harness/src/cli.ts pnpm-lock.yaml
-git commit -m "feat(harness): wire k8sSandboxExtension into headless cli (env-gated)"
-```
-
----
-
-## Task 10: Sandbox pod manifest fixture (`deploy/sandbox.yaml`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/deploy/sandbox.yaml`
-
-- [ ] **Step 1: Write the manifest**
-
-Create `packages/k8s-sandbox/deploy/sandbox.yaml`. The image must carry `bash`, `coreutils` (`base64`, `file`, `stat`), `findutils`, and `ripgrep`. `alpine` provides bash/coreutils/findutils/ripgrep via apk; install them in a startup command so the fixture is self-contained on any node.
-```yaml
-apiVersion: v1
-kind: PersistentVolumeClaim
-metadata:
-  name: sandbox-workspace
-  namespace: default
-spec:
-  accessModes: ["ReadWriteOnce"]
-  resources:
-    requests:
-      storage: 1Gi
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: sandbox
-  namespace: default
-  labels:
-    app: sandbox
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: sandbox
-  template:
-    metadata:
-      labels:
-        app: sandbox
-    spec:
-      containers:
-        - name: sandbox
-          image: alpine:3.20
-          # Install the tools the Operations rely on, then idle.
-          command: ["/bin/sh", "-c"]
-          args:
-            - apk add --no-cache bash coreutils findutils ripgrep file >/dev/null 2>&1;
-              mkdir -p /workspace;
-              exec sleep infinity
-          workingDir: /workspace
-          volumeMounts:
-            - name: workspace
-              mountPath: /workspace
-      volumes:
-        - name: workspace
-          persistentVolumeClaim:
-            claimName: sandbox-workspace
-```
-
-- [ ] **Step 2: Validate the YAML parses (no cluster needed)**
-
-Run:
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-python3 -c "import yaml,sys; list(yaml.safe_load_all(open('packages/k8s-sandbox/deploy/sandbox.yaml'))); print('OK')"
-```
-Expected: `OK`.
-
-- [ ] **Step 3: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/deploy/sandbox.yaml
-git commit -m "feat(k8s-sandbox): add plain Deployment+PVC sandbox fixture"
-```
-
----
-
-## Task 11: Real kind smoke — prove tools run in the pod
-
-**Files:**
-- Create: `packages/k8s-sandbox/SMOKE.md` (runbook + recorded result)
-
-This is the M2 gate's real-cluster half. It is a **manual runbook** (cluster + model gateway dependent), executed once and its result recorded. Requires: a kind cluster with `kubectl` context, the same model-gateway env used for the M1 smoke (`ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN`), and the `sh-redis` container from M1 on `:6379`.
-
-- [ ] **Step 1: Build Pi (M1 build order) and ensure prerequisites**
-
-Run:
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-for p in ai agent tui coding-agent; do pnpm -C pi-fork/packages/$p build > /tmp/pi-build-$p.log 2>&1 && echo "built $p" || { echo "FAIL $p (see /tmp/pi-build-$p.log)"; break; }; done
-docker ps --format '{{.Names}}' | grep -q sh-redis && echo "redis up" || echo "START sh-redis first"
-kubectl config current-context
-```
-Expected: all four `built …` lines; `redis up`; a kind context printed.
-
-- [ ] **Step 2: Apply the sandbox fixture and wait for Ready**
-
-Run:
-```bash
-kubectl apply -f packages/k8s-sandbox/deploy/sandbox.yaml > /tmp/sbx-apply.log 2>&1; echo "EXIT:$?"
-kubectl -n default rollout status deploy/sandbox --timeout=120s > /tmp/sbx-roll.log 2>&1; echo "EXIT:$?"
-POD=$(kubectl -n default get pod -l app=sandbox -o jsonpath='{.items[0].metadata.name}'); echo "POD=$POD"
-# Confirm tools installed inside the pod:
-kubectl -n default exec "$POD" -- sh -c 'command -v bash base64 file rg find && echo TOOLS_OK'
-```
-Expected: both EXIT:0; a `POD=sandbox-…` name; `TOOLS_OK`.
-
-- [ ] **Step 2b: Sanity-check the bare transport against the pod**
-
-Run:
-```bash
-kubectl -n default exec -i "$POD" -- bash -c 'hostname'
-```
-Expected: prints the **pod's** hostname (= `$POD`), establishing the baseline for the isolation assertion in Step 4.
-
-- [ ] **Step 3: Drive one agent turn with the sandbox enabled**
-
-Run (the prompt instructs a file write + a host identity command, both must land in the pod):
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness/harness
-export KAGENTI_SANDBOX_POD="$POD"
-export KAGENTI_SANDBOX_NAMESPACE=default
-export KAGENTI_SANDBOX_CWD=/workspace
-unset PI_SESSION_ID
-pnpm exec tsx src/cli.ts "Create a file proof.txt in the current directory containing the output of \`hostname\`. Then tell me the hostname." > /tmp/m2-smoke.log 2>&1
-echo "EXIT:$?"; tail -5 /tmp/m2-smoke.log
-```
-Expected: EXIT:0; the log ends with `SESSION_ID=…` and the assistant reply names a hostname.
-
-- [ ] **Step 4: Assert the side effects landed in the POD, not the head**
-
-Run:
-```bash
-# (a) the file the agent wrote exists IN the pod:
-kubectl -n default exec "$POD" -- cat /workspace/proof.txt > /tmp/m2-proof.log 2>&1; echo "EXIT:$?"
-cat /tmp/m2-proof.log
-# (b) it must NOT exist on the head:
-test ! -e /Users/paolo/Projects/aiplatform/serverless-harness/harness/proof.txt && echo "HEAD_CLEAN" || echo "LEAKED TO HEAD"
-# (c) the hostname the agent reported equals the pod's, not the head's:
-echo "pod hostname: $POD"; hostname
-```
-Expected: (a) EXIT:0 and `proof.txt` contains the **pod** hostname (matches `$POD`); (b) `HEAD_CLEAN`; (c) the reported hostname matches the pod, differs from the head's `hostname`. Together these prove isolation actually happened.
-
-- [ ] **Step 5: Record the result and commit**
-
-Create `packages/k8s-sandbox/SMOKE.md` with the runbook above plus a "Result (YYYY-MM-DD)" section pasting the Step 4 outputs (pod name, proof.txt contents, HEAD_CLEAN, both hostnames). Then:
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/SMOKE.md
-git commit -m "test(k8s-sandbox): record real kind smoke proving in-pod execution"
-```
-
-- [ ] **Step 6: Tear down the fixture**
-
-Run: `kubectl delete -f packages/k8s-sandbox/deploy/sandbox.yaml > /tmp/sbx-del.log 2>&1; echo "EXIT:$?"`
-Expected: EXIT:0.
-
----
-
-## Task 12: Docs + submodule pointer + close-out
-
-**Files:**
-- Create: `packages/k8s-sandbox/README.md`
-- Modify: `README.md` (repo root)
-
-- [ ] **Step 1: Write the package README**
-
-Create `packages/k8s-sandbox/README.md`:
-```markdown
-# @sh/k8s-sandbox
-
-Routes Pi tool execution (read/write/edit/bash/ls/grep/find) to a remote
-Kubernetes pod via `kubectl exec`, using Pi's native `Operations` seam. Part of
-the serverless harness (Milestone 2). See
-[`docs/specs/2026-06-17-m2-k8s-sandbox-client-design.md`](../../docs/specs/2026-06-17-m2-k8s-sandbox-client-design.md).
-
-## Use
-
-`harness/cli.ts` registers `k8sSandboxExtension()`. It is **inert unless
-`KAGENTI_SANDBOX_POD` is set**:
-
-| Env var | Default | Meaning |
-|---------|---------|---------|
-| `KAGENTI_SANDBOX_POD` | (unset → off) | pod to exec into |
-| `KAGENTI_SANDBOX_NAMESPACE` | `default` | namespace |
-| `KAGENTI_SANDBOX_CONTEXT` | current-context | kube context |
-| `KAGENTI_SANDBOX_CWD` | `/workspace` | pod working dir (announced to the model) |
-
-Apply the fixture pod first: `kubectl apply -f deploy/sandbox.yaml`.
-See `SMOKE.md` for the end-to-end runbook.
-
-## Notes
-
-- No pi-fork change: the `Operations` seam is native. The one exception is
-  `grep`, whose search hardwires a local `rg`; its tool gets an `execute`
-  override (`grep-tool.ts`). See `NOTES-pi-operations.md`.
-- `find` honours basename globs only (no .gitignore/ignore list) — an M2
-  simplification vs Pi's local `fd`.
-- Per-op `kubectl exec` latency is acceptable for M2 (not the perf milestone);
-  a persistent in-pod channel is the M3 upgrade path.
-```
-
-- [ ] **Step 2: Add an M2 line to the repo root README**
-
-In the root `README.md`, append a Milestones note (after the existing M1 mention; if none, add a short "## Milestones" section):
-```markdown
-- **M2 — K8sSandboxClient** (`packages/k8s-sandbox`): routes Pi tool execution to
-  a remote Kubernetes pod via `kubectl exec`. Env-gated (`KAGENTI_SANDBOX_POD`);
-  off by default. Design: `docs/specs/2026-06-17-m2-k8s-sandbox-client-design.md`.
-```
-
-- [ ] **Step 3: Full workspace test sweep (final regression gate)**
-
-Run:
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-pnpm -C packages/k8s-sandbox test 2>&1 | tail -6; echo "k8s EXIT:${PIPESTATUS[0]}"
-pnpm -C packages/session-backend test 2>&1 | tail -6; echo "sb EXIT:${PIPESTATUS[0]}"
-pnpm -C harness test 2>&1 | tail -6; echo "harness EXIT:${PIPESTATUS[0]}"
-```
-Expected: all three suites green (M1's session-backend + harness suites must remain green — no regressions).
-
-- [ ] **Step 4: Commit**
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-git add packages/k8s-sandbox/README.md README.md
-git commit -m "docs(k8s-sandbox): add package README and M2 milestone note"
-```
-
-- [ ] **Step 5: Update the memory note**
-
-Append M2 status to `/Users/paolo/.claude/projects/-Users-paolo-Projects-aiplatform-kagenti/memory/project_serverless_harness_m1.md` (or create a sibling `project_serverless_harness_m2.md` and add a `MEMORY.md` pointer): record that M2 is complete, the commit range, the `@sh/k8s-sandbox` layout, the grep-override / find-glob findings, env-gate var names, and the smoke result. (No git commit — memory lives outside the repo.)
-
----
-
-## Self-review (completed by plan author)
-
-**1. Spec coverage:**
-- §2 D1 kubectl exec transport → Task 5. D2 all 7 ops → Tasks 6 (six) + 7 (grep). D3 existing pod + manifest → Task 10. D4 injectable seam + fake-exec tests + kind smoke → Tasks 5/6 + 11. D5 new package + harness wiring, no pi-fork change → Tasks 2/8/9. D6 env config gate → Task 4. D7 path mapping → Task 3 + bash/grep cwd handling.
-- §4 ops table → Task 6 + 7. §4.1 grep/find risk → Task 1 (note) + 7 (override). §5 extension/headless → Tasks 8/9. §6 manifest → Task 10. §7 gate → Task 11. All covered.
-
-**2. Placeholder scan:** No TBD/TODO/"handle edge cases"; every code step shows complete code; every command states expected output.
-
-**3. Type consistency:** `ExecInPod` (command, opts)→`{stdout, exitCode}` used identically in exec.ts, operations.ts, grep-tool.ts, tests. `K8sSandboxConfig` fields (`pod/namespace/context/podCwd/headCwd`) consistent across config/exec/operations/extension. `resolveConfig(env, headCwd)`, `mapPath(p, headCwd, podCwd)`, `shQuote(s)`, `k8sSandboxExtension({config?, exec?})`, `createPod{Read,Write,Edit,Bash,Ls,Find}Ops(exec, cfg)`, `createPodGrepTool(localCwd, exec, cfg)` — names match every call site. Grep result shape matches `grep.ts:311`.
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-17-m3-persistent-channel.md b/docs/superpowers/plans/2026-06-17-m3-persistent-channel.md
deleted file mode 100644
index 394a300..0000000
--- a/docs/superpowers/plans/2026-06-17-m3-persistent-channel.md
+++ /dev/null
@@ -1,1027 +0,0 @@
-# M3 Persistent Channel + Env Injection + Find Ignore-list — Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Cut per-operation `kubectl exec` latency with a persistent in-pod bash channel for fast request/response ops, inject Pi's per-command `env`, and make find honour the ignore list + `.gitignore` — all harness-side, `pi-fork` untouched.
-
-**Architecture:** A new `persistentExecInPod` transport implements the existing M2 `ExecInPod` type, holding one long-lived `kubectl exec -i … -- bash` open and multiplexing commands over it via a base64-framed, nonce-bracketed protocol with a one-in-flight queue and transparent fallback to per-call exec. The extension routes the small request/response ops (read/write/edit/ls/find) to this channel and keeps bash/grep/`user_bash` on M2's per-call `kubectl exec`. Env injection happens at the bash-ops layer; find switches to `rg --files`.
-
-**Tech Stack:** TypeScript (ESM, `.js` import specifiers), Node `child_process`, vitest, ripgrep (already in the pod image), `kubectl`.
-
-**Spec:** `docs/specs/2026-06-17-m3-persistent-channel-design.md`
-
-**Conventions (from M2):**
-- Package: `packages/k8s-sandbox/`. Tests: vitest in `test/`, imports use `.js` extensions.
-- Run one test file: `pnpm -C packages/k8s-sandbox exec vitest run test/<file>.test.ts`
-- Run all package tests: `pnpm -C packages/k8s-sandbox test`
-- Commits: conventional + **DCO sign-off** (`git commit -s`). No `Co-Authored-By` (use `Assisted-By` only in PR/whole-impl). Shell cwd resets between commands → use absolute paths or `git -C`.
-
----
-
-## File Structure
-
-| File | Responsibility |
-|------|----------------|
-| `packages/k8s-sandbox/src/framing.ts` | **new (pure).** `wrapCommand(nonce, command, stdin?)` builds the bash stdin line(s); `FrameParser` consumes stdout chunks → `{nonce, stdout, exitCode}` frames. No process/cluster deps. |
-| `packages/k8s-sandbox/src/persistent-exec.ts` | **new.** `buildPersistentKubectlArgs(config)` + `persistentExecInPod(config, {fallback, spawn?})` → `ExecInPod & {dispose}`. Owns the long-lived child, the queue, timeout/abort, fallback. |
-| `packages/k8s-sandbox/src/operations.ts` | **edit.** `createPodBashOps`: env prefix. `createPodFindOps.glob`: `rg --files`. |
-| `packages/k8s-sandbox/src/extension.ts` | **edit.** Two-tier routing (`fastExec`/`streamExec`) + dispose on `session_shutdown`. |
-| `packages/k8s-sandbox/src/index.ts` | **edit.** Export `persistentExecInPod`. |
-| `packages/k8s-sandbox/test/framing.test.ts` | **new.** wrapCommand + FrameParser tests. |
-| `packages/k8s-sandbox/test/persistent-exec.test.ts` | **new.** Fake-`spawn` transport tests. |
-| `packages/k8s-sandbox/test/operations.test.ts` | **edit.** Add env cases; rewrite the find case for `rg --files`. |
-| `packages/k8s-sandbox/test/extension.test.ts` | **new.** Registration count + dispose-on-shutdown + inert-when-null. |
-| `packages/k8s-sandbox/SMOKE.md` | **append.** M3 smoke results. |
-
-`deploy/sandbox.yaml`, `config.ts`, `exec.ts`, `paths.ts`, `grep-tool.ts` are **unchanged**.
-
----
-
-## Task 1: Framing protocol (`framing.ts`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/framing.ts`
-- Test: `packages/k8s-sandbox/test/framing.test.ts`
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `packages/k8s-sandbox/test/framing.test.ts`:
-
-```ts
-import { describe, expect, it } from "vitest";
-import { FrameParser, wrapCommand } from "../src/framing.js";
-
-const SOH = "\x01";
-
-describe("wrapCommand", () => {
-  it("brackets base64 output with nonce markers and reports the command's exit code", () => {
-    const line = wrapCommand("n1", "cat '/workspace/a.txt'");
-    expect(line).toBe(
-      `printf '${SOH}B%s\\n' n1; { cat '/workspace/a.txt'; } | base64; ` +
-        `printf '${SOH}E%s %d\\n' n1 "\${PIPESTATUS[0]}"\n`,
-    );
-  });
-
-  it("delivers stdin to the command via a nonce-delimited heredoc", () => {
-    const line = wrapCommand("n2", "base64 -d > '/workspace/a.txt'", Buffer.from("aGk="));
-    expect(line).toBe(
-      `printf '${SOH}B%s\\n' n2; { base64 -d > '/workspace/a.txt' <<'${SOH}Hn2'\n` +
-        `aGk=\n${SOH}Hn2\n} | base64; ` +
-        `printf '${SOH}E%s %d\\n' n2 "\${PIPESTATUS[0]}"\n`,
-    );
-  });
-});
-
-describe("FrameParser", () => {
-  const SOHb = SOH;
-  function frame(nonce: string, payload: string, code: number): string {
-    const b64 = Buffer.from(payload).toString("base64");
-    return `${SOHb}B${nonce}\n${b64}\n${SOHb}E${nonce} ${code}\n`;
-  }
-
-  it("emits a complete frame in one chunk, base64-decoded", () => {
-    const p = new FrameParser();
-    const frames = p.push(Buffer.from(frame("n1", "hello", 0)));
-    expect(frames).toHaveLength(1);
-    expect(frames[0]).toMatchObject({ nonce: "n1", exitCode: 0 });
-    expect(frames[0].stdout.toString()).toBe("hello");
-  });
-
-  it("waits for the end marker (no emit on a partial frame)", () => {
-    const p = new FrameParser();
-    const full = frame("n1", "hello", 0);
-    expect(p.push(Buffer.from(full.slice(0, 10)))).toHaveLength(0);
-    const rest = p.push(Buffer.from(full.slice(10)));
-    expect(rest).toHaveLength(1);
-    expect(rest[0].stdout.toString()).toBe("hello");
-  });
-
-  it("handles a split in the middle of the begin marker", () => {
-    const p = new FrameParser();
-    const full = frame("n7", "x", 0);
-    const cut = 1; // mid "\x01B..."
-    expect(p.push(Buffer.from(full.slice(0, cut)))).toHaveLength(0);
-    expect(p.push(Buffer.from(full.slice(cut)))).toHaveLength(1);
-  });
-
-  it("emits multiple frames present in one chunk, preserving exit codes", () => {
-    const p = new FrameParser();
-    const frames = p.push(Buffer.from(frame("a", "one", 0) + frame("b", "two", 2)));
-    expect(frames.map((f) => [f.nonce, f.stdout.toString(), f.exitCode])).toEqual([
-      ["a", "one", 0],
-      ["b", "two", 2],
-    ]);
-  });
-
-  it("round-trips binary payloads (NUL and high bytes)", () => {
-    const p = new FrameParser();
-    const bin = Buffer.from([0x00, 0xff, 0x01, 0x42, 0x0a]);
-    const b64 = bin.toString("base64");
-    const frames = p.push(Buffer.from(`${SOHb}Bn1\n${b64}\n${SOHb}En1 0\n`));
-    expect(frames[0].stdout.equals(bin)).toBe(true);
-  });
-});
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/framing.test.ts`
-Expected: FAIL — `Failed to resolve import "../src/framing.js"`.
-
-- [ ] **Step 3: Implement `framing.ts`**
-
-Create `packages/k8s-sandbox/src/framing.ts`:
-
-```ts
-// Wire protocol for the persistent in-pod bash channel. One long-lived `bash`
-// reads commands from stdin and writes every command's output to one stdout
-// stream, so each command's output is bracketed by nonce markers and
-// base64-encoded. base64's alphabet ([A-Za-z0-9+/=] + "\n") cannot contain the
-// \x01-prefixed markers, so framing is collision-proof and binary-safe.
-
-const SOH = "\x01"; // marker lead byte; never appears in base64 output
-
-export interface Frame {
-  nonce: string;
-  stdout: Buffer; // base64-decoded command stdout
-  exitCode: number;
-}
-
-/**
- * Build the line(s) written to the session's stdin for one command.
- *
- * `command` is run verbatim; its stdout is base64-encoded between
- * `\x01B<nonce>` and `\x01E<nonce> <exit>` markers. The reported exit code is
- * the COMMAND's (`${PIPESTATUS[0]}`) — NOT base64's `$?`, which is ~always 0.
- *
- * When `stdin` is provided it is delivered to the command via a nonce-delimited
- * heredoc (a shared-stdin session can't pipe separate per-command stdin). The
- * command must be a single pipeline whose first stage consumes stdin (holds for
- * `base64 -d > <path>`).
- */
-export function wrapCommand(nonce: string, command: string, stdin?: Buffer): string {
-  const begin = `printf '${SOH}B%s\\n' ${nonce}; `;
-  const end = `printf '${SOH}E%s %d\\n' ${nonce} "\${PIPESTATUS[0]}"\n`;
-  if (stdin) {
-    const h = `${SOH}H${nonce}`;
-    return `${begin}{ ${command} <<'${h}'\n${stdin.toString()}\n${h}\n} | base64; ${end}`;
-  }
-  return `${begin}{ ${command}; } | base64; ${end}`;
-}
-
-function escapeRe(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/** Chunk-fed parser that emits complete frames as bytes arrive. */
-export class FrameParser {
-  private buf = Buffer.alloc(0);
-
-  push(chunk: Buffer): Frame[] {
-    this.buf = Buffer.concat([this.buf, chunk]);
-    const frames: Frame[] = [];
-    for (;;) {
-      // latin1 keeps bytes 1:1 for the marker scan; payload is ASCII base64.
-      const text = this.buf.toString("latin1");
-      const begin = text.match(/\x01B(\S+)\n/);
-      if (!begin) break;
-      const nonce = begin[1];
-      const bodyStart = begin.index! + begin[0].length;
-      const endRe = new RegExp(`\\x01E${escapeRe(nonce)} (-?\\d+)\\n`);
-      const after = text.slice(bodyStart);
-      const end = after.match(endRe);
-      if (!end) break; // frame not complete yet
-      const b64 = after.slice(0, end.index!);
-      frames.push({
-        nonce,
-        stdout: Buffer.from(b64.replace(/\s/g, ""), "base64"),
-        exitCode: parseInt(end[1], 10),
-      });
-      this.buf = this.buf.subarray(bodyStart + end.index! + end[0].length);
-    }
-    return frames;
-  }
-}
-```
-
-- [ ] **Step 4: Run the tests to verify they pass**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/framing.test.ts`
-Expected: PASS (2 wrapCommand + 5 FrameParser).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/k8s-sandbox/src/framing.ts packages/k8s-sandbox/test/framing.test.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "feat(k8s-sandbox): add persistent-channel wire protocol (framing)"
-```
-
----
-
-## Task 2: Persistent transport (`persistent-exec.ts`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/persistent-exec.ts`
-- Test: `packages/k8s-sandbox/test/persistent-exec.test.ts`
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `packages/k8s-sandbox/test/persistent-exec.test.ts`:
-
-```ts
-import { EventEmitter } from "node:events";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { K8sSandboxConfig } from "../src/config.js";
-import type { ExecInPod } from "../src/exec.js";
-import { buildPersistentKubectlArgs, persistentExecInPod } from "../src/persistent-exec.js";
-
-const cfg: K8sSandboxConfig = {
-  pod: "sbx-0",
-  namespace: "team1",
-  context: undefined,
-  podCwd: "/workspace",
-  headCwd: "/head",
-};
-
-const SOH = "\x01";
-function frameFor(nonce: string, payload: string, code = 0): Buffer {
-  const b64 = Buffer.from(payload).toString("base64");
-  return Buffer.from(`${SOH}B${nonce}\n${b64}\n${SOH}E${nonce} ${code}\n`);
-}
-
-/** A fake ChildProcess: records stdin writes, lets the test push stdout/events. */
-function makeFakeChild() {
-  const child = new EventEmitter() as any;
-  child.stdout = new EventEmitter();
-  child.stderr = new EventEmitter();
-  const writes: string[] = [];
-  child.stdin = { write: (s: string) => (writes.push(s), true), end: vi.fn() };
-  child.kill = vi.fn(() => child.emit("close", null));
-  return { child, writes };
-}
-
-/** A spawn stub returning queued fake children and recording argv. */
-function fakeSpawn(children: any[]) {
-  const calls: { cmd: string; args: string[] }[] = [];
-  const spawn = ((cmd: string, args: string[]) => {
-    calls.push({ cmd, args });
-    return children.shift();
-  }) as any;
-  return { spawn, calls };
-}
-
-function recordingFallback(result = { stdout: Buffer.from("FB"), exitCode: 7 }) {
-  const calls: string[] = [];
-  const fallback: ExecInPod = async (command) => (calls.push(command), result);
-  return { fallback, calls };
-}
-
-afterEach(() => vi.useRealTimers());
-
-describe("buildPersistentKubectlArgs", () => {
-  it("execs a bare interactive bash (no -c) with namespace", () => {
-    expect(buildPersistentKubectlArgs(cfg)).toEqual([
-      "exec", "-i", "-n", "team1", "sbx-0", "--", "bash",
-    ]);
-  });
-  it("includes --context when set", () => {
-    expect(buildPersistentKubectlArgs({ ...cfg, context: "kind-x" })).toEqual([
-      "exec", "-i", "-n", "team1", "--context", "kind-x", "sbx-0", "--", "bash",
-    ]);
-  });
-});
-
-describe("persistentExecInPod", () => {
-  it("spawns once, writes the framed command, resolves from the matching frame", async () => {
-    const { child, writes } = makeFakeChild();
-    const { spawn, calls } = fakeSpawn([child]);
-    const { fallback } = recordingFallback();
-    const exec = persistentExecInPod(cfg, { fallback, spawn });
-
-    const p = exec("cat '/workspace/a.txt'");
-    expect(calls).toHaveLength(1); // lazy spawn happened
-    expect(writes[0]).toContain("cat '/workspace/a.txt'");
-    const nonce = writes[0].match(/\x01B(\S+)\\n/) ? "" : ""; // nonce read below
-    child.stdout.emit("data", frameFor("n1", "hello", 0));
-    expect(await p).toEqual({ stdout: Buffer.from("hello"), exitCode: 0 });
-  });
-
-  it("reuses one child across sequential calls (no second spawn)", async () => {
-    const { child } = makeFakeChild();
-    const { spawn, calls } = fakeSpawn([child]);
-    const exec = persistentExecInPod(cfg, { fallback: recordingFallback().fallback, spawn });
-
-    const p1 = exec("echo a");
-    child.stdout.emit("data", frameFor("n1", "a", 0));
-    await p1;
-    const p2 = exec("echo b");
-    child.stdout.emit("data", frameFor("n2", "b", 0));
-    await p2;
-    expect(calls).toHaveLength(1);
-  });
-
-  it("serializes: the second command is not written until the first frame arrives", async () => {
-    const { child, writes } = makeFakeChild();
-    const { spawn } = fakeSpawn([child]);
-    const exec = persistentExecInPod(cfg, { fallback: recordingFallback().fallback, spawn });
-
-    const p1 = exec("first");
-    const p2 = exec("second");
-    expect(writes).toHaveLength(1); // only first in flight
-    child.stdout.emit("data", frameFor("n1", "", 0));
-    await p1;
-    expect(writes).toHaveLength(2); // second now written
-    child.stdout.emit("data", frameFor("n2", "", 0));
-    await p2;
-  });
-
-  it("falls back when the session dies mid-command", async () => {
-    const { child } = makeFakeChild();
-    const { spawn } = fakeSpawn([child, makeFakeChild().child]);
-    const { fallback, calls } = recordingFallback();
-    const exec = persistentExecInPod(cfg, { fallback, spawn });
-
-    const p = exec("cat '/workspace/a.txt'");
-    child.emit("error", new Error("broken pipe"));
-    expect(await p).toEqual({ stdout: Buffer.from("FB"), exitCode: 7 });
-    expect(calls).toEqual(["cat '/workspace/a.txt'"]);
-  });
-
-  it("times out: kills the child and rejects with timeout:<n>", async () => {
-    vi.useFakeTimers();
-    const { child } = makeFakeChild();
-    const { spawn } = fakeSpawn([child]);
-    const exec = persistentExecInPod(cfg, { fallback: recordingFallback().fallback, spawn });
-
-    const p = exec("sleep 999", { timeout: 2 });
-    const assertion = expect(p).rejects.toThrow("timeout:2");
-    await vi.advanceTimersByTimeAsync(2000);
-    await assertion;
-    expect(child.kill).toHaveBeenCalled();
-  });
-
-  it("aborts: kills the child and rejects with 'aborted'", async () => {
-    const { child } = makeFakeChild();
-    const { spawn } = fakeSpawn([child]);
-    const exec = persistentExecInPod(cfg, { fallback: recordingFallback().fallback, spawn });
-    const ac = new AbortController();
-
-    const p = exec("sleep 999", { signal: ac.signal });
-    ac.abort();
-    await expect(p).rejects.toThrow("aborted");
-    expect(child.kill).toHaveBeenCalled();
-  });
-
-  it("dispose() kills the child and routes later calls to the fallback", async () => {
-    const { child } = makeFakeChild();
-    const { spawn } = fakeSpawn([child]);
-    const { fallback, calls } = recordingFallback();
-    const exec = persistentExecInPod(cfg, { fallback, spawn });
-
-    const p1 = exec("echo a");
-    child.stdout.emit("data", frameFor("n1", "a", 0));
-    await p1;
-    exec.dispose();
-    expect(child.stdin.end).toHaveBeenCalled();
-    expect(child.kill).toHaveBeenCalled();
-    expect(await exec("echo later")).toEqual({ stdout: Buffer.from("FB"), exitCode: 7 });
-    expect(calls).toEqual(["echo later"]);
-  });
-});
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/persistent-exec.test.ts`
-Expected: FAIL — `Failed to resolve import "../src/persistent-exec.js"`.
-
-- [ ] **Step 3: Implement `persistent-exec.ts`**
-
-Create `packages/k8s-sandbox/src/persistent-exec.ts`:
-
-```ts
-import { type ChildProcess, spawn as nodeSpawn } from "node:child_process";
-import type { K8sSandboxConfig } from "./config.js";
-import type { ExecInPod } from "./exec.js";
-import { FrameParser, wrapCommand } from "./framing.js";
-
-/** argv for the long-lived session: a bare interactive `bash` (NOT `bash -c`). */
-export function buildPersistentKubectlArgs(config: K8sSandboxConfig): string[] {
-  const args = ["exec", "-i", "-n", config.namespace];
-  if (config.context) args.push("--context", config.context);
-  args.push(config.pod, "--", "bash");
-  return args;
-}
-
-type SpawnFn = typeof nodeSpawn;
-export type PersistentExec = ExecInPod & { dispose: () => void };
-
-interface Inflight {
-  nonce: string;
-  /** resolve from a matching frame */
-  done: (r: { stdout: Buffer; exitCode: number | null }) => void;
-  /** channel died → caller retries via fallback */
-  fail: (e: Error) => void;
-}
-
-/**
- * An ExecInPod backed by ONE long-lived `kubectl exec -i -- bash`. Commands are
- * multiplexed over the framed protocol (framing.ts), one in flight at a time.
- * Channel unavailability (spawn error, mid-command death) transparently retries
- * the op via `deps.fallback`; timeout/abort reject with M2-compatible errors.
- * The session is spawned lazily and torn down by dispose().
- */
-export function persistentExecInPod(
-  config: K8sSandboxConfig,
-  deps: { fallback: ExecInPod; spawn?: SpawnFn },
-): PersistentExec {
-  const spawnFn = deps.spawn ?? nodeSpawn;
-  let child: ChildProcess | null = null;
-  let parser = new FrameParser();
-  let inflight: Inflight | null = null;
-  const queue: Array<() => void> = [];
-  let seq = 0;
-  let disposed = false;
-
-  const killChild = () => {
-    if (!child) return;
-    try {
-      child.kill("SIGKILL");
-    } catch {
-      /* already gone */
-    }
-    child = null;
-  };
-
-  const pump = () => {
-    if (inflight || queue.length === 0) return;
-    queue.shift()!();
-  };
-
-  // Tear the session down and signal channel failure for any in-flight command.
-  const failSession = (err: Error) => {
-    killChild();
-    parser = new FrameParser();
-    const cur = inflight;
-    inflight = null;
-    cur?.fail(err);
-    pump();
-  };
-
-  const ensureChild = () => {
-    if (child || disposed) return;
-    const c = spawnFn("kubectl", buildPersistentKubectlArgs(config), {
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    child = c;
-    c.stdout!.on("data", (d: Buffer) => {
-      for (const f of parser.push(d)) {
-        if (inflight && f.nonce === inflight.nonce) {
-          const cur = inflight;
-          inflight = null;
-          cur.done({ stdout: f.stdout, exitCode: f.exitCode });
-          pump();
-        }
-      }
-    });
-    c.on("error", (e) => failSession(e instanceof Error ? e : new Error(String(e))));
-    c.on("close", () => {
-      if (inflight || queue.length) failSession(new Error("session closed"));
-      else child = null;
-    });
-  };
-
-  const exec: ExecInPod = (command, opts = {}) => {
-    if (disposed) return deps.fallback(command, opts);
-    return new Promise((resolve, reject) => {
-      const start = () => {
-        ensureChild();
-        if (!child) {
-          // spawn unavailable → fall back
-          deps.fallback(command, opts).then(resolve, reject);
-          return;
-        }
-        const nonce = `n${++seq}`;
-        let settled = false;
-        let timer: ReturnType<typeof setTimeout> | undefined;
-        const cleanup = () => {
-          if (timer) clearTimeout(timer);
-          opts.signal?.removeEventListener("abort", onAbort);
-        };
-        // timeout / abort: kill+reset the session and reject (NO fallback).
-        const killAndReject = (err: Error) => {
-          if (settled) return;
-          settled = true;
-          cleanup();
-          inflight = null;
-          killChild();
-          parser = new FrameParser();
-          reject(err);
-          pump();
-        };
-        function onAbort() {
-          killAndReject(new Error("aborted"));
-        }
-        if (opts.signal?.aborted) return killAndReject(new Error("aborted"));
-        opts.signal?.addEventListener("abort", onAbort, { once: true });
-        if (opts.timeout && opts.timeout > 0) {
-          timer = setTimeout(() => killAndReject(new Error(`timeout:${opts.timeout}`)), opts.timeout * 1000);
-        }
-        inflight = {
-          nonce,
-          done: (r) => {
-            if (settled) return;
-            settled = true;
-            cleanup();
-            resolve(r);
-          },
-          fail: () => {
-            if (settled) return;
-            settled = true;
-            cleanup();
-            deps.fallback(command, opts).then(resolve, reject);
-          },
-        };
-        try {
-          child.stdin!.write(wrapCommand(nonce, command, opts.stdin));
-        } catch (e) {
-          failSession(e instanceof Error ? e : new Error(String(e)));
-        }
-      };
-      queue.push(start);
-      pump();
-    });
-  };
-
-  return Object.assign(exec, {
-    dispose: () => {
-      disposed = true;
-      try {
-        child?.stdin?.end();
-      } catch {
-        /* noop */
-      }
-      killChild();
-      queue.length = 0;
-    },
-  });
-}
-```
-
-- [ ] **Step 4: Run the tests to verify they pass**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/persistent-exec.test.ts`
-Expected: PASS (2 argv + 7 transport).
-
-Note on the timeout test: `failSession`/`close` may fire after `killChild()` emits `close`; the `settled` guard and the `inflight=null` set in `killAndReject` keep the rejection single. If the close handler races, it sees `inflight===null` and `queue.length===0` and is a no-op.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/k8s-sandbox/src/persistent-exec.ts packages/k8s-sandbox/test/persistent-exec.test.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "feat(k8s-sandbox): add persistent kubectl-exec transport with fallback"
-```
-
----
-
-## Task 3: Env injection in `createPodBashOps`
-
-**Files:**
-- Modify: `packages/k8s-sandbox/src/operations.ts:64-74`
-- Test: `packages/k8s-sandbox/test/operations.test.ts` (add cases to `describe("bash ops")`)
-
-- [ ] **Step 1: Write the failing tests**
-
-In `packages/k8s-sandbox/test/operations.test.ts`, add inside `describe("bash ops", ...)` (after the existing test):
-
-```ts
-  it("injects env as a non-leaking, per-invocation prefix when env is provided", async () => {
-    const { fn, calls } = fakeExec({ exitCode: 0 });
-    const ops = createPodBashOps(fn, cfg);
-    await ops.exec("echo $FOO", "/head", { onData: vi.fn(), env: { FOO: "bar baz" } });
-    expect(calls[0].command).toBe("cd '/workspace' && env FOO='bar baz' bash -c 'echo $FOO'");
-  });
-
-  it("skips env keys whose value is undefined", async () => {
-    const { fn, calls } = fakeExec({ exitCode: 0 });
-    const ops = createPodBashOps(fn, cfg);
-    await ops.exec("true", "/head", { onData: vi.fn(), env: { A: "1", B: undefined } });
-    expect(calls[0].command).toBe("cd '/workspace' && env A='1' bash -c 'true'");
-  });
-
-  it("emits the M2 form (no prefix) when env is absent or empty", async () => {
-    const { fn, calls } = fakeExec({ exitCode: 0 });
-    const ops = createPodBashOps(fn, cfg);
-    await ops.exec("echo hi", "/head", { onData: vi.fn(), env: {} });
-    expect(calls[0].command).toBe("cd '/workspace' && echo hi");
-  });
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/operations.test.ts -t "bash ops"`
-Expected: FAIL — the new assertions don't match (env dropped; current output is `cd '/workspace' && echo $FOO`).
-
-- [ ] **Step 3: Implement the env prefix**
-
-In `packages/k8s-sandbox/src/operations.ts`, replace `createPodBashOps` (lines 64-74) with:
-
-```ts
-export function createPodBashOps(exec: ExecInPod, cfg: K8sSandboxConfig): BashOperations {
-  const q = mapper(cfg);
-  return {
-    // Pi passes `env` only to the bash tool. Inject it here (transport-agnostic)
-    // as an `env VAR=val … bash -c <cmd>` prefix: scoped to this one invocation,
-    // so nothing leaks across calls (M2 dropped env entirely — see git history).
-    exec: async (command, cwd, { onData, signal, timeout, env }) => {
-      const pairs = env
-        ? Object.entries(env)
-            .filter(([, v]) => v !== undefined)
-            .map(([k, v]) => `${k}=${shQuote(String(v))}`)
-        : [];
-      const wrapped = pairs.length
-        ? `cd ${q(cwd)} && env ${pairs.join(" ")} bash -c ${shQuote(command)}`
-        : `cd ${q(cwd)} && ${command}`; // M2's exact form — unchanged when no env
-      const r = await exec(wrapped, { onData, signal, timeout });
-      return { exitCode: r.exitCode };
-    },
-  };
-}
-```
-
-- [ ] **Step 4: Run the tests to verify they pass**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/operations.test.ts -t "bash ops"`
-Expected: PASS (original + 3 new bash-ops cases).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/k8s-sandbox/src/operations.ts packages/k8s-sandbox/test/operations.test.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "feat(k8s-sandbox): inject per-command env for pod bash ops"
-```
-
----
-
-## Task 4: find on `rg --files` (ignore list + .gitignore)
-
-**Files:**
-- Modify: `packages/k8s-sandbox/src/operations.ts:94-110`
-- Test: `packages/k8s-sandbox/test/operations.test.ts` (rewrite the `describe("find ops")` case)
-
-- [ ] **Step 1: Rewrite the failing test**
-
-In `packages/k8s-sandbox/test/operations.test.ts`, replace the entire `describe("find ops", ...)` block (currently asserting `find . -type f -name …`) with:
-
-```ts
-describe("find ops", () => {
-  it("globs via rg --files, honouring the ignore list and stripping ./", async () => {
-    const { fn, calls } = fakeExec({ stdout: "src/a.ts\nb.ts\n" });
-    const ops = createPodFindOps(fn, cfg);
-    const results = await ops.glob("*.ts", "/head", {
-      ignore: ["**/node_modules/**", "**/.git/**"],
-      limit: 100,
-    });
-    expect(results).toEqual(["src/a.ts", "b.ts"]);
-    expect(calls[0].command).toBe(
-      "cd '/workspace' && rg --files --hidden -g '*.ts' " +
-        "-g '!**/node_modules/**' -g '!**/.git/**' | head -n 100",
-    );
-  });
-
-  it("emits no ignore globs when the ignore list is empty", async () => {
-    const { fn, calls } = fakeExec({ stdout: "" });
-    const ops = createPodFindOps(fn, cfg);
-    await ops.glob("*.go", "/head", { ignore: [], limit: 50 });
-    expect(calls[0].command).toBe("cd '/workspace' && rg --files --hidden -g '*.go' | head -n 50");
-  });
-
-  it("exists uses test -e on the mapped path", async () => {
-    const { fn, calls } = fakeExec({ exitCode: 0 });
-    expect(await createPodFindOps(fn, cfg).exists("/head/x")).toBe(true);
-    expect(calls[0].command).toBe("test -e '/workspace/x'");
-  });
-});
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/operations.test.ts -t "find ops"`
-Expected: FAIL — current `glob` emits `find . -type f -name '*.ts' …`, not `rg --files …`.
-
-- [ ] **Step 3: Implement `rg --files`**
-
-In `packages/k8s-sandbox/src/operations.ts`, replace `createPodFindOps` (lines 94-110) with:
-
-```ts
-export function createPodFindOps(exec: ExecInPod, cfg: K8sSandboxConfig): FindOperations {
-  const q = mapper(cfg);
-  return {
-    exists: async (p) => (await exec(`test -e ${q(p)}`)).exitCode === 0,
-    // `rg --files` lists files honouring .gitignore by default (matching Pi's
-    // local `fd` — "respects .gitignore"); --hidden keeps dotfiles in view while
-    // gitignore still applies. Each Pi `ignore` entry becomes a negated glob.
-    // Paths come back relative to cwd; strip any leading "./" defensively.
-    glob: async (pattern, cwd, { ignore, limit }) => {
-      const globs = [`-g ${shQuote(pattern)}`, ...ignore.map((ig) => `-g ${shQuote(`!${ig}`)}`)];
-      const r = await exec(`cd ${q(cwd)} && rg --files --hidden ${globs.join(" ")} | head -n ${limit}`);
-      return r.stdout
-        .toString()
-        .split("\n")
-        .filter((x) => x.length > 0)
-        .map((rel) => rel.replace(/^\.\//, ""));
-    },
-  };
-}
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/operations.test.ts -t "find ops"`
-Expected: PASS (3 find-ops cases).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/k8s-sandbox/src/operations.ts packages/k8s-sandbox/test/operations.test.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "feat(k8s-sandbox): route find through rg --files (ignore + gitignore)"
-```
-
----
-
-## Task 5: Two-tier extension wiring + dispose on shutdown
-
-**Files:**
-- Modify: `packages/k8s-sandbox/src/extension.ts`
-- Modify: `packages/k8s-sandbox/src/index.ts`
-- Test: `packages/k8s-sandbox/test/extension.test.ts` (create)
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `packages/k8s-sandbox/test/extension.test.ts`:
-
-```ts
-import { describe, expect, it, vi } from "vitest";
-import type { K8sSandboxConfig } from "../src/config.js";
-import type { ExecInPod } from "../src/exec.js";
-import { k8sSandboxExtension } from "../src/extension.js";
-
-const cfg: K8sSandboxConfig = {
-  pod: "sbx-0",
-  namespace: "default",
-  context: undefined,
-  podCwd: "/workspace",
-  headCwd: "/head",
-};
-
-/** Minimal ExtensionAPI stub recording registrations + event handlers. */
-function fakePi() {
-  const tools: unknown[] = [];
-  const handlers: Record<string, (...a: unknown[]) => unknown> = {};
-  const pi = {
-    registerTool: (t: unknown) => tools.push(t),
-    on: (name: string, h: (...a: unknown[]) => unknown) => {
-      handlers[name] = h;
-    },
-  } as unknown as Parameters<ReturnType<typeof k8sSandboxExtension>>[0];
-  return { pi, tools, handlers };
-}
-
-describe("k8sSandboxExtension", () => {
-  it("registers the seven pod tools and wires the lifecycle handlers", () => {
-    const exec: ExecInPod = async () => ({ stdout: Buffer.from(""), exitCode: 0 });
-    const { pi, tools, handlers } = fakePi();
-    k8sSandboxExtension({ config: cfg, exec })(pi);
-    expect(tools).toHaveLength(7);
-    expect(typeof handlers.user_bash).toBe("function");
-    expect(typeof handlers.before_agent_start).toBe("function");
-    expect(typeof handlers.session_shutdown).toBe("function");
-  });
-
-  it("disposes the fast channel on session_shutdown when it exposes dispose()", () => {
-    const dispose = vi.fn();
-    const exec = Object.assign(async () => ({ stdout: Buffer.from(""), exitCode: 0 }), { dispose }) as ExecInPod;
-    const { pi, handlers } = fakePi();
-    k8sSandboxExtension({ config: cfg, exec })(pi);
-    handlers.session_shutdown();
-    expect(dispose).toHaveBeenCalledTimes(1);
-  });
-
-  it("is inert (registers nothing) when config is null", () => {
-    const { pi, tools } = fakePi();
-    k8sSandboxExtension({ config: null })(pi);
-    expect(tools).toHaveLength(0);
-  });
-});
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/extension.test.ts`
-Expected: FAIL — no `session_shutdown` handler yet (the dispose test fails / `handlers.session_shutdown` is undefined).
-
-- [ ] **Step 3: Implement the two-tier wiring**
-
-Replace `packages/k8s-sandbox/src/extension.ts` in full with:
-
-```ts
-import {
-  createBashTool,
-  createEditTool,
-  createFindTool,
-  createLsTool,
-  createReadTool,
-  createWriteTool,
-  type ExtensionAPI,
-  type ExtensionFactory,
-} from "@earendil-works/pi-coding-agent";
-import { type K8sSandboxConfig, resolveConfig } from "./config.js";
-import { type ExecInPod, kubectlExecInPod } from "./exec.js";
-import { persistentExecInPod } from "./persistent-exec.js";
-import {
-  createPodBashOps,
-  createPodEditOps,
-  createPodFindOps,
-  createPodLsOps,
-  createPodReadOps,
-  createPodWriteOps,
-} from "./operations.js";
-import { createPodGrepTool } from "./grep-tool.js";
-
-/**
- * Pi extension that overrides the seven built-in tools so file/search/exec run
- * in a remote Kubernetes pod. Inert (local tools stand) unless a sandbox is
- * configured.
- *
- * Two-tier transport:
- *  - fastExec: a persistent in-pod bash channel for the small request/response
- *    ops (read/write/edit/ls/find), with transparent fallback to per-call exec.
- *  - streamExec: M2's per-call `kubectl exec` for the streaming/long-running ops
- *    (bash, grep, user `!`), which need onData/abort/long-running semantics.
- *
- * @param opts.config Explicit config; if omitted, resolved from process.env.
- *                    Pass `null` to force-disable.
- * @param opts.exec   Override BOTH transports (used by tests / alternate auth).
- */
-export function k8sSandboxExtension(opts?: {
-  config?: K8sSandboxConfig | null;
-  exec?: ExecInPod;
-}): ExtensionFactory {
-  return (pi: ExtensionAPI) => {
-    const localCwd = process.cwd();
-    const config =
-      opts?.config !== undefined ? opts.config : resolveConfig(process.env, localCwd);
-    if (!config) return; // off gate — local tools stand
-
-    const streamExec = opts?.exec ?? kubectlExecInPod(config);
-    const fastExec =
-      opts?.exec ?? persistentExecInPod(config, { fallback: kubectlExecInPod(config) });
-
-    // Fast request/response ops → persistent channel.
-    pi.registerTool(createReadTool(localCwd, { operations: createPodReadOps(fastExec, config) }));
-    pi.registerTool(createWriteTool(localCwd, { operations: createPodWriteOps(fastExec, config) }));
-    pi.registerTool(createEditTool(localCwd, { operations: createPodEditOps(fastExec, config) }));
-    pi.registerTool(createLsTool(localCwd, { operations: createPodLsOps(fastExec, config) }));
-    pi.registerTool(createFindTool(localCwd, { operations: createPodFindOps(fastExec, config) }));
-
-    // Streaming / long-running ops → per-call kubectl exec (M2 path, unchanged).
-    pi.registerTool(createBashTool(localCwd, { operations: createPodBashOps(streamExec, config) }));
-    pi.registerTool(createPodGrepTool(localCwd, streamExec, config));
-    pi.on("user_bash", () => ({ operations: createPodBashOps(streamExec, config) }));
-
-    // Tell the model its cwd is the pod's, not the head's.
-    pi.on("before_agent_start", (event) => {
-      const modified = event.systemPrompt.replace(
-        `Current working directory: ${localCwd}`,
-        `Current working directory: ${config.podCwd} (sandbox pod ${config.namespace}/${config.pod})`,
-      );
-      return { systemPrompt: modified };
-    });
-
-    // Tear down the persistent kubectl process so it is never leaked.
-    pi.on("session_shutdown", () => {
-      const maybe = fastExec as ExecInPod & { dispose?: () => void };
-      if (typeof maybe.dispose === "function") maybe.dispose();
-    });
-  };
-}
-```
-
-- [ ] **Step 4: Export the transport from the package index**
-
-In `packages/k8s-sandbox/src/index.ts`, add after the `exec.js` export line:
-
-```ts
-export { buildPersistentKubectlArgs, persistentExecInPod, type PersistentExec } from "./persistent-exec.js";
-```
-
-- [ ] **Step 5: Run the extension tests to verify they pass**
-
-Run: `pnpm -C packages/k8s-sandbox exec vitest run test/extension.test.ts`
-Expected: PASS (3 cases).
-
-- [ ] **Step 6: Run the full package suite (M2 + M3 all green)**
-
-Run: `pnpm -C packages/k8s-sandbox test`
-Expected: PASS — framing (7), persistent-exec (9), operations (paths/read/write/edit/bash incl. env, ls, find), config, exec, extension. No failures.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/k8s-sandbox/src/extension.ts packages/k8s-sandbox/src/index.ts packages/k8s-sandbox/test/extension.test.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "feat(k8s-sandbox): two-tier transport routing + dispose persistent channel"
-```
-
----
-
-## Task 6: Real kind smoke
-
-**Files:**
-- Modify: `packages/k8s-sandbox/SMOKE.md` (append an M3 section)
-
-Goal: on a real kind cluster, prove the three M3 claims — (1) a burst of fast ops reuses **one** kubectl process, (2) an env var set on a bash call is visible in the pod, (3) find honours `.gitignore` for ignored **directories** (`dist/` excluded by `.gitignore`; `node_modules/`,`.git/` also excluded — the latter via Pi's `ignore` list) — with the verified nuance that an individually-gitignored *file* matching the positive `-g <pattern>` is re-included (rg whitelist-override, see design D5). Also prove the post-fix **write/edit over the persistent channel** works (heredoc-delimiter fix) and the persistent process is disposed on shutdown. This task is run against a live cluster; record the actual results.
-
-- [ ] **Step 1: Ensure a sandbox pod and gateway env**
-
-Run (redirect noisy output per the repo context-budget rule):
-
-```bash
-export LOG_DIR=/tmp/kagenti/m3-smoke; mkdir -p $LOG_DIR
-kubectl apply -f /Users/paolo/Projects/aiplatform/serverless-harness/packages/k8s-sandbox/deploy/sandbox.yaml > $LOG_DIR/apply.log 2>&1; echo "EXIT:$?"
-kubectl rollout status deploy/sandbox --timeout=120s > $LOG_DIR/rollout.log 2>&1; echo "EXIT:$?"
-POD=$(kubectl get pod -l app=sandbox -o jsonpath='{.items[0].metadata.name}'); echo "POD=$POD"
-```
-
-Expected: `EXIT:0` for both; `POD=sandbox-...`. Gateway env (`ANTHROPIC_BASE_URL`, `ANTHROPIC_AUTH_TOKEN`) and `sh-redis` on :6379 present (M1/M2 setup).
-
-- [ ] **Step 2: Seed pod fixtures for find (gitignore + node_modules)**
-
-```bash
-kubectl exec "$POD" -- bash -lc '
-  cd /workspace &&
-  mkdir -p src node_modules/pkg .git &&
-  printf "node_modules/\n" > .gitignore &&
-  : > src/keep.ts && : > node_modules/pkg/skip.ts && : > .git/cfg.ts &&
-  : > top.ts
-' > $LOG_DIR/seed.log 2>&1; echo "EXIT:$?"
-```
-
-Expected: `EXIT:0`.
-
-- [ ] **Step 3: Drive a headless turn that triggers a burst of fast ops + an env bash call**
-
-Set the sandbox env and run the harness headless against the pod, asking the agent to (a) list/read several files (fast ops), (b) run a bash command echoing an injected env var, (c) find `*.ts` files:
-
-```bash
-cd /Users/paolo/Projects/aiplatform/serverless-harness
-KAGENTI_SANDBOX_POD="$POD" KAGENTI_SANDBOX_CONTEXT="kind-kagenti" \
-  pnpm -C harness exec tsx src/cli.ts -p \
-  "Run: ls /workspace; read /workspace/.gitignore; then run the bash command 'echo MARKER=\$M3_SMOKE' (M3_SMOKE is set); then find *.ts files under /workspace. Report what you saw." \
-  > $LOG_DIR/run.log 2>&1; echo "EXIT:$?"
-```
-
-(If the headless CLI needs a different flag/entrypoint than M2's smoke used, mirror M2's `SMOKE.md` invocation. The env var the agent must see is provided to the bash tool by Pi; to inject `M3_SMOKE`, pass it through whatever per-call env Pi forwards — for a manual check you may instead instruct the agent to run `echo MARKER=$M3_SMOKE` after the harness sets it via the bash tool env path.)
-
-- [ ] **Step 4: Verify the three claims (use a subagent to scan the log, per context-budget rule)**
-
-Dispatch an Explore subagent:
-
-> Use Grep (with `-C 2`) on `$LOG_DIR/run.log`. Confirm and report: (1) the find result lists `src/keep.ts` and `top.ts` but NOT `dist/bundle.ts` (excluded by `.gitignore` `dist/` — gitignored *directory* pruned), `node_modules/pkg/skip.ts` or `.git/cfg.ts` (ignore list `**/node_modules/**`,`**/.git/**`). Per D5, a gitignored *file* (not dir) matching the glob WOULD still appear; (2) a line `MARKER=` shows the injected env value (env injection works); (3) no errors/tracebacks. Return the matching lines only, not the whole file.
-
-For claim (1)-process-reuse: confirm a single persistent session served the burst. Quick external check — while a run is active, `kubectl get pod "$POD" -o jsonpath='{range .status..}{end}'` won't show it; instead rely on the temporary spawn log: add a one-line `console.error("spawned persistent session")` in `ensureChild` for the smoke run and assert it appears exactly once in `$LOG_DIR/run.log` for the multi-read burst, then revert the log line. Record the count.
-
-- [ ] **Step 5: Record results in `SMOKE.md`**
-
-Append an `## M3 smoke (YYYY-MM-DD)` section to `packages/k8s-sandbox/SMOKE.md` capturing: pod name, cluster/context, the find output (kept vs excluded), the `MARKER=` line, the single-spawn count, and a PASS/FAIL verdict. Keep it factual (mirror the M2 section's format).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/k8s-sandbox/SMOKE.md
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "test(k8s-sandbox): record M3 persistent-channel + env + find smoke"
-```
-
----
-
-## Self-Review (completed by plan author)
-
-**Spec coverage:**
-- §2 D1 persistent transport T1 → Task 2 (`persistentExecInPod`, bare `bash`). ✅
-- §2 D2 S-fast scope (fast ops persistent, bash/grep per-call) → Task 5 routing. ✅
-- §2 D3 framing (sentinel + base64 + `${PIPESTATUS[0]}`, one-in-flight) → Task 1 + Task 2 queue. ✅
-- §2 D4 env at bash-ops layer, no signature change → Task 3. ✅
-- §2 D5 find on `rg --files` → Task 4. ✅
-- §2 D6 transparent fallback (spawn fail + mid-command death, non-zero exit passes through) → Task 2 tests + impl. ✅
-- §2 D7 dispose on `session_shutdown`, lazy spawn → Task 2 (lazy `ensureChild`, `dispose`) + Task 5 (`session_shutdown`). ✅
-- §3.1 per-command stdin via heredoc → Task 1 `wrapCommand(stdin)` + test. ✅
-- §3.3 no new config → no config.ts task (intentional). ✅
-- §6 verification gate (framing pure tests; fake-spawn transport tests incl. fallback/timeout/abort/dispose; operations env + find; M2 green; one kind smoke) → Tasks 1–6. ✅
-- §5 error-handling table (timeout/abort reject; channel death → fallback; non-zero exit pass-through) → Task 2 tests. ✅
-
-**Placeholder scan:** No TBD/TODO; every code step shows complete code. The smoke task (Task 6) records live results at execution time — that is data, not a code placeholder (mirrors M2's smoke task). ✅
-
-**Type consistency:** `ExecInPod` (from `exec.ts`) reused unchanged; `persistentExecInPod` returns `ExecInPod & { dispose }` (`PersistentExec`); `wrapCommand(nonce, command, stdin?)` and `FrameParser.push → Frame[]` signatures match across Tasks 1, 2, 5; `buildPersistentKubectlArgs` name consistent in impl/test/index; `createPodBashOps`/`createPodFindOps` keep their M2 signatures. ✅
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-17-m4-knative-serverless-wrapper.md b/docs/superpowers/plans/2026-06-17-m4-knative-serverless-wrapper.md
deleted file mode 100644
index 3190abb..0000000
--- a/docs/superpowers/plans/2026-06-17-m4-knative-serverless-wrapper.md
+++ /dev/null
@@ -1,1321 +0,0 @@
-# M4: Knative Serverless Wrapper — Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Wrap the serverless harness as a Knative Serving HTTP service that scales to zero between turns, proving the core serverless thesis on a local Kind cluster.
-
-**Architecture:** Extract the shared turn logic from `cli.ts` into a reusable `runTurn()` function. Build a new `@sh/knative-server` package with a minimal Node HTTP server. Containerize with a multi-stage Dockerfile and deploy as a Knative Service on Kind with Kourier networking.
-
-**Tech Stack:** TypeScript, Node.js 20, pnpm workspaces, vitest, Docker, Knative Serving, Kourier, Kind, Redis
-
-**Spec:** `docs/specs/2026-06-17-m4-knative-serverless-wrapper-design.md`
-
----
-
-## File Map
-
-### New files
-
-| File | Responsibility |
-|------|---------------|
-| `harness/src/run-turn.ts` | Reusable turn logic: create/resume session, run prompt, return result |
-| `harness/test/run-turn.test.ts` | Integration test for `runTurn()` with real Redis |
-| `packages/knative-server/package.json` | Package manifest for `@sh/knative-server` |
-| `packages/knative-server/tsconfig.json` | TypeScript config |
-| `packages/knative-server/vitest.config.ts` | Vitest config |
-| `packages/knative-server/src/server.ts` | HTTP server (`POST /turn`, `GET /health`, graceful shutdown) |
-| `packages/knative-server/src/index.ts` | Package exports |
-| `packages/knative-server/test/server.test.ts` | Unit tests (mocked `runTurn`) |
-| `Dockerfile` | Multi-stage container build |
-| `deploy/knative/service.yaml` | Knative Service manifest |
-| `deploy/knative/redis.yaml` | Redis Deployment + Service for Kind |
-| `deploy/knative/sandbox.yaml` | Sandbox pod (copy of k8s-sandbox/deploy/sandbox.yaml) |
-| `deploy/knative/setup-kind.sh` | One-shot setup: Knative + Redis + build + deploy |
-| `deploy/knative/smoke.sh` | Live smoke test: scale 0→1→0 + session recall |
-
-### Modified files
-
-| File | Change |
-|------|--------|
-| `harness/src/cli.ts` | Replace inline logic with `runTurn()` call |
-| `pnpm-workspace.yaml` | Already covers `packages/*` — no change needed |
-
----
-
-## Task 1: Extract `runTurn()` from `cli.ts`
-
-**Files:**
-- Create: `harness/src/run-turn.ts`
-- Modify: `harness/src/cli.ts`
-
-- [ ] **Step 1: Create `harness/src/run-turn.ts` with the full implementation**
-
-```ts
-// harness/src/run-turn.ts
-import {
-  createAgentSession,
-  DefaultResourceLoader,
-  getAgentDir,
-  SessionManager,
-  SettingsManager,
-  type FileEntry,
-} from "@earendil-works/pi-coding-agent";
-import { getModel, type AssistantMessage } from "@earendil-works/pi-ai";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { BufferedRedisBackend } from "./buffered-redis-backend.js";
-import { flushExtension } from "./flush-extension.js";
-import { k8sSandboxExtension } from "@sh/k8s-sandbox";
-
-export interface TurnConfig {
-  redisUrl?: string;
-  cwd?: string;
-  anthropicBaseUrl?: string;
-  anthropicAuthToken?: string;
-}
-
-export interface TurnResult {
-  sessionId: string;
-  response: string;
-  stopReason: string;
-  errorMessage?: string;
-}
-
-export async function runTurn(
-  prompt: string,
-  sessionId: string | undefined,
-  config?: TurnConfig,
-): Promise<TurnResult> {
-  const redisUrl = config?.redisUrl ?? "redis://localhost:6379";
-  const cwd = config?.cwd ?? process.cwd();
-
-  // Gateway bridge: mirror token into API_KEY env for Pi's key guard.
-  const authToken = config?.anthropicAuthToken ?? process.env.ANTHROPIC_AUTH_TOKEN;
-  if (authToken && !process.env.ANTHROPIC_API_KEY) {
-    process.env.ANTHROPIC_API_KEY = authToken;
-  }
-
-  const store = new RedisSessionBackend<FileEntry>(redisUrl);
-  const backend = new BufferedRedisBackend(store);
-
-  const sessionManager = sessionId
-    ? await SessionManager.openFromBackend(sessionId, backend, cwd)
-    : SessionManager.create(cwd, undefined, undefined, backend);
-
-  const agentDir = getAgentDir();
-  const settingsManager = SettingsManager.create(cwd, agentDir);
-
-  const resourceLoader = new DefaultResourceLoader({
-    cwd,
-    agentDir,
-    settingsManager,
-    extensionFactories: [flushExtension(backend), k8sSandboxExtension()],
-  });
-  await resourceLoader.reload();
-
-  const baseModel = getModel("anthropic", "claude-opus-4-8");
-  const gatewayBase = config?.anthropicBaseUrl ?? process.env.ANTHROPIC_BASE_URL;
-  const model =
-    gatewayBase || authToken
-      ? {
-          ...baseModel,
-          ...(gatewayBase ? { baseUrl: gatewayBase } : {}),
-          ...(authToken
-            ? {
-                headers: {
-                  ...baseModel.headers,
-                  Authorization: `Bearer ${authToken}`,
-                  "x-api-key": null,
-                } as Record<string, string>,
-              }
-            : {}),
-        }
-      : baseModel;
-
-  const { session } = await createAgentSession({
-    sessionManager,
-    model,
-    resourceLoader,
-    settingsManager,
-  });
-
-  await session.prompt(prompt);
-
-  const lastMessage = session.state.messages.at(-1) as AssistantMessage | undefined;
-  let response = "";
-  let stopReason = "end_turn";
-  let errorMessage: string | undefined;
-
-  if (lastMessage?.role === "assistant") {
-    stopReason = lastMessage.stopReason ?? "end_turn";
-    if (stopReason === "error" || stopReason === "aborted") {
-      errorMessage = lastMessage.errorMessage || `Request ${stopReason}`;
-    } else {
-      for (const content of lastMessage.content) {
-        if (content.type === "text") {
-          response += content.text;
-        }
-      }
-    }
-  }
-
-  await backend.flush();
-
-  return {
-    sessionId: sessionManager.getSessionId(),
-    response,
-    stopReason,
-    ...(errorMessage ? { errorMessage } : {}),
-  };
-}
-```
-
-- [ ] **Step 2: Rewrite `harness/src/cli.ts` as a thin wrapper**
-
-```ts
-// harness/src/cli.ts
-import { runTurn } from "./run-turn.js";
-
-async function main() {
-  const prompt = process.argv[2];
-  if (!prompt) {
-    throw new Error('usage: cli.ts "<prompt>"   (set PI_SESSION_ID to resume)');
-  }
-
-  const result = await runTurn(prompt, process.env.PI_SESSION_ID, {
-    redisUrl: process.env.REDIS_URL,
-    cwd: process.cwd(),
-    anthropicBaseUrl: process.env.ANTHROPIC_BASE_URL,
-    anthropicAuthToken: process.env.ANTHROPIC_AUTH_TOKEN,
-  });
-
-  if (result.errorMessage) {
-    console.error(result.errorMessage);
-  } else {
-    console.log(result.response);
-  }
-  console.log(`SESSION_ID=${result.sessionId}`);
-  process.exit(0);
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-```
-
-- [ ] **Step 3: Verify existing tests still pass**
-
-Run: `pnpm -C harness test`
-
-Expected: All tests pass (the `integration.test.ts` and `buffered-redis-backend.test.ts` do not import from `cli.ts`, so they are unaffected by the refactor).
-
-- [ ] **Step 4: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add harness/src/run-turn.ts harness/src/cli.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Feat: Extract runTurn() from cli.ts for reuse by HTTP server"
-```
-
----
-
-## Task 2: Integration test for `runTurn()`
-
-**Files:**
-- Create: `harness/test/run-turn.test.ts`
-
-**Prerequisites:** Task 1 complete. Redis running on localhost:6379 (the same `sh-redis` container used by existing integration tests).
-
-- [ ] **Step 1: Write the integration test**
-
-```ts
-// harness/test/run-turn.test.ts
-import { describe, it, expect, afterAll } from "vitest";
-import { RedisSessionBackend } from "@sh/session-backend";
-import type { FileEntry } from "@earendil-works/pi-coding-agent";
-import { runTurn } from "../src/run-turn.js";
-
-const REDIS = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-const store = new RedisSessionBackend<FileEntry>(REDIS);
-const createdSessions: string[] = [];
-
-afterAll(async () => {
-  for (const sid of createdSessions) {
-    await store.reset(sid);
-  }
-  await store.close();
-});
-
-describe("runTurn()", () => {
-  it("creates a new session when sessionId is undefined", async () => {
-    const result = await runTurn("Say exactly: PONG", undefined, {
-      redisUrl: REDIS,
-    });
-
-    expect(result.sessionId).toBeTruthy();
-    expect(result.response).toContain("PONG");
-    expect(result.stopReason).toBe("end_turn");
-    createdSessions.push(result.sessionId);
-  });
-
-  it("resumes an existing session from Redis", async () => {
-    // Create a session first
-    const first = await runTurn("Remember the code word: ZEBRA42", undefined, {
-      redisUrl: REDIS,
-    });
-    createdSessions.push(first.sessionId);
-
-    // Resume and ask for recall
-    const second = await runTurn(
-      "What was the code word I told you?",
-      first.sessionId,
-      { redisUrl: REDIS },
-    );
-
-    expect(second.sessionId).toBe(first.sessionId);
-    expect(second.response).toContain("ZEBRA42");
-  });
-
-  it("throws when sessionId does not exist in Redis", async () => {
-    await expect(
-      runTurn("hello", "nonexistent-session-id-12345", { redisUrl: REDIS }),
-    ).rejects.toThrow("no session in backend");
-  });
-});
-```
-
-- [ ] **Step 2: Run the test**
-
-Run: `pnpm -C harness exec vitest run test/run-turn.test.ts`
-
-Expected: All three tests pass. (Requires `ANTHROPIC_API_KEY` set for the LLM calls in tests 1 and 2; test 3 fails fast at the Redis lookup without an LLM call.)
-
-Note: Tests 1 and 2 make real LLM calls. They will be slow (~10–30s each). This is acceptable for an integration test — these are not run in CI without credentials.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add harness/test/run-turn.test.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Test: Add runTurn() integration tests with real Redis"
-```
-
----
-
-## Task 3: Create `@sh/knative-server` package scaffold
-
-**Files:**
-- Create: `packages/knative-server/package.json`
-- Create: `packages/knative-server/tsconfig.json`
-- Create: `packages/knative-server/vitest.config.ts`
-- Create: `packages/knative-server/src/index.ts`
-
-- [ ] **Step 1: Create `packages/knative-server/package.json`**
-
-```json
-{
-  "name": "@sh/knative-server",
-  "type": "module",
-  "version": "0.0.0",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "scripts": {
-    "start": "node --import tsx src/server.ts",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@sh/harness": "workspace:*"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  }
-}
-```
-
-- [ ] **Step 2: Create `packages/knative-server/tsconfig.json`**
-
-```json
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true
-  },
-  "include": ["src", "test"]
-}
-```
-
-- [ ] **Step 3: Create `packages/knative-server/vitest.config.ts`**
-
-```ts
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: { include: ["test/**/*.test.ts"] },
-});
-```
-
-- [ ] **Step 4: Create `packages/knative-server/src/index.ts`**
-
-```ts
-// packages/knative-server/src/index.ts
-export { startServer } from "./server.js";
-```
-
-- [ ] **Step 5: Add `@sh/harness` exports field to `harness/package.json`**
-
-The `@sh/knative-server` package depends on `@sh/harness` for `runTurn`. The harness
-package needs an `exports` field so the workspace link resolves:
-
-Edit `harness/package.json` to add `exports`:
-
-```json
-{
-  "name": "@sh/harness",
-  "type": "module",
-  "version": "0.0.0",
-  "exports": {
-    ".": "./src/index.ts",
-    "./run-turn": "./src/run-turn.ts"
-  },
-  "scripts": {
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@sh/session-backend": "workspace:*",
-    "@sh/k8s-sandbox": "workspace:*",
-    "@earendil-works/pi-ai": "link:../pi-fork/packages/ai",
-    "@earendil-works/pi-coding-agent": "link:../pi-fork/packages/coding-agent"
-  },
-  "devDependencies": {
-    "tsx": "^4.19.0",
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  }
-}
-```
-
-Also create `harness/src/index.ts` if it does not exist:
-
-```ts
-// harness/src/index.ts
-export { runTurn, type TurnConfig, type TurnResult } from "./run-turn.js";
-```
-
-- [ ] **Step 6: Run `pnpm install` to link the new package**
-
-Run: `pnpm -C /Users/paolo/Projects/aiplatform/serverless-harness install`
-
-Expected: Lockfile updates, workspace link for `@sh/knative-server` resolves.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/knative-server/ harness/package.json harness/src/index.ts pnpm-lock.yaml
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Feat: Scaffold @sh/knative-server package"
-```
-
----
-
-## Task 4: Implement the HTTP server
-
-**Files:**
-- Create: `packages/knative-server/src/server.ts`
-
-- [ ] **Step 1: Write the server implementation**
-
-```ts
-// packages/knative-server/src/server.ts
-import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
-import { runTurn, type TurnConfig } from "@sh/harness/run-turn";
-
-const PORT = parseInt(process.env.PORT || "8080", 10);
-const JSON_HEADERS = { "Content-Type": "application/json" };
-
-function buildConfig(): TurnConfig {
-  return {
-    redisUrl: process.env.REDIS_URL,
-    cwd: process.env.HARNESS_CWD || process.cwd(),
-    anthropicBaseUrl: process.env.ANTHROPIC_BASE_URL,
-    anthropicAuthToken: process.env.ANTHROPIC_AUTH_TOKEN,
-  };
-}
-
-function readBody(req: IncomingMessage): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    req.on("data", (chunk: Buffer) => chunks.push(chunk));
-    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
-    req.on("error", reject);
-  });
-}
-
-async function handleTurn(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  let body: string;
-  try {
-    body = await readBody(req);
-  } catch {
-    res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "read_error" }));
-    return;
-  }
-
-  let parsed: { sessionId?: string; prompt?: string };
-  try {
-    parsed = JSON.parse(body);
-  } catch {
-    res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "invalid_json" }));
-    return;
-  }
-
-  const { sessionId, prompt } = parsed;
-  if (!prompt) {
-    res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "prompt_required" }));
-    return;
-  }
-
-  try {
-    const result = await runTurn(prompt, sessionId, buildConfig());
-    res.writeHead(200, JSON_HEADERS).end(JSON.stringify(result));
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const status = message.includes("no session in backend") ? 404 : 500;
-    res.writeHead(status, JSON_HEADERS).end(
-      JSON.stringify({
-        error: status === 404 ? "session_not_found" : message,
-        ...(sessionId ? { sessionId } : {}),
-      }),
-    );
-  }
-}
-
-function handler(req: IncomingMessage, res: ServerResponse): void {
-  if (req.method === "GET" && req.url === "/health") {
-    res.writeHead(200).end("ok");
-    return;
-  }
-
-  if (req.method === "POST" && req.url === "/turn") {
-    handleTurn(req, res).catch((err) => {
-      if (!res.headersSent) {
-        res.writeHead(500, JSON_HEADERS).end(
-          JSON.stringify({ error: String(err) }),
-        );
-      }
-    });
-    return;
-  }
-
-  res.writeHead(404).end();
-}
-
-export function startServer(port = PORT): ReturnType<typeof createServer> {
-  const server = createServer(handler);
-
-  process.on("SIGTERM", () => {
-    server.close(() => process.exit(0));
-  });
-
-  server.listen(port, () => {
-    console.log(`serverless-harness listening on :${port}`);
-  });
-
-  return server;
-}
-
-// Auto-start when run directly (not imported for tests)
-const isMainModule =
-  typeof process.argv[1] === "string" &&
-  process.argv[1].includes("knative-server");
-if (isMainModule) {
-  startServer();
-}
-```
-
-- [ ] **Step 2: Update `packages/knative-server/src/index.ts`**
-
-```ts
-// packages/knative-server/src/index.ts
-export { startServer } from "./server.js";
-```
-
-- [ ] **Step 3: Verify it compiles**
-
-Run: `pnpm -C packages/knative-server exec tsc --noEmit`
-
-Expected: No errors.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/knative-server/src/server.ts packages/knative-server/src/index.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Feat: Implement HTTP server for Knative serverless wrapper"
-```
-
----
-
-## Task 5: Unit tests for the HTTP server
-
-**Files:**
-- Create: `packages/knative-server/test/server.test.ts`
-
-- [ ] **Step 1: Write the unit tests (mocked `runTurn`)**
-
-```ts
-// packages/knative-server/test/server.test.ts
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import http from "node:http";
-
-// Mock runTurn before importing server
-vi.mock("@sh/harness/run-turn", () => ({
-  runTurn: vi.fn(),
-}));
-
-import { startServer } from "../src/server.js";
-import { runTurn } from "@sh/harness/run-turn";
-
-const mockedRunTurn = vi.mocked(runTurn);
-let server: ReturnType<typeof startServer>;
-let baseUrl: string;
-
-function request(
-  method: string,
-  path: string,
-  body?: unknown,
-): Promise<{ status: number; body: string }> {
-  return new Promise((resolve, reject) => {
-    const url = new URL(path, baseUrl);
-    const req = http.request(url, { method }, (res) => {
-      const chunks: Buffer[] = [];
-      res.on("data", (c: Buffer) => chunks.push(c));
-      res.on("end", () =>
-        resolve({
-          status: res.statusCode ?? 0,
-          body: Buffer.concat(chunks).toString(),
-        }),
-      );
-    });
-    req.on("error", reject);
-    if (body !== undefined) {
-      req.setHeader("Content-Type", "application/json");
-      req.write(JSON.stringify(body));
-    }
-    req.end();
-  });
-}
-
-beforeAll(async () => {
-  server = startServer(0); // port 0 = random available port
-  await new Promise<void>((resolve) => server.on("listening", resolve));
-  const addr = server.address();
-  if (addr && typeof addr === "object") {
-    baseUrl = `http://127.0.0.1:${addr.port}`;
-  }
-});
-
-afterAll(async () => {
-  await new Promise<void>((resolve) => server.close(() => resolve()));
-});
-
-describe("GET /health", () => {
-  it("returns 200 ok", async () => {
-    const res = await request("GET", "/health");
-    expect(res.status).toBe(200);
-    expect(res.body).toBe("ok");
-  });
-});
-
-describe("POST /turn", () => {
-  it("returns 200 with session result on success", async () => {
-    mockedRunTurn.mockResolvedValueOnce({
-      sessionId: "test-session-1",
-      response: "Hello!",
-      stopReason: "end_turn",
-    });
-
-    const res = await request("POST", "/turn", { prompt: "Hi" });
-    expect(res.status).toBe(200);
-
-    const json = JSON.parse(res.body);
-    expect(json.sessionId).toBe("test-session-1");
-    expect(json.response).toBe("Hello!");
-    expect(json.stopReason).toBe("end_turn");
-  });
-
-  it("passes sessionId to runTurn when provided", async () => {
-    mockedRunTurn.mockResolvedValueOnce({
-      sessionId: "existing-session",
-      response: "Resumed!",
-      stopReason: "end_turn",
-    });
-
-    const res = await request("POST", "/turn", {
-      sessionId: "existing-session",
-      prompt: "Continue",
-    });
-    expect(res.status).toBe(200);
-    expect(mockedRunTurn).toHaveBeenCalledWith(
-      "Continue",
-      "existing-session",
-      expect.any(Object),
-    );
-  });
-
-  it("returns 400 when prompt is missing", async () => {
-    const res = await request("POST", "/turn", { sessionId: "abc" });
-    expect(res.status).toBe(400);
-    expect(JSON.parse(res.body).error).toBe("prompt_required");
-  });
-
-  it("returns 400 on invalid JSON", async () => {
-    const res = await new Promise<{ status: number; body: string }>(
-      (resolve, reject) => {
-        const url = new URL("/turn", baseUrl);
-        const req = http.request(url, { method: "POST" }, (r) => {
-          const chunks: Buffer[] = [];
-          r.on("data", (c: Buffer) => chunks.push(c));
-          r.on("end", () =>
-            resolve({
-              status: r.statusCode ?? 0,
-              body: Buffer.concat(chunks).toString(),
-            }),
-          );
-        });
-        req.on("error", reject);
-        req.write("not valid json{{{");
-        req.end();
-      },
-    );
-    expect(res.status).toBe(400);
-    expect(JSON.parse(res.body).error).toBe("invalid_json");
-  });
-
-  it("returns 404 when session not found", async () => {
-    mockedRunTurn.mockRejectedValueOnce(
-      new Error("Cannot resume: no session in backend for id xyz"),
-    );
-
-    const res = await request("POST", "/turn", {
-      sessionId: "xyz",
-      prompt: "hello",
-    });
-    expect(res.status).toBe(404);
-    expect(JSON.parse(res.body).error).toBe("session_not_found");
-  });
-
-  it("returns 500 on unexpected errors", async () => {
-    mockedRunTurn.mockRejectedValueOnce(new Error("LLM timeout"));
-
-    const res = await request("POST", "/turn", { prompt: "hello" });
-    expect(res.status).toBe(500);
-    expect(JSON.parse(res.body).error).toBe("LLM timeout");
-  });
-});
-
-describe("unknown routes", () => {
-  it("returns 404", async () => {
-    const res = await request("GET", "/unknown");
-    expect(res.status).toBe(404);
-  });
-});
-```
-
-- [ ] **Step 2: Run the tests**
-
-Run: `pnpm -C packages/knative-server test`
-
-Expected: All 7 tests pass. No Redis or LLM calls — fully mocked.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add packages/knative-server/test/server.test.ts
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Test: Add unit tests for knative-server HTTP layer"
-```
-
----
-
-## Task 6: Dockerfile
-
-**Files:**
-- Create: `Dockerfile`
-- Create: `.dockerignore`
-
-- [ ] **Step 1: Create `.dockerignore`**
-
-```
-node_modules
-.git
-*.log
-deploy
-docs
-```
-
-- [ ] **Step 2: Create the multi-stage Dockerfile**
-
-```dockerfile
-# Stage 1: install + build pi-fork
-FROM node:20-alpine AS builder
-RUN corepack enable && corepack prepare pnpm@9 --activate
-WORKDIR /app
-
-# Copy manifests first for layer caching
-COPY pnpm-workspace.yaml pnpm-lock.yaml package.json ./
-COPY pi-fork/package.json pi-fork/pnpm-workspace.yaml ./pi-fork/
-COPY pi-fork/packages/ai/package.json ./pi-fork/packages/ai/
-COPY pi-fork/packages/agent/package.json ./pi-fork/packages/agent/
-COPY pi-fork/packages/tui/package.json ./pi-fork/packages/tui/
-COPY pi-fork/packages/coding-agent/package.json ./pi-fork/packages/coding-agent/
-COPY packages/session-backend/package.json ./packages/session-backend/
-COPY packages/k8s-sandbox/package.json ./packages/k8s-sandbox/
-COPY packages/knative-server/package.json ./packages/knative-server/
-COPY harness/package.json ./harness/
-
-RUN pnpm install --frozen-lockfile
-
-# Copy full source
-COPY pi-fork/ ./pi-fork/
-COPY packages/ ./packages/
-COPY harness/ ./harness/
-
-# Build pi-fork (required order per M1 gotcha)
-RUN pnpm -C pi-fork/packages/ai build && \
-    pnpm -C pi-fork/packages/agent build && \
-    pnpm -C pi-fork/packages/tui build && \
-    pnpm -C pi-fork/packages/coding-agent build
-
-# Stage 2: slim runtime
-FROM node:20-alpine
-RUN apk add --no-cache kubectl
-WORKDIR /app
-COPY --from=builder /app ./
-ENV NODE_ENV=production
-EXPOSE 8080
-CMD ["node", "--import", "tsx", "packages/knative-server/src/server.ts"]
-```
-
-- [ ] **Step 3: Verify the image builds**
-
-Run: `docker build -t serverless-harness:local /Users/paolo/Projects/aiplatform/serverless-harness`
-
-Expected: Build completes without errors. (Note: this requires the pi-fork submodule to be checked out.)
-
-- [ ] **Step 4: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add Dockerfile .dockerignore
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Feat: Add multi-stage Dockerfile for Knative deployment"
-```
-
----
-
-## Task 7: Knative manifests
-
-**Files:**
-- Create: `deploy/knative/service.yaml`
-- Create: `deploy/knative/redis.yaml`
-- Create: `deploy/knative/sandbox.yaml`
-
-- [ ] **Step 1: Create `deploy/knative/` directory structure**
-
-Run: `mkdir -p /Users/paolo/Projects/aiplatform/serverless-harness/deploy/knative`
-
-- [ ] **Step 2: Create `deploy/knative/redis.yaml`**
-
-```yaml
-# deploy/knative/redis.yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: redis
-  namespace: default
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: redis
-  template:
-    metadata:
-      labels:
-        app: redis
-    spec:
-      containers:
-        - name: redis
-          image: redis:7-alpine
-          ports:
-            - containerPort: 6379
-          resources:
-            requests:
-              memory: "64Mi"
-              cpu: "50m"
-            limits:
-              memory: "128Mi"
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: redis
-  namespace: default
-spec:
-  selector:
-    app: redis
-  ports:
-    - port: 6379
-      targetPort: 6379
-```
-
-- [ ] **Step 3: Create `deploy/knative/sandbox.yaml`**
-
-```yaml
-# deploy/knative/sandbox.yaml
-apiVersion: v1
-kind: Pod
-metadata:
-  name: sandbox-0
-  namespace: default
-  labels:
-    app: sandbox
-spec:
-  containers:
-    - name: sandbox
-      image: alpine:3.20
-      command: ["sleep", "infinity"]
-      resources:
-        requests:
-          memory: "64Mi"
-          cpu: "50m"
-        limits:
-          memory: "256Mi"
-```
-
-Note: This is a minimal sandbox for the smoke test. The real sandbox image (with ripgrep) from `packages/k8s-sandbox/deploy/sandbox.yaml` can be used instead for full tool testing.
-
-- [ ] **Step 4: Create `deploy/knative/service.yaml`**
-
-```yaml
-# deploy/knative/service.yaml
-apiVersion: serving.knative.dev/v1
-kind: Service
-metadata:
-  name: serverless-harness
-  namespace: default
-spec:
-  template:
-    metadata:
-      annotations:
-        autoscaling.knative.dev/min-scale: "0"
-        autoscaling.knative.dev/max-scale: "5"
-        autoscaling.knative.dev/scale-to-zero-pod-retention-period: "30s"
-    spec:
-      containerConcurrency: 1
-      timeoutSeconds: 300
-      serviceAccountName: serverless-harness
-      containers:
-        - image: serverless-harness:local
-          ports:
-            - containerPort: 8080
-          env:
-            - name: REDIS_URL
-              value: "redis://redis.default.svc:6379"
-            - name: KAGENTI_SANDBOX_POD
-              value: "sandbox-0"
-            - name: ANTHROPIC_API_KEY
-              valueFrom:
-                secretKeyRef:
-                  name: llm-credentials
-                  key: api-key
-          readinessProbe:
-            httpGet:
-              path: /health
-              port: 8080
-            initialDelaySeconds: 2
-            periodSeconds: 5
-          resources:
-            requests:
-              memory: "256Mi"
-              cpu: "100m"
-            limits:
-              memory: "512Mi"
-              cpu: "500m"
----
-# ServiceAccount + RBAC for kubectl exec into sandbox pod
-apiVersion: v1
-kind: ServiceAccount
-metadata:
-  name: serverless-harness
-  namespace: default
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: Role
-metadata:
-  name: serverless-harness-sandbox
-  namespace: default
-rules:
-  - apiGroups: [""]
-    resources: ["pods"]
-    verbs: ["get", "list"]
-  - apiGroups: [""]
-    resources: ["pods/exec"]
-    verbs: ["create"]
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: RoleBinding
-metadata:
-  name: serverless-harness-sandbox
-  namespace: default
-subjects:
-  - kind: ServiceAccount
-    name: serverless-harness
-    namespace: default
-roleRef:
-  kind: Role
-  name: serverless-harness-sandbox
-  apiGroup: rbac.authorization.k8s.io
-```
-
-- [ ] **Step 5: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add deploy/knative/
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Feat: Add Knative Service + Redis + sandbox manifests"
-```
-
----
-
-## Task 8: Kind + Knative setup script
-
-**Files:**
-- Create: `deploy/knative/setup-kind.sh`
-
-- [ ] **Step 1: Write the setup script**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/setup-kind.sh
-# One-shot setup: installs Knative Serving on Kind, deploys Redis + sandbox + harness.
-#
-# Prerequisites:
-#   - kind cluster running (e.g., `kind create cluster --name sh-knative`)
-#   - kubectl configured to the kind cluster
-#   - docker available (for image build + kind load)
-#   - ANTHROPIC_API_KEY env var set
-#
-# Usage:
-#   ./deploy/knative/setup-kind.sh [--skip-build] [--cluster-name <name>]
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-CLUSTER_NAME="${CLUSTER_NAME:-sh-knative}"
-SKIP_BUILD="${SKIP_BUILD:-false}"
-KNATIVE_VERSION="v1.14.1"
-
-# Parse args
-for arg in "$@"; do
-  case $arg in
-    --skip-build) SKIP_BUILD=true ;;
-    --cluster-name) shift; CLUSTER_NAME="$1" ;;
-    --cluster-name=*) CLUSTER_NAME="${arg#*=}" ;;
-  esac
-  shift 2>/dev/null || true
-done
-
-echo "=== M4 Knative Setup (cluster: $CLUSTER_NAME) ==="
-
-# 1. Create kind cluster if it doesn't exist
-if ! kind get clusters 2>/dev/null | grep -q "^${CLUSTER_NAME}$"; then
-  echo "--- Creating kind cluster: $CLUSTER_NAME ---"
-  kind create cluster --name "$CLUSTER_NAME"
-fi
-kubectl config use-context "kind-${CLUSTER_NAME}"
-
-# 2. Install Knative Serving
-echo "--- Installing Knative Serving $KNATIVE_VERSION ---"
-kubectl apply -f "https://github.com/knative/serving/releases/download/knative-${KNATIVE_VERSION}/serving-crds.yaml"
-kubectl apply -f "https://github.com/knative/serving/releases/download/knative-${KNATIVE_VERSION}/serving-core.yaml"
-
-# 3. Install Kourier (networking layer)
-echo "--- Installing Kourier ---"
-kubectl apply -f "https://github.com/knative/net-kourier/releases/download/knative-${KNATIVE_VERSION}/kourier.yaml"
-
-# Configure Knative to use Kourier
-kubectl patch configmap/config-network \
-  --namespace knative-serving \
-  --type merge \
-  --patch '{"data":{"ingress-class":"kourier.ingress.networking.knative.dev"}}'
-
-# Wait for Knative components
-echo "--- Waiting for Knative Serving to be ready ---"
-kubectl wait --for=condition=Available deployment --all -n knative-serving --timeout=120s
-
-# 4. Deploy Redis
-echo "--- Deploying Redis ---"
-kubectl apply -f "$SCRIPT_DIR/redis.yaml"
-kubectl wait --for=condition=Available deployment/redis -n default --timeout=60s
-
-# 5. Deploy sandbox pod
-echo "--- Deploying sandbox pod ---"
-kubectl apply -f "$SCRIPT_DIR/sandbox.yaml"
-kubectl wait --for=condition=Ready pod/sandbox-0 -n default --timeout=60s
-
-# 6. Build and load harness image
-if [ "$SKIP_BUILD" != "true" ]; then
-  echo "--- Building serverless-harness image ---"
-  docker build -t serverless-harness:local "$REPO_ROOT"
-  echo "--- Loading image into kind ---"
-  kind load docker-image serverless-harness:local --name "$CLUSTER_NAME"
-fi
-
-# 7. Create LLM credentials secret
-if [ -z "${ANTHROPIC_API_KEY:-}" ]; then
-  echo "ERROR: ANTHROPIC_API_KEY must be set"
-  exit 1
-fi
-kubectl create secret generic llm-credentials \
-  --from-literal=api-key="$ANTHROPIC_API_KEY" \
-  --dry-run=client -o yaml | kubectl apply -f -
-
-# 8. Deploy Knative Service
-echo "--- Deploying serverless-harness Knative Service ---"
-kubectl apply -f "$SCRIPT_DIR/service.yaml"
-
-# 9. Wait for service to become ready
-echo "--- Waiting for Knative Service to be ready ---"
-kubectl wait ksvc/serverless-harness --for=condition=Ready --timeout=120s
-
-# 10. Print access info
-KOURIER_IP=$(kubectl get svc kourier -n kourier-system -o jsonpath='{.spec.clusterIP}' 2>/dev/null || echo "pending")
-echo ""
-echo "=== Setup complete ==="
-echo ""
-echo "Knative Service URL (in-cluster):"
-echo "  http://serverless-harness.default.svc.cluster.local"
-echo ""
-echo "Kourier ClusterIP: $KOURIER_IP"
-echo ""
-echo "To access from host, run in a separate terminal:"
-echo "  kubectl port-forward -n kourier-system svc/kourier 8080:80"
-echo ""
-echo "Then send requests with the Host header:"
-echo "  curl -H 'Host: serverless-harness.default.example.com' \\"
-echo "       -H 'Content-Type: application/json' \\"
-echo "       -d '{\"prompt\": \"Hello\"}' \\"
-echo "       http://localhost:8080/turn"
-echo ""
-```
-
-- [ ] **Step 2: Make the script executable**
-
-Run: `chmod +x /Users/paolo/Projects/aiplatform/serverless-harness/deploy/knative/setup-kind.sh`
-
-- [ ] **Step 3: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add deploy/knative/setup-kind.sh
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Feat: Add Kind + Knative setup script"
-```
-
----
-
-## Task 9: Live smoke test script
-
-**Files:**
-- Create: `deploy/knative/smoke.sh`
-
-- [ ] **Step 1: Write the smoke test**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/smoke.sh
-# Live smoke: proves scale 0→1→0 and session recall across cold starts.
-#
-# Prerequisites: setup-kind.sh completed, port-forward running:
-#   kubectl port-forward -n kourier-system svc/kourier 8080:80
-#
-# Usage:
-#   ./deploy/knative/smoke.sh [--port 8080]
-
-set -euo pipefail
-
-PORT="${PORT:-8080}"
-HOST_HEADER="Host: serverless-harness.default.example.com"
-BASE="http://localhost:${PORT}"
-PASS=0
-FAIL=0
-
-for arg in "$@"; do
-  case $arg in
-    --port) shift; PORT="$1" ;;
-    --port=*) PORT="${arg#*=}" ;;
-  esac
-  shift 2>/dev/null || true
-done
-
-claim() {
-  echo ""
-  echo "--- Claim $1: $2 ---"
-}
-
-pass() {
-  echo "  PASS"
-  PASS=$((PASS + 1))
-}
-
-fail() {
-  echo "  FAIL: $1"
-  FAIL=$((FAIL + 1))
-}
-
-# Helper: wait for scale-to-zero
-wait_for_zero_pods() {
-  echo "  Waiting for scale-to-zero (up to 90s)..."
-  for i in $(seq 1 18); do
-    COUNT=$(kubectl get pods -l serving.knative.dev/service=serverless-harness \
-      --field-selector=status.phase=Running --no-headers 2>/dev/null | wc -l | tr -d ' ')
-    if [ "$COUNT" = "0" ]; then
-      echo "  Scaled to zero after ~$((i * 5))s"
-      return 0
-    fi
-    sleep 5
-  done
-  echo "  WARNING: did not scale to zero within 90s"
-  return 1
-}
-
-# ============================================================
-claim 1 "Health endpoint responds"
-HEALTH=$(curl -s -o /dev/null -w "%{http_code}" -H "$HOST_HEADER" "$BASE/health")
-if [ "$HEALTH" = "200" ]; then pass; else fail "got HTTP $HEALTH"; fi
-
-# ============================================================
-claim 2 "POST /turn creates a new session"
-RESP=$(curl -s -H "$HOST_HEADER" -H "Content-Type: application/json" \
-  -d '{"prompt":"Remember the number 7777. Reply only with OK."}' \
-  "$BASE/turn")
-
-SESSION_ID=$(echo "$RESP" | jq -r '.sessionId // empty')
-RESPONSE=$(echo "$RESP" | jq -r '.response // empty')
-
-if [ -n "$SESSION_ID" ] && echo "$RESPONSE" | grep -qi "ok"; then
-  pass
-  echo "  sessionId=$SESSION_ID"
-else
-  fail "sessionId=$SESSION_ID response=$RESPONSE"
-fi
-
-# ============================================================
-claim 3 "Pod scales to zero after idle"
-wait_for_zero_pods && pass || fail "pods did not scale to zero"
-
-# ============================================================
-claim 4 "Cold-start resume recalls session state from Redis"
-RESP2=$(curl -s -H "$HOST_HEADER" -H "Content-Type: application/json" \
-  -d "{\"sessionId\":\"$SESSION_ID\",\"prompt\":\"What number did I ask you to remember? Reply with just the number.\"}" \
-  "$BASE/turn")
-
-RESPONSE2=$(echo "$RESP2" | jq -r '.response // empty')
-SID2=$(echo "$RESP2" | jq -r '.sessionId // empty')
-
-if [ "$SID2" = "$SESSION_ID" ] && echo "$RESPONSE2" | grep -q "7777"; then
-  pass
-else
-  fail "sessionId=$SID2 (expected $SESSION_ID) response=$RESPONSE2"
-fi
-
-# ============================================================
-claim 5 "Pod scaled up from zero for claim 4"
-COUNT=$(kubectl get pods -l serving.knative.dev/service=serverless-harness \
-  --field-selector=status.phase=Running --no-headers 2>/dev/null | wc -l | tr -d ' ')
-if [ "$COUNT" -ge "1" ]; then
-  pass
-else
-  fail "expected >=1 running pod, got $COUNT"
-fi
-
-# ============================================================
-claim 6 "404 on unknown session"
-RESP3=$(curl -s -w "\n%{http_code}" -H "$HOST_HEADER" -H "Content-Type: application/json" \
-  -d '{"sessionId":"does-not-exist-xyz","prompt":"hello"}' \
-  "$BASE/turn")
-HTTP_CODE=$(echo "$RESP3" | tail -1)
-if [ "$HTTP_CODE" = "404" ]; then pass; else fail "got HTTP $HTTP_CODE"; fi
-
-# ============================================================
-echo ""
-echo "=== Results: $PASS passed, $FAIL failed ==="
-if [ "$FAIL" -gt 0 ]; then exit 1; fi
-```
-
-- [ ] **Step 2: Make the script executable**
-
-Run: `chmod +x /Users/paolo/Projects/aiplatform/serverless-harness/deploy/knative/smoke.sh`
-
-- [ ] **Step 3: Commit**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add deploy/knative/smoke.sh
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Test: Add live smoke script for Knative scale-to-zero verification"
-```
-
----
-
-## Task 10: Run setup + smoke on Kind
-
-**Files:** None (execution-only task)
-
-**Prerequisites:** Tasks 1–9 complete and committed. Docker running. `ANTHROPIC_API_KEY` set.
-
-- [ ] **Step 1: Run the setup script**
-
-Run: `cd /Users/paolo/Projects/aiplatform/serverless-harness && ./deploy/knative/setup-kind.sh`
-
-Expected: Completes with "Setup complete" and prints access instructions. All components (Knative, Redis, sandbox, harness service) are Ready.
-
-- [ ] **Step 2: Start port-forward in background**
-
-Run: `kubectl port-forward -n kourier-system svc/kourier 8080:80 &`
-
-Expected: Port-forward starts, no errors.
-
-- [ ] **Step 3: Run the smoke test**
-
-Run: `./deploy/knative/smoke.sh`
-
-Expected: All 6 claims pass. Output shows the full 0→1→0→1 lifecycle.
-
-- [ ] **Step 4: Record results**
-
-Create `deploy/knative/SMOKE.md` documenting:
-- Date, cluster name, Knative version
-- Cold-start latency (time from curl send to first response byte for claim 4)
-- All claims PASS/FAIL
-- Any issues encountered
-
-- [ ] **Step 5: Commit the smoke record**
-
-```bash
-git -C /Users/paolo/Projects/aiplatform/serverless-harness add deploy/knative/SMOKE.md
-git -C /Users/paolo/Projects/aiplatform/serverless-harness commit -s -m "Docs: Record M4 Knative smoke test results"
-```
-
----
-
-## Verification checklist (post-completion)
-
-- [ ] All existing tests pass: `pnpm -C harness test` and `pnpm -C packages/k8s-sandbox test`
-- [ ] New unit tests pass: `pnpm -C packages/knative-server test`
-- [ ] Integration test passes: `pnpm -C harness exec vitest run test/run-turn.test.ts`
-- [ ] TypeScript compiles: `pnpm -C packages/knative-server exec tsc --noEmit`
-- [ ] Live smoke passes all 6 claims
-- [ ] Pod scales 0→1→0 (observed in smoke claim 3 + 5)
-- [ ] `cli.ts` still works headless: `pnpm -C harness exec tsx src/cli.ts "hello"` prints a response
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-23-m5-compaction-checkpoint.md b/docs/superpowers/plans/2026-06-23-m5-compaction-checkpoint.md
deleted file mode 100644
index d545ca4..0000000
--- a/docs/superpowers/plans/2026-06-23-m5-compaction-checkpoint.md
+++ /dev/null
@@ -1,824 +0,0 @@
-# M5 Compaction-Checkpoint Fast Path + Budget Voter Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Make cold-start session reconstruction O(tail) by riding Pi's native compaction as the checkpoint, and cap runaway token spend with a per-turn budget voter.
-
-**Architecture:** A checkpoint *marker* (a tiny Pi `custom` entry) is appended on each `session_compact`, recording the log position of the compaction's `firstKeptEntryId`. A new additive `SessionManager.openFromCheckpoint()` reads only that tail slice and reuses Pi's `buildSessionContext()`, so cold context == warm context by construction. A `RedisSessionBackend` stream-id scheme (`<position>-0`) makes `read(fromPosition)` an O(tail) `XRANGE` seek. A separate budget voter extension meters per-turn token spend via `ctx.sessionManager.getBranch()` and blocks tool calls (appending an `abort` entry) once a cap is breached.
-
-**Tech Stack:** TypeScript (ESM), pnpm workspaces, vitest, Redis (Streams), the pi-fork submodule (`@earendil-works/pi-coding-agent`), `@sh/session-backend`, `@sh/harness`.
-
-**Spec:** `docs/specs/2026-06-23-m5-compaction-checkpoint-design.md` (approved, commit 35e171a). Read it before starting.
-
-## Global Constraints
-
-These apply to **every** task. Each task's requirements implicitly include this section.
-
-- **Branching:** Work on a feature branch off `main`, created in BOTH the parent repo and the `pi-fork` submodule (this milestone edits the submodule). Do NOT commit on `main`.
-- **No LLM key required:** The build and all M5 tests run with unit tests + real-Redis integration only. Never write a new test that calls `runTurn()` with a live prompt or otherwise needs `ANTHROPIC_API_KEY`. The pre-existing `harness/test/run-turn.test.ts` IS LLM-gated and will fail/skip without a key — that is expected and out of M5's regression scope.
-- **Redis:** Real Redis is running at `redis://127.0.0.1:6379`. Integration tests use `process.env.REDIS_URL ?? "redis://127.0.0.1:6379"` and clean up their session ids in `afterAll`.
-- **TDD:** Every task writes the failing test first, runs it to confirm it fails, implements the minimum, runs to green, then commits.
-- **Context budget:** Redirect any command that prints more than ~5 lines to `$LOG_DIR` and report only the exit code / a one-line grep. Set once per session:
-  ```bash
-  export LOG_DIR=/tmp/kagenti/tdd/serverless-harness && mkdir -p $LOG_DIR
-  ```
-  Analyze large logs (pi-fork build/test output) via a subagent, never by reading the whole file inline.
-- **Commits:** Conventional-commit subjects (`feat:`, `fix:`, …). DCO sign-off is mandatory: `git commit -s`. Append the trailer `Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>`. NEVER use `Co-Authored-By` or `Generated by`. The pi-fork submodule has DCO enforced repo-wide too — sign-off there as well.
-- **Stream-id scheme is scoped to fresh sessions.** Pre-M5 dev sessions written with auto stream id `"*"` are throwaway; do not add back-compat shims for them (document the cutover in the backend file).
-- **Running a single test file (no LLM):**
-  - session-backend: `pnpm -C packages/session-backend exec vitest run test/redis-backend.test.ts > $LOG_DIR/<name>.log 2>&1; echo "EXIT:$?"`
-  - harness: `pnpm -C harness exec vitest run test/<file>.ts > $LOG_DIR/<name>.log 2>&1; echo "EXIT:$?"`
-  - pi-fork build: `pnpm -C pi-fork/packages/coding-agent build > $LOG_DIR/pi-build.log 2>&1; echo "EXIT:$?"`
-
----
-
-## File Structure
-
-| File | Responsibility | Task |
-|------|----------------|------|
-| `packages/session-backend/src/backend.ts` | `LogStore` interface — add `positionOfId` | 1 |
-| `packages/session-backend/src/redis-backend.ts` | Stream-id seek (`<position>-0`) + `positionOfId` | 1 |
-| `packages/session-backend/test/redis-backend.test.ts` | Tail-seek + `positionOfId` tests | 1 |
-| `pi-fork/packages/coding-agent/src/core/session-manager.ts` | Additive `static openFromCheckpoint()` + `markerResumePosition` helper | 2 |
-| `harness/test/checkpoint.test.ts` | NEW — loader behavior (2), marker write (4), reconstruction parity gate (5) | 2,4,5 |
-| `harness/src/budget-voter.ts` | NEW — pure `decideBudget`, `sessionSpendTotal`, `budgetVoterExtension` | 3 |
-| `harness/test/budget-voter.test.ts` | NEW — voter unit/behavior tests (fakes, no infra) | 3 |
-| `harness/src/checkpoint-extension.ts` | NEW — `session_compact` → resume-pointer marker | 4 |
-| `harness/src/run-turn.ts` | Use `openFromCheckpoint`; register checkpoint + (conditional) budget extensions | 5 |
-
----
-
-## Task 1: Efficient tail read + `positionOfId` in `RedisSessionBackend`
-
-**Files:**
-- Modify: `packages/session-backend/src/backend.ts` (add `positionOfId` to the `LogStore` interface)
-- Modify: `packages/session-backend/src/redis-backend.ts` (stream id `<position>-0`; O(tail) `read`; `positionOfId`)
-- Test: `packages/session-backend/test/redis-backend.test.ts` (extend)
-
-**Interfaces:**
-- Consumes: existing `RedisSessionBackend`, `StoredEntry<E>`, `LogStore<E>`.
-- Produces:
-  - `LogStore<E>.positionOfId(session_id: string, id: string): Promise<number | null>`
-  - `RedisSessionBackend.read(sid, fromPosition?)` now seeks via stream id (O(tail)); behavior unchanged for callers.
-  - `RedisSessionBackend.positionOfId(sid, id)` — returns the `position` of the stored entry whose decoded `entry.id === id`, else `null`.
-
-- [ ] **Step 1: Write the failing tests**
-
-Append these to `packages/session-backend/test/redis-backend.test.ts` (note the existing test type param already includes optional fields; extend it to carry `id`):
-
-First, widen the backend's element type at the top of the file so entries can carry an `id`:
-```ts
-// CHANGE the existing line:
-//   const b = new RedisSessionBackend<{ type: string; customType?: string; n?: number }>("redis://127.0.0.1:6379");
-// TO:
-const b = new RedisSessionBackend<{ type: string; customType?: string; n?: number; id?: string }>(
-  "redis://127.0.0.1:6379",
-);
-```
-
-Then add inside the `describe(...)` block:
-```ts
-  it("read(fromPosition) uses a stream-id seek and returns exactly the tail", async () => {
-    await b.append(SID, { type: "message", n: 1 }, "message"); // pos 1
-    await b.append(SID, { type: "message", n: 2 }, "message"); // pos 2
-    await b.append(SID, { type: "message", n: 3 }, "message"); // pos 3
-    const tail = await b.read(SID, 2);
-    expect(tail.map((r) => r.position)).toEqual([2, 3]);
-    expect(tail.map((r) => r.entry.n)).toEqual([2, 3]);
-  });
-
-  it("read(fromPosition) past the end returns empty", async () => {
-    await b.append(SID, { type: "message", n: 1 }, "message"); // pos 1
-    const tail = await b.read(SID, 99);
-    expect(tail).toEqual([]);
-  });
-
-  it("positionOfId returns the position of the entry with the matching id, or null", async () => {
-    await b.append(SID, { type: "message", id: "a" }, "message"); // pos 1
-    await b.append(SID, { type: "message", id: "b" }, "message"); // pos 2
-    await b.append(SID, { type: "compaction", id: "c" }, "compaction"); // pos 3
-    expect(await b.positionOfId(SID, "b")).toBe(2);
-    expect(await b.positionOfId(SID, "c")).toBe(3);
-    expect(await b.positionOfId(SID, "missing")).toBeNull();
-  });
-```
-
-- [ ] **Step 2: Run tests to verify they fail**
-
-```bash
-pnpm -C packages/session-backend exec vitest run test/redis-backend.test.ts > $LOG_DIR/t1-red.log 2>&1; echo "EXIT:$?"
-```
-Expected: FAIL — `positionOfId` is not a function (and the seek test may still pass via the old filter, but `positionOfId` failures make the run red).
-
-- [ ] **Step 3: Add `positionOfId` to the `LogStore` interface**
-
-In `packages/session-backend/src/backend.ts`, add to the `LogStore<E>` interface (next to `nextPosition`):
-```ts
-  /** Position (1-based) of the stored entry whose decoded payload `.id` equals `id`, or null. O(N). */
-  positionOfId(session_id: string, id: string): Promise<number | null>;
-```
-
-- [ ] **Step 4: Implement stream-id seek + `positionOfId` in `RedisSessionBackend`**
-
-In `packages/session-backend/src/redis-backend.ts`:
-
-Change `append` to use a deterministic stream id (positions are already monotonic via `INCR`):
-```ts
-    await this.client.xAdd(streamKey(sid), `${stored.position}-0`, {
-      position: String(stored.position),
-      timestamp: String(stored.timestamp),
-      piType: stored.piType,
-      entry: JSON.stringify(stored.entry),
-      content_sha256: stored.content_sha256,
-    });
-```
-
-Change `read` to seek by stream id and drop the O(N) post-filter:
-```ts
-  async read(sid: string, fromPosition = 1): Promise<StoredEntry<E>[]> {
-    await this.ready;
-    const start = fromPosition <= 1 ? "-" : `${fromPosition}-0`;
-    const rows = await this.client.xRange(streamKey(sid), start, "+");
-    return rows.map((r): StoredEntry<E> => ({
-      position: Number(r.message.position),
-      timestamp: Number(r.message.timestamp),
-      session_id: sid,
-      piType: r.message.piType,
-      entry: JSON.parse(r.message.entry) as E,
-      content_sha256: r.message.content_sha256,
-    }));
-  }
-```
-
-Add `positionOfId` (place it after `latestWhere`):
-```ts
-  async positionOfId(sid: string, id: string): Promise<number | null> {
-    const rows = await this.read(sid);
-    for (const r of rows) {
-      if ((r.entry as { id?: unknown } | null)?.id === id) return r.position;
-    }
-    return null;
-  }
-```
-
-Also update the class doc comment to note the cutover: stream ids are now `"<position>-0"` (was `"*"`); sessions written by pre-M5 code are not back-compatible and are treated as throwaway.
-
-- [ ] **Step 5: Run tests to verify they pass**
-
-```bash
-pnpm -C packages/session-backend exec vitest run test/redis-backend.test.ts > $LOG_DIR/t1-green.log 2>&1; echo "EXIT:$?"
-```
-Expected: PASS (all existing + 3 new tests). If red, grep the log for `AssertionError`/`Error`.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add packages/session-backend/src/backend.ts packages/session-backend/src/redis-backend.ts packages/session-backend/test/redis-backend.test.ts
-git commit -s -m "feat(session-backend): O(tail) stream-id read seek + positionOfId
-
-Assigns each entry the Redis stream id \"<position>-0\" so read(fromPosition)
-is an XRANGE seek instead of a full-stream scan, and adds positionOfId for the
-M5 checkpoint marker.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 2: Additive `SessionManager.openFromCheckpoint()` (pi-fork)
-
-**Files:**
-- Modify: `pi-fork/packages/coding-agent/src/core/session-manager.ts` (add module-level `markerResumePosition` + `static openFromCheckpoint`)
-- Test: `harness/test/checkpoint.test.ts` (NEW — loader behavior; real Redis; no LLM)
-
-**Interfaces:**
-- Consumes: `SessionStorageBackend.latestCheckpoint`/`read` (existing), private `loadFromEntries`/constructor, `CustomEntry`, `FileEntry`, `SessionManager.openFromBackend` (existing).
-- Produces:
-  - `static SessionManager.openFromCheckpoint(sessionId: string, backend: SessionStorageBackend, cwd?: string): Promise<SessionManager>` — reads only the marker's `resumeFromPosition`-forward slice; falls back to `openFromBackend` when there is no usable marker or the slice is empty.
-
-> **Note (design gate, verified):** `buildSessionContext()` derives `model` from the last assistant message (always inside the kept tail) and `thinkingLevel` from `thinking_level_change` entries, defaulting to `"off"`. Tail-load parity holds for `model` (unaffected — re-set by every assistant message). For `thinkingLevel`: Pi appends a `thinking_level_change` at session start (before any messages), so that entry is pre-`firstKeptEntryId` and excluded from the tail; a tail-load therefore resets `thinkingLevel` to `"off"` on the first post-compaction resume (self-heals next turn). Safe while thinking level is settings-governed and not changed per session. This task only proves the slice is read correctly and the never-compacted fallback; the full `buildSessionContext` parity gate is Task 5.
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `harness/test/checkpoint.test.ts`:
-```ts
-import { describe, it, expect, afterAll } from "vitest";
-import { SessionManager, type FileEntry } from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { BufferedRedisBackend } from "../src/buffered-redis-backend";
-
-const REDIS = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-const store = new RedisSessionBackend<FileEntry>(REDIS);
-const sids: string[] = [];
-
-afterAll(async () => {
-  for (const sid of sids) await store.reset(sid);
-  await store.close();
-});
-
-describe("SessionManager.openFromCheckpoint", () => {
-  it("loads only the tail slice from a checkpoint marker", async () => {
-    const backend = new BufferedRedisBackend(store);
-    const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-    const sid = sm.getSessionId();
-    sids.push(sid);
-
-    sm.appendMessage({ role: "user", content: "one" } as never);    // ~pos 2
-    const keepId = sm.appendMessage({ role: "assistant", content: "two" } as never); // ~pos 3
-    sm.appendMessage({ role: "user", content: "three" } as never);  // ~pos 4
-    await backend.flush();
-
-    const resumeFrom = await store.positionOfId(sid, keepId);
-    expect(resumeFrom).not.toBeNull();
-    sm.appendCustomEntry("checkpoint", { resumeFromPosition: resumeFrom }); // marker
-    await backend.flush();
-
-    const resumed = await SessionManager.openFromCheckpoint(sid, backend, process.cwd());
-    const tail = await store.read(sid, resumeFrom!);
-    // Reconstructed entry ids equal exactly the stored tail slice (firstKept..marker).
-    expect(resumed.getEntries().map((e) => (e as { id?: string }).id)).toEqual(
-      tail.map((r) => (r.entry as { id?: string }).id),
-    );
-    // The slice is strictly smaller than the full log.
-    const full = await store.read(sid);
-    expect(tail.length).toBeLessThan(full.length);
-  });
-
-  it("falls back to full reconstruction when there is no marker", async () => {
-    const backend = new BufferedRedisBackend(store);
-    const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-    const sid = sm.getSessionId();
-    sids.push(sid);
-    sm.appendMessage({ role: "user", content: "hi" } as never);
-    sm.appendMessage({ role: "assistant", content: "hello" } as never);
-    await backend.flush();
-
-    const viaCheckpoint = await SessionManager.openFromCheckpoint(sid, backend, process.cwd());
-    const viaBackend = await SessionManager.openFromBackend(sid, backend, process.cwd());
-    expect(viaCheckpoint.getEntries().map((e) => JSON.stringify(e))).toEqual(
-      viaBackend.getEntries().map((e) => JSON.stringify(e)),
-    );
-  });
-});
-```
-
-- [ ] **Step 2: Run tests to verify they fail**
-
-```bash
-pnpm -C harness exec vitest run test/checkpoint.test.ts > $LOG_DIR/t2-red.log 2>&1; echo "EXIT:$?"
-```
-Expected: FAIL — `SessionManager.openFromCheckpoint is not a function`.
-
-- [ ] **Step 3: Implement `openFromCheckpoint` + helper in pi-fork**
-
-In `pi-fork/packages/coding-agent/src/core/session-manager.ts`, add a module-level helper (near the other top-level helpers, after the `CustomEntry` interface):
-```ts
-/** Extracts a 1-based resume position from a checkpoint marker entry, or null if absent/invalid. */
-export function markerResumePosition(marker: FileEntry | null): number | null {
-  if (!marker || marker.type !== "custom") return null;
-  const data = (marker as CustomEntry).data as { resumeFromPosition?: unknown } | undefined;
-  const pos = data?.resumeFromPosition;
-  return typeof pos === "number" && Number.isFinite(pos) && pos >= 1 ? pos : null;
-}
-```
-
-Add the static loader immediately after `openFromBackend` (around line 1434), inside the `SessionManager` class:
-```ts
-  /**
-   * Fast-start loader: reads only the latest-checkpoint-forward slice of the log and
-   * reconstructs from it (O(tail)). Falls back to full openFromBackend when there is no
-   * usable checkpoint marker. Reuses buildSessionContext, so cold context == warm context.
-   */
-  static async openFromCheckpoint(
-    sessionId: string,
-    backend: SessionStorageBackend,
-    cwd: string = process.cwd(),
-  ): Promise<SessionManager> {
-    const marker = await backend.latestCheckpoint(sessionId);
-    const resumeFrom = markerResumePosition(marker);
-    if (resumeFrom == null) {
-      return SessionManager.openFromBackend(sessionId, backend, cwd);
-    }
-    const entries = await backend.read(sessionId, resumeFrom);
-    if (entries.length === 0) {
-      return SessionManager.openFromBackend(sessionId, backend, cwd);
-    }
-    const sm = new SessionManager(cwd, "", undefined, false, undefined, backend);
-    sm.loadFromEntries(sessionId, entries);
-    return sm;
-  }
-```
-
-If `CustomEntry` / `FileEntry` are not already in scope at the helper's location, they are defined in this same file — no new import needed. Verify `markerResumePosition` is placed after `CustomEntry`'s declaration.
-
-- [ ] **Step 4: Build pi-fork and run the tests**
-
-```bash
-pnpm -C pi-fork/packages/coding-agent build > $LOG_DIR/t2-pibuild.log 2>&1; echo "EXIT:$?"
-pnpm -C harness exec vitest run test/checkpoint.test.ts > $LOG_DIR/t2-green.log 2>&1; echo "EXIT:$?"
-```
-Expected: build EXIT:0; tests PASS. If the build log is large, dispatch a subagent to grep it for `error TS`.
-
-- [ ] **Step 5: Commit (submodule first, then parent pointer)**
-
-```bash
-# Inside the submodule
-git -C pi-fork add packages/coding-agent/src/core/session-manager.ts
-git -C pi-fork commit -s -m "feat(session-manager): add openFromCheckpoint tail loader
-
-Additive static loader that reads only the checkpoint-forward slice and
-reconstructs via the existing loadFromEntries/buildSessionContext path.
-Falls back to openFromBackend when no usable marker exists.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-# Record the new submodule SHA + the new test in the parent repo
-git add pi-fork harness/test/checkpoint.test.ts
-git commit -s -m "feat(harness): cover openFromCheckpoint tail load + fallback
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 3: Budget voter module
-
-**Files:**
-- Create: `harness/src/budget-voter.ts`
-- Test: `harness/test/budget-voter.test.ts` (NEW — no Redis, no LLM, no Pi session; hand-rolled fakes)
-
-**Interfaces:**
-- Consumes: `ExtensionFactory`, `ExtensionContext` (types from `@earendil-works/pi-coding-agent`), `SessionManager` (for `appendCustomEntry`), `ToolCallEventResult` shape (`{ block?: boolean; reason?: string }`).
-- Produces:
-  - `interface BudgetState { spent: number; estimated: number; limit: number }`
-  - `type BudgetDecision = { decision: "commit" } | { decision: "abort"; reason: "budget_exceeded" }`
-  - `function decideBudget(s: BudgetState): BudgetDecision`
-  - `function sessionSpendTotal(ctx: ExtensionContext): number | null` — sum of assistant `usage.{input,output,cacheRead,cacheWrite}` over `ctx.sessionManager.getBranch()`; `null` only when `sessionManager`/`getBranch` is unavailable (0 for a fresh branch).
-  - `function budgetVoterExtension(sm: SessionManager, opts: { limit: number; margin?: number }): ExtensionFactory`
-
-> **Deliberate deviation from spec §4.5 sketch:** the spec's helper returned `null` for a zero total, which would set `baseline = null` at `session_start` on a fresh session and silently disable the voter for the entire turn. `sessionSpendTotal` here returns `0` for a genuinely-empty branch and reserves `null` for "stat unavailable", matching decision D6's intent ("a missing/null reading ⇒ do not block").
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `harness/test/budget-voter.test.ts`:
-```ts
-import { describe, it, expect } from "vitest";
-import {
-  decideBudget,
-  sessionSpendTotal,
-  budgetVoterExtension,
-} from "../src/budget-voter";
-
-// --- minimal fakes (no Pi runtime) -------------------------------------------
-function fakeCtx(assistantUsages: Array<{ input: number; output: number; cacheRead: number; cacheWrite: number }>) {
-  return {
-    sessionManager: {
-      getBranch: () =>
-        assistantUsages.map((usage) => ({
-          type: "message",
-          message: { role: "assistant", usage },
-        })),
-    },
-  } as unknown as Parameters<typeof sessionSpendTotal>[0];
-}
-function emptyCtx() {
-  return { sessionManager: { getBranch: () => [] } } as unknown as Parameters<typeof sessionSpendTotal>[0];
-}
-function brokenCtx() {
-  return {} as unknown as Parameters<typeof sessionSpendTotal>[0];
-}
-// Captures handlers + appendCustomEntry calls.
-function harness() {
-  const handlers: Record<string, Function> = {};
-  const appended: Array<{ customType: string; data: unknown }> = [];
-  const pi = { on: (ev: string, h: Function) => { handlers[ev] = h; } };
-  const sm = { appendCustomEntry: (customType: string, data: unknown) => { appended.push({ customType, data }); return "id"; } };
-  return { handlers, appended, pi, sm };
-}
-
-describe("decideBudget", () => {
-  it("commits below the cap", () => {
-    expect(decideBudget({ spent: 10, estimated: 0, limit: 100 })).toEqual({ decision: "commit" });
-  });
-  it("aborts when spent + estimated exceeds the cap", () => {
-    expect(decideBudget({ spent: 90, estimated: 20, limit: 100 })).toEqual({
-      decision: "abort",
-      reason: "budget_exceeded",
-    });
-  });
-  it("commits exactly at the cap (not strictly greater)", () => {
-    expect(decideBudget({ spent: 100, estimated: 0, limit: 100 })).toEqual({ decision: "commit" });
-  });
-  it("is disabled (always commits) when limit <= 0 or non-finite", () => {
-    expect(decideBudget({ spent: 999, estimated: 0, limit: 0 })).toEqual({ decision: "commit" });
-    expect(decideBudget({ spent: 999, estimated: 0, limit: NaN })).toEqual({ decision: "commit" });
-  });
-});
-
-describe("sessionSpendTotal", () => {
-  it("sums all assistant usage fields", () => {
-    const ctx = fakeCtx([
-      { input: 10, output: 5, cacheRead: 1, cacheWrite: 0 },
-      { input: 20, output: 4, cacheRead: 0, cacheWrite: 1 },
-    ]);
-    expect(sessionSpendTotal(ctx)).toBe(41);
-  });
-  it("returns 0 for an empty branch (valid baseline, not null)", () => {
-    expect(sessionSpendTotal(emptyCtx())).toBe(0);
-  });
-  it("returns null when the branch is unavailable", () => {
-    expect(sessionSpendTotal(brokenCtx())).toBeNull();
-  });
-});
-
-describe("budgetVoterExtension", () => {
-  it("blocks a tool call and appends exactly one abort entry once over cap", () => {
-    const { handlers, appended, pi, sm } = harness();
-    budgetVoterExtension(sm as never, { limit: 50 })(pi as never);
-    // baseline at session_start = 0 (no assistant messages yet)
-    handlers.session_start({}, emptyCtx());
-    // tool_call after 60 tokens of spend -> over the cap of 50
-    const ctx = fakeCtx([{ input: 40, output: 20, cacheRead: 0, cacheWrite: 0 }]);
-    const res = handlers.tool_call({}, ctx);
-    expect(res).toEqual({ block: true, reason: "Session token budget exceeded" });
-    expect(appended).toEqual([
-      { customType: "abort", data: { reason: "budget_exceeded", spent: 60, limit: 50 } },
-    ]);
-  });
-  it("does not block below the cap and writes no abort entry", () => {
-    const { handlers, appended, pi, sm } = harness();
-    budgetVoterExtension(sm as never, { limit: 1000 })(pi as never);
-    handlers.session_start({}, emptyCtx());
-    const ctx = fakeCtx([{ input: 10, output: 5, cacheRead: 0, cacheWrite: 0 }]);
-    expect(handlers.tool_call({}, ctx)).toEqual({});
-    expect(appended).toEqual([]);
-  });
-  it("does not block when the stat reading is unavailable (defensive)", () => {
-    const { handlers, pi, sm } = harness();
-    budgetVoterExtension(sm as never, { limit: 1 })(pi as never);
-    handlers.session_start({}, emptyCtx()); // baseline = 0
-    expect(handlers.tool_call({}, brokenCtx())).toEqual({}); // total == null -> no block
-  });
-});
-```
-
-- [ ] **Step 2: Run tests to verify they fail**
-
-```bash
-pnpm -C harness exec vitest run test/budget-voter.test.ts > $LOG_DIR/t3-red.log 2>&1; echo "EXIT:$?"
-```
-Expected: FAIL — cannot find module `../src/budget-voter`.
-
-- [ ] **Step 3: Implement the budget voter**
-
-Create `harness/src/budget-voter.ts`:
-```ts
-import type { ExtensionContext, ExtensionFactory, SessionManager } from "@earendil-works/pi-coding-agent";
-
-export interface BudgetState {
-  spent: number;
-  estimated: number;
-  limit: number;
-}
-export type BudgetDecision =
-  | { decision: "commit" }
-  | { decision: "abort"; reason: "budget_exceeded" };
-
-/** Pure policy. Disabled (always commits) when limit is non-finite or <= 0. */
-export function decideBudget(s: BudgetState): BudgetDecision {
-  if (!Number.isFinite(s.limit) || s.limit <= 0) return { decision: "commit" };
-  return s.spent + s.estimated > s.limit
-    ? { decision: "abort", reason: "budget_exceeded" }
-    : { decision: "commit" };
-}
-
-/**
- * Cumulative token spend = sum of assistant message usage over the current branch
- * (same total as AgentSession.getSessionStats().tokens.total). Mirrors the
- * custom-footer example's read of ctx.sessionManager.getBranch().
- * Returns 0 for an empty branch (a valid baseline); null only when the branch is unavailable.
- */
-export function sessionSpendTotal(ctx: ExtensionContext): number | null {
-  const sm = ctx.sessionManager as { getBranch?: () => unknown[] } | undefined;
-  if (!sm || typeof sm.getBranch !== "function") return null;
-  let total = 0;
-  for (const entry of sm.getBranch() as Array<{
-    type?: string;
-    message?: { role?: string; usage?: { input: number; output: number; cacheRead: number; cacheWrite: number } };
-  }>) {
-    if (entry?.type === "message" && entry.message?.role === "assistant" && entry.message.usage) {
-      const u = entry.message.usage;
-      total += u.input + u.output + u.cacheRead + u.cacheWrite;
-    }
-  }
-  return total;
-}
-
-/**
- * Meters per-turn token spend (delta from the per-process baseline captured at
- * session_start) and blocks tool calls once the cap is breached, appending a single
- * `abort` custom entry. Inert when limit <= 0.
- */
-export function budgetVoterExtension(
-  sm: SessionManager,
-  opts: { limit: number; margin?: number },
-): ExtensionFactory {
-  return (pi) => {
-    let baseline: number | null = null;
-    pi.on("session_start", (_e, ctx) => {
-      baseline = sessionSpendTotal(ctx);
-    });
-    pi.on("tool_call", (_e, ctx) => {
-      const total = sessionSpendTotal(ctx);
-      if (baseline == null || total == null) return {}; // defensive: don't block on unknown
-      const spent = total - baseline;
-      const d = decideBudget({ spent, estimated: opts.margin ?? 0, limit: opts.limit });
-      if (d.decision === "abort") {
-        sm.appendCustomEntry("abort", { reason: d.reason, spent, limit: opts.limit });
-        return { block: true, reason: "Session token budget exceeded" };
-      }
-      return {};
-    });
-  };
-}
-```
-
-If TypeScript complains that `pi.on("tool_call", …)` must return `ToolCallEventResult | void`, the returned `{}`/`{ block, reason }` literals already satisfy `{ block?: boolean; reason?: string }`; no cast needed. If `session_start`'s handler signature rejects a return value, ensure that handler returns nothing (it assigns `baseline` and falls through).
-
-- [ ] **Step 4: Run tests to verify they pass**
-
-```bash
-pnpm -C harness exec vitest run test/budget-voter.test.ts > $LOG_DIR/t3-green.log 2>&1; echo "EXIT:$?"
-```
-Expected: PASS (all describe blocks).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/budget-voter.ts harness/test/budget-voter.test.ts
-git commit -s -m "feat(harness): per-turn budget voter (decideBudget + tool_call block)
-
-Pure decideBudget policy plus an extension that meters cumulative assistant
-token spend via ctx.sessionManager.getBranch(), blocks the tool call and
-appends a single abort entry once the per-turn delta breaches the cap.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 4: Checkpoint-marker extension
-
-**Files:**
-- Create: `harness/src/checkpoint-extension.ts`
-- Test: `harness/test/checkpoint.test.ts` (extend — marker-write test, real Redis)
-
-**Interfaces:**
-- Consumes: `ExtensionFactory`, `SessionManager` (`getSessionId`, `appendCustomEntry`), `LogStore.positionOfId` (Task 1), the `session_compact` event's `compactionEntry.firstKeptEntryId`.
-- Produces:
-  - `function checkpointExtension(store: LogStore<FileEntry>, sm: SessionManager): ExtensionFactory` — on `session_compact`, resolves `positionOfId(sid, firstKeptEntryId)` and, if found, appends a `custom` `"checkpoint"` entry `{ resumeFromPosition }` via `sm.appendCustomEntry`.
-
-- [ ] **Step 1: Write the failing test**
-
-Add to `harness/test/checkpoint.test.ts` a new `describe` block (the file already imports `SessionManager`, `RedisSessionBackend`, `BufferedRedisBackend`, `store`, `sids`):
-```ts
-import { checkpointExtension } from "../src/checkpoint-extension";
-
-describe("checkpointExtension", () => {
-  it("writes a checkpoint marker pointing at the compaction's firstKeptEntryId on session_compact", async () => {
-    const backend = new BufferedRedisBackend(store);
-    const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-    const sid = sm.getSessionId();
-    sids.push(sid);
-
-    sm.appendMessage({ role: "user", content: "q" } as never);
-    const firstKeptId = sm.appendMessage({ role: "assistant", content: "a" } as never);
-    sm.appendCompaction("summary so far", firstKeptId, 1234);
-    await backend.flush();
-
-    // Capture the session_compact handler the extension registers.
-    const handlers: Record<string, Function> = {};
-    const pi = { on: (ev: string, h: Function) => { handlers[ev] = h; } };
-    checkpointExtension(store, sm)(pi as never);
-
-    await handlers.session_compact({ compactionEntry: { firstKeptEntryId: firstKeptId } });
-    await backend.flush();
-
-    const marker = await backend.latestCheckpoint(sid);
-    const expectedPos = await store.positionOfId(sid, firstKeptId);
-    expect((marker as { customType?: string })?.customType).toBe("checkpoint");
-    expect((marker as { data?: { resumeFromPosition?: number } })?.data?.resumeFromPosition).toBe(expectedPos);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-```bash
-pnpm -C harness exec vitest run test/checkpoint.test.ts > $LOG_DIR/t4-red.log 2>&1; echo "EXIT:$?"
-```
-Expected: FAIL — cannot find module `../src/checkpoint-extension`.
-
-- [ ] **Step 3: Implement the extension**
-
-Create `harness/src/checkpoint-extension.ts`:
-```ts
-import type { ExtensionFactory, FileEntry, SessionManager } from "@earendil-works/pi-coding-agent";
-import type { LogStore } from "@sh/session-backend";
-
-/**
- * On each native compaction, append a tiny resume-pointer marker recording the log
- * position of the compaction's firstKeptEntryId. The marker is written through the
- * SessionManager (not the store directly) so it flows through the buffered backend
- * and the existing flush path, keeping positions consistent with Pi's append order.
- */
-export function checkpointExtension(store: LogStore<FileEntry>, sm: SessionManager): ExtensionFactory {
-  return (pi) => {
-    pi.on("session_compact", async (e) => {
-      const firstKeptEntryId = (e as { compactionEntry?: { firstKeptEntryId?: string } })
-        .compactionEntry?.firstKeptEntryId;
-      if (!firstKeptEntryId) return;
-      const pos = await store.positionOfId(sm.getSessionId(), firstKeptEntryId);
-      if (pos != null) {
-        sm.appendCustomEntry("checkpoint", { resumeFromPosition: pos });
-      }
-    });
-  };
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-```bash
-pnpm -C harness exec vitest run test/checkpoint.test.ts > $LOG_DIR/t4-green.log 2>&1; echo "EXIT:$?"
-```
-Expected: PASS (Task 2 loader tests + this marker-write test).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/checkpoint-extension.ts harness/test/checkpoint.test.ts
-git commit -s -m "feat(harness): checkpoint-marker extension on session_compact
-
-Appends a resume-pointer custom entry recording positionOf(firstKeptEntryId)
-so cold start can seek directly to the kept tail.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 5: Wiring + reconstruction parity gate
-
-**Files:**
-- Modify: `harness/src/run-turn.ts` (resume via `openFromCheckpoint`; register `checkpointExtension` + conditional `budgetVoterExtension`)
-- Test: `harness/test/checkpoint.test.ts` (extend — the M5 reconstruction parity gate, real Redis, no LLM)
-
-**Interfaces:**
-- Consumes: `SessionManager.openFromCheckpoint` (Task 2), `checkpointExtension` (Task 4), `budgetVoterExtension` (Task 3), existing `runTurn` wiring.
-- Produces: no new exported symbols; `runTurn` now resumes via the fast path and registers the two new extensions.
-
-> **Parity gate is the M5 done-criterion #1.** It drives a session that compacts once, runs the real `checkpointExtension` to write the marker, then asserts `buildSessionContext()` from `openFromCheckpoint` deep-equals the result from `openFromBackend`. The test uses only user/assistant messages + a compaction (no `thinking_level_change`), so both `model` and `thinkingLevel` are `"off"` / `null` in both loads and the deep-equal holds. Note: if a `thinking_level_change` is appended *before* `firstKeptEntryId` (e.g. at session start), a tail-load will reset `thinkingLevel` to `"off"` while a full load preserves it — this is documented behavior, locked by the separate "thinkingLevel reset" test. `model` is unaffected (re-set by every assistant message, always in the kept tail).
-
-- [ ] **Step 1: Write the failing parity-gate test**
-
-Add to `harness/test/checkpoint.test.ts`:
-```ts
-describe("reconstruction parity (M5 gate)", () => {
-  it("openFromCheckpoint buildSessionContext deep-equals openFromBackend after a compaction", async () => {
-    const backend = new BufferedRedisBackend(store);
-    const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-    const sid = sm.getSessionId();
-    sids.push(sid);
-
-    sm.appendMessage({ role: "user", content: "old turn 1" } as never);
-    sm.appendMessage({ role: "assistant", content: "old answer 1" } as never);
-    const firstKeptId = sm.appendMessage({ role: "user", content: "kept question" } as never);
-    sm.appendMessage({ role: "assistant", content: "kept answer" } as never);
-    sm.appendCompaction("summary of earlier turns", firstKeptId, 4321);
-    await backend.flush();
-
-    // Run the real extension to write the marker.
-    const handlers: Record<string, Function> = {};
-    const pi = { on: (ev: string, h: Function) => { handlers[ev] = h; } };
-    checkpointExtension(store, sm)(pi as never);
-    await handlers.session_compact({ compactionEntry: { firstKeptEntryId: firstKeptId } });
-    await backend.flush();
-
-    const viaCheckpoint = await SessionManager.openFromCheckpoint(sid, backend, process.cwd());
-    const viaBackend = await SessionManager.openFromBackend(sid, backend, process.cwd());
-    expect(viaCheckpoint.buildSessionContext()).toEqual(viaBackend.buildSessionContext());
-
-    // And it really read a smaller slice than the full log.
-    const cpMarker = await backend.latestCheckpoint(sid);
-    const resumeFrom = (cpMarker as { data?: { resumeFromPosition?: number } }).data!.resumeFromPosition!;
-    const tail = await store.read(sid, resumeFrom);
-    const full = await store.read(sid);
-    expect(tail.length).toBeLessThan(full.length);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails (or passes pre-wiring)**
-
-```bash
-pnpm -C harness exec vitest run test/checkpoint.test.ts > $LOG_DIR/t5-red.log 2>&1; echo "EXIT:$?"
-```
-Expected: this gate uses the components directly (not `runTurn`), so it should already PASS if Tasks 2 & 4 are correct. If it FAILS on `buildSessionContext` inequality, grep the log and inspect which field (`messages`/`model`/`thinkingLevel`) diverged before changing `run-turn.ts`. (This step validates the gate itself; Step 3 wires it into `runTurn`.)
-
-- [ ] **Step 3: Wire the fast path + extensions into `run-turn.ts`**
-
-In `harness/src/run-turn.ts`:
-
-Add imports near the existing extension imports:
-```ts
-import { checkpointExtension } from "./checkpoint-extension.js";
-import { budgetVoterExtension } from "./budget-voter.js";
-```
-
-Change the resume line (currently `await SessionManager.openFromBackend(...)`):
-```ts
-  const sessionManager = sessionId
-    ? await SessionManager.openFromCheckpoint(sessionId, backend, cwd)
-    : SessionManager.create(cwd, undefined, undefined, backend);
-```
-
-Build the extension list with the conditional voter, and pass it to the loader. Replace the `extensionFactories: [flushExtension(backend), k8sSandboxExtension()],` line with:
-```ts
-  const budgetLimit = Number(process.env.SH_BUDGET_TOKENS);
-  const budgetMargin = Number(process.env.SH_BUDGET_MARGIN);
-  const extensionFactories = [
-    flushExtension(backend),
-    k8sSandboxExtension(),
-    checkpointExtension(store, sessionManager),
-  ];
-  if (Number.isFinite(budgetLimit) && budgetLimit > 0) {
-    extensionFactories.push(
-      budgetVoterExtension(sessionManager, {
-        limit: budgetLimit,
-        ...(Number.isFinite(budgetMargin) && budgetMargin > 0 ? { margin: budgetMargin } : {}),
-      }),
-    );
-  }
-```
-Then in the `new DefaultResourceLoader({ ... })` call, set `extensionFactories,` (shorthand).
-
-`store` is already in scope (`const store = new RedisSessionBackend<FileEntry>(redisUrl);` at the top of `runTurn`). `checkpointExtension` requires the concrete `store` (for `positionOfId`).
-
-- [ ] **Step 4: Build pi-fork (unchanged) + run the full harness + session-backend suites**
-
-```bash
-pnpm -C harness exec vitest run test/checkpoint.test.ts test/budget-voter.test.ts test/integration.test.ts test/buffered-redis-backend.test.ts > $LOG_DIR/t5-harness.log 2>&1; echo "EXIT:$?"
-pnpm -C packages/session-backend exec vitest run > $LOG_DIR/t5-backend.log 2>&1; echo "EXIT:$?"
-```
-Expected: PASS. (Note: `test/run-turn.test.ts` is intentionally excluded — it needs an LLM key. Run it only in an environment that has `ANTHROPIC_API_KEY`.)
-
-If TypeScript fails to compile `run-turn.ts` (e.g. `extensionFactories` type), confirm the array element type is `ExtensionFactory` — all four factories return that. Grep the log for `error TS`.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/run-turn.ts harness/test/checkpoint.test.ts
-git commit -s -m "feat(harness): wire openFromCheckpoint + checkpoint & budget extensions
-
-Resume via the O(tail) openFromCheckpoint loader, always register the
-checkpoint-marker extension, and register the budget voter when
-SH_BUDGET_TOKENS is set. Adds the reconstruction parity gate.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Final verification (after all tasks)
-
-- [ ] **pi-fork still builds and its own suite passes** (analyze logs via subagent):
-  ```bash
-  pnpm -C pi-fork/packages/coding-agent build > $LOG_DIR/final-pibuild.log 2>&1; echo "EXIT:$?"
-  pnpm -C pi-fork/packages/coding-agent test > $LOG_DIR/final-pitest.log 2>&1; echo "EXIT:$?"
-  ```
-  Dispatch an Explore subagent to grep `final-pitest.log` for `fail|FAIL|✗` and report only the failing test names + counts. Do not read the whole file inline.
-
-- [ ] **All M5 + adjacent harness/backend suites green** (excluding LLM-gated `run-turn.test.ts`):
-  ```bash
-  pnpm -C harness exec vitest run test/checkpoint.test.ts test/budget-voter.test.ts test/integration.test.ts test/buffered-redis-backend.test.ts > $LOG_DIR/final-harness.log 2>&1; echo "EXIT:$?"
-  pnpm -C packages/session-backend exec vitest run > $LOG_DIR/final-backend.log 2>&1; echo "EXIT:$?"
-  ```
-
-- [ ] **Update the M4 memory note / add an M5 note** recording: parity-gate constraint (no mid-session `thinking_level_change`), the stream-id cutover (pre-M5 sessions throwaway), and the `sessionSpendTotal` 0-vs-null fix. (Per the repo's memory convention.)
-
----
-
-## Verification gate mapping (spec §5 → tasks)
-
-| Spec gate | Task |
-|-----------|------|
-| `decideBudget` commit/abort/disabled | 3 |
-| `read(fromPosition)` tail seek; `positionOfId` right/null | 1 |
-| Reconstruction parity (the gate) | 5 |
-| Resume recalls kept context; slice strictly smaller | 5 (also 2) |
-| Never-compacted fallback | 2 |
-| Budget voter blocks + one `abort`; inert unset | 3 |
-| pi-fork builds + its tests pass | 2, Final |
-| Existing harness/session-backend/k8s-sandbox suites green | 5, Final |
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-24-m6-experiments.md b/docs/superpowers/plans/2026-06-24-m6-experiments.md
deleted file mode 100644
index 8888770..0000000
--- a/docs/superpowers/plans/2026-06-24-m6-experiments.md
+++ /dev/null
@@ -1,1018 +0,0 @@
-# M6 Experiments (E2 + E5) Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Turn the M5 `openFromCheckpoint` loader and budget voter into reproducible, asserted experiments — E2 (local reconstruction cost) and E5 (budget enforcement) — in a new in-process TypeScript `experiments/` workspace, with the model + provider made runtime inputs.
-
-**Architecture:** A new `@sh/experiments` pnpm workspace (vitest, in-process, local Redis). E2 wraps the `SessionStorageBackend` the loaders consume in a counting decorator and measures Redis read volume for `openFromCheckpoint` vs `openFromBackend` across synthetic compacted sessions of growing length. E5 drives the existing `budgetVoterExtension` against real Redis (no-key structural gate) plus a key-gated tiny-cap live run. The only production change is making the model id + provider runtime inputs in `harness/src/run-turn.ts`. No pi-fork edits.
-
-**Tech Stack:** TypeScript (ESNext, Bundler resolution, strict), Node ≥ 22, pnpm workspaces, vitest ^2, Redis 7 (Streams), Pi fork via `link:` deps.
-
-## Global Constraints
-
-- **Branch:** `feat/m6-experiments` off `origin/main` (already created and checked out). PR to `main` when green.
-- **No pi-fork edits.** M6 consumes M5's already-merged pi-fork code; do not modify `pi-fork/`. No submodule branch.
-- **DCO + attribution:** every commit uses `git commit -s` AND includes the trailer `Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>`. NEVER `Co-Authored-By` or "Generated by".
-- **Conventional commits:** `feat:`, `chore:`, `docs:`, `test:`.
-- **Real Redis required** for fixture/E2/E5-structural tests — not auto-running in this env. Start once: `docker run -d --rm --name sh-m6-redis -p 6379:6379 redis:7-alpine`. Tests read `process.env.REDIS_URL ?? "redis://127.0.0.1:6379"`.
-- **No LLM key for the pass gate.** E2 and E5-structural run with no key. Only the gated E5 live run uses a model/key, supplied at runtime via env (`SH_MODEL_PROVIDER`, `SH_MODEL`, `ANTHROPIC_AUTH_TOKEN`, optional `ANTHROPIC_BASE_URL`). No secrets in the repo.
-- **Context budget:** redirect long command output to `/tmp/kagenti/tdd/serverless-harness/*.log` and return only exit codes; analyze big logs via subagents. Set `export LOG_DIR=/tmp/kagenti/tdd/serverless-harness && mkdir -p $LOG_DIR` at the start of each session.
-- **Defaults preserved:** the production change must not alter behavior when the new env/config are unset (M4/M5 stay green).
-- **Spec:** `docs/specs/2026-06-24-m6-experiments-design.md` (the source of truth; section refs below are to it).
-
-## File Structure
-
-| File | Responsibility |
-|------|----------------|
-| `pnpm-workspace.yaml` (modify) | Add `experiments` to workspace globs. |
-| `experiments/package.json` (create) | `@sh/experiments` private package; deps + `test` script. |
-| `experiments/tsconfig.json` (create) | Mirror `harness/tsconfig.json`. |
-| `experiments/vitest.config.ts` (create) | Mirror `harness/vitest.config.ts`. |
-| `experiments/src/counting-backend.ts` (create) | `CountingBackend`: `SessionStorageBackend` decorator tallying read entries + bytes. |
-| `experiments/src/session-fixture.ts` (create) | `buildCompactedSession(...)`: synthetic length-N compacted session in Redis. |
-| `experiments/src/report.ts` (create) | `buildResultsMarkdown(...)`: format E2 rows + static E5 section → RESULTS.md text. |
-| `experiments/test/counting-backend.test.ts` (create) | Unit: tally correctness (no Redis). |
-| `experiments/test/session-fixture.test.ts` (create) | Integration (real Redis): fixture shape + parity. |
-| `experiments/test/e2-reconstruction-cost.test.ts` (create) | E2 measurement + ratio gate + parity; writes RESULTS.md. |
-| `experiments/test/e5-budget-structural.test.ts` (create) | E5 pass gate (real Redis): block + single abort + inert. |
-| `experiments/test/e5-budget-live.test.ts` (create) | E5 live (key-gated): tiny-cap real-model breach. |
-| `experiments/RESULTS.md` (generated) | Recorded E2 table + E5 outcome. Committed. |
-| `experiments/README.md` (create) | How to run both experiments (§9.1). |
-| `harness/src/run-turn.ts` (modify) | Model + provider runtime inputs; export `resolveModelSelection`. |
-| `harness/test/run-turn-model.test.ts` (create) | Unit: model/provider precedence (no key). |
-
----
-
-### Task 1: Scaffold `experiments/` workspace + counting backend
-
-Stand up the new workspace and the `CountingBackend` decorator (spec §3 D6, §4.3). Fixture/E2/E5 all depend on this package existing and installing.
-
-**Files:**
-- Modify: `pnpm-workspace.yaml`
-- Create: `experiments/package.json`
-- Create: `experiments/tsconfig.json`
-- Create: `experiments/vitest.config.ts`
-- Create: `experiments/src/counting-backend.ts`
-- Test: `experiments/test/counting-backend.test.ts`
-
-**Interfaces:**
-- Consumes: `SessionStorageBackend` from `@earendil-works/pi-coding-agent` (`append(sid,entry)→Promise<void>`, `read(sid,fromPosition?)→Promise<FileEntry[]>`, `latestCheckpoint(sid)→Promise<FileEntry|null>`, `list()→Promise<string[]>`); `FileEntry` type.
-- Produces:
-  - `class CountingBackend implements SessionStorageBackend` — constructor `(inner: SessionStorageBackend)`; delegates all 4 methods; on `read()` accumulates counts; extra methods `counts(): { reads: number; entriesRead: number; bytesRead: number; checkpointLookups: number }` and `reset(): void`.
-
-- [ ] **Step 1: Add the workspace glob**
-
-Modify `pnpm-workspace.yaml` to (final contents):
-
-```yaml
-packages:
-  - "packages/*"
-  - "harness"
-  - "experiments"
-```
-
-- [ ] **Step 2: Create `experiments/package.json`**
-
-```json
-{
-  "name": "@sh/experiments",
-  "type": "module",
-  "private": true,
-  "version": "0.0.0",
-  "scripts": {
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@sh/session-backend": "workspace:*",
-    "@sh/harness": "workspace:*",
-    "@earendil-works/pi-ai": "link:../pi-fork/packages/ai",
-    "@earendil-works/pi-coding-agent": "link:../pi-fork/packages/coding-agent"
-  },
-  "devDependencies": {
-    "tsx": "^4.19.0",
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  }
-}
-```
-
-- [ ] **Step 3: Create `experiments/tsconfig.json`** (mirror harness)
-
-```json
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noEmit": true
-  },
-  "include": ["src", "test"]
-}
-```
-
-- [ ] **Step 4: Create `experiments/vitest.config.ts`** (mirror harness)
-
-```ts
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: { include: ["test/**/*.test.ts"] },
-});
-```
-
-- [ ] **Step 5: Install the new workspace**
-
-Run: `pnpm install > $LOG_DIR/m6t1-install.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0` and `@sh/experiments` linked. If it fails, analyze `$LOG_DIR/m6t1-install.log` via a subagent (do not read it inline).
-
-- [ ] **Step 6: Write the failing test**
-
-Create `experiments/test/counting-backend.test.ts`:
-
-```ts
-import { describe, it, expect } from "vitest";
-import type { SessionStorageBackend } from "@earendil-works/pi-coding-agent";
-import { CountingBackend } from "../src/counting-backend";
-
-// A trivial in-memory backend returning a fixed list, to exercise the decorator.
-function fakeBackend(entries: unknown[]): SessionStorageBackend {
-  return {
-    append: async () => {},
-    read: async (_sid: string, fromPosition = 1) =>
-      entries.slice(fromPosition - 1) as never,
-    latestCheckpoint: async () => null,
-    list: async () => [],
-  };
-}
-
-describe("CountingBackend", () => {
-  it("tallies entries and bytes per read, and reset() zeroes", async () => {
-    const entries = [{ a: 1 }, { b: 22 }, { c: 333 }];
-    const cb = new CountingBackend(fakeBackend(entries));
-
-    const full = await cb.read("s");
-    expect(full.length).toBe(3);
-    const c1 = cb.counts();
-    expect(c1.reads).toBe(1);
-    expect(c1.entriesRead).toBe(3);
-    expect(c1.bytesRead).toBe(
-      entries.reduce((n, e) => n + Buffer.byteLength(JSON.stringify(e)), 0),
-    );
-
-    await cb.read("s", 3); // tail of 1 entry
-    expect(cb.counts().reads).toBe(2);
-    expect(cb.counts().entriesRead).toBe(4);
-
-    cb.reset();
-    expect(cb.counts()).toEqual({ reads: 0, entriesRead: 0, bytesRead: 0, checkpointLookups: 0 });
-  });
-
-  it("counts latestCheckpoint lookups separately and delegates", async () => {
-    const cb = new CountingBackend(fakeBackend([]));
-    expect(await cb.latestCheckpoint("s")).toBeNull();
-    expect(cb.counts().checkpointLookups).toBe(1);
-    expect(cb.counts().entriesRead).toBe(0);
-  });
-});
-```
-
-- [ ] **Step 7: Run the test to verify it fails**
-
-Run: `pnpm -C experiments test counting-backend > $LOG_DIR/m6t1-red.log 2>&1; echo "EXIT:$?"`
-Expected: non-zero EXIT — `Cannot find module '../src/counting-backend'`.
-
-- [ ] **Step 8: Implement `experiments/src/counting-backend.ts`**
-
-```ts
-import type { FileEntry, SessionStorageBackend } from "@earendil-works/pi-coding-agent";
-
-export interface ReadCounts {
-  reads: number;
-  entriesRead: number;
-  bytesRead: number;
-  checkpointLookups: number;
-}
-
-/**
- * SessionStorageBackend decorator that tallies the read volume the session loaders
- * consume. Headline metric = entries + bytes returned by read() (the slice the loader
- * reconstructs from): full for openFromBackend, tail for openFromCheckpoint.
- * latestCheckpoint lookups are counted separately (each returns <= 1 entry).
- */
-export class CountingBackend implements SessionStorageBackend {
-  private _reads = 0;
-  private _entries = 0;
-  private _bytes = 0;
-  private _checkpointLookups = 0;
-
-  constructor(private readonly inner: SessionStorageBackend) {}
-
-  async append(sessionId: string, entry: FileEntry): Promise<void> {
-    await this.inner.append(sessionId, entry);
-  }
-
-  async read(sessionId: string, fromPosition?: number): Promise<FileEntry[]> {
-    const result = await this.inner.read(sessionId, fromPosition);
-    this._reads += 1;
-    this._entries += result.length;
-    for (const e of result) this._bytes += Buffer.byteLength(JSON.stringify(e));
-    return result;
-  }
-
-  async latestCheckpoint(sessionId: string): Promise<FileEntry | null> {
-    this._checkpointLookups += 1;
-    return this.inner.latestCheckpoint(sessionId);
-  }
-
-  async list(): Promise<string[]> {
-    return this.inner.list();
-  }
-
-  counts(): ReadCounts {
-    return {
-      reads: this._reads,
-      entriesRead: this._entries,
-      bytesRead: this._bytes,
-      checkpointLookups: this._checkpointLookups,
-    };
-  }
-
-  reset(): void {
-    this._reads = 0;
-    this._entries = 0;
-    this._bytes = 0;
-    this._checkpointLookups = 0;
-  }
-}
-```
-
-- [ ] **Step 9: Run the test to verify it passes**
-
-Run: `pnpm -C experiments test counting-backend > $LOG_DIR/m6t1-green.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0`, 2 tests passing.
-
-- [ ] **Step 10: Commit**
-
-```bash
-git add pnpm-workspace.yaml experiments/package.json experiments/tsconfig.json \
-  experiments/vitest.config.ts experiments/src/counting-backend.ts \
-  experiments/test/counting-backend.test.ts pnpm-lock.yaml
-git commit -s -m "feat(experiments): scaffold @sh/experiments + counting backend decorator
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 2: Synthetic compacted-session fixture
-
-Build the length-N compacted session in Redis (spec §3 D1, §4.4) that E2 measures. Mirrors the M5 `harness/test/checkpoint.test.ts` parity-test construction, parameterized by N with a fixed kept tail so checkpoint reads stay constant while full reads grow.
-
-**Files:**
-- Create: `experiments/src/session-fixture.ts`
-- Test: `experiments/test/session-fixture.test.ts`
-
-**Interfaces:**
-- Consumes: `SessionManager.create(cwd, sessionDir?, options?, backend?)`, `sm.appendMessage(msg)→string` (returns entry id), `sm.appendCompaction(summary, firstKeptEntryId, tokensBefore)→string`, `sm.appendCustomEntry(customType, data)→string`, `sm.getSessionId()→string`; `RedisSessionBackend<FileEntry>` (`positionOfId(sid,id)→Promise<number|null>`, `read(sid,fromPosition?)→Promise<StoredEntry<FileEntry>[]>`, `reset`, `close`); `BufferedRedisBackend(store)` with `flush()`.
-- Produces:
-  - `async function buildCompactedSession(store: RedisSessionBackend<FileEntry>, opts: { n: number; tailKept?: number }): Promise<{ sessionId: string; resumeFromPosition: number; fullLength: number; tailLength: number }>` — appends `n` message entries, compacts keeping the last `tailKept` (default 4) messages, writes the checkpoint marker, flushes. `fullLength` = total stored entries; `tailLength` = entries from `resumeFromPosition` forward.
-
-- [ ] **Step 1: Write the failing test**
-
-Create `experiments/test/session-fixture.test.ts`:
-
-```ts
-import { describe, it, expect, afterAll } from "vitest";
-import { SessionManager, type FileEntry } from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { BufferedRedisBackend } from "@sh/harness/buffered-redis-backend";
-import { buildCompactedSession } from "../src/session-fixture";
-
-const REDIS = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-const store = new RedisSessionBackend<FileEntry>(REDIS);
-const sids: string[] = [];
-
-afterAll(async () => {
-  for (const sid of sids) await store.reset(sid);
-  await store.close();
-});
-
-describe("buildCompactedSession", () => {
-  it("produces a compacted, checkpointed session whose tail is far smaller than the full log", async () => {
-    const fx = await buildCompactedSession(store, { n: 40, tailKept: 4 });
-    sids.push(fx.sessionId);
-
-    expect(fx.fullLength).toBeGreaterThan(40); // n messages + compaction + marker
-    expect(fx.tailLength).toBeLessThan(fx.fullLength);
-    expect(fx.tailLength).toBeLessThanOrEqual(10); // ~tailKept + compaction + marker
-
-    const backend = new BufferedRedisBackend(store);
-    const marker = await backend.latestCheckpoint(fx.sessionId);
-    expect((marker as { customType?: string } | null)?.customType).toBe("checkpoint");
-  });
-
-  it("reconstructs identically via openFromCheckpoint and openFromBackend (parity)", async () => {
-    const fx = await buildCompactedSession(store, { n: 30, tailKept: 4 });
-    sids.push(fx.sessionId);
-
-    const backend = new BufferedRedisBackend(store);
-    const viaCheckpoint = await SessionManager.openFromCheckpoint(fx.sessionId, backend, process.cwd());
-    const viaBackend = await SessionManager.openFromBackend(fx.sessionId, backend, process.cwd());
-    expect(viaCheckpoint.buildSessionContext()).toEqual(viaBackend.buildSessionContext());
-  });
-});
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-First ensure Redis is up: `docker ps --filter name=sh-m6-redis --format '{{.Names}}' || docker run -d --rm --name sh-m6-redis -p 6379:6379 redis:7-alpine`
-
-Run: `pnpm -C experiments test session-fixture > $LOG_DIR/m6t2-red.log 2>&1; echo "EXIT:$?"`
-Expected: non-zero EXIT — `Cannot find module '../src/session-fixture'`.
-
-- [ ] **Step 3: Implement `experiments/src/session-fixture.ts`**
-
-```ts
-import { SessionManager, type FileEntry } from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { BufferedRedisBackend } from "@sh/harness/buffered-redis-backend";
-
-export interface CompactedFixture {
-  sessionId: string;
-  resumeFromPosition: number;
-  fullLength: number;
-  tailLength: number;
-}
-
-/**
- * Build a length-n session in Redis that compacted once, keeping the last `tailKept`
- * messages, with a checkpoint marker pointing at the kept-tail position. The kept tail
- * is fixed independent of n, so openFromCheckpoint reads ~constant while openFromBackend
- * grows with n. No thinking_level_change is appended, so buildSessionContext() parity
- * holds (the M5 thinkingLevel caveat only triggers on a pre-tail thinking_level_change).
- */
-export async function buildCompactedSession(
-  store: RedisSessionBackend<FileEntry>,
-  opts: { n: number; tailKept?: number },
-): Promise<CompactedFixture> {
-  const tailKept = opts.tailKept ?? 4;
-  const backend = new BufferedRedisBackend(store);
-  const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-  const sessionId = sm.getSessionId();
-
-  const ids: string[] = [];
-  for (let i = 0; i < opts.n; i++) {
-    const role = i % 2 === 0 ? "user" : "assistant";
-    const id = sm.appendMessage({ role, content: `m${i}` } as never);
-    ids.push(id);
-  }
-
-  // Keep the last `tailKept` messages: firstKept = the message at index n - tailKept.
-  const firstKeptId = ids[Math.max(0, opts.n - tailKept)];
-  sm.appendCompaction("summary of earlier turns", firstKeptId, 1234);
-  await backend.flush();
-
-  const resumeFromPosition = await store.positionOfId(sessionId, firstKeptId);
-  if (resumeFromPosition == null) {
-    throw new Error(`fixture: positionOfId returned null for firstKeptId ${firstKeptId}`);
-  }
-  sm.appendCustomEntry("checkpoint", { resumeFromPosition });
-  await backend.flush();
-
-  const full = await store.read(sessionId);
-  const tail = await store.read(sessionId, resumeFromPosition);
-  return {
-    sessionId,
-    resumeFromPosition,
-    fullLength: full.length,
-    tailLength: tail.length,
-  };
-}
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `pnpm -C experiments test session-fixture > $LOG_DIR/m6t2-green.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0`, 2 tests passing. If the `@sh/harness/buffered-redis-backend` import fails to resolve, verify `harness/package.json` `exports` includes `"./buffered-redis-backend"`; if it does not, import via the package's `src` path used by harness tests (`../../harness/src/buffered-redis-backend`) and note it for Step 5.
-
-- [ ] **Step 5: Confirm the harness subpath export (adjust import if needed)**
-
-Run: `node -e "console.log(require('./harness/package.json').exports)" > $LOG_DIR/m6t2-exports.log 2>&1; echo "EXIT:$?"`
-If `./buffered-redis-backend` is absent from harness exports, either (a) add `"./buffered-redis-backend": "./src/buffered-redis-backend.ts"` to `harness/package.json` exports (preferred — additive, harmless), or (b) switch the fixture + tests to the relative import `../../harness/src/buffered-redis-backend`. Pick (a). Re-run Step 4 to confirm green.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add experiments/src/session-fixture.ts experiments/test/session-fixture.test.ts harness/package.json
-git commit -s -m "feat(experiments): synthetic compacted-session fixture for E2
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 3: E2 measurement + ratio gate + RESULTS.md
-
-Measure reconstruction read volume across N and assert the ratio gate (spec §3 D2/D3, §4.5, §5). Write the recorded results.
-
-**Files:**
-- Create: `experiments/src/report.ts`
-- Test: `experiments/test/e2-reconstruction-cost.test.ts`
-- Generated: `experiments/RESULTS.md`
-
-**Interfaces:**
-- Consumes: `CountingBackend` (Task 1), `buildCompactedSession` (Task 2), `SessionManager.openFromBackend/openFromCheckpoint`, `BufferedRedisBackend`, `RedisSessionBackend`.
-- Produces:
-  - `interface E2Row { n: number; backendEntries: number; checkpointEntries: number; backendBytes: number; checkpointBytes: number; ratioEntries: number; backendMs: number; checkpointMs: number }`
-  - `function buildResultsMarkdown(rows: E2Row[]): string` — full RESULTS.md text (E2 table + a static E5 outcome section).
-
-- [ ] **Step 1: Write `experiments/src/report.ts`**
-
-```ts
-export interface E2Row {
-  n: number;
-  backendEntries: number;
-  checkpointEntries: number;
-  backendBytes: number;
-  checkpointBytes: number;
-  ratioEntries: number;
-  backendMs: number;
-  checkpointMs: number;
-}
-
-export function buildResultsMarkdown(rows: E2Row[]): string {
-  const header =
-    "| N (session len) | backend entries | checkpoint entries | ratio (b/c) | backend bytes | checkpoint bytes | backend ms* | checkpoint ms* |\n" +
-    "|---|---|---|---|---|---|---|---|";
-  const body = rows
-    .map(
-      (r) =>
-        `| ${r.n} | ${r.backendEntries} | ${r.checkpointEntries} | ${r.ratioEntries.toFixed(1)} | ${r.backendBytes} | ${r.checkpointBytes} | ${r.backendMs.toFixed(1)} | ${r.checkpointMs.toFixed(1)} |`,
-    )
-    .join("\n");
-  return `# M6 Experiment Results
-
-## E2 — local reconstruction cost (openFromCheckpoint vs openFromBackend)
-
-Synthetic sessions, each compacted once with a fixed kept tail. Metric = entries + bytes
-returned by \`backend.read()\` during reconstruction (the slice each loader rebuilds from).
-\`*\` ms columns are wall-clock on a dev box — **illustrative only**; the gate is the
-deterministic entries ratio.
-
-${header}
-${body}
-
-**Pass:** checkpoint entries stay ~constant (bounded by the kept tail) while backend entries
-grow linearly with N, so the backend/checkpoint ratio strictly increases with N. \`buildSessionContext()\`
-is identical under both loaders at every N.
-
-## E5 — budget-voter enforcement
-
-Verified by \`e5-budget-structural.test.ts\` (no key, real Redis): once per-turn spend exceeds
-\`SH_BUDGET_TOKENS\`, the \`tool_call\` is blocked and exactly one \`abort\` entry is persisted;
-with the cap unset the voter is inert (no block, no \`abort\`). A key-gated live run
-(\`e5-budget-live.test.ts\`, tiny cap) confirms the same end-to-end with a real model. See
-\`README.md\` for how to run the live variant.
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
-`;
-}
-```
-
-- [ ] **Step 2: Write the failing test**
-
-Create `experiments/test/e2-reconstruction-cost.test.ts`:
-
-```ts
-import { describe, it, expect, afterAll } from "vitest";
-import { writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { SessionManager, type FileEntry } from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { BufferedRedisBackend } from "@sh/harness/buffered-redis-backend";
-import { CountingBackend } from "../src/counting-backend";
-import { buildCompactedSession } from "../src/session-fixture";
-import { buildResultsMarkdown, type E2Row } from "../src/report";
-
-const REDIS = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-const store = new RedisSessionBackend<FileEntry>(REDIS);
-const sids: string[] = [];
-const Ns = [50, 200, 1000, 5000];
-
-afterAll(async () => {
-  for (const sid of sids) await store.reset(sid);
-  await store.close();
-});
-
-async function measure(sessionId: string): Promise<{
-  backend: { entries: number; bytes: number; ms: number };
-  checkpoint: { entries: number; bytes: number; ms: number };
-}> {
-  const cb = new CountingBackend(new BufferedRedisBackend(store));
-
-  cb.reset();
-  let t0 = performance.now();
-  const viaBackend = await SessionManager.openFromBackend(sessionId, cb, process.cwd());
-  const backendMs = performance.now() - t0;
-  const b = cb.counts();
-
-  cb.reset();
-  t0 = performance.now();
-  const viaCheckpoint = await SessionManager.openFromCheckpoint(sessionId, cb, process.cwd());
-  const checkpointMs = performance.now() - t0;
-  const c = cb.counts();
-
-  // Parity re-confirmation (spec §5).
-  expect(viaCheckpoint.buildSessionContext()).toEqual(viaBackend.buildSessionContext());
-
-  return {
-    backend: { entries: b.entriesRead, bytes: b.bytesRead, ms: backendMs },
-    checkpoint: { entries: c.entriesRead, bytes: c.bytesRead, ms: checkpointMs },
-  };
-}
-
-describe("E2 — reconstruction cost", () => {
-  it("checkpoint read stays ~constant while backend grows; ratio increases with N", async () => {
-    const rows: E2Row[] = [];
-    for (const n of Ns) {
-      const fx = await buildCompactedSession(store, { n, tailKept: 4 });
-      sids.push(fx.sessionId);
-      const m = await measure(fx.sessionId);
-      rows.push({
-        n,
-        backendEntries: m.backend.entries,
-        checkpointEntries: m.checkpoint.entries,
-        backendBytes: m.backend.bytes,
-        checkpointBytes: m.checkpoint.bytes,
-        ratioEntries: m.backend.entries / m.checkpoint.entries,
-        backendMs: m.backend.ms,
-        checkpointMs: m.checkpoint.ms,
-      });
-    }
-
-    // Checkpoint entries are bounded by the kept tail, independent of N.
-    const cpEntries = rows.map((r) => r.checkpointEntries);
-    expect(Math.max(...cpEntries)).toBeLessThanOrEqual(10);
-
-    // Backend entries grow with N.
-    expect(rows[rows.length - 1].backendEntries).toBeGreaterThan(rows[0].backendEntries * 5);
-
-    // Ratio strictly increases across the N series.
-    for (let i = 1; i < rows.length; i++) {
-      expect(rows[i].ratioEntries).toBeGreaterThan(rows[i - 1].ratioEntries);
-    }
-    // And the largest N dwarfs the smallest.
-    expect(rows[rows.length - 1].ratioEntries).toBeGreaterThan(rows[0].ratioEntries * 5);
-
-    // Record results next to this file.
-    const resultsPath = fileURLToPath(new URL("../RESULTS.md", import.meta.url));
-    writeFileSync(resultsPath, buildResultsMarkdown(rows));
-    // Echo to stdout (redirected to $LOG_DIR by the runner) for the record.
-    console.log(JSON.stringify(rows, null, 2));
-  }, 120_000);
-});
-```
-
-- [ ] **Step 3: Run the test to verify it fails**
-
-Run: `pnpm -C experiments test e2-reconstruction-cost > $LOG_DIR/m6t3-red.log 2>&1; echo "EXIT:$?"`
-Expected: non-zero EXIT — module `../src/report` resolves but the test fails to import or assertions are unmet only after implementation; if `report.ts` from Step 1 exists, the red signal is the missing `RESULTS.md` write path or the assertions running against real data. Confirm the failure is a real assertion/compile failure, not a Redis-down error (if `ECONNREFUSED`, start Redis per Task 2 Step 2).
-
-- [ ] **Step 4: Make it pass**
-
-`report.ts` (Step 1) and the fixture (Task 2) already provide the implementation; no new production code is needed. Run:
-
-Run: `pnpm -C experiments test e2-reconstruction-cost > $LOG_DIR/m6t3-green.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0`, 1 test passing, and `experiments/RESULTS.md` written. Verify via a subagent that `$LOG_DIR/m6t3-green.log` shows the ratio increasing across N (do not read the full log inline).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add experiments/src/report.ts experiments/test/e2-reconstruction-cost.test.ts experiments/RESULTS.md
-git commit -s -m "feat(experiments): E2 reconstruction-cost measurement + ratio gate + results
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 4: Model + provider as runtime inputs (production change)
-
-Make the model id and provider runtime inputs in the turn path (spec §2, §3 D7/D8, §4.2), defaults preserved, with a no-key unit test on the resolution helper.
-
-**Files:**
-- Modify: `harness/src/run-turn.ts` (`TurnConfig` interface; line ~78 model construction)
-- Test: `harness/test/run-turn-model.test.ts`
-
-**Interfaces:**
-- Produces:
-  - `interface ModelSelection { provider: string; modelId: string }`
-  - `function resolveModelSelection(config?: { model?: string; provider?: string }, env?: NodeJS.ProcessEnv): ModelSelection` — precedence: `config` > env (`SH_MODEL_PROVIDER`/`SH_MODEL`) > defaults (`"anthropic"`/`"claude-opus-4-8"`). Exported from `run-turn.ts`.
-  - `TurnConfig` gains optional `model?: string` and `provider?: string`.
-
-- [ ] **Step 1: Write the failing test**
-
-Create `harness/test/run-turn-model.test.ts`:
-
-```ts
-import { describe, it, expect } from "vitest";
-import { resolveModelSelection } from "../src/run-turn";
-
-describe("resolveModelSelection", () => {
-  it("defaults to anthropic / claude-opus-4-8 when nothing is set", () => {
-    expect(resolveModelSelection(undefined, {})).toEqual({
-      provider: "anthropic",
-      modelId: "claude-opus-4-8",
-    });
-  });
-
-  it("reads env when config is absent", () => {
-    expect(
-      resolveModelSelection(undefined, { SH_MODEL_PROVIDER: "openai", SH_MODEL: "gpt-x" }),
-    ).toEqual({ provider: "openai", modelId: "gpt-x" });
-  });
-
-  it("config overrides env and defaults", () => {
-    expect(
-      resolveModelSelection(
-        { provider: "anthropic", model: "claude-sonnet-4-6" },
-        { SH_MODEL_PROVIDER: "openai", SH_MODEL: "gpt-x" },
-      ),
-    ).toEqual({ provider: "anthropic", modelId: "claude-sonnet-4-6" });
-  });
-
-  it("mixes config and env per-field", () => {
-    expect(resolveModelSelection({ model: "m1" }, { SH_MODEL_PROVIDER: "p1" })).toEqual({
-      provider: "p1",
-      modelId: "m1",
-    });
-  });
-});
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `pnpm -C harness test run-turn-model > $LOG_DIR/m6t4-red.log 2>&1; echo "EXIT:$?"`
-Expected: non-zero EXIT — `resolveModelSelection` is not exported.
-
-- [ ] **Step 3: Edit `harness/src/run-turn.ts`**
-
-Add `model?` / `provider?` to `TurnConfig` (after `anthropicAuthToken?: string;`):
-
-```ts
-  anthropicBaseUrl?: string;
-  anthropicAuthToken?: string;
-  model?: string;
-  provider?: string;
-```
-
-Add the exported helper near the top of the module (after the `TurnResult` interface):
-
-```ts
-export interface ModelSelection {
-  provider: string;
-  modelId: string;
-}
-
-/** Resolve model + provider as runtime inputs: config > env > default. */
-export function resolveModelSelection(
-  config?: { model?: string; provider?: string },
-  env: NodeJS.ProcessEnv = process.env,
-): ModelSelection {
-  return {
-    provider: config?.provider ?? env.SH_MODEL_PROVIDER ?? "anthropic",
-    modelId: config?.model ?? env.SH_MODEL ?? "claude-opus-4-8",
-  };
-}
-```
-
-Replace the hardcoded model line (`const baseModel = getModel("anthropic", "claude-opus-4-8");`) with:
-
-```ts
-  const { provider, modelId } = resolveModelSelection(config);
-  const baseModel = getModel(provider, modelId);
-```
-
-Leave the existing gateway/auth-header branch (lines ~79–95) unchanged.
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `pnpm -C harness test run-turn-model > $LOG_DIR/m6t4-green.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0`, 4 tests passing.
-
-- [ ] **Step 5: Run the full harness suite (no regression)**
-
-Run: `pnpm -C harness test > $LOG_DIR/m6t4-harness.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0` (the LLM-gated `run-turn.test.ts` self-skips without a key). If anything other than the live test fails, analyze `$LOG_DIR/m6t4-harness.log` via a subagent.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add harness/src/run-turn.ts harness/test/run-turn-model.test.ts
-git commit -s -m "feat(harness): model + provider as runtime inputs in run-turn
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 5: E5 structural gate (real Redis)
-
-Prove the wired voter blocks and persists exactly one `abort`, and is inert when the cap is disabled (spec §3 D4, §4.6, §5). This is the M6 pass gate for E5.
-
-**Files:**
-- Test: `experiments/test/e5-budget-structural.test.ts`
-
-**Interfaces:**
-- Consumes: `budgetVoterExtension(sm, { limit })` from `@sh/harness` (`harness/src/budget-voter.ts`); `SessionManager.create`, `BufferedRedisBackend`, `RedisSessionBackend`. The extension registers `session_start` and `tool_call` handlers via `pi.on(event, handler)`; `session_start(_e, ctx)` captures baseline = `sessionSpendTotal(ctx)`; `tool_call(_e, ctx)` blocks (`{ block: true, reason }`) and calls `sm.appendCustomEntry("abort", { reason, spent, limit })` once over cap.
-- Produces: nothing consumed downstream (terminal experiment).
-
-- [ ] **Step 1: Write the test (it will fail until imports/behavior line up)**
-
-Create `experiments/test/e5-budget-structural.test.ts`:
-
-```ts
-import { describe, it, expect, afterAll } from "vitest";
-import { SessionManager, type FileEntry } from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { BufferedRedisBackend } from "@sh/harness/buffered-redis-backend";
-import { budgetVoterExtension } from "@sh/harness/budget-voter";
-
-const REDIS = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-const store = new RedisSessionBackend<FileEntry>(REDIS);
-const sids: string[] = [];
-
-afterAll(async () => {
-  for (const sid of sids) await store.reset(sid);
-  await store.close();
-});
-
-// A synthetic ExtensionContext whose branch reports a given assistant token spend.
-function spendCtx(total: number) {
-  return {
-    sessionManager: {
-      getBranch: () =>
-        total === 0
-          ? []
-          : [{ type: "message", message: { role: "assistant", usage: { input: total, output: 0, cacheRead: 0, cacheWrite: 0 } } }],
-    },
-  } as never;
-}
-
-function register(sm: SessionManager, limit: number) {
-  const handlers: Record<string, (e: unknown, ctx: unknown) => unknown> = {};
-  const pi = { on: (ev: string, h: (e: unknown, ctx: unknown) => unknown) => { handlers[ev] = h; } };
-  budgetVoterExtension(sm, { limit })(pi as never);
-  return handlers;
-}
-
-async function abortCount(sessionId: string): Promise<number> {
-  const entries = await store.read(sessionId);
-  return entries.filter(
-    (r) => (r.entry as { type?: string; customType?: string }).type === "custom" &&
-           (r.entry as { customType?: string }).customType === "abort",
-  ).length;
-}
-
-describe("E5 — budget voter enforcement (structural, real Redis)", () => {
-  it("blocks the tool call and persists exactly one abort entry once over cap", async () => {
-    const backend = new BufferedRedisBackend(store);
-    const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-    const sid = sm.getSessionId();
-    sids.push(sid);
-
-    const handlers = register(sm, 50);
-    handlers.session_start({}, spendCtx(0)); // baseline = 0
-    const res = handlers.tool_call({}, spendCtx(60)); // 60 > 50
-
-    expect(res).toEqual({ block: true, reason: "Session token budget exceeded" });
-    await backend.flush();
-    expect(await abortCount(sid)).toBe(1);
-  });
-
-  it("is inert when the cap is disabled (limit <= 0): no block, no abort", async () => {
-    const backend = new BufferedRedisBackend(store);
-    const sm = SessionManager.create(process.cwd(), undefined, undefined, backend);
-    const sid = sm.getSessionId();
-    sids.push(sid);
-
-    const handlers = register(sm, 0); // disabled cap
-    handlers.session_start({}, spendCtx(0));
-    const res = handlers.tool_call({}, spendCtx(10_000)); // way over, but cap disabled
-
-    expect(res).toEqual({});
-    await backend.flush();
-    expect(await abortCount(sid)).toBe(0);
-  });
-});
-```
-
-- [ ] **Step 2: Run the test to verify it fails (then identify the real cause)**
-
-Run: `pnpm -C experiments test e5-budget-structural > $LOG_DIR/m6t5-red.log 2>&1; echo "EXIT:$?"`
-Expected: non-zero EXIT. The likely first failure is the `@sh/harness/budget-voter` import not resolving.
-
-- [ ] **Step 3: Add the harness subpath exports (additive)**
-
-In `harness/package.json`, ensure `exports` includes the budget-voter (and the buffered backend from Task 2):
-
-```json
-  "exports": {
-    ".": "./src/index.ts",
-    "./run-turn": "./src/run-turn.ts",
-    "./buffered-redis-backend": "./src/buffered-redis-backend.ts",
-    "./budget-voter": "./src/budget-voter.ts"
-  },
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `pnpm -C experiments test e5-budget-structural > $LOG_DIR/m6t5-green.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0`, 2 tests passing. If the abort count is 0 in the over-cap case, confirm the voter writes through `sm.appendCustomEntry` on the real `sm` (not a fake) and that `backend.flush()` ran before reading.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add experiments/test/e5-budget-structural.test.ts harness/package.json
-git commit -s -m "test(experiments): E5 budget-voter structural gate (block + single abort + inert)
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 6: E5 live run (key-gated) + run docs
-
-Add the gated end-to-end live run and the experiments README (spec §3 D5, §4.7, §7, §9.1).
-
-**Files:**
-- Test: `experiments/test/e5-budget-live.test.ts`
-- Create: `experiments/README.md`
-
-**Interfaces:**
-- Consumes: `runTurn(prompt, sessionId?, config?)` from `@sh/harness/run-turn` (returns `{ sessionId, response, stopReason, errorMessage? }`); `RedisSessionBackend` for the abort assertion.
-- Produces: nothing downstream.
-
-- [ ] **Step 1: Write the gated live test**
-
-Create `experiments/test/e5-budget-live.test.ts`:
-
-```ts
-import { describe, it, expect, afterAll } from "vitest";
-import { type FileEntry } from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { runTurn } from "@sh/harness/run-turn";
-
-const REDIS = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-const LIVE = process.env.SH_RUN_LIVE === "1" && !!process.env.ANTHROPIC_AUTH_TOKEN;
-const store = new RedisSessionBackend<FileEntry>(REDIS);
-const sids: string[] = [];
-
-afterAll(async () => {
-  for (const sid of sids) await store.reset(sid);
-  await store.close();
-});
-
-async function abortCount(sessionId: string): Promise<number> {
-  const entries = await store.read(sessionId);
-  return entries.filter(
-    (r) => (r.entry as { type?: string }).type === "custom" &&
-           (r.entry as { customType?: string }).customType === "abort",
-  ).length;
-}
-
-describe("E5 — budget voter enforcement (live)", () => {
-  // Skips unless SH_RUN_LIVE=1 and a key is present (see README).
-  (LIVE ? it : it.skip)(
-    "blocks a real tool call and records exactly one abort under a tiny cap",
-    async () => {
-      // SH_BUDGET_TOKENS=1 must be exported by the runner so run-turn registers the voter.
-      expect(Number(process.env.SH_BUDGET_TOKENS)).toBeGreaterThan(0);
-      // A prompt that forces a tool call (a tool must be registered — see README §tools).
-      const prompt =
-        "Use the shell tool to run `echo hello`. You must call a tool; do not answer directly.";
-      const result = await runTurn(prompt, undefined, { redisUrl: REDIS });
-      sids.push(result.sessionId);
-
-      expect(await abortCount(result.sessionId)).toBe(1);
-    },
-    300_000,
-  );
-});
-```
-
-- [ ] **Step 2: Run it (skips without a key)**
-
-Run: `pnpm -C experiments test e5-budget-live > $LOG_DIR/m6t6-skip.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0` with the test reported as skipped (no key set). Confirm "skipped" via a subagent on the log; this is the CI-path behavior.
-
-- [ ] **Step 3: Write `experiments/README.md`**
-
-````markdown
-# @sh/experiments — M6 experiments (E2 + E5)
-
-In-process experiment runners for the serverless-harness. See
-`docs/specs/2026-06-24-m6-experiments-design.md`.
-
-## Prerequisites
-
-```bash
-docker run -d --rm --name sh-m6-redis -p 6379:6379 redis:7-alpine
-```
-
-## E2 + E5 structural (no LLM key — the pass gate)
-
-```bash
-pnpm -C experiments test
-```
-
-- E2 writes recorded results to `experiments/RESULTS.md` and asserts the
-  checkpoint/backend read ratio grows with session length.
-- E5 structural asserts the voter blocks + persists exactly one `abort` over cap,
-  and is inert when the cap is disabled.
-
-## E5 live (real model — manual, end-to-end)
-
-Model + provider + credentials are runtime inputs; no secrets live in the repo.
-
-```bash
-export SH_MODEL_PROVIDER=anthropic
-export SH_MODEL=claude-opus-4-8
-export ANTHROPIC_AUTH_TOKEN=…              # (+ ANTHROPIC_BASE_URL=… for the litellm gateway)
-export SH_RUN_LIVE=1 SH_BUDGET_TOKENS=1
-pnpm -C experiments test e5-budget-live
-```
-
-### Tools (so the model has something to call)
-
-The live run needs at least one registered tool so a `tool_call` fires and trips the
-tiny cap. If the harness registers no tools without a sandbox, set
-`KAGENTI_SANDBOX_POD=<pod>` (M2 sandbox) before running, or adjust the prompt to target
-whatever built-in tool the `DefaultResourceLoader` exposes. The live run is **not** the
-pass gate (the structural test is); it is the end-to-end confirmation.
-````
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add experiments/test/e5-budget-live.test.ts experiments/README.md
-git commit -s -m "test(experiments): E5 live budget run (key-gated) + run docs
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 7: Full-suite regression sweep
-
-Confirm no regressions across the monorepo and that the experiments gate is green (spec §5 Build/regression).
-
-**Files:** none (verification only).
-
-- [ ] **Step 1: Run every workspace test suite (no key)**
-
-Ensure Redis is up, then run each suite, redirecting output:
-
-```bash
-pnpm -C packages/session-backend test > $LOG_DIR/m6t7-sb.log 2>&1; echo "session-backend EXIT:$?"
-pnpm -C harness test               > $LOG_DIR/m6t7-harness.log 2>&1; echo "harness EXIT:$?"
-pnpm -C experiments test           > $LOG_DIR/m6t7-exp.log 2>&1; echo "experiments EXIT:$?"
-```
-
-(If `@sh/k8s-sandbox` has its own suite, run it too: `pnpm -C packages/k8s-sandbox test > $LOG_DIR/m6t7-k8s.log 2>&1; echo "k8s EXIT:$?"`.)
-
-Expected: all `EXIT:0` (LLM-gated and `SH_RUN_LIVE` tests self-skip). Analyze any non-zero log via a subagent — do not read full logs inline.
-
-- [ ] **Step 2: Confirm pi-fork is untouched**
-
-Run: `git -C pi-fork status --porcelain | head; echo "pi-fork-clean-EXIT:$?"`
-Expected: empty output (no pi-fork changes) and the submodule pointer unchanged in the parent (`git status --porcelain | grep pi-fork || echo "no pi-fork pointer change"`).
-
-- [ ] **Step 3: Verify RESULTS.md was recorded**
-
-Run: `test -s experiments/RESULTS.md && echo "RESULTS present" || echo "MISSING"`
-Expected: `RESULTS present`. (If E2 was last run on this machine, the numbers are current; otherwise re-run Task 3 Step 4 and re-commit.)
-
-- [ ] **Step 4: Final commit (only if RESULTS.md was refreshed)**
-
-```bash
-git add experiments/RESULTS.md
-git commit -s -m "chore(experiments): record E2 results from final run
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>" || echo "nothing to commit"
-```
-
----
-
-## Self-Review
-
-**Spec coverage:**
-- §2 model runtime input → Task 4. §3 D1 synthetic fixture → Task 2. §3 D2/D3 entries+bytes metric + ratio gate → Task 3. §3 D4 E5 structural gate → Task 5. §3 D5 E5 live → Task 6. §3 D6 experiments workspace → Task 1. §3 D7/D8 model/provider knob → Task 4. §3 D9 one branch, no pi-fork → Global Constraints + Task 7 Step 2. §4.1 file layout → all tasks. §4.3 counting decorator → Task 1. §4.4 fixture → Task 2. §4.5 E2 → Task 3. §4.6 E5 structural → Task 5. §4.7 E5 live → Task 6. §5 verification gate → Tasks 1–7. §9.1 run docs → Task 6 README. All covered.
-- Minor documented choice: RESULTS.md is written solely by the E2 test and embeds a static E5 outcome section (single-writer), rather than two tests writing one file — honors spec §4.1 (E2 table + E5 outcome) without file contention.
-
-**Placeholder scan:** No TBD/TODO; every code step shows full code; every command shows expected output. The one runtime-resolved detail (live-run tool availability, §4.7) is explicitly outside the pass gate and documented in the README, not left as a code placeholder.
-
-**Type consistency:** `CountingBackend.counts()` shape `{ reads, entriesRead, bytesRead, checkpointLookups }` is identical in Task 1 impl, Task 1 test, and Task 3 `measure()`. `E2Row` fields match between `report.ts` (Task 3 Step 1) and the E2 test (Task 3 Step 2). `buildCompactedSession` return `{ sessionId, resumeFromPosition, fullLength, tailLength }` matches its consumers (Tasks 2, 3). `resolveModelSelection(config?, env?)` signature matches its test (Task 4). `budgetVoterExtension(sm, { limit })` + handler return `{ block, reason }` and abort entry `{ type:"custom", customType:"abort" }` match Task 5's assertions. Harness subpath exports (`./buffered-redis-backend`, `./budget-voter`, `./run-turn`) are added in Tasks 2/5 and consumed consistently.
diff --git a/docs/superpowers/plans/2026-06-25-m7-cluster-experiments.md b/docs/superpowers/plans/2026-06-25-m7-cluster-experiments.md
deleted file mode 100644
index e7b46c2..0000000
--- a/docs/superpowers/plans/2026-06-25-m7-cluster-experiments.md
+++ /dev/null
@@ -1,614 +0,0 @@
-# M7 Cluster Experiments (E1 / E3-mobility / E4) Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Turn M4's informal Knative smoke claims into three rigorous, measured end-to-end cluster experiments — E1 (scale-to-zero economics), E3-mobility (fresh-instance recall from the Redis log), E4 (crash recovery) — as idempotent bash drivers under `deploy/knative/`, sharing a `lib.sh` factored out of `smoke.sh`.
-
-**Architecture:** Bash + `kubectl` + `curl` + `jq` against the running Kind+Knative deploy (ksvc `serverless-harness`, namespace `default`). A shared `deploy/knative/lib.sh` holds cluster/HTTP helpers; `smoke.sh` is refactored to source it (regression anchor). Three drivers self-assert `PASS`/`FAIL`; `run-experiments.sh` does setup/harden then runs all three and records `EXPERIMENTS.md`. No application/pi-fork code changes.
-
-**Tech Stack:** bash, kubectl, curl, jq, Knative Serving v1.14 + Kourier on Kind (`sh-knative`), litellm gateway (`claude-haiku-4-5`).
-
-## Global Constraints
-
-- **Branch:** `feat/m7-cluster-experiments` off `origin/main` (already created; the M7 spec is committed on it). PR to `main` when green.
-- **No application or pi-fork changes.** M7 only adds/edits files under `deploy/knative/`. pi-fork untouched (no submodule branch).
-- **DCO + attribution:** every commit uses `git commit -s` AND the trailer `Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>`. NEVER `Co-Authored-By` or "Generated by".
-- **Conventional commits:** `feat:`, `chore:`, `docs:`, `test:`.
-- **Target names (verbatim):** namespace `default`, ksvc `serverless-harness`, pod selector `serving.knative.dev/service=serverless-harness`. Parameterize as `NS` / `KSVC` in `lib.sh` with those defaults.
-- **Experiment model:** `SH_MODEL=claude-haiku-4-5` (dash-form, anthropic provider) on the ksvc env. Never a dotted id.
-- **Live execution:** E1/E3/E4 and the post-refactor `smoke.sh` run against the live `sh-knative` Kind cluster and need the `llm-credentials` secret (created from the operator's `ANTHROPIC_API_KEY` / `ANTHROPIC_BASE_URL` / `ANTHROPIC_AUTH_TOKEN` env). No secrets in the repo. A kourier port-forward must be active: `kubectl port-forward -n kourier-system svc/kourier 8080:80`.
-- **No-cluster gate for every bash file:** `bash -n <file>` must pass (syntax). Run `shellcheck` if available.
-- **Context budget:** redirect long output to `/tmp/kagenti/tdd/serverless-harness/*.log` and report exit codes; analyze big logs via subagents. `export LOG_DIR=/tmp/kagenti/tdd/serverless-harness && mkdir -p $LOG_DIR`.
-- **Spec:** `docs/specs/2026-06-25-m7-cluster-experiments-design.md` (source of truth; §refs below point to it).
-
-## File Structure
-
-| File | Responsibility |
-|------|----------------|
-| `deploy/knative/lib.sh` (create) | Shared helpers: `NS`/`KSVC`/`PORT`/`HOST_HEADER`/`BASE` vars; `harness_running_pods`, `wait_for_zero_pods`, `turn`, `set_min_scale`, `wait_ksvc_ready`, `force_kill_pod`, `ensure_secret`, `ensure_port_forward`, sampler (`start_sampler`/`stop_sampler`/`pod_seconds_from`), reporting (`ok`/`ko`). |
-| `deploy/knative/smoke.sh` (modify) | Source `lib.sh`; drop duplicated inline helpers. Behavior unchanged — regression anchor. |
-| `deploy/knative/service.yaml` (modify) | Add `SH_MODEL=claude-haiku-4-5` to the ksvc container env. |
-| `deploy/knative/e1-economics.sh` (create) | Sampled pod-seconds at `min-scale=1` vs `0` over an idle pattern; PASS if serverless ≤ 0.6× persistent. |
-| `deploy/knative/e3-mobility.sh` (create) | Plant a token; force the pod to zero; follow-up on a fresh pod must recall it. |
-| `deploy/knative/e4-recovery.sh` (create) | Complete 3 turns; force-kill the pod; next turn recalls all three. |
-| `deploy/knative/run-experiments.sh` (create) | Setup/harden (apply ksvc, ensure secret, port-forward, smoke-check) then run E1/E3/E4 and write `EXPERIMENTS.md`. |
-| `deploy/knative/EXPERIMENTS.md` (generated) | Recorded results from a real run. Committed. |
-
----
-
-### Task 1: Factor `lib.sh` from `smoke.sh` (regression anchor)
-
-Extract the reusable cluster/HTTP helpers into `lib.sh` and make `smoke.sh` source it, unchanged in behavior. This is the foundation every driver builds on, and `smoke.sh` proves the refactor is faithful.
-
-**Files:**
-- Create: `deploy/knative/lib.sh`
-- Modify: `deploy/knative/smoke.sh`
-
-**Interfaces:**
-- Produces (sourced by all later tasks):
-  - Vars: `NS` (default `default`), `KSVC` (default `serverless-harness`), `PORT` (default `8080`), `HOST_HEADER` (`Host: serverless-harness.default.example.com`), `BASE` (`http://localhost:$PORT`).
-  - `harness_running_pods` → echoes the count of Running harness pods.
-  - `wait_for_zero_pods [timeout_s=90]` → returns 0 when count hits 0, else 1.
-  - `turn <prompt> [sessionId]` → POSTs `/turn`, echoes the raw JSON response.
-  - `ok <msg>` / `ko <msg>` → increment global `PASS`/`FAIL` counters and print.
-
-- [ ] **Step 1: Create `deploy/knative/lib.sh`**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/lib.sh
-# Shared helpers for the Knative smoke + experiment drivers.
-# Source this; do not execute. Targets ksvc serverless-harness in namespace default.
-
-NS="${NS:-default}"
-KSVC="${KSVC:-serverless-harness}"
-PORT="${PORT:-8080}"
-HOST_HEADER="${HOST_HEADER:-Host: ${KSVC}.${NS}.example.com}"
-BASE="${BASE:-http://localhost:${PORT}}"
-SELECTOR="serving.knative.dev/service=${KSVC}"
-SAMPLE_INTERVAL="${SAMPLE_INTERVAL:-5}"
-
-PASS=0
-FAIL=0
-ok()  { echo "  PASS${1:+: $1}"; PASS=$((PASS + 1)); }
-ko()  { echo "  FAIL: $1"; FAIL=$((FAIL + 1)); }
-
-# Count Running harness pods.
-harness_running_pods() {
-  kubectl get pods -n "$NS" -l "$SELECTOR" \
-    --field-selector=status.phase=Running --no-headers 2>/dev/null | wc -l | tr -d ' '
-}
-
-# Wait until no harness pods are Running (scale-to-zero). Arg: timeout seconds (default 90).
-wait_for_zero_pods() {
-  local timeout="${1:-90}" waited=0
-  while [ "$waited" -lt "$timeout" ]; do
-    [ "$(harness_running_pods)" = "0" ] && return 0
-    sleep "$SAMPLE_INTERVAL"; waited=$((waited + SAMPLE_INTERVAL))
-  done
-  return 1
-}
-
-# POST /turn. Usage: turn "prompt" [sessionId]. Echoes raw JSON response.
-turn() {
-  local prompt="$1" sid="${2:-}"
-  local body
-  if [ -n "$sid" ]; then
-    body=$(jq -nc --arg s "$sid" --arg p "$prompt" '{sessionId:$s, prompt:$p}')
-  else
-    body=$(jq -nc --arg p "$prompt" '{prompt:$p}')
-  fi
-  curl -s --max-time 120 -H "$HOST_HEADER" -H "Content-Type: application/json" \
-    -d "$body" "$BASE/turn"
-}
-
-# Set the ksvc min-scale annotation (creates a new revision) and wait for Ready.
-set_min_scale() {
-  kubectl patch ksvc "$KSVC" -n "$NS" --type=merge -p \
-    "{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"autoscaling.knative.dev/min-scale\":\"$1\"}}}}}" >/dev/null
-  wait_ksvc_ready
-}
-
-wait_ksvc_ready() {
-  kubectl wait --for=condition=Ready "ksvc/$KSVC" -n "$NS" --timeout=120s >/dev/null 2>&1 || true
-}
-
-# Force-delete all harness pods (crash simulation).
-force_kill_pod() {
-  kubectl delete pod -n "$NS" -l "$SELECTOR" --force --grace-period=0 >/dev/null 2>&1 || true
-}
-
-# Create the llm-credentials secret from the operator's env if absent. Fails if env unset.
-ensure_secret() {
-  if kubectl get secret llm-credentials -n "$NS" >/dev/null 2>&1; then return 0; fi
-  : "${ANTHROPIC_AUTH_TOKEN:?ANTHROPIC_AUTH_TOKEN must be set to create llm-credentials}"
-  kubectl create secret generic llm-credentials -n "$NS" \
-    --from-literal=api-key="${ANTHROPIC_API_KEY:-${ANTHROPIC_AUTH_TOKEN}}" \
-    --from-literal=auth-token="${ANTHROPIC_AUTH_TOKEN}" \
-    --from-literal=base-url="${ANTHROPIC_BASE_URL:-}" >/dev/null
-}
-
-# Start a kourier port-forward if nothing is listening on $PORT. Echoes the bg pid (or empty).
-ensure_port_forward() {
-  if curl -s -o /dev/null --max-time 2 "$BASE/" 2>/dev/null; then return 0; fi
-  kubectl port-forward -n kourier-system svc/kourier "${PORT}:80" >/dev/null 2>&1 &
-  local pid=$!
-  sleep 3
-  echo "$pid"
-}
-
-# Background pod sampler. start_sampler <outfile> echoes pid; sum with pod_seconds_from.
-start_sampler() {
-  local out="$1"
-  ( while :; do harness_running_pods >> "$out"; sleep "$SAMPLE_INTERVAL"; done ) &
-  echo $!
-}
-stop_sampler() { kill "$1" 2>/dev/null || true; }
-pod_seconds_from() { awk -v iv="$SAMPLE_INTERVAL" '{s+=$1} END{printf "%d", s*iv}' "$1"; }
-```
-
-- [ ] **Step 2: Refactor `smoke.sh` to source `lib.sh`**
-
-Replace the inline `PORT`/`HOST_HEADER`/`BASE`/`PASS`/`FAIL`/`pass`/`fail`/`wait_for_zero_pods` definitions and the duplicated pod-count and curl calls with `lib.sh` helpers. Final `smoke.sh`:
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/smoke.sh
-# Live smoke: proves scale 0→1→0 and session recall across cold starts.
-# Prereq: setup-kind.sh done + port-forward: kubectl port-forward -n kourier-system svc/kourier 8080:80
-# Usage: ./deploy/knative/smoke.sh [--port 8080]
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-for arg in "$@"; do
-  case $arg in
-    --port=*) PORT="${arg#*=}"; BASE="http://localhost:${PORT}" ;;
-  esac
-done
-
-claim() { echo ""; echo "--- Claim $1: $2 ---"; }
-
-claim 1 "Health endpoint responds"
-HEALTH=$(curl -s -o /dev/null -w "%{http_code}" -H "$HOST_HEADER" "$BASE/health")
-[ "$HEALTH" = "200" ] && ok || ko "got HTTP $HEALTH"
-
-claim 2 "POST /turn creates a new session"
-RESP=$(turn "Remember the number 7777. Reply only with OK.")
-SESSION_ID=$(echo "$RESP" | jq -r '.sessionId // empty')
-RESPONSE=$(echo "$RESP" | jq -r '.response // empty')
-if [ -n "$SESSION_ID" ] && echo "$RESPONSE" | grep -qi "ok"; then ok "sessionId=$SESSION_ID"; else ko "sessionId=$SESSION_ID response=$RESPONSE"; fi
-
-claim 3 "Pod scales to zero after idle"
-wait_for_zero_pods 90 && ok || ko "pods did not scale to zero"
-
-claim 4 "Cold-start resume recalls session state from Redis"
-RESP2=$(turn "What number did I ask you to remember? Reply with just the number." "$SESSION_ID")
-RESPONSE2=$(echo "$RESP2" | jq -r '.response // empty')
-SID2=$(echo "$RESP2" | jq -r '.sessionId // empty')
-if [ "$SID2" = "$SESSION_ID" ] && echo "$RESPONSE2" | grep -q "7777"; then ok; else ko "sessionId=$SID2 (expected $SESSION_ID) response=$RESPONSE2"; fi
-
-claim 5 "Pod scaled up from zero for claim 4"
-[ "$(harness_running_pods)" -ge 1 ] && ok || ko "expected >=1 running pod"
-
-claim 6 "404 on unknown session"
-HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" --max-time 30 -H "$HOST_HEADER" -H "Content-Type: application/json" \
-  -d '{"sessionId":"does-not-exist-xyz","prompt":"hello"}' "$BASE/turn")
-[ "$HTTP_CODE" = "404" ] && ok || ko "got HTTP $HTTP_CODE"
-
-echo ""; echo "=== Results: $PASS passed, $FAIL failed ==="
-[ "$FAIL" -gt 0 ] && exit 1 || exit 0
-```
-
-- [ ] **Step 3: Syntax-check both files (no cluster)**
-
-Run: `bash -n deploy/knative/lib.sh && bash -n deploy/knative/smoke.sh && echo "SYNTAX-OK"`
-Expected: `SYNTAX-OK`. If `shellcheck` is installed: `shellcheck deploy/knative/lib.sh deploy/knative/smoke.sh` (source-following warnings about `lib.sh` vars are acceptable).
-
-- [ ] **Step 4: Live regression — smoke still passes**
-
-Ensure the port-forward is up (`kubectl port-forward -n kourier-system svc/kourier 8080:80 &`), then:
-Run: `deploy/knative/smoke.sh > $LOG_DIR/m7t1-smoke.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0`, and the log ends `=== Results: 6 passed, 0 failed ===`. Analyze the log via a subagent if it fails (do not read it inline). If the cluster/secret/port-forward is not ready, this is an environment issue, not a code failure — report it.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add deploy/knative/lib.sh deploy/knative/smoke.sh
-git commit -s -m "refactor(knative): factor smoke.sh helpers into lib.sh
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 2: Set `SH_MODEL` on the ksvc + readiness check
-
-Pin the experiment model on the deployed service and confirm a real gateway turn works through it. Drivers in later tasks assume the deploy is ready.
-
-**Files:**
-- Modify: `deploy/knative/service.yaml`
-
-**Interfaces:**
-- Consumes: `lib.sh` (`ensure_secret`, `turn`, `wait_ksvc_ready`).
-- Produces: a deployed ksvc whose container env includes `SH_MODEL=claude-haiku-4-5`.
-
-- [ ] **Step 1: Add `SH_MODEL` to the ksvc env**
-
-In `deploy/knative/service.yaml`, add to the container `env:` list (after the `REDIS_URL` entry, before `KAGENTI_SANDBOX_POD`):
-
-```yaml
-            - name: SH_MODEL
-              value: "claude-haiku-4-5"
-```
-
-- [ ] **Step 2: Apply and confirm a real turn (live)**
-
-```bash
-export LOG_DIR=/tmp/kagenti/tdd/serverless-harness
-cd /Users/paolo/Projects/aiplatform/serverless-harness/deploy/knative
-source ./lib.sh
-ensure_secret
-kubectl apply -f service.yaml > $LOG_DIR/m7t2-apply.log 2>&1; echo "APPLY EXIT:$?"
-wait_ksvc_ready
-turn "Say exactly: PONG" | jq -r '.response' > $LOG_DIR/m7t2-turn.log 2>&1; echo "TURN EXIT:$?"
-grep -qi "pong" $LOG_DIR/m7t2-turn.log && echo "MODEL-OK" || echo "MODEL-FAIL (see log)"
-```
-Expected: `APPLY EXIT:0`, `MODEL-OK` (haiku answered through the gateway). Confirm the running pod's env via a subagent if needed: `kubectl get pod -n default -l serving.knative.dev/service=serverless-harness -o jsonpath='{.items[0].spec.containers[0].env[*].name}'` includes `SH_MODEL`.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add deploy/knative/service.yaml
-git commit -s -m "feat(knative): pin SH_MODEL=claude-haiku-4-5 on the experiment ksvc
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 3: E1 — scale-to-zero economics
-
-Measure sampled pod-seconds for the same idle-heavy workload at `min-scale=1` (persistent) vs `min-scale=0` (serverless); PASS if serverless ≤ 0.6× persistent (spec §3 D2/D3, §4.2).
-
-**Files:**
-- Create: `deploy/knative/e1-economics.sh`
-
-**Interfaces:**
-- Consumes: `lib.sh` (`set_min_scale`, `start_sampler`/`stop_sampler`/`pod_seconds_from`, `turn`, `wait_for_zero_pods`, `ok`/`ko`).
-- Produces: prints `persistent_pod_seconds`, `serverless_pod_seconds`, `ratio`, and a PASS/FAIL line; exit 0 on PASS.
-
-- [ ] **Step 1: Write `deploy/knative/e1-economics.sh`**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/e1-economics.sh
-# E1: sampled pod-seconds, persistent (min-scale=1) vs serverless (min-scale=0),
-# over an idle-heavy workload. PASS if serverless <= 0.6 * persistent.
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-E1_TURNS="${E1_TURNS:-5}"      # short turns per run
-E1_IDLE="${E1_IDLE:-120}"      # idle gap (s) between turns; >> 30s scale-to-zero retention
-
-run_workload() {               # fires E1_TURNS turns with idle gaps; ignores content
-  local sid=""
-  for i in $(seq 1 "$E1_TURNS"); do
-    local resp; resp=$(turn "ping $i; reply OK" "$sid")
-    sid=$(echo "$resp" | jq -r '.sessionId // empty')
-    [ "$i" -lt "$E1_TURNS" ] && sleep "$E1_IDLE"
-  done
-}
-
-measure() {                    # $1 = min-scale; echoes pod-seconds
-  set_min_scale "$1"
-  local f; f=$(mktemp)
-  local pid; pid=$(start_sampler "$f")
-  run_workload
-  stop_sampler "$pid"
-  pod_seconds_from "$f"
-  rm -f "$f"
-}
-
-echo "--- E1: economics (turns=$E1_TURNS idle=${E1_IDLE}s interval=${SAMPLE_INTERVAL}s) ---"
-PERSISTENT=$(measure 1)
-echo "  persistent_pod_seconds=$PERSISTENT"
-set_min_scale 0; wait_for_zero_pods 90 || true   # reset to serverless, let it settle
-SERVERLESS=$(measure 0)
-echo "  serverless_pod_seconds=$SERVERLESS"
-
-RATIO=$(awk -v s="$SERVERLESS" -v p="$PERSISTENT" 'BEGIN{ printf (p>0 ? "%.2f" : "inf"), (p>0 ? s/p : 0) }')
-echo "  ratio(serverless/persistent)=$RATIO"
-
-if awk -v s="$SERVERLESS" -v p="$PERSISTENT" 'BEGIN{ exit !(p>0 && s <= 0.6*p) }'; then
-  ok "serverless ${SERVERLESS}s <= 0.6 * persistent ${PERSISTENT}s"
-else
-  ko "serverless ${SERVERLESS}s not <= 0.6 * persistent ${PERSISTENT}s (ratio $RATIO)"
-fi
-echo "E1_RESULT persistent=$PERSISTENT serverless=$SERVERLESS ratio=$RATIO pass=$([ "$FAIL" = 0 ] && echo yes || echo no)"
-[ "$FAIL" -gt 0 ] && exit 1 || exit 0
-```
-
-- [ ] **Step 2: Syntax-check (no cluster)**
-
-Run: `bash -n deploy/knative/e1-economics.sh && echo SYNTAX-OK`
-Expected: `SYNTAX-OK`.
-
-- [ ] **Step 3: Live run (uses a short idle to keep the run fast during dev)**
-
-```bash
-export LOG_DIR=/tmp/kagenti/tdd/serverless-harness
-E1_TURNS=3 E1_IDLE=90 deploy/knative/e1-economics.sh > $LOG_DIR/m7t3-e1.log 2>&1; echo "EXIT:$?"
-grep "E1_RESULT" $LOG_DIR/m7t3-e1.log
-```
-Expected: `EXIT:0`; the `E1_RESULT` line shows `serverless` materially below `persistent` (`pass=yes`). Analyze the log via a subagent for the per-run numbers; record them for `EXPERIMENTS.md` (Task 6). If `pass=no` because the idle/retention ratio was too small, note the numbers and raise `E1_IDLE` — the directional result (serverless < persistent) is what matters; tune params, don't weaken the gate.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/e1-economics.sh
-git commit -s -m "feat(knative): E1 scale-to-zero economics (sampled pod-seconds)
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 4: E3 — session mobility
-
-After the session's pod is gone, a fresh instance must answer a follow-up from the Redis log (spec §3 D8, §4.3).
-
-**Files:**
-- Create: `deploy/knative/e3-mobility.sh`
-
-**Interfaces:**
-- Consumes: `lib.sh` (`turn`, `set_min_scale`, `wait_for_zero_pods`, `harness_running_pods`, `ok`/`ko`).
-- Produces: prints PASS/FAIL; exit 0 on PASS.
-
-- [ ] **Step 1: Write `deploy/knative/e3-mobility.sh`**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/e3-mobility.sh
-# E3-mobility: plant a token on instance A, force the pod to zero, then a fresh
-# instance B must answer a follow-up from the Redis log (not in-pod memory).
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-TOKEN="ZEBRA42"
-echo "--- E3: session mobility (token=$TOKEN) ---"
-
-# Turn 1 on instance A: plant the token.
-RESP=$(turn "Remember the code word: ${TOKEN}. Reply only with OK.")
-SID=$(echo "$RESP" | jq -r '.sessionId // empty')
-[ -n "$SID" ] || { ko "no sessionId from first turn: $RESP"; echo "=== $PASS passed, $FAIL failed ==="; exit 1; }
-echo "  sessionId=$SID"
-
-# Force a fresh instance: ensure serverless, scale to zero, assert the pod is gone.
-set_min_scale 0
-if wait_for_zero_pods 120; then echo "  pod scaled to zero (instance A gone)"; else ko "pod did not scale to zero"; fi
-
-# Follow-up on instance B (cold start): must recall the token from the log.
-RESP2=$(turn "What is the code word? Reply with just the word." "$SID")
-SID2=$(echo "$RESP2" | jq -r '.sessionId // empty')
-ANS=$(echo "$RESP2" | jq -r '.response // empty')
-echo "  fresh-pod response: $ANS"
-
-if [ "$SID2" = "$SID" ] && echo "$ANS" | grep -q "$TOKEN"; then
-  ok "fresh instance recalled '$TOKEN' from the Redis log"
-else
-  ko "expected '$TOKEN' from sid=$SID, got sid=$SID2 response=$ANS"
-fi
-echo "=== E3: $PASS passed, $FAIL failed ==="
-[ "$FAIL" -gt 0 ] && exit 1 || exit 0
-```
-
-- [ ] **Step 2: Syntax-check (no cluster)**
-
-Run: `bash -n deploy/knative/e3-mobility.sh && echo SYNTAX-OK`
-Expected: `SYNTAX-OK`.
-
-- [ ] **Step 3: Live run**
-
-```bash
-export LOG_DIR=/tmp/kagenti/tdd/serverless-harness
-deploy/knative/e3-mobility.sh > $LOG_DIR/m7t4-e3.log 2>&1; echo "EXIT:$?"
-tail -3 $LOG_DIR/m7t4-e3.log
-```
-Expected: `EXIT:0`, last line `=== E3: 2 passed, 0 failed ===` (scale-to-zero + token recall). If the model omits the token despite the explicit prompt, tighten the prompt (e.g. append `Do not add any other words.`); the assertion stays a literal `$TOKEN` grep.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/e3-mobility.sh
-git commit -s -m "feat(knative): E3 session mobility (fresh-instance recall from log)
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 5: E4 — crash recovery
-
-Force-kill the pod mid-session; the next turn must recall all completed turns (zero loss) (spec §4.4).
-
-**Files:**
-- Create: `deploy/knative/e4-recovery.sh`
-
-**Interfaces:**
-- Consumes: `lib.sh` (`turn`, `force_kill_pod`, `wait_for_zero_pods`, `ok`/`ko`).
-- Produces: prints PASS/FAIL; exit 0 on PASS.
-
-- [ ] **Step 1: Write `deploy/knative/e4-recovery.sh`**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/e4-recovery.sh
-# E4: complete three turns, force-kill the pod mid-session, then a new turn must
-# recall all three completed turns from the persisted Redis log.
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-echo "--- E4: crash recovery ---"
-FRUITS=(APPLE BANANA CHERRY)
-
-RESP=$(turn "We are listing fruits. Fruit 1 is ${FRUITS[0]}. Reply only with OK.")
-SID=$(echo "$RESP" | jq -r '.sessionId // empty')
-[ -n "$SID" ] || { ko "no sessionId from first turn: $RESP"; echo "=== $PASS passed, $FAIL failed ==="; exit 1; }
-echo "  sessionId=$SID"
-turn "Fruit 2 is ${FRUITS[1]}. Reply only with OK." "$SID" >/dev/null
-turn "Fruit 3 is ${FRUITS[2]}. Reply only with OK." "$SID" >/dev/null
-
-# Crash: force-kill the harness pod mid-session.
-echo "  force-killing harness pod..."
-force_kill_pod
-wait_for_zero_pods 60 || true
-
-# Next turn on a freshly-started pod: must recall all three completed turns.
-RESP2=$(turn "List all the fruits I told you, in order. Reply with just the fruit names." "$SID")
-ANS=$(echo "$RESP2" | jq -r '.response // empty')
-echo "  post-crash response: $ANS"
-
-MISSING=""
-for f in "${FRUITS[@]}"; do echo "$ANS" | grep -q "$f" || MISSING="$MISSING $f"; done
-if [ -z "$MISSING" ]; then
-  ok "all completed turns survived the crash (${FRUITS[*]})"
-else
-  ko "lost turns after crash; missing:$MISSING (response=$ANS)"
-fi
-echo "=== E4: $PASS passed, $FAIL failed ==="
-[ "$FAIL" -gt 0 ] && exit 1 || exit 0
-```
-
-- [ ] **Step 2: Syntax-check (no cluster)**
-
-Run: `bash -n deploy/knative/e4-recovery.sh && echo SYNTAX-OK`
-Expected: `SYNTAX-OK`.
-
-- [ ] **Step 3: Live run**
-
-```bash
-export LOG_DIR=/tmp/kagenti/tdd/serverless-harness
-deploy/knative/e4-recovery.sh > $LOG_DIR/m7t5-e4.log 2>&1; echo "EXIT:$?"
-tail -3 $LOG_DIR/m7t5-e4.log
-```
-Expected: `EXIT:0`, last line `=== E4: 1 passed, 0 failed ===` (all three fruits recalled post-crash). If the model summarizes loosely, tighten the recall prompt; the assertion greps each literal fruit token.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/e4-recovery.sh
-git commit -s -m "feat(knative): E4 crash recovery (zero completed-turn loss)
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 6: Orchestrator + recorded results
-
-Tie setup/harden + the three drivers together and record a real run in `EXPERIMENTS.md` (spec §4.5, §5).
-
-**Files:**
-- Create: `deploy/knative/run-experiments.sh`
-- Create: `deploy/knative/EXPERIMENTS.md` (generated by a real run)
-
-**Interfaces:**
-- Consumes: `lib.sh` (`ensure_secret`, `ensure_port_forward`, `wait_ksvc_ready`, `turn`), and the three driver scripts.
-- Produces: `EXPERIMENTS.md` with E1 numbers + E3/E4 verdicts.
-
-- [ ] **Step 1: Write `deploy/knative/run-experiments.sh`**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/run-experiments.sh
-# Setup/harden + run E1/E3/E4 and record results to EXPERIMENTS.md.
-# Prereq: Kind cluster with the Knative deploy; gateway creds in env.
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-echo "=== M7 setup/harden ==="
-ensure_secret
-kubectl apply -f service.yaml >/dev/null
-wait_ksvc_ready
-PF_PID=$(ensure_port_forward || true)
-trap '[ -n "${PF_PID:-}" ] && kill "$PF_PID" 2>/dev/null || true' EXIT
-# Fail fast if the deploy is unhealthy.
-if ! echo "$(turn 'Say exactly: PONG')" | jq -r '.response' | grep -qi pong; then
-  echo "SETUP-FAIL: deploy did not answer a real turn"; exit 1
-fi
-echo "setup OK"
-
-E1_OUT=$(./e1-economics.sh 2>&1); E1_RC=$?; echo "$E1_OUT"
-E3_OUT=$(./e3-mobility.sh 2>&1); E3_RC=$?; echo "$E3_OUT"
-E4_OUT=$(./e4-recovery.sh 2>&1); E4_RC=$?; echo "$E4_OUT"
-
-E1_LINE=$(echo "$E1_OUT" | grep '^E1_RESULT' || echo "E1_RESULT (missing)")
-verdict() { [ "$1" = 0 ] && echo PASS || echo FAIL; }
-
-cat > EXPERIMENTS.md <<EOF
-# M7 Cluster Experiment Results
-
-Cluster: Kind \`sh-knative\`, ksvc \`serverless-harness\` (ns \`default\`), model \`claude-haiku-4-5\`.
-Spec: docs/specs/2026-06-25-m7-cluster-experiments-design.md
-
-## E1 — scale-to-zero economics
-\`$E1_LINE\`
-Verdict: $(verdict "$E1_RC") (PASS = serverless pod-seconds <= 0.6 x persistent)
-
-## E3 — session mobility
-A fresh instance recalled the planted token from the Redis log after scale-to-zero.
-Verdict: $(verdict "$E3_RC")
-
-## E4 — crash recovery
-After a mid-session pod force-kill, the next turn recalled all completed turns.
-Verdict: $(verdict "$E4_RC")
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
-EOF
-
-echo "=== wrote EXPERIMENTS.md ==="
-[ "$E1_RC" = 0 ] && [ "$E3_RC" = 0 ] && [ "$E4_RC" = 0 ] || { echo "one or more experiments FAILED"; exit 1; }
-```
-
-- [ ] **Step 2: Syntax-check (no cluster)**
-
-Run: `bash -n deploy/knative/run-experiments.sh && echo SYNTAX-OK`
-Expected: `SYNTAX-OK`.
-
-- [ ] **Step 3: Full live run**
-
-```bash
-export LOG_DIR=/tmp/kagenti/tdd/serverless-harness
-deploy/knative/run-experiments.sh > $LOG_DIR/m7t6-all.log 2>&1; echo "EXIT:$?"
-tail -20 $LOG_DIR/m7t6-all.log
-```
-Expected: `EXIT:0`; `EXPERIMENTS.md` written with all three verdicts `PASS`. Analyze the full log via a subagent for the numbers. This is the milestone's live gate.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/run-experiments.sh deploy/knative/EXPERIMENTS.md
-git commit -s -m "feat(knative): M7 experiment orchestrator + recorded results
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Self-Review
-
-**Spec coverage:**
-- §1 done-criteria 1–4 → Task 3 (E1), Task 4 (E3), Task 5 (E4), Task 1 (smoke regression / no pi-fork). ✓
-- §3 D1 bash/`deploy/knative/` → all tasks. D2/D3 E1 sampled pod-seconds + 0.6× gate → Task 3. D4 one milestone/shared lib → Task 1 + Task 6. D5 `SH_MODEL=claude-haiku-4-5` → Task 2 (+ Global Constraints). D6 names `default`/`serverless-harness` → `lib.sh` (Task 1) + Global Constraints. D7 secret from env → `ensure_secret` (Task 1/2/6). D8 conversational recall → Tasks 4–5. ✓
-- §4.1 setup/harden → Task 2 + Task 6 preamble. §4.2 E1 → Task 3. §4.3 E3 → Task 4. §4.4 E4 → Task 5. §4.5 EXPERIMENTS.md → Task 6. ✓
-- §5 verification gate → live-run steps in each task + `smoke.sh` regression (Task 1 Step 4). ✓
-- §7 risks: generous curl timeouts (`turn` uses `--max-time 120`); `wait_*` use timeouts; smoke is the regression anchor; E1 params tunable (`E1_IDLE`/`E1_TURNS`). The `session_shutdown` dead-handler is **out of scope** per the spec — intentionally no task. ✓
-
-**Placeholder scan:** No TBD/TODO; every script is complete bash; every step has an exact command + expected output. Live steps are explicitly gated on the cluster + secret (environment, not code).
-
-**Type/name consistency:** `lib.sh` helper names (`harness_running_pods`, `wait_for_zero_pods`, `turn`, `set_min_scale`, `wait_ksvc_ready`, `force_kill_pod`, `ensure_secret`, `ensure_port_forward`, `start_sampler`/`stop_sampler`/`pod_seconds_from`, `ok`/`ko`) are defined in Task 1 and used with the same names/arity in Tasks 3–6. Selector `serving.knative.dev/service=serverless-harness`, ns `default`, `SH_MODEL=claude-haiku-4-5`, and the `/turn` JSON shape (`{prompt}` / `{sessionId,prompt}` → `.sessionId`/`.response`) are consistent across `smoke.sh` and all drivers. E1 emits the `E1_RESULT` line that Task 6 greps.
diff --git a/docs/superpowers/plans/2026-06-26-mvp-leaf-session-contract.md b/docs/superpowers/plans/2026-06-26-mvp-leaf-session-contract.md
deleted file mode 100644
index 61118c9..0000000
--- a/docs/superpowers/plans/2026-06-26-mvp-leaf-session-contract.md
+++ /dev/null
@@ -1,793 +0,0 @@
-# MVP Leaf-Session Invocation Contract — Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Make the harness a leaf-session backend an external orchestrator can call: a `/runs` endpoint that runs a Pi agent to completion in a sandbox, captures a schema-validated verdict via a `submit_verdict` tool, and delivers it through a shared-volume envelope.
-
-**Architecture:** A new `runLeaf` function (sibling to `runTurn`) reads a candidate from `inputs_ref` on a shared volume, seeds a Pi session whose only required output is a `submit_verdict` tool call, runs it to completion, validates the captured verdict, and writes it to `result_ref`. The Knative server exposes this as `POST /runs`. A minimal bash orchestrator (stand-in for the external orchestrator) fans out N calls, retries failures, and audits coverage. Reuses M2/M3 sandbox, M4 Knative + `runTurn` internals, M6 model selection.
-
-**Tech Stack:** TypeScript (ESM, `tsx` runtime, `noEmit`), pnpm workspaces, Pi (`@earendil-works/pi-coding-agent`, `@earendil-works/pi-ai`), TypeBox tool schemas, vitest, raw Node `http`, Knative + a shared PVC on Kind.
-
-## Global Constraints
-
-- **No new spec scope.** Single-tenant, **provider key in env** (no Z3 injector). No per-user identity (Z1), no credentialed egress (Z5), no human-gate, no trigger. (charter)
-- **Re-entrancy-friendly (do not preclude):** `/runs` must NOT assume only an external orchestrator calls it — a leaf session may later call it to spawn a child. Do not bake a caller-identity check. (MVP spec §2.5)
-- **Harness does not own the domain store:** the verdict travels via `result_ref` on a volume the caller owns; the HTTP response carries **terminal status only**. (MVP spec §2.1, charter G3)
-- **The harness (trusted code) writes `result_ref`,** after schema validation — never model-authored code; the workspace mount is **read-only** to the agent. (MVP spec §2.3)
-- **Verdict schema:** `{ item_id: string, verdict: "FLAGGED" | "CLEAR", reason: string }`. (MVP spec §2.3)
-- **Idempotency key = `session_id`;** retry = re-invoke; `result_ref` rewritten fresh each run. (MVP spec §2.4)
-- **DCO:** every commit uses `git commit -s`; no `Co-Authored-By`. Conventional-commit prefixes.
-- Tests are vitest under each package's `test/**/*.test.ts`; run with `pnpm -C harness exec vitest run test/<file>`.
-
----
-
-## File Structure
-
-- `harness/src/verdict.ts` — verdict type + dependency-free `validateVerdict()`.
-- `harness/src/submit-verdict-tool.ts` — `submitVerdictExtension(capture)`: registers the `submit_verdict` Pi tool (TypeBox params), validates, captures.
-- `harness/src/run-leaf.ts` — `runLeaf()` (envelope I/O + status), `buildLeafPrompt()`, `realProduceVerdict()` (the Pi session runner, injectable).
-- `harness/test/verdict.test.ts`, `harness/test/submit-verdict-tool.test.ts`, `harness/test/run-leaf.test.ts` — unit tests.
-- `packages/knative-server/src/server.ts` — add `POST /run-leaf` route (modify).
-- `packages/knative-server/test/run-leaf-route.test.ts` — route test (vi.mock runLeaf).
-- `deploy/knative/fixtures/repo/` + `deploy/knative/fixtures/inputs/` — tiny fixture repo + sample candidates.
-- `deploy/knative/leaf-pvc.yaml`, `deploy/knative/leaf-orchestrator.yaml` — shared PVC + in-cluster orchestrator pod.
-- `deploy/knative/leaf-smoke.sh` — gated Kind smoke (parallel + retry + coverage + scale-to-zero).
-
----
-
-### Task 1: Verdict schema + validation
-
-**Files:**
-- Create: `harness/src/verdict.ts`
-- Test: `harness/test/verdict.test.ts`
-
-**Interfaces:**
-- Produces:
-  - `type Verdict = { item_id: string; verdict: "FLAGGED" | "CLEAR"; reason: string }`
-  - `function validateVerdict(obj: unknown): { ok: true; value: Verdict } | { ok: false; error: string }`
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/verdict.test.ts
-import { describe, it, expect } from "vitest";
-import { validateVerdict } from "../src/verdict";
-
-describe("validateVerdict", () => {
-  it("accepts a well-formed verdict", () => {
-    const r = validateVerdict({ item_id: "i1", verdict: "FLAGGED", reason: "calls eval on input" });
-    expect(r).toEqual({ ok: true, value: { item_id: "i1", verdict: "FLAGGED", reason: "calls eval on input" } });
-  });
-
-  it("rejects an unknown verdict label", () => {
-    const r = validateVerdict({ item_id: "i1", verdict: "MAYBE", reason: "x" });
-    expect(r.ok).toBe(false);
-  });
-
-  it("rejects missing fields", () => {
-    expect(validateVerdict({ item_id: "i1", verdict: "CLEAR" }).ok).toBe(false);
-    expect(validateVerdict({ verdict: "CLEAR", reason: "x" }).ok).toBe(false);
-  });
-
-  it("rejects non-object input", () => {
-    expect(validateVerdict(null).ok).toBe(false);
-    expect(validateVerdict("nope").ok).toBe(false);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run test/verdict.test.ts`
-Expected: FAIL — cannot find module `../src/verdict`.
-
-- [ ] **Step 3: Write minimal implementation**
-
-```typescript
-// harness/src/verdict.ts
-export type VerdictLabel = "FLAGGED" | "CLEAR";
-
-export interface Verdict {
-  item_id: string;
-  verdict: VerdictLabel;
-  reason: string;
-}
-
-export function validateVerdict(
-  obj: unknown,
-): { ok: true; value: Verdict } | { ok: false; error: string } {
-  if (typeof obj !== "object" || obj === null) {
-    return { ok: false, error: "verdict must be an object" };
-  }
-  const o = obj as Record<string, unknown>;
-  if (typeof o.item_id !== "string" || o.item_id.length === 0) {
-    return { ok: false, error: "item_id must be a non-empty string" };
-  }
-  if (o.verdict !== "FLAGGED" && o.verdict !== "CLEAR") {
-    return { ok: false, error: 'verdict must be "FLAGGED" or "CLEAR"' };
-  }
-  if (typeof o.reason !== "string") {
-    return { ok: false, error: "reason must be a string" };
-  }
-  return { ok: true, value: { item_id: o.item_id, verdict: o.verdict, reason: o.reason } };
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run test/verdict.test.ts`
-Expected: PASS (4 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/verdict.ts harness/test/verdict.test.ts
-git commit -s -m "feat(harness): verdict schema + validateVerdict"
-```
-
----
-
-### Task 2: `submit_verdict` tool + capture extension
-
-**Files:**
-- Create: `harness/src/submit-verdict-tool.ts`
-- Test: `harness/test/submit-verdict-tool.test.ts`
-
-**Interfaces:**
-- Consumes: `Verdict`, `validateVerdict` (Task 1).
-- Produces:
-  - `interface VerdictCapture { verdict?: Verdict }`
-  - `function submitVerdictExtension(capture: VerdictCapture): ExtensionFactory` — registers a tool named `submit_verdict`.
-- Mirror the TypeBox `Type` import and `registerTool`/`ToolDefinition` shape from an existing tool — see `packages/k8s-sandbox/src/*` tool creators and `pi-fork/packages/coding-agent/src/core/tools/read.ts` (`Type.Object({...})`). `ExtensionFactory` and `ExtensionAPI` come from `@earendil-works/pi-coding-agent`.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/submit-verdict-tool.test.ts
-import { describe, it, expect } from "vitest";
-import { submitVerdictExtension, type VerdictCapture } from "../src/submit-verdict-tool";
-
-// Minimal fake ExtensionAPI that records the registered tool.
-function fakePi() {
-  const tools: any[] = [];
-  return { api: { registerTool: (t: any) => tools.push(t), on: () => {} } as any, tools };
-}
-
-describe("submitVerdictExtension", () => {
-  it("registers a submit_verdict tool", () => {
-    const capture: VerdictCapture = {};
-    const { api, tools } = fakePi();
-    submitVerdictExtension(capture)(api);
-    expect(tools).toHaveLength(1);
-    expect(tools[0].name).toBe("submit_verdict");
-  });
-
-  it("captures a valid verdict and returns success", async () => {
-    const capture: VerdictCapture = {};
-    const { api, tools } = fakePi();
-    submitVerdictExtension(capture)(api);
-    const res = await tools[0].execute("call-1", { item_id: "i1", verdict: "FLAGGED", reason: "r" }, undefined, undefined, {} as any);
-    expect(capture.verdict).toEqual({ item_id: "i1", verdict: "FLAGGED", reason: "r" });
-    expect(res.isError).toBeFalsy();
-  });
-
-  it("rejects an invalid verdict and does not capture", async () => {
-    const capture: VerdictCapture = {};
-    const { api, tools } = fakePi();
-    submitVerdictExtension(capture)(api);
-    const res = await tools[0].execute("call-1", { item_id: "i1", verdict: "MAYBE", reason: "r" }, undefined, undefined, {} as any);
-    expect(capture.verdict).toBeUndefined();
-    expect(res.isError).toBe(true);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run test/submit-verdict-tool.test.ts`
-Expected: FAIL — cannot find module `../src/submit-verdict-tool`.
-
-- [ ] **Step 3: Write minimal implementation**
-
-```typescript
-// harness/src/submit-verdict-tool.ts
-import { Type } from "@sinclair/typebox";
-import type { ExtensionAPI, ExtensionFactory } from "@earendil-works/pi-coding-agent";
-import { validateVerdict, type Verdict } from "./verdict";
-
-export interface VerdictCapture {
-  verdict?: Verdict;
-}
-
-const params = Type.Object({
-  item_id: Type.String({ description: "The id of the item being judged (echo the input item_id)" }),
-  verdict: Type.Union([Type.Literal("FLAGGED"), Type.Literal("CLEAR")], {
-    description: "FLAGGED if the pattern is present and relevant; CLEAR otherwise",
-  }),
-  reason: Type.String({ description: "One sentence justifying the verdict" }),
-});
-
-export function submitVerdictExtension(capture: VerdictCapture): ExtensionFactory {
-  return (pi: ExtensionAPI) => {
-    pi.registerTool({
-      name: "submit_verdict",
-      label: "Submit verdict",
-      description:
-        "Submit your final verdict for the item. Call this exactly once when you are done. " +
-        "After calling it, stop.",
-      parameters: params,
-      async execute(_id, args) {
-        const r = validateVerdict(args);
-        if (!r.ok) {
-          return { isError: true, content: [{ type: "text", text: `Invalid verdict: ${r.error}` }] };
-        }
-        capture.verdict = r.value;
-        return { content: [{ type: "text", text: "Verdict recorded." }] };
-      },
-    } as any);
-  };
-}
-```
-
-> If the build complains that `Type` is not exported from `@sinclair/typebox`, import it from the
-> same module the existing Pi tools use (check the import line at the top of
-> `pi-fork/packages/coding-agent/src/core/tools/read.ts`) and match that.
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run test/submit-verdict-tool.test.ts`
-Expected: PASS (3 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/submit-verdict-tool.ts harness/test/submit-verdict-tool.test.ts
-git commit -s -m "feat(harness): submit_verdict tool + capture extension"
-```
-
----
-
-### Task 3: `runLeaf` — envelope I/O, prompt, status (model boundary injected)
-
-**Files:**
-- Create: `harness/src/run-leaf.ts`
-- Test: `harness/test/run-leaf.test.ts`
-
-**Interfaces:**
-- Consumes: `Verdict`, `validateVerdict` (Task 1); `submitVerdictExtension`, `VerdictCapture` (Task 2); `TurnConfig` (`harness/src/run-turn.ts:17`).
-- Produces:
-  - `interface LeafItem { item_id: string; file: string; pattern: string }`
-  - `interface LeafEnvelope { sessionId: string; model?: string; provider?: string; inputsRef: string; resultRef: string; workspaceRef?: string; maxTurns?: number }`
-  - `type LeafResult = { status: "done"; resultRef: string } | { status: "failed"; reason: "no_verdict" | "invalid_verdict" | "bad_inputs" | "error"; message?: string }`
-  - `function buildLeafPrompt(item: LeafItem, workspaceRef?: string): string`
-  - `type ProduceVerdict = (item: LeafItem, env: LeafEnvelope, config: TurnConfig | undefined, capture: VerdictCapture) => Promise<void>`
-  - `function runLeaf(env: LeafEnvelope, config?: TurnConfig, deps?: { produceVerdict?: ProduceVerdict }): Promise<LeafResult>`
-  - `const realProduceVerdict: ProduceVerdict` (wires Pi; exercised in Task 6, not unit-tested here)
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/run-leaf.test.ts
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, readFileSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { runLeaf, buildLeafPrompt, type LeafEnvelope } from "../src/run-leaf";
-
-let dir: string;
-beforeEach(() => { dir = mkdtempSync(join(tmpdir(), "leaf-")); });
-afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
-
-function envelope(): LeafEnvelope {
-  const inputsRef = join(dir, "in.json");
-  const resultRef = join(dir, "out.json");
-  writeFileSync(inputsRef, JSON.stringify({ item_id: "i1", file: "a.py", pattern: "eval(" }));
-  return { sessionId: "run/i1", inputsRef, resultRef };
-}
-
-describe("buildLeafPrompt", () => {
-  it("includes the file, pattern, and submit_verdict instruction", () => {
-    const p = buildLeafPrompt({ item_id: "i1", file: "a.py", pattern: "eval(" });
-    expect(p).toContain("a.py");
-    expect(p).toContain("eval(");
-    expect(p).toContain("submit_verdict");
-  });
-});
-
-describe("runLeaf", () => {
-  it("writes the validated verdict to result_ref and returns done", async () => {
-    const env = envelope();
-    const produceVerdict = async (_i, _e, _c, capture) => {
-      capture.verdict = { item_id: "i1", verdict: "FLAGGED", reason: "found eval" };
-    };
-    const res = await runLeaf(env, undefined, { produceVerdict });
-    expect(res).toEqual({ status: "done", resultRef: env.resultRef });
-    expect(JSON.parse(readFileSync(env.resultRef, "utf8"))).toEqual({
-      item_id: "i1", verdict: "FLAGGED", reason: "found eval",
-    });
-  });
-
-  it("returns failed:no_verdict and writes nothing when the agent submits none", async () => {
-    const env = envelope();
-    const produceVerdict = async () => { /* never captures */ };
-    const res = await runLeaf(env, undefined, { produceVerdict });
-    expect(res).toEqual({ status: "failed", reason: "no_verdict" });
-    expect(existsSync(env.resultRef)).toBe(false);
-  });
-
-  it("returns failed:bad_inputs when inputs_ref is missing/invalid", async () => {
-    const env = { ...envelope(), inputsRef: join(dir, "nope.json") };
-    const res = await runLeaf(env, undefined, { produceVerdict: async () => {} });
-    expect(res.status).toBe("failed");
-    if (res.status === "failed") expect(res.reason).toBe("bad_inputs");
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run test/run-leaf.test.ts`
-Expected: FAIL — cannot find module `../src/run-leaf`.
-
-- [ ] **Step 3: Write minimal implementation**
-
-```typescript
-// harness/src/run-leaf.ts
-import { readFileSync, writeFileSync } from "node:fs";
-import {
-  createAgentSession,
-  SessionManager,
-  type AssistantMessage,
-} from "@earendil-works/pi-coding-agent";
-import { getModel } from "@earendil-works/pi-ai";
-import { resolveModelSelection, requireModel, type TurnConfig } from "./run-turn";
-import { submitVerdictExtension, type VerdictCapture } from "./submit-verdict-tool";
-import { validateVerdict } from "./verdict";
-
-export interface LeafItem { item_id: string; file: string; pattern: string }
-
-export interface LeafEnvelope {
-  sessionId: string;
-  model?: string;
-  provider?: string;
-  inputsRef: string;
-  resultRef: string;
-  workspaceRef?: string;
-  maxTurns?: number;
-}
-
-export type LeafResult =
-  | { status: "done"; resultRef: string }
-  | { status: "failed"; reason: "no_verdict" | "invalid_verdict" | "bad_inputs" | "error"; message?: string };
-
-export function buildLeafPrompt(item: LeafItem, workspaceRef?: string): string {
-  const root = workspaceRef ?? ".";
-  return [
-    `You are reviewing one candidate finding in the repository at ${root}.`,
-    `Item id: ${item.item_id}`,
-    `File: ${item.file}`,
-    `Pattern of interest: ${item.pattern}`,
-    `Open the file, decide whether the pattern is present and relevant, then report by calling`,
-    `the submit_verdict tool exactly once with item_id="${item.item_id}". Do not do anything else.`,
-  ].join("\n");
-}
-
-export type ProduceVerdict = (
-  item: LeafItem,
-  env: LeafEnvelope,
-  config: TurnConfig | undefined,
-  capture: VerdictCapture,
-) => Promise<void>;
-
-function readItem(inputsRef: string): LeafItem | null {
-  try {
-    const o = JSON.parse(readFileSync(inputsRef, "utf8"));
-    if (o && typeof o.item_id === "string" && typeof o.file === "string" && typeof o.pattern === "string") {
-      return { item_id: o.item_id, file: o.file, pattern: o.pattern };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-export async function runLeaf(
-  env: LeafEnvelope,
-  config?: TurnConfig,
-  deps?: { produceVerdict?: ProduceVerdict },
-): Promise<LeafResult> {
-  const item = readItem(env.inputsRef);
-  if (!item) return { status: "failed", reason: "bad_inputs" };
-
-  const capture: VerdictCapture = {};
-  const produce = deps?.produceVerdict ?? realProduceVerdict;
-  try {
-    await produce(item, env, config, capture);
-  } catch (err) {
-    return { status: "failed", reason: "error", message: err instanceof Error ? err.message : String(err) };
-  }
-
-  if (!capture.verdict) return { status: "failed", reason: "no_verdict" };
-  const v = validateVerdict(capture.verdict);
-  if (!v.ok) return { status: "failed", reason: "invalid_verdict", message: v.error };
-
-  writeFileSync(env.resultRef, JSON.stringify(v.value));
-  return { status: "done", resultRef: env.resultRef };
-}
-
-// Real Pi session runner — mirrors harness/src/run-turn.ts session setup.
-// Exercised by the Kind smoke (Task 6), not the unit tests.
-export const realProduceVerdict: ProduceVerdict = async (item, env, config, capture) => {
-  const { provider, modelId } = resolveModelSelection({
-    model: env.model ?? config?.model,
-    provider: env.provider ?? config?.provider,
-  });
-  requireModel(provider, modelId);
-  const model = getModel(provider as never, modelId as never);
-
-  const sessionManager = SessionManager.create(
-    env.workspaceRef ?? config?.cwd ?? process.cwd(),
-    undefined as never,
-  );
-  const { session } = await createAgentSession({
-    sessionManager,
-    model: model as never,
-  });
-  // Register the verdict tool by extending the session's extension set the same way
-  // run-turn.ts wires extensions; here we add submitVerdictExtension(capture).
-  // (See run-turn.ts:83-103 for the extensionFactories pattern to mirror.)
-  await (session as any).addExtension?.(submitVerdictExtension(capture));
-  await session.prompt(buildLeafPrompt(item, env.workspaceRef));
-  void (session.state.messages.at(-1) as AssistantMessage | undefined);
-};
-```
-
-> **Note for the implementer:** `realProduceVerdict` must register `submitVerdictExtension(capture)`
-> on the session **before** `session.prompt(...)`. The exact wiring mirrors the `extensionFactories`
-> array in `harness/src/run-turn.ts:83-103` (pass it into `createAgentSession` via the same
-> mechanism `run-turn.ts` uses for `k8sSandboxExtension()` and `flushExtension`). If
-> `createAgentSession` takes extensions as an option, pass `[submitVerdictExtension(capture),
-> k8sSandboxExtension()]` there instead of the `addExtension` shim above. Confirm against the
-> `CreateAgentSessionOptions` type in `pi-fork/packages/coding-agent/src/core/sdk.ts:166`. This part
-> is verified live in Task 6, not by unit tests.
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run test/run-leaf.test.ts`
-Expected: PASS (buildLeafPrompt + 3 runLeaf tests). The unit tests inject `produceVerdict`, so the live Pi path is not exercised here.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/run-leaf.ts harness/test/run-leaf.test.ts
-git commit -s -m "feat(harness): runLeaf envelope I/O + verdict status (model boundary injected)"
-```
-
----
-
-### Task 4: `POST /run-leaf` route on the Knative server
-
-**Files:**
-- Modify: `packages/knative-server/src/server.ts` (add a handler + route; mirror `handleTurn` at `:1-90`)
-- Test: `packages/knative-server/test/run-leaf-route.test.ts`
-
-**Interfaces:**
-- Consumes: `runLeaf`, `LeafEnvelope`, `LeafResult` from `@sh/harness/run-leaf`.
-- Produces: `POST /run-leaf` → `200 { status, ... }` on a handled invocation (done OR failed), `400 { error: "envelope_invalid" }` on a malformed body.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// packages/knative-server/test/run-leaf-route.test.ts
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-const runLeaf = vi.fn();
-vi.mock("@sh/harness/run-leaf", () => ({ runLeaf: (...a: any[]) => runLeaf(...a) }));
-
-import { startServer } from "../src/server";
-
-let base: string; let server: any;
-beforeEach(() => { runLeaf.mockReset(); });
-
-async function post(path: string, body: unknown) {
-  const res = await fetch(base + path, {
-    method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body),
-  });
-  return { status: res.status, json: await res.json().catch(() => ({})) };
-}
-
-describe("POST /run-leaf", () => {
-  beforeEach(() => { server = startServer(0); base = `http://127.0.0.1:${server.address().port}`; });
-
-  it("400s on a malformed envelope (missing inputsRef)", async () => {
-    const r = await post("/run-leaf", { sessionId: "s", resultRef: "/x" });
-    expect(r.status).toBe(400);
-    server.close();
-  });
-
-  it("returns runLeaf's terminal status on a valid envelope", async () => {
-    runLeaf.mockResolvedValue({ status: "done", resultRef: "/work/out.json" });
-    const r = await post("/run-leaf", { sessionId: "s", inputsRef: "/in", resultRef: "/out" });
-    expect(r.status).toBe(200);
-    expect(r.json).toEqual({ status: "done", resultRef: "/work/out.json" });
-    expect(runLeaf).toHaveBeenCalledOnce();
-    server.close();
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C packages/knative-server exec vitest run test/run-leaf-route.test.ts`
-Expected: FAIL — no `/run-leaf` route (404) and/or `startServer` not accepting port 0 return value.
-
-- [ ] **Step 3: Write minimal implementation**
-
-In `packages/knative-server/src/server.ts`, add the import and a handler, and route `POST /run-leaf`. Mirror `handleTurn`:
-
-```typescript
-import { runLeaf, type LeafEnvelope } from "@sh/harness/run-leaf";
-
-function isEnvelope(o: any): o is LeafEnvelope {
-  return o && typeof o.sessionId === "string" && typeof o.inputsRef === "string" && typeof o.resultRef === "string";
-}
-
-async function handleRunLeaf(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const body = JSON.parse(await readBody(req));
-  if (!isEnvelope(body)) {
-    res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "envelope_invalid" }));
-    return;
-  }
-  const result = await runLeaf(body, buildConfig());
-  res.writeHead(200, JSON_HEADERS).end(JSON.stringify(result));
-}
-```
-
-In the request router (where `POST /turn` is dispatched), add:
-
-```typescript
-if (req.method === "POST" && url === "/run-leaf") return handleRunLeaf(req, res);
-```
-
-Ensure `startServer(port)` returns the `server` object (so tests can read `.address().port` and `.close()`); if it currently returns `void`, change it to `return server;`.
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C packages/knative-server exec vitest run test/run-leaf-route.test.ts`
-Expected: PASS (2 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add packages/knative-server/src/server.ts packages/knative-server/test/run-leaf-route.test.ts
-git commit -s -m "feat(knative-server): POST /run-leaf route"
-```
-
----
-
-### Task 5: Fixture repo + sample candidates
-
-**Files:**
-- Create: `deploy/knative/fixtures/repo/safe.py`
-- Create: `deploy/knative/fixtures/repo/risky.py`
-- Create: `deploy/knative/fixtures/inputs/i1.json`, `.../i2.json`, `.../i3.json`
-- Test: `harness/test/fixtures.test.ts` (sanity: inputs reference existing files + parse)
-
-**Interfaces:**
-- Produces: a small workspace + N candidate JSONs in the envelope's `{item_id, file, pattern}` shape.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/fixtures.test.ts
-import { describe, it, expect } from "vitest";
-import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-
-const root = join(__dirname, "../../deploy/knative/fixtures");
-
-describe("fixtures", () => {
-  for (const id of ["i1", "i2", "i3"]) {
-    it(`${id}.json references an existing fixture file`, () => {
-      const item = JSON.parse(readFileSync(join(root, "inputs", `${id}.json`), "utf8"));
-      expect(typeof item.item_id).toBe("string");
-      expect(typeof item.pattern).toBe("string");
-      expect(existsSync(join(root, "repo", item.file))).toBe(true);
-    });
-  }
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run test/fixtures.test.ts`
-Expected: FAIL — fixture files do not exist.
-
-- [ ] **Step 3: Create the fixtures**
-
-```python
-# deploy/knative/fixtures/repo/safe.py
-def handler(request):
-    name = request.args.get("name", "world")
-    return "hello " + name
-```
-
-```python
-# deploy/knative/fixtures/repo/risky.py
-def run(request):
-    cmd = request.args.get("cmd")
-    return eval(cmd)  # pattern of interest: eval(
-```
-
-```json
-// deploy/knative/fixtures/inputs/i1.json
-{ "item_id": "i1", "file": "risky.py", "pattern": "eval(" }
-```
-```json
-// deploy/knative/fixtures/inputs/i2.json
-{ "item_id": "i2", "file": "safe.py", "pattern": "eval(" }
-```
-```json
-// deploy/knative/fixtures/inputs/i3.json
-{ "item_id": "i3", "file": "risky.py", "pattern": "subprocess" }
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run test/fixtures.test.ts`
-Expected: PASS (3 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add deploy/knative/fixtures harness/test/fixtures.test.ts
-git commit -s -m "test(harness): fixture repo + sample candidate inputs"
-```
-
----
-
-### Task 6: Kind smoke — parallel fan-out, retry, coverage audit, scale-to-zero (gated)
-
-**Files:**
-- Create: `deploy/knative/leaf-pvc.yaml` — a `ReadWriteMany`/`ReadWriteOnce` PVC `leaf-work`.
-- Create: `deploy/knative/leaf-orchestrator.yaml` — a Pod (`alpine` + curl + jq + kubectl optional) mounting `leaf-work` at `/work`.
-- Modify: `deploy/knative/service.yaml` — mount `leaf-work` PVC at `/work` (so leaf sessions read/write the same volume) and keep `KAGENTI_SANDBOX_POD` as today.
-- Create: `deploy/knative/leaf-smoke.sh` — gated driver (`LEAF_LIVE_SMOKE=1`), mirrors `smoke.sh`/`lib.sh` style.
-
-**Interfaces:**
-- Consumes: `POST /run-leaf` (Task 4), fixtures (Task 5), the shared `leaf-work` PVC.
-- Produces: a pass/fail smoke proving the §7 verification gate (MVP spec): parallel N, retry, coverage, scale-to-zero.
-
-- [ ] **Step 1: Write the gate as an executable smoke script (the "test")**
-
-```bash
-# deploy/knative/leaf-smoke.sh
-#!/usr/bin/env bash
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh   # provides BASE, HOST_HEADER, NS, ok/ko, wait_for_zero_pods
-
-[ "${LEAF_LIVE_SMOKE:-0}" = "1" ] || { echo "SKIP (set LEAF_LIVE_SMOKE=1)"; exit 0; }
-
-RUN="run-$$"
-# 1) seed inputs + fixture repo onto the shared volume via the orchestrator pod
-kubectl -n "$NS" cp ./fixtures "leaf-orchestrator:/work/$RUN-fixtures"
-ITEMS="i1 i2 i3"
-
-dispatch() {  # item_id -> POST /run-leaf, return terminal status JSON
-  local id="$1" model="${2:-claude-haiku-4-5}"
-  local body
-  body=$(jq -nc --arg s "$RUN/$id" --arg m "$model" \
-    --arg in "/work/$RUN-fixtures/inputs/$id.json" \
-    --arg out "/work/$RUN/results/$id.json" \
-    --arg ws "/work/$RUN-fixtures/repo" \
-    '{sessionId:$s, model:$m, inputsRef:$in, resultRef:$out, workspaceRef:$ws}')
-  curl -s --max-time 240 -H "$HOST_HEADER" -H "Content-Type: application/json" -d "$body" "$BASE/run-leaf"
-}
-
-kubectl -n "$NS" exec leaf-orchestrator -- mkdir -p "/work/$RUN/results"
-
-# 2) parallel fan-out
-for id in $ITEMS; do dispatch "$id" & done; wait
-
-# 3) coverage audit (read result files from the shared volume via the orchestrator pod)
-missing=""
-for id in $ITEMS; do
-  kubectl -n "$NS" exec leaf-orchestrator -- test -f "/work/$RUN/results/$id.json" || missing="$missing $id"
-done
-
-# 4) retry any missing once (idempotent re-invoke)
-for id in $missing; do dispatch "$id"; done
-for id in $ITEMS; do
-  kubectl -n "$NS" exec leaf-orchestrator -- sh -c "jq -e '.verdict' /work/$RUN/results/$id.json >/dev/null" \
-    && ok "$id verdict present" || ko "$id missing verdict"
-done
-
-# 5) per-call model routed: i1 with a different model still succeeds
-dispatch "i1" "claude-haiku-4-5" >/dev/null && ok "model-param accepted" || ko "model-param"
-
-# 6) scale-to-zero after idle
-wait_for_zero_pods 120 && ok "scaled to zero" || ko "did not scale to zero"
-echo "LEAF SMOKE PASS"
-```
-
-- [ ] **Step 2: Add the PVC + orchestrator manifests and mount the PVC into the service**
-
-```yaml
-# deploy/knative/leaf-pvc.yaml
-apiVersion: v1
-kind: PersistentVolumeClaim
-metadata: { name: leaf-work, namespace: default }
-spec:
-  accessModes: ["ReadWriteOnce"]
-  resources: { requests: { storage: 1Gi } }
-```
-
-```yaml
-# deploy/knative/leaf-orchestrator.yaml
-apiVersion: v1
-kind: Pod
-metadata: { name: leaf-orchestrator, namespace: default }
-spec:
-  containers:
-    - name: tools
-      image: alpine:3.20
-      command: ["sh", "-c", "apk add --no-cache curl jq && sleep 100000"]
-      volumeMounts: [{ name: work, mountPath: /work }]
-  volumes:
-    - name: work
-      persistentVolumeClaim: { claimName: leaf-work }
-```
-
-In `deploy/knative/service.yaml`, under the container, add the volume + mount (Knative supports PVC volumes when the `kubernetes.podspec-persistent-volume-claim` feature flag is enabled in `config-features`):
-
-```yaml
-          volumeMounts:
-            - name: work
-              mountPath: /work
-      volumes:
-        - name: work
-          persistentVolumeClaim: { claimName: leaf-work }
-```
-
-- [ ] **Step 3: Deploy and run the gated smoke on Kind**
-
-Run (redirect verbose output per repo context-budget rules):
-
-```bash
-kubectl apply -f deploy/knative/leaf-pvc.yaml -f deploy/knative/leaf-orchestrator.yaml > /tmp/leaf-deploy.log 2>&1; echo "EXIT:$?"
-# (re)deploy the harness service with the PVC mount + build/push image per existing kind-full-test flow
-LEAF_LIVE_SMOKE=1 bash deploy/knative/leaf-smoke.sh > /tmp/leaf-smoke.log 2>&1; echo "EXIT:$?"
-```
-
-Expected: `/tmp/leaf-smoke.log` ends with `LEAF SMOKE PASS`; all `ok` lines present; final line confirms scale-to-zero. (Analyze the log in a subagent if it fails — do not read it whole in the main context.)
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/leaf-pvc.yaml deploy/knative/leaf-orchestrator.yaml deploy/knative/leaf-smoke.sh deploy/knative/service.yaml
-git commit -s -m "test(knative): gated kind smoke — parallel leaf fan-out, retry, coverage, scale-to-zero"
-```
-
----
-
-## Self-Review
-
-**Spec coverage (MVP spec §2/§4/§7):**
-- §2.1 invocation envelope → Task 4 (`/run-leaf`, terminal status) + Task 3 (`LeafEnvelope`). ✓
-- §2.2 run-to-completion → Task 3 `realProduceVerdict` (`session.prompt`) ; proven Task 6. ✓
-- §2.3 structured output + harness writes result → Tasks 1, 2, 3. ✓
-- §2.4 idempotency → Task 3 (re-invoke rewrites `result_ref`); exercised Task 6 retry. ✓
-- §2.5 re-entrancy (no caller-identity assumption) → Global Constraints + Task 4 (no caller check). ✓
-- §4 components 1–9 → Tasks 1–6 (contract, job mode, tool+validation, driver, fixture; reuse M2–M6). ✓
-- §5 volume layout → Task 6 (`/work/<run>/{inputs,results,repo}`). ✓
-- §6 failure modes → Task 3 (no_verdict/invalid_verdict/bad_inputs/error) + Task 6 retry/coverage. ✓
-- §7 gate 1–6 → Task 6; gate 7 (resume) reuses M5, not separately built here (stretch, noted). ✓
-
-**Placeholder scan:** the only deferred-to-implementer detail is the exact extension-wiring in `realProduceVerdict` (Task 3) — flagged explicitly with the file:line to mirror (`run-turn.ts:83-103`, `sdk.ts:166`) and verified live in Task 6, because the precise `createAgentSession` extension-passing API must be read from source at implementation time. No other placeholders.
-
-**Type consistency:** `Verdict`/`validateVerdict` (T1) used by T2 `submit-verdict-tool` and T3 `runLeaf`; `VerdictCapture` (T2) consumed by T3; `LeafEnvelope`/`LeafResult` (T3) consumed by T4 route; envelope field names (`sessionId`, `inputsRef`, `resultRef`, `workspaceRef`, `model`) consistent across T3/T4/T6.
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-27-async-leaf-completion.md b/docs/superpowers/plans/2026-06-27-async-leaf-completion.md
deleted file mode 100644
index fa00820..0000000
--- a/docs/superpowers/plans/2026-06-27-async-leaf-completion.md
+++ /dev/null
@@ -1,1273 +0,0 @@
-# Async Leaf Completion Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Add true background (async) execution of leaf sessions — `POST /runs {async:true}` returns `202` immediately, a KEDA-spawned Job runs the leaf to completion via a Redis Streams work queue, writes `result_ref` + a done-marker, and the orchestrator polls.
-
-**Architecture:** A thin control plane (the Knative Service enqueues to a Redis Stream `leaf-queue` and reports status) + an ephemeral data plane (KEDA `ScaledJob` spawns one Job per pending entry; the Job is a thin wrapper around the **unchanged** `runLeaf`). At-least-once delivery; a crashed leaf re-runs the same `sessionId` → gate-7 resume; scale-to-zero when the queue drains.
-
-**Tech Stack:** TypeScript (ESM, `tsx`, `noEmit`), pnpm workspaces, `redis` (node-redis v6) Redis Streams, vitest, Knative Serving + KEDA on Kind.
-
-## Global Constraints
-
-- **No new spec scope.** Single-tenant, **provider key in env**. No authn/identity (Z1), no per-user credentials (Z3/Z5), no per-tenant sandbox/data isolation, no cron/event triggers (C), no human-gate (B). (design §8)
-- **Synchronous `POST /runs` is unchanged.** Async is purely additive (the `async` flag). (design §2)
-- **`runLeaf` is reused unchanged.** The Job is a queue wrapper around it; all leaf logic (sandbox routing, gateway, gate-7 resume) is inherited. (design §5)
-- **Harness adds NO Job RBAC** — KEDA creates Jobs; the Job pod reuses the existing `serverless-harness` ServiceAccount. (design §2)
-- **Done-marker** path defaults to `<resultRef>.status`; written **last, atomically** (temp + rename). (design §3.3)
-- **Delivery is at-least-once;** idempotent `runLeaf` (resume + overwrite) makes the outcome effectively-once. A true retry uses a NEW `sessionId`. (design §3.5)
-- **DCO:** every commit uses `git commit -s`; no `Co-Authored-By`. Conventional-commit prefixes.
-- Tests are vitest under each package's `test/**/*.test.ts`. Redis-backed tests connect to `process.env.REDIS_URL ?? "redis://127.0.0.1:6379"` and run unconditionally (a Redis must be reachable — `docker run -p 6379:6379 redis:7-alpine`), mirroring `packages/session-backend/test/redis-backend.test.ts`.
-
----
-
-## File Structure
-
-- `packages/work-queue/package.json` — new `@sh/work-queue` package manifest.
-- `packages/work-queue/src/queue.ts` — `WorkQueue` interface, `ClaimedEntry` type, `RedisWorkQueue` (Redis Streams impl).
-- `packages/work-queue/src/index.ts` — re-exports.
-- `packages/work-queue/test/queue.test.ts` — gated Redis tests.
-- `harness/src/done-marker.ts` — `deriveDoneMarkerPath`, `writeDoneMarker`, `readDoneMarker`.
-- `harness/test/done-marker.test.ts` — unit tests.
-- `harness/src/classify-outcome.ts` — pure `classifyOutcome(LeafResult)`.
-- `harness/test/classify-outcome.test.ts` — unit tests.
-- `harness/src/run-leaf.ts` — MODIFY: add `async?`/`doneMarkerRef?`/`tenant?` to `LeafEnvelope`; add `leafSessionId(env)` (tenant-prefixed, sanitized) and use it.
-- `harness/test/run-leaf.test.ts` — MODIFY: add `leafSessionId` cases.
-- `harness/src/leaf-job-runner.ts` — `runLeafJob(deps)`: claim → `runLeaf` → classify → marker → ack/reclaim.
-- `harness/test/leaf-job-runner.test.ts` — unit tests with injected fakes.
-- `harness/package.json` — MODIFY: add `@sh/work-queue` dependency.
-- `packages/knative-server/src/server.ts` — MODIFY: async branch on `POST /run-leaf` + `GET /run-leaf/status`.
-- `packages/knative-server/test/run-leaf-async-route.test.ts` — route tests (`vi.mock`).
-- `packages/knative-server/src/leaf-job.ts` — Job entrypoint (thin `main`, live-gated).
-- `packages/knative-server/package.json` — MODIFY: add `@sh/work-queue` dependency.
-- `deploy/knative/leaf-scaledjob.yaml` — KEDA `ScaledJob`.
-- `deploy/knative/setup-kind.sh` — MODIFY: idempotent KEDA install.
-- `deploy/knative/leaf-async-smoke.sh` — gated live gate.
-
----
-
-### Task 1: `@sh/work-queue` — Redis Streams work queue
-
-**Files:**
-- Create: `packages/work-queue/package.json`, `packages/work-queue/src/queue.ts`, `packages/work-queue/src/index.ts`
-- Test: `packages/work-queue/test/queue.test.ts`
-
-**Interfaces:**
-- Produces:
-  - `interface ClaimedEntry { entryId: string; envelope: unknown; deliveryCount: number }`
-  - `interface WorkQueue { ensureGroup(): Promise<void>; enqueue(envelope: unknown): Promise<string>; claim(consumerId: string, opts: { minIdleMs: number; blockMs: number }): Promise<ClaimedEntry | null>; ack(entryId: string): Promise<void>; touch(entryId: string, consumerId: string): Promise<void>; pending(): Promise<number>; purge(): Promise<void>; close(): Promise<void>; }`
-  - `class RedisWorkQueue implements WorkQueue` — `new RedisWorkQueue(url: string, streamKey?: string, group?: string)` (defaults `"leaf-queue"`, `"leaf-workers"`).
-
-- [ ] **Step 1: Create the package manifest**
-
-```json
-// packages/work-queue/package.json
-{
-  "name": "@sh/work-queue",
-  "type": "module",
-  "version": "0.0.0",
-  "exports": { ".": "./src/index.ts" },
-  "scripts": { "test": "vitest run" },
-  "devDependencies": { "typescript": "^5.5.0", "vitest": "^2.0.0" },
-  "dependencies": { "redis": "^6.0.0" }
-}
-```
-
-- [ ] **Step 2: Link the workspace**
-
-Run: `pnpm install`
-Expected: `@sh/work-queue` is linked (pnpm-workspace already globs `packages/*`). Exit 0.
-
-- [ ] **Step 3: Write the failing test**
-
-```typescript
-// packages/work-queue/test/queue.test.ts
-import { describe, it, expect, afterEach } from "vitest";
-import { RedisWorkQueue } from "../src/queue";
-
-const URL = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-let q: RedisWorkQueue;
-// unique stream per test so runs don't collide
-const stream = () => `test-leaf-queue-${process.pid}-${Math.floor(performance.now())}`;
-
-afterEach(async () => { if (q) { await q.purge(); await q.close(); } });
-
-describe("RedisWorkQueue", () => {
-  it("enqueues and claims an entry with the envelope and deliveryCount 1", async () => {
-    q = new RedisWorkQueue(URL, stream());
-    await q.ensureGroup();
-    await q.enqueue({ sessionId: "s1", inputsRef: "/in", resultRef: "/out" });
-    const c = await q.claim("worker-a", { minIdleMs: 5000, blockMs: 200 });
-    expect(c).not.toBeNull();
-    expect((c!.envelope as any).sessionId).toBe("s1");
-    expect(c!.deliveryCount).toBe(1);
-  });
-
-  it("ack removes the entry from the pending list", async () => {
-    q = new RedisWorkQueue(URL, stream());
-    await q.ensureGroup();
-    await q.enqueue({ sessionId: "s2" });
-    const c = await q.claim("worker-a", { minIdleMs: 5000, blockMs: 200 });
-    await q.ack(c!.entryId);
-    expect(await q.pending()).toBe(0);
-  });
-
-  it("claim returns null when there is no new or reclaimable work", async () => {
-    q = new RedisWorkQueue(URL, stream());
-    await q.ensureGroup();
-    const c = await q.claim("worker-a", { minIdleMs: 5000, blockMs: 100 });
-    expect(c).toBeNull();
-  });
-
-  it("reclaims an unacked entry for another consumer and bumps deliveryCount", async () => {
-    q = new RedisWorkQueue(URL, stream());
-    await q.ensureGroup();
-    await q.enqueue({ sessionId: "s3" });
-    const first = await q.claim("worker-a", { minIdleMs: 0, blockMs: 200 });
-    expect(first!.deliveryCount).toBe(1);
-    // worker-a never acks; worker-b reclaims with minIdle 0
-    const second = await q.claim("worker-b", { minIdleMs: 0, blockMs: 200 });
-    expect(second!.entryId).toBe(first!.entryId);
-    expect(second!.deliveryCount).toBe(2);
-  });
-});
-```
-
-- [ ] **Step 4: Run test to verify it fails**
-
-Run: `pnpm -C packages/work-queue exec vitest run test/queue.test.ts`
-Expected: FAIL — cannot find module `../src/queue`.
-
-- [ ] **Step 5: Write the implementation**
-
-```typescript
-// packages/work-queue/src/queue.ts
-import { createClient, type RedisClientType } from "redis";
-
-export interface ClaimedEntry {
-  entryId: string;
-  envelope: unknown;
-  deliveryCount: number;
-}
-
-export interface WorkQueue {
-  ensureGroup(): Promise<void>;
-  enqueue(envelope: unknown): Promise<string>;
-  claim(consumerId: string, opts: { minIdleMs: number; blockMs: number }): Promise<ClaimedEntry | null>;
-  ack(entryId: string): Promise<void>;
-  touch(entryId: string, consumerId: string): Promise<void>;
-  pending(): Promise<number>;
-  purge(): Promise<void>;
-  close(): Promise<void>;
-}
-
-export class RedisWorkQueue implements WorkQueue {
-  private client: RedisClientType;
-  private ready: Promise<void>;
-  constructor(
-    url = process.env.REDIS_URL ?? "redis://127.0.0.1:6379",
-    private readonly stream = "leaf-queue",
-    private readonly group = "leaf-workers",
-  ) {
-    this.client = createClient({ url });
-    this.ready = this.client.connect().then(() => undefined);
-  }
-
-  async ensureGroup(): Promise<void> {
-    await this.ready;
-    try {
-      // "0" = deliver from the start of the stream; MKSTREAM creates it if absent.
-      await this.client.xGroupCreate(this.stream, this.group, "0", { MKSTREAM: true });
-    } catch (err) {
-      if (!String((err as Error).message).includes("BUSYGROUP")) throw err;
-    }
-  }
-
-  async enqueue(envelope: unknown): Promise<string> {
-    await this.ready;
-    return this.client.xAdd(this.stream, "*", { envelope: JSON.stringify(envelope) });
-  }
-
-  async claim(consumerId: string, opts: { minIdleMs: number; blockMs: number }): Promise<ClaimedEntry | null> {
-    await this.ready;
-    // 1. Prefer reclaiming a stale (delivered-but-unacked) entry — crash recovery.
-    const auto = await this.client.xAutoClaim(this.stream, this.group, consumerId, opts.minIdleMs, "0", { COUNT: 1 });
-    const reclaimed = auto.messages?.find((m) => m && m.message);
-    if (reclaimed) {
-      return { entryId: reclaimed.id, envelope: JSON.parse(reclaimed.message.envelope), deliveryCount: await this.deliveryCount(reclaimed.id) };
-    }
-    // 2. Otherwise read a brand-new entry.
-    const res = await this.client.xReadGroup(this.group, consumerId, [{ key: this.stream, id: ">" }], { COUNT: 1, BLOCK: opts.blockMs });
-    const msg = res?.[0]?.messages?.[0];
-    if (!msg) return null;
-    return { entryId: msg.id, envelope: JSON.parse(msg.message.envelope), deliveryCount: 1 };
-  }
-
-  private async deliveryCount(id: string): Promise<number> {
-    const rows = await this.client.xPendingRange(this.stream, this.group, id, id, 1);
-    return rows?.[0]?.deliveriesCounter ?? 1;
-  }
-
-  async ack(entryId: string): Promise<void> {
-    await this.ready;
-    await this.client.xAck(this.stream, this.group, entryId);
-  }
-
-  async touch(entryId: string, consumerId: string): Promise<void> {
-    await this.ready;
-    // Reset idle time without re-fetching the payload, so a healthy long run is not reclaimed.
-    await this.client.xClaim(this.stream, this.group, consumerId, 0, [entryId], { JUSTID: true });
-  }
-
-  async pending(): Promise<number> {
-    await this.ready;
-    const summary = await this.client.xPending(this.stream, this.group);
-    return summary?.pending ?? 0;
-  }
-
-  async purge(): Promise<void> {
-    await this.ready;
-    try { await this.client.xGroupDestroy(this.stream, this.group); } catch { /* ignore */ }
-    try { await this.client.del(this.stream); } catch { /* ignore */ }
-  }
-
-  async close(): Promise<void> {
-    await this.ready;
-    await this.client.close();
-  }
-}
-```
-
-```typescript
-// packages/work-queue/src/index.ts
-export { RedisWorkQueue } from "./queue.js";
-export type { WorkQueue, ClaimedEntry } from "./queue.js";
-```
-
-- [ ] **Step 6: Run test to verify it passes**
-
-Run: `pnpm -C packages/work-queue exec vitest run test/queue.test.ts`
-Expected: PASS (4 tests). If a node-redis method name/shape differs (e.g. `xAutoClaim` return shape), the failing assertion pinpoints it — adjust against the installed `redis` v6 API and re-run.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add packages/work-queue
-git commit -s -m "feat(work-queue): Redis Streams work queue (@sh/work-queue)"
-```
-
----
-
-### Task 2: Done-marker writer/reader
-
-**Files:**
-- Create: `harness/src/done-marker.ts`
-- Test: `harness/test/done-marker.test.ts`
-
-**Interfaces:**
-- Produces:
-  - `interface DoneMarker { status: "done" | "failed"; sessionId: string; reason: string | null; ts: string }`
-  - `function deriveDoneMarkerPath(resultRef: string, override?: string): string`
-  - `function writeDoneMarker(path: string, marker: DoneMarker): void` (atomic temp + rename)
-  - `function readDoneMarker(path: string): DoneMarker | null`
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/done-marker.test.ts
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { deriveDoneMarkerPath, writeDoneMarker, readDoneMarker } from "../src/done-marker";
-
-let dir: string;
-beforeEach(() => { dir = mkdtempSync(join(tmpdir(), "marker-")); });
-afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
-
-describe("deriveDoneMarkerPath", () => {
-  it("derives <resultRef>.status by default", () => {
-    expect(deriveDoneMarkerPath("/work/r/out.json")).toBe("/work/r/out.json.status");
-  });
-  it("honors an explicit override", () => {
-    expect(deriveDoneMarkerPath("/work/r/out.json", "/work/r/done")).toBe("/work/r/done");
-  });
-});
-
-describe("writeDoneMarker / readDoneMarker", () => {
-  it("round-trips a done marker and leaves no temp file", () => {
-    const p = join(dir, "out.json.status");
-    writeDoneMarker(p, { status: "done", sessionId: "s1", reason: null, ts: "2026-06-27T00:00:00Z" });
-    expect(readDoneMarker(p)).toEqual({ status: "done", sessionId: "s1", reason: null, ts: "2026-06-27T00:00:00Z" });
-    expect(readdirSync(dir)).toEqual(["out.json.status"]); // no .tmp left behind
-  });
-  it("round-trips a failed marker with a reason", () => {
-    const p = join(dir, "m.status");
-    writeDoneMarker(p, { status: "failed", sessionId: "s2", reason: "bad_inputs", ts: "t" });
-    expect(readDoneMarker(p)?.reason).toBe("bad_inputs");
-  });
-  it("returns null for a missing marker", () => {
-    expect(readDoneMarker(join(dir, "nope.status"))).toBeNull();
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run test/done-marker.test.ts`
-Expected: FAIL — cannot find module `../src/done-marker`.
-
-- [ ] **Step 3: Write the implementation**
-
-```typescript
-// harness/src/done-marker.ts
-import { writeFileSync, renameSync, readFileSync } from "node:fs";
-
-export interface DoneMarker {
-  status: "done" | "failed";
-  sessionId: string;
-  reason: string | null;
-  ts: string;
-}
-
-export function deriveDoneMarkerPath(resultRef: string, override?: string): string {
-  return override && override.length > 0 ? override : `${resultRef}.status`;
-}
-
-/** Write atomically (temp + rename) so a reader never observes a partial marker. */
-export function writeDoneMarker(path: string, marker: DoneMarker): void {
-  const tmp = `${path}.tmp`;
-  writeFileSync(tmp, JSON.stringify(marker));
-  renameSync(tmp, path);
-}
-
-export function readDoneMarker(path: string): DoneMarker | null {
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as DoneMarker;
-  } catch {
-    return null;
-  }
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run test/done-marker.test.ts`
-Expected: PASS (5 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/done-marker.ts harness/test/done-marker.test.ts
-git commit -s -m "feat(harness): atomic done-marker writer/reader"
-```
-
----
-
-### Task 3: `classifyOutcome` — ack-vs-reclaim decision
-
-**Files:**
-- Create: `harness/src/classify-outcome.ts`
-- Test: `harness/test/classify-outcome.test.ts`
-
-**Interfaces:**
-- Consumes: `LeafResult` from `harness/src/run-leaf.ts` (`{ status: "done"; resultRef } | { status: "failed"; reason: "no_verdict"|"invalid_verdict"|"bad_inputs"|"error"; message? }`).
-- Produces:
-  - `interface Outcome { ack: boolean; marker: { status: "done" | "failed"; reason: string | null } | null; retryable: boolean }`
-  - `function classifyOutcome(result: LeafResult): Outcome`
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/classify-outcome.test.ts
-import { describe, it, expect } from "vitest";
-import { classifyOutcome } from "../src/classify-outcome";
-
-describe("classifyOutcome", () => {
-  it("done → ack + done marker", () => {
-    expect(classifyOutcome({ status: "done", resultRef: "/out" })).toEqual({
-      ack: true, marker: { status: "done", reason: null }, retryable: false,
-    });
-  });
-  for (const reason of ["bad_inputs", "no_verdict", "invalid_verdict"] as const) {
-    it(`failed:${reason} → ack + failed marker (deterministic)`, () => {
-      expect(classifyOutcome({ status: "failed", reason })).toEqual({
-        ack: true, marker: { status: "failed", reason }, retryable: false,
-      });
-    });
-  }
-  it("failed:error → no ack, retryable, no marker (yet)", () => {
-    expect(classifyOutcome({ status: "failed", reason: "error", message: "boom" })).toEqual({
-      ack: false, marker: null, retryable: true,
-    });
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run test/classify-outcome.test.ts`
-Expected: FAIL — cannot find module `../src/classify-outcome`.
-
-- [ ] **Step 3: Write the implementation**
-
-```typescript
-// harness/src/classify-outcome.ts
-import type { LeafResult } from "./run-leaf.js";
-
-export interface Outcome {
-  ack: boolean;
-  marker: { status: "done" | "failed"; reason: string | null } | null;
-  retryable: boolean;
-}
-
-/**
- * Decide what the leaf-job does with a queue entry given the leaf's terminal result.
- * - done / deterministic failures → write a marker and ACK (no reprocess).
- * - "error" (possibly transient model/gateway) → no marker, no ack, retryable (reclaim).
- *   (A process crash never returns here at all → entry stays pending → reclaimed.)
- */
-export function classifyOutcome(result: LeafResult): Outcome {
-  if (result.status === "done") {
-    return { ack: true, marker: { status: "done", reason: null }, retryable: false };
-  }
-  if (result.reason === "error") {
-    return { ack: false, marker: null, retryable: true };
-  }
-  return { ack: true, marker: { status: "failed", reason: result.reason }, retryable: false };
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run test/classify-outcome.test.ts`
-Expected: PASS (5 tests).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/classify-outcome.ts harness/test/classify-outcome.test.ts
-git commit -s -m "feat(harness): classifyOutcome ack-vs-reclaim decision"
-```
-
----
-
-### Task 4: Envelope async fields + tenant-namespaced session id
-
-**Files:**
-- Modify: `harness/src/run-leaf.ts` (add fields to `LeafEnvelope`; add `leafSessionId`; use it in `realProduceVerdict`)
-- Test: `harness/test/run-leaf.test.ts` (add `leafSessionId` cases)
-
-**Interfaces:**
-- Consumes: existing `toSessionId` (`harness/src/run-leaf.ts`).
-- Produces:
-  - `LeafEnvelope` gains `async?: boolean`, `doneMarkerRef?: string`, `tenant?: string` (all optional).
-  - `function leafSessionId(env: { sessionId: string; tenant?: string }): string` — tenant-prefixed then sanitized.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// append to harness/test/run-leaf.test.ts
-import { leafSessionId } from "../src/run-leaf";
-
-describe("leafSessionId", () => {
-  it("sanitizes the bare sessionId when no tenant is set", () => {
-    expect(leafSessionId({ sessionId: "run-1/i1" })).toBe("run-1-i1");
-  });
-  it("prefixes and sanitizes with the tenant for per-tenant id isolation", () => {
-    expect(leafSessionId({ sessionId: "run-1/i1", tenant: "acme" })).toBe("acme-run-1-i1");
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run test/run-leaf.test.ts`
-Expected: FAIL — `leafSessionId` is not exported.
-
-- [ ] **Step 3: Add the fields and helper, and use it**
-
-In `harness/src/run-leaf.ts`, extend the `LeafEnvelope` interface:
-
-```typescript
-export interface LeafEnvelope {
-  sessionId: string;
-  model?: string;
-  provider?: string;
-  inputsRef: string;
-  resultRef: string;
-  workspaceRef?: string;
-  maxTurns?: number;
-  async?: boolean;            // when true, the HTTP layer enqueues instead of running inline
-  doneMarkerRef?: string;     // overrides the derived <resultRef>.status
-  tenant?: string;            // namespaces the session id (non-precluding; design §7)
-}
-```
-
-Add the helper near `toSessionId`:
-
-```typescript
-/** The Pi/Redis session id for a leaf: tenant-prefixed (if any), then sanitized. */
-export function leafSessionId(env: { sessionId: string; tenant?: string }): string {
-  return toSessionId(env.tenant ? `${env.tenant}/${env.sessionId}` : env.sessionId);
-}
-```
-
-In `realProduceVerdict`, replace the existing `const sid = toSessionId(env.sessionId);` line with:
-
-```typescript
-  const sid = leafSessionId(env);
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run test/run-leaf.test.ts`
-Expected: PASS (existing run-leaf tests + 2 new `leafSessionId` cases).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/run-leaf.ts harness/test/run-leaf.test.ts
-git commit -s -m "feat(harness): async/doneMarkerRef/tenant envelope fields + leafSessionId"
-```
-
----
-
-### Task 5: `leaf-job-runner` — the queue wrapper around `runLeaf`
-
-**Files:**
-- Create: `harness/src/leaf-job-runner.ts`
-- Test: `harness/test/leaf-job-runner.test.ts`
-- Modify: `harness/package.json` (add `@sh/work-queue` dependency)
-
-**Interfaces:**
-- Consumes: `WorkQueue`, `ClaimedEntry` (`@sh/work-queue`); `classifyOutcome` (Task 3); `writeDoneMarker`, `deriveDoneMarkerPath`, `DoneMarker` (Task 2); `runLeaf`, `LeafEnvelope`, `LeafResult` (`./run-leaf.js`).
-- Produces:
-  - `interface LeafJobDeps { queue: WorkQueue; runLeaf: (env: LeafEnvelope) => Promise<LeafResult>; writeMarker?: (path: string, m: DoneMarker) => void; consumerId: string; maxAttempts?: number; minIdleMs?: number; blockMs?: number; heartbeatMs?: number; now?: () => string; setHeartbeat?: (fn: () => void, ms: number) => unknown; clearHeartbeat?: (h: unknown) => void; }`
-  - `function processOne(deps: LeafJobDeps): Promise<"done" | "failed" | "deadletter" | "idle" | "retry">`
-
-- [ ] **Step 1: Add the dependency**
-
-In `harness/package.json`, add to `dependencies`:
-
-```json
-    "@sh/work-queue": "workspace:*",
-```
-
-Run: `pnpm install`
-Expected: linked, exit 0.
-
-- [ ] **Step 2: Write the failing test**
-
-```typescript
-// harness/test/leaf-job-runner.test.ts
-import { describe, it, expect, vi } from "vitest";
-import { processOne, type LeafJobDeps } from "../src/leaf-job-runner";
-import type { ClaimedEntry, WorkQueue } from "@sh/work-queue";
-import type { LeafEnvelope, LeafResult } from "../src/run-leaf";
-
-function fakeQueue(claimed: ClaimedEntry | null): WorkQueue & { acked: string[]; touched: string[] } {
-  const acked: string[] = []; const touched: string[] = [];
-  return {
-    acked, touched,
-    ensureGroup: async () => {},
-    enqueue: async () => "1-0",
-    claim: async () => claimed,
-    ack: async (id: string) => { acked.push(id); },
-    touch: async (id: string) => { touched.push(id); },
-    pending: async () => 0,
-    purge: async () => {},
-    close: async () => {},
-  };
-}
-
-const ENV: LeafEnvelope = { sessionId: "run/i1", inputsRef: "/in", resultRef: "/out" };
-function baseDeps(over: Partial<LeafJobDeps>): LeafJobDeps {
-  const markers: Array<{ path: string; status: string; reason: string | null }> = [];
-  return {
-    queue: fakeQueue(null),
-    runLeaf: async () => ({ status: "done", resultRef: "/out" }),
-    writeMarker: (path, m) => { markers.push({ path, status: m.status, reason: m.reason }); (baseDeps as any)._m = markers; },
-    consumerId: "w1",
-    now: () => "t",
-    setHeartbeat: () => 0,
-    clearHeartbeat: () => {},
-    ...over,
-  };
-}
-
-describe("processOne", () => {
-  it("returns idle and does nothing when the queue is empty", async () => {
-    const q = fakeQueue(null);
-    const r = await processOne(baseDeps({ queue: q }));
-    expect(r).toBe("idle");
-    expect(q.acked).toEqual([]);
-  });
-
-  it("dead-letters (failed marker + ack, runLeaf NOT called) past maxAttempts", async () => {
-    const q = fakeQueue({ entryId: "9-0", envelope: ENV, deliveryCount: 4 });
-    const runLeaf = vi.fn();
-    const markers: any[] = [];
-    const r = await processOne(baseDeps({ queue: q, runLeaf: runLeaf as any, maxAttempts: 3, writeMarker: (p, m) => markers.push(m) }));
-    expect(r).toBe("deadletter");
-    expect(runLeaf).not.toHaveBeenCalled();
-    expect(markers[0]).toMatchObject({ status: "failed", reason: "error" });
-    expect(q.acked).toEqual(["9-0"]);
-  });
-
-  it("done → writes done marker and acks", async () => {
-    const q = fakeQueue({ entryId: "1-0", envelope: ENV, deliveryCount: 1 });
-    const markers: any[] = [];
-    const r = await processOne(baseDeps({ queue: q, runLeaf: async () => ({ status: "done", resultRef: "/out" }), writeMarker: (p, m) => markers.push(m) }));
-    expect(r).toBe("done");
-    expect(markers[0]).toMatchObject({ status: "done", reason: null });
-    expect(q.acked).toEqual(["1-0"]);
-  });
-
-  it("deterministic failure → failed marker + ack", async () => {
-    const q = fakeQueue({ entryId: "1-0", envelope: ENV, deliveryCount: 1 });
-    const markers: any[] = [];
-    const r = await processOne(baseDeps({ queue: q, runLeaf: async () => ({ status: "failed", reason: "bad_inputs" }), writeMarker: (p, m) => markers.push(m) }));
-    expect(r).toBe("failed");
-    expect(markers[0]).toMatchObject({ status: "failed", reason: "bad_inputs" });
-    expect(q.acked).toEqual(["1-0"]);
-  });
-
-  it("retryable error → no ack, no marker, returns retry", async () => {
-    const q = fakeQueue({ entryId: "1-0", envelope: ENV, deliveryCount: 1 });
-    const markers: any[] = [];
-    const r = await processOne(baseDeps({ queue: q, runLeaf: async () => ({ status: "failed", reason: "error", message: "x" }), writeMarker: (p, m) => markers.push(m) }));
-    expect(r).toBe("retry");
-    expect(markers).toEqual([]);
-    expect(q.acked).toEqual([]);
-  });
-
-  it("schedules and clears a heartbeat around the run", async () => {
-    const q = fakeQueue({ entryId: "1-0", envelope: ENV, deliveryCount: 1 });
-    const set = vi.fn(() => 42); const clear = vi.fn();
-    await processOne(baseDeps({ queue: q, setHeartbeat: set as any, clearHeartbeat: clear as any }));
-    expect(set).toHaveBeenCalledOnce();
-    expect(clear).toHaveBeenCalledWith(42);
-  });
-});
-```
-
-- [ ] **Step 3: Run test to verify it fails**
-
-Run: `pnpm -C harness exec vitest run test/leaf-job-runner.test.ts`
-Expected: FAIL — cannot find module `../src/leaf-job-runner`.
-
-- [ ] **Step 4: Write the implementation**
-
-```typescript
-// harness/src/leaf-job-runner.ts
-import type { WorkQueue } from "@sh/work-queue";
-import { classifyOutcome } from "./classify-outcome.js";
-import { deriveDoneMarkerPath, writeDoneMarker, type DoneMarker } from "./done-marker.js";
-import type { LeafEnvelope, LeafResult } from "./run-leaf.js";
-
-export interface LeafJobDeps {
-  queue: WorkQueue;
-  runLeaf: (env: LeafEnvelope) => Promise<LeafResult>;
-  writeMarker?: (path: string, m: DoneMarker) => void;
-  consumerId: string;
-  maxAttempts?: number;
-  minIdleMs?: number;
-  blockMs?: number;
-  heartbeatMs?: number;
-  now?: () => string;
-  setHeartbeat?: (fn: () => void, ms: number) => unknown;
-  clearHeartbeat?: (h: unknown) => void;
-}
-
-/**
- * Claim and process at most one queue entry. Returns a label describing the outcome.
- * - "idle": nothing to claim.
- * - "deadletter": delivery count exceeded → failed marker + ack, runLeaf not run.
- * - "done"/"failed": runLeaf reached a terminal state → marker + ack.
- * - "retry": transient error → NOT acked (entry stays pending for reclaim).
- */
-export async function processOne(deps: LeafJobDeps): Promise<"done" | "failed" | "deadletter" | "idle" | "retry"> {
-  const maxAttempts = deps.maxAttempts ?? 3;
-  const minIdleMs = deps.minIdleMs ?? 90_000;
-  const blockMs = deps.blockMs ?? 5_000;
-  const heartbeatMs = deps.heartbeatMs ?? 30_000;
-  const writeMarker = deps.writeMarker ?? writeDoneMarker;
-  const now = deps.now ?? (() => new Date().toISOString());
-  const setHb = deps.setHeartbeat ?? ((fn, ms) => setInterval(fn, ms));
-  const clearHb = deps.clearHeartbeat ?? ((h) => clearInterval(h as ReturnType<typeof setInterval>));
-
-  const claimed = await deps.queue.claim(deps.consumerId, { minIdleMs, blockMs });
-  if (!claimed) return "idle";
-
-  const env = claimed.envelope as LeafEnvelope;
-  const markerPath = deriveDoneMarkerPath(env.resultRef, env.doneMarkerRef);
-
-  if (claimed.deliveryCount > maxAttempts) {
-    writeMarker(markerPath, { status: "failed", sessionId: env.sessionId, reason: "error", ts: now() });
-    await deps.queue.ack(claimed.entryId);
-    return "deadletter";
-  }
-
-  const hb = setHb(() => { void deps.queue.touch(claimed.entryId, deps.consumerId); }, heartbeatMs);
-  let result: LeafResult;
-  try {
-    result = await deps.runLeaf(env);
-  } finally {
-    clearHb(hb);
-  }
-
-  const outcome = classifyOutcome(result);
-  if (outcome.marker) {
-    writeMarker(markerPath, { status: outcome.marker.status, sessionId: env.sessionId, reason: outcome.marker.reason, ts: now() });
-  }
-  if (outcome.ack) {
-    await deps.queue.ack(claimed.entryId);
-    return result.status === "done" ? "done" : "failed";
-  }
-  return "retry";
-}
-```
-
-- [ ] **Step 5: Run test to verify it passes**
-
-Run: `pnpm -C harness exec vitest run test/leaf-job-runner.test.ts`
-Expected: PASS (6 tests).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add harness/src/leaf-job-runner.ts harness/test/leaf-job-runner.test.ts harness/package.json pnpm-lock.yaml
-git commit -s -m "feat(harness): leaf-job-runner queue wrapper around runLeaf"
-```
-
----
-
-### Task 6: `POST /run-leaf` async branch + `GET /run-leaf/status`
-
-**Files:**
-- Modify: `packages/knative-server/src/server.ts`
-- Modify: `packages/knative-server/package.json` (add `@sh/work-queue`)
-- Test: `packages/knative-server/test/run-leaf-async-route.test.ts`
-
-**Interfaces:**
-- Consumes: `RedisWorkQueue` (`@sh/work-queue`); `readDoneMarker`, `deriveDoneMarkerPath` (`@sh/harness/done-marker`); `runLeaf`, `LeafEnvelope`, `leafSessionId` (`@sh/harness/run-leaf`).
-- Produces: `POST /run-leaf` with `async:true` → `202 { status:"accepted", sessionId, resultRef, doneMarker }`; `GET /run-leaf/status?doneMarker=&sessionId=` → `{ status: "queued"|"running"|"done"|"failed", reason? }`.
-
-- [ ] **Step 1: Add the dependency + a harness export for done-marker**
-
-In `packages/knative-server/package.json` dependencies add `"@sh/work-queue": "workspace:*",`.
-In `harness/package.json` `exports`, add `"./done-marker": "./src/done-marker.ts"`.
-Run: `pnpm install` (exit 0).
-
-- [ ] **Step 2: Write the failing test**
-
-```typescript
-// packages/knative-server/test/run-leaf-async-route.test.ts
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-const enqueue = vi.fn(async () => "1-0");
-const ensureGroup = vi.fn(async () => {});
-vi.mock("@sh/work-queue", () => ({
-  RedisWorkQueue: class { ensureGroup = ensureGroup; enqueue = enqueue; close = async () => {}; },
-}));
-const readDoneMarker = vi.fn();
-vi.mock("@sh/harness/done-marker", () => ({
-  readDoneMarker: (...a: any[]) => readDoneMarker(...a),
-  deriveDoneMarkerPath: (r: string, o?: string) => o ?? `${r}.status`,
-}));
-
-import { startServer } from "../src/server";
-
-let base: string; let server: any;
-beforeEach(() => { enqueue.mockClear(); readDoneMarker.mockReset(); });
-async function req(method: string, path: string, body?: unknown) {
-  const res = await fetch(base + path, { method, headers: { "content-type": "application/json" }, body: body ? JSON.stringify(body) : undefined });
-  return { status: res.status, json: await res.json().catch(() => ({})) };
-}
-
-describe("async /run-leaf", () => {
-  beforeEach(() => { server = startServer(0); base = `http://127.0.0.1:${server.address().port}`; });
-
-  it("202 + enqueues on async:true with a valid envelope", async () => {
-    const r = await req("POST", "/run-leaf", { sessionId: "run/i1", inputsRef: "/in", resultRef: "/out", async: true });
-    expect(r.status).toBe(202);
-    expect(r.json).toMatchObject({ status: "accepted", sessionId: "run/i1", doneMarker: "/out.status" });
-    expect(enqueue).toHaveBeenCalledOnce();
-    server.close();
-  });
-
-  it("400 and no enqueue on a malformed async envelope", async () => {
-    const r = await req("POST", "/run-leaf", { sessionId: "s", async: true });
-    expect(r.status).toBe(400);
-    expect(enqueue).not.toHaveBeenCalled();
-    server.close();
-  });
-
-  it("status returns done from the marker", async () => {
-    readDoneMarker.mockReturnValue({ status: "done", sessionId: "run/i1", reason: null, ts: "t" });
-    const r = await req("GET", "/run-leaf/status?doneMarker=/out.status&sessionId=run/i1");
-    expect(r.status).toBe(200);
-    expect(r.json).toMatchObject({ status: "done" });
-    server.close();
-  });
-
-  it("status returns queued when no marker yet", async () => {
-    readDoneMarker.mockReturnValue(null);
-    const r = await req("GET", "/run-leaf/status?doneMarker=/out.status&sessionId=run/i1");
-    expect(r.json).toMatchObject({ status: "queued" });
-    server.close();
-  });
-});
-```
-
-- [ ] **Step 3: Run test to verify it fails**
-
-Run: `pnpm -C packages/knative-server exec vitest run test/run-leaf-async-route.test.ts`
-Expected: FAIL — async branch / status route absent (404 or 200-sync).
-
-- [ ] **Step 4: Implement the async branch + status route**
-
-In `packages/knative-server/src/server.ts`, add imports:
-
-```typescript
-import { RedisWorkQueue } from "@sh/work-queue";
-import { readDoneMarker, deriveDoneMarkerPath } from "@sh/harness/done-marker";
-import { leafSessionId } from "@sh/harness/run-leaf";
-```
-
-Add a lazily-constructed queue and handlers:
-
-```typescript
-let queue: RedisWorkQueue | undefined;
-function getQueue(): RedisWorkQueue {
-  if (!queue) queue = new RedisWorkQueue(process.env.REDIS_URL);
-  return queue;
-}
-
-async function handleEnqueueLeaf(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const body = JSON.parse(await readBody(req));
-  if (!isLeafEnvelope(body)) {
-    res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "envelope_invalid" }));
-    return;
-  }
-  const q = getQueue();
-  await q.ensureGroup();
-  await q.enqueue(body);
-  res.writeHead(202, JSON_HEADERS).end(JSON.stringify({
-    status: "accepted",
-    sessionId: body.sessionId,
-    resultRef: body.resultRef,
-    doneMarker: deriveDoneMarkerPath(body.resultRef, body.doneMarkerRef),
-  }));
-}
-
-function handleLeafStatus(url: URL, res: ServerResponse): void {
-  const doneMarker = url.searchParams.get("doneMarker");
-  if (!doneMarker) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "doneMarker_required" })); return; }
-  const marker = readDoneMarker(doneMarker);
-  if (marker) {
-    res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: marker.status, reason: marker.reason ?? undefined }));
-    return;
-  }
-  // No terminal marker yet — best-effort non-terminal state for visibility.
-  res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: "queued" }));
-}
-```
-
-In the request `handler`, before the existing `POST /run-leaf` branch, route async and status. Replace the current `if (req.method === "POST" && req.url === "/run-leaf")` block with:
-
-```typescript
-  if (req.method === "GET" && req.url?.startsWith("/run-leaf/status")) {
-    handleLeafStatus(new URL(req.url, "http://localhost"), res);
-    return;
-  }
-
-  if (req.method === "POST" && req.url === "/run-leaf") {
-    const route = async () => {
-      const raw = await readBody(req);
-      let parsed: any = {};
-      try { parsed = JSON.parse(raw); } catch { /* handled below */ }
-      if (parsed && parsed.async === true) return handleEnqueueLeafParsed(parsed, res);
-      return handleRunLeafParsed(parsed, raw, res);
-    };
-    route().catch((err) => { if (!res.headersSent) res.writeHead(500, JSON_HEADERS).end(JSON.stringify({ error: String(err) })); });
-    return;
-  }
-```
-
-To avoid double-reading the body, refactor `handleRunLeaf`/`handleEnqueueLeaf` to take the already-parsed body. Add:
-
-```typescript
-async function handleEnqueueLeafParsed(body: any, res: ServerResponse): Promise<void> {
-  if (!isLeafEnvelope(body)) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "envelope_invalid" })); return; }
-  const q = getQueue();
-  await q.ensureGroup();
-  await q.enqueue(body);
-  res.writeHead(202, JSON_HEADERS).end(JSON.stringify({
-    status: "accepted", sessionId: body.sessionId, resultRef: body.resultRef,
-    doneMarker: deriveDoneMarkerPath(body.resultRef, body.doneMarkerRef),
-  }));
-}
-
-async function handleRunLeafParsed(body: any, _raw: string, res: ServerResponse): Promise<void> {
-  if (!isLeafEnvelope(body)) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "envelope_invalid" })); return; }
-  const result = await runLeaf(body, buildConfig());
-  res.writeHead(200, JSON_HEADERS).end(JSON.stringify(result));
-}
-```
-
-(Delete the now-unused `handleRunLeaf`/`handleEnqueueLeaf` body-reading variants if present, keeping only the `*Parsed` forms. `leafSessionId` import is available for future status-by-session lookups; leave it imported.)
-
-- [ ] **Step 5: Run test to verify it passes**
-
-Run: `pnpm -C packages/knative-server exec vitest run test/run-leaf-async-route.test.ts`
-Expected: PASS (4 tests). Also run the existing sync route test to confirm no regression:
-Run: `pnpm -C packages/knative-server exec vitest run`
-Expected: PASS (all).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add packages/knative-server/src/server.ts packages/knative-server/package.json harness/package.json pnpm-lock.yaml packages/knative-server/test/run-leaf-async-route.test.ts
-git commit -s -m "feat(knative-server): async POST /run-leaf enqueue + GET /run-leaf/status"
-```
-
----
-
-### Task 7: Leaf-job entrypoint
-
-**Files:**
-- Create: `packages/knative-server/src/leaf-job.ts`
-
-**Interfaces:**
-- Consumes: `RedisWorkQueue` (`@sh/work-queue`); `processOne` (`@sh/harness/leaf-job-runner`); `runLeaf` (`@sh/harness/run-leaf`); `buildConfig` pattern (mirror `server.ts`).
-- Produces: a runnable entrypoint `node --import tsx src/leaf-job.ts` that drains the queue then exits 0 (exercised by the Task 9 live gate, not unit-tested — it constructs real Redis + Pi, like `realProduceVerdict`).
-
-- [ ] **Step 1: Add the harness exports the entrypoint needs**
-
-In `harness/package.json` `exports`, add `"./leaf-job-runner": "./src/leaf-job-runner.ts"` (so the entrypoint can import `processOne`).
-Run: `pnpm install` (exit 0).
-
-- [ ] **Step 2: Write the entrypoint**
-
-```typescript
-// packages/knative-server/src/leaf-job.ts
-import { RedisWorkQueue } from "@sh/work-queue";
-import { processOne } from "@sh/harness/leaf-job-runner";
-import { runLeaf, type LeafEnvelope, type TurnConfig } from "@sh/harness/run-leaf";
-
-function buildConfig(): TurnConfig {
-  return {
-    redisUrl: process.env.REDIS_URL,
-    cwd: process.env.HARNESS_CWD || process.cwd(),
-    anthropicBaseUrl: process.env.ANTHROPIC_BASE_URL,
-    anthropicAuthToken: process.env.ANTHROPIC_AUTH_TOKEN,
-  };
-}
-
-async function main(): Promise<void> {
-  const queue = new RedisWorkQueue(process.env.REDIS_URL);
-  await queue.ensureGroup();
-  const consumerId = process.env.HOSTNAME ?? `leaf-job-${process.pid}`;
-  // Drain: process entries until the queue yields nothing, then exit so KEDA can scale to zero.
-  // A transient "retry" rethrows below (non-zero exit) so the entry is reclaimed by a later Job.
-  for (;;) {
-    const outcome = await processOne({
-      queue,
-      runLeaf: (env: LeafEnvelope) => runLeaf(env, buildConfig()),
-      consumerId,
-    });
-    if (outcome === "idle") break;
-    if (outcome === "retry") { await queue.close(); process.exit(1); }
-  }
-  await queue.close();
-  process.exit(0);
-}
-
-main().catch(async (err) => {
-  console.error("leaf-job error:", err);
-  process.exit(1);
-});
-```
-
-- [ ] **Step 3: Verify it type-resolves / imports**
-
-Run: `pnpm -C packages/knative-server exec tsx --eval "import('./src/leaf-job.ts').then(()=>{}).catch(e=>{console.error(String(e));process.exit(2)})" 2>&1 | head -5; echo "EXIT:$?"`
-Expected: it attempts to start (may block connecting to Redis — that's fine) or exits cleanly; it must NOT fail with a module-resolution / syntax error. If Redis is unreachable it will hang — Ctrl-C / kill is acceptable here; the goal is only to confirm imports resolve. (A cleaner check: `pnpm -C packages/knative-server exec vitest run` still passes — no import breakage.)
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add packages/knative-server/src/leaf-job.ts harness/package.json pnpm-lock.yaml
-git commit -s -m "feat(knative-server): leaf-job entrypoint (drains the queue via processOne)"
-```
-
----
-
-### Task 8: KEDA install + ScaledJob manifest
-
-**Files:**
-- Modify: `deploy/knative/setup-kind.sh` (idempotent KEDA install)
-- Create: `deploy/knative/leaf-scaledjob.yaml`
-
-**Interfaces:**
-- Consumes: the `leaf-job` entrypoint (Task 7), the `dev.local/serverless-harness:local` image, the `serverless-harness` ServiceAccount, the `leaf-work` PVC, the `llm-credentials` secret.
-- Produces: a KEDA `ScaledJob` that spawns leaf-job Jobs from `leaf-queue`.
-
-- [ ] **Step 1: Add an idempotent KEDA install to setup-kind.sh**
-
-After the `config-features` PVC patch block in `deploy/knative/setup-kind.sh`, add:
-
-```bash
-# Install KEDA (event-driven autoscaling) — async leaf completion uses a KEDA ScaledJob.
-KEDA_VERSION="${KEDA_VERSION:-v2.14.0}"
-if ! kubectl get crd scaledjobs.keda.sh >/dev/null 2>&1; then
-  echo "--- Installing KEDA $KEDA_VERSION ---"
-  kubectl apply --server-side -f "https://github.com/kedacore/keda/releases/download/${KEDA_VERSION}/keda-${KEDA_VERSION}.yaml"
-fi
-kubectl wait --for=condition=Available deployment --all -n keda --timeout=180s || true
-```
-
-- [ ] **Step 2: Write the ScaledJob manifest**
-
-```yaml
-# deploy/knative/leaf-scaledjob.yaml
-apiVersion: keda.sh/v1alpha1
-kind: ScaledJob
-metadata:
-  name: leaf-worker
-  namespace: default
-spec:
-  jobTargetRef:
-    backoffLimit: 0
-    template:
-      spec:
-        restartPolicy: Never
-        serviceAccountName: serverless-harness
-        containers:
-          - name: leaf-job
-            image: dev.local/serverless-harness:local
-            imagePullPolicy: IfNotPresent
-            workingDir: /app/packages/knative-server
-            command: ["node", "--import", "tsx", "src/leaf-job.ts"]
-            env:
-              - name: REDIS_URL
-                value: "redis://redis.default.svc:6379"
-              - name: SH_MODEL
-                value: "claude-haiku-4-5"
-              - name: KAGENTI_SANDBOX_POD
-                value: "sandbox-0"
-              - name: ANTHROPIC_API_KEY
-                valueFrom: { secretKeyRef: { name: llm-credentials, key: api-key } }
-              - name: ANTHROPIC_BASE_URL
-                valueFrom: { secretKeyRef: { name: llm-credentials, key: base-url, optional: true } }
-              - name: ANTHROPIC_AUTH_TOKEN
-                valueFrom: { secretKeyRef: { name: llm-credentials, key: auth-token, optional: true } }
-            volumeMounts:
-              - name: work
-                mountPath: /work
-        volumes:
-          - name: work
-            persistentVolumeClaim:
-              claimName: leaf-work
-  pollingInterval: 5
-  maxReplicaCount: 10
-  successfulJobsHistoryLimit: 3
-  failedJobsHistoryLimit: 3
-  triggers:
-    - type: redis-streams
-      metadata:
-        addressFromEnv: ""
-        address: redis.default.svc:6379
-        stream: leaf-queue
-        consumerGroup: leaf-workers
-        pendingEntriesCount: "1"
-```
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add deploy/knative/setup-kind.sh deploy/knative/leaf-scaledjob.yaml
-git commit -s -m "feat(keda): KEDA install + leaf-worker ScaledJob for async leaves"
-```
-
-> Live validation of this manifest happens in Task 9 (it requires the rebuilt image + a running cluster).
-
----
-
-### Task 9: Live gate — async fan-out, crash-resume, scale-to-zero
-
-**Files:**
-- Create: `deploy/knative/leaf-async-smoke.sh`
-
-**Interfaces:**
-- Consumes: everything above + the gate-7 resume + the `leaf-work` PVC + `sandbox-0` + fixtures.
-- Produces: a gated pass/fail proving design §6.2 claims 1–6.
-
-- [ ] **Step 1: Write the gated smoke script**
-
-```bash
-# deploy/knative/leaf-async-smoke.sh
-#!/usr/bin/env bash
-# Gated Kind smoke for async leaf completion (design §6.2). Proves: async accept, KEDA
-# scale-out, completion via done-marker, crash-resume, scale-to-zero, deterministic failure.
-# Prereq: setup-kind.sh (incl. KEDA) done; image rebuilt with leaf-job + async routes;
-#   leaf-pvc.yaml + leaf-orchestrator.yaml applied; leaf-scaledjob.yaml applied; sandbox-0 up.
-# Usage: ASYNC_LIVE_SMOKE=1 bash deploy/knative/leaf-async-smoke.sh
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-[ "${ASYNC_LIVE_SMOKE:-0}" = "1" ] || { echo "SKIP (set ASYNC_LIVE_SMOKE=1)"; exit 0; }
-
-ORCH=leaf-orchestrator; SBOX="${KAGENTI_SANDBOX_POD:-sandbox-0}"
-RUN="arun-$$"; INPUTS="/work/$RUN/inputs"; RES="/work/$RUN/results"; SBOX_REPO="/workspace/$RUN/repo"
-ITEMS="i1 i2 i3"; MODEL="${SH_MODEL:-claude-haiku-4-5}"
-declare -A EXPECT=( [i1]=FLAGGED [i2]=CLEAR [i3]=CLEAR )
-claim() { echo ""; echo "--- Claim $1: $2 ---"; }
-oexec() { kubectl -n "$NS" exec "$ORCH" -- "$@"; }
-leaf_job_pods() { kubectl get pods -n "$NS" -l scaledjob.keda.sh/name=leaf-worker --field-selector=status.phase=Running --no-headers 2>/dev/null | wc -l | tr -d ' '; }
-
-# async dispatch: POST {async:true} -> 202 handle
-adispatch() {
-  local id="$1" model="${2:-$MODEL}" in="${3:-$INPUTS/$id.json}"
-  jq -nc --arg s "$RUN/$id" --arg m "$model" --arg in "$in" --arg out "$RES/$id.json" --arg ws "$SBOX_REPO" \
-    '{sessionId:$s, model:$m, inputsRef:$in, resultRef:$out, workspaceRef:$ws, async:true}' \
-  | curl -s --max-time 30 -H "$HOST_HEADER" -H "Content-Type: application/json" -d @- "$BASE/run-leaf"
-}
-
-echo "=== Async leaf smoke (run=$RUN) ==="
-ensure_port_forward >/dev/null || true
-kubectl -n "$NS" wait --for=condition=Ready "pod/$ORCH" --timeout=90s >/dev/null
-kubectl -n "$NS" wait --for=condition=Ready "pod/$SBOX" --timeout=90s >/dev/null
-for _ in $(seq 1 30); do oexec sh -c 'command -v jq >/dev/null && command -v curl >/dev/null' && break; sleep 2; done
-oexec mkdir -p "$INPUTS" "$RES"
-kubectl -n "$NS" cp ./fixtures/inputs "$ORCH:$INPUTS"
-kubectl -n "$NS" exec "$SBOX" -- mkdir -p "$SBOX_REPO"
-kubectl -n "$NS" cp ./fixtures/repo "$SBOX:$SBOX_REPO"
-
-# Claim 1: async accept (fast 202)
-claim 1 "Async accept: 202 + handle, returns fast"
-acc_ok=1
-for id in $ITEMS; do
-  st=$(adispatch "$id" | jq -r '.status // "none"'); echo "    $id -> $st"
-  [ "$st" = "accepted" ] || acc_ok=0
-done
-[ "$acc_ok" = 1 ] && ok "all accepted" || ko "not all accepted"
-
-# Claim 2: KEDA scale-out (>=2 leaf-job pods at some point)
-claim 2 "KEDA scales out leaf-job pods"
-maxp=0
-for _ in $(seq 1 24); do p=$(leaf_job_pods); [ "$p" -gt "$maxp" ] && maxp=$p; [ "$p" -ge 2 ] && break; sleep 5; done
-[ "$maxp" -ge 2 ] && ok "observed $maxp concurrent leaf-job pods" || echo "  NOTE: observed max $maxp (cap/scheduling may serialize)"
-
-# Claim 3: completion via done-marker + correct verdicts
-claim 3 "Completion via done-marker; verdicts correct"
-cov_ok=1
-for id in $ITEMS; do
-  got=""
-  for _ in $(seq 1 60); do
-    if oexec test -f "$RES/$id.json.status"; then got=$(oexec sh -c "jq -r .status $RES/$id.json.status"); break; fi
-    sleep 5
-  done
-  v=$(oexec sh -c "jq -r .verdict $RES/$id.json 2>/dev/null" 2>/dev/null || echo "")
-  if [ "$got" = "done" ] && [ "$v" = "${EXPECT[$id]}" ]; then echo "    $id done verdict=$v"; else echo "    $id status=$got verdict=$v (want ${EXPECT[$id]})"; cov_ok=0; fi
-done
-[ "$cov_ok" = 1 ] && ok "all async leaves completed with correct verdicts" || ko "missing/incorrect"
-
-# Claim 4: crash-resume — kill a running leaf-job mid-run, entry reclaimed, still completes
-claim 4 "Crash mid-run → reclaimed → resumes → verdict"
-RID="$RUN/r1"; adispatch "r1" "$MODEL" "$INPUTS/i1.json" >/dev/null
-# wait for a running leaf-job pod, then kill it
-killed=0
-for _ in $(seq 1 24); do
-  pod=$(kubectl get pods -n "$NS" -l scaledjob.keda.sh/name=leaf-worker --field-selector=status.phase=Running --no-headers 2>/dev/null | awk '{print $1}' | head -1)
-  [ -n "$pod" ] && { kubectl delete pod -n "$NS" "$pod" --force --grace-period=0 >/dev/null 2>&1; killed=1; break; }
-  sleep 5
-done
-res_ok=""
-for _ in $(seq 1 72); do
-  if oexec test -f "$RES/r1.json.status"; then res_ok=$(oexec sh -c "jq -r .status $RES/r1.json.status"); break; fi
-  sleep 5
-done
-if [ "$killed" = 1 ] && [ "$res_ok" = "done" ] && oexec sh -c "jq -e .verdict $RES/r1.json >/dev/null 2>&1"; then
-  ok "killed a running leaf-job; reclaimed + resumed → verdict produced"
-else
-  ko "crash-resume: killed=$killed status=$res_ok"
-fi
-
-# Claim 5: scale-to-zero when queue drains
-claim 5 "Scale-to-zero: no leaf-job pods when idle"
-zero=0
-for _ in $(seq 1 36); do [ "$(leaf_job_pods)" = "0" ] && { zero=1; break; }; sleep 5; done
-[ "$zero" = 1 ] && ok "leaf-worker scaled to zero" || ko "leaf-job pods still running"
-
-# Claim 6: deterministic failure → failed marker, no result, no infinite reprocess
-claim 6 "Bad inputs → failed marker, no result_ref"
-adispatch "ineg" "$MODEL" "$INPUTS/does-not-exist.json" >/dev/null
-neg=""
-for _ in $(seq 1 36); do
-  if oexec test -f "$RES/ineg.json.status"; then neg=$(oexec sh -c "jq -r .reason $RES/ineg.json.status"); break; fi
-  sleep 5
-done
-if [ "$neg" = "bad_inputs" ] && ! oexec test -f "$RES/ineg.json"; then ok "failed (bad_inputs), no result_ref"; else ko "reason=$neg"; fi
-
-kubectl -n "$NS" exec "$SBOX" -- sh -c "rm -rf /workspace/$RUN" 2>/dev/null || true
-echo ""; echo "=== Results: $PASS passed, $FAIL failed ==="
-if [ "$FAIL" -gt 0 ]; then echo "ASYNC SMOKE FAIL"; exit 1; else echo "ASYNC SMOKE PASS"; exit 0; fi
-```
-
-- [ ] **Step 2: Make it executable and syntax-check**
-
-Run: `chmod +x deploy/knative/leaf-async-smoke.sh && bash -n deploy/knative/leaf-async-smoke.sh && echo OK`
-Expected: `OK`. Gate honored: `bash deploy/knative/leaf-async-smoke.sh` (no env) prints `SKIP`.
-
-- [ ] **Step 3: Rebuild image, (re)deploy, install KEDA + ScaledJob, run the gate**
-
-Redirect verbose output to logs (CLAUDE.md context-budget); analyze failures in a subagent.
-
-```bash
-export LOG_DIR=/tmp/kagenti/leaf-async; mkdir -p $LOG_DIR
-# KEDA + ScaledJob (setup-kind.sh installs KEDA; or apply the release directly once)
-kubectl get crd scaledjobs.keda.sh >/dev/null 2>&1 || kubectl apply --server-side -f https://github.com/kedacore/keda/releases/download/v2.14.0/keda-v2.14.0.yaml > $LOG_DIR/keda.log 2>&1
-kubectl wait --for=condition=Available deployment --all -n keda --timeout=180s >> $LOG_DIR/keda.log 2>&1; echo "keda:EXIT:$?"
-# rebuild + reload the image (now has leaf-job.ts + async routes)
-docker build --load -t dev.local/serverless-harness:local . > $LOG_DIR/build.log 2>&1 && kind load docker-image dev.local/serverless-harness:local --name sh-knative >> $LOG_DIR/build.log 2>&1; echo "build:EXIT:$?"
-kubectl apply -f deploy/knative/leaf-scaledjob.yaml > $LOG_DIR/sj.log 2>&1; echo "sj:EXIT:$?"
-# ensure PVC + orchestrator present (from the gate-7/Task-6 work)
-kubectl apply -f deploy/knative/leaf-pvc.yaml -f deploy/knative/leaf-orchestrator.yaml >> $LOG_DIR/sj.log 2>&1
-ASYNC_LIVE_SMOKE=1 bash deploy/knative/leaf-async-smoke.sh > $LOG_DIR/smoke.log 2>&1; echo "smoke:EXIT:$?"
-```
-
-Expected: `/tmp/kagenti/leaf-async/smoke.log` ends with `ASYNC SMOKE PASS` (6 claims). If a claim fails, analyze the log + `kubectl get jobs,pods -l scaledjob.keda.sh/name=leaf-worker` and the KEDA operator logs in a subagent — do not read whole logs in the main context.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/leaf-async-smoke.sh
-git commit -s -m "test(keda): gated async smoke — accept, scale-out, done-marker, crash-resume, scale-to-zero"
-```
-
----
-
-## Self-Review
-
-**Spec coverage (design §2–§9):**
-- §2 architecture / control-plane vs data-plane → Tasks 6 (enqueue/status) + 7 (job) + 8 (ScaledJob). ✓
-- §3.1 envelope additions (`async`/`doneMarkerRef`/`tenant`) → Task 4. ✓
-- §3.2 enqueue `202` → Task 6. §3.3 atomic done-marker → Task 2. §3.4 status endpoint → Task 6. ✓
-- §3.5 idempotency/at-least-once → reuses gate-7 (`runLeaf` unchanged, Task 4 only adds fields) + Task 1 reclaim. ✓
-- §4 queue + KEDA (group, lifecycle, heartbeat, dead-letter, scaler) → Task 1 (queue incl. `touch`/`pending`/delivery-count) + Task 8 (ScaledJob). ✓
-- §5 leaf-job + classifyOutcome table → Task 3 (pure) + Task 5 (runner) + Task 7 (entrypoint). ✓
-- §6.1 unit coverage → Tasks 1,2,3,4,5,6. §6.2 live gate (6 claims) → Task 9. ✓
-- §7 tenant non-precluding → Task 4 (`leafSessionId` prefix; single shared queue). ✓
-- §8 scope/YAGNI; §9 prereqs (KEDA install) → Task 8. ✓
-
-**Placeholder scan:** none — every code/test/command step is concrete. The Task 7 import-resolution check is intentionally loose (it may block on Redis) and offers the vitest-passes fallback as the real signal.
-
-**Type consistency:** `LeafResult`/`LeafEnvelope` (run-leaf) consumed identically by `classifyOutcome` (T3), `leaf-job-runner` (T5), the entrypoint (T7), and the route (T6). `WorkQueue`/`ClaimedEntry` (T1) consumed by `leaf-job-runner` (T5) and the entrypoint (T7). `DoneMarker`/`deriveDoneMarkerPath`/`writeDoneMarker`/`readDoneMarker` (T2) consumed by T5 (write) and T6 (read/derive). `leafSessionId` (T4) consumed by T6's import (reserved) and used in `realProduceVerdict`. The `processOne` outcome union (`"done"|"failed"|"deadletter"|"idle"|"retry"`) matches the entrypoint's drain loop checks.
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-28-human-gate.md b/docs/superpowers/plans/2026-06-28-human-gate.md
deleted file mode 100644
index d700850..0000000
--- a/docs/superpowers/plans/2026-06-28-human-gate.md
+++ /dev/null
@@ -1,1425 +0,0 @@
-# Human-Gate (Gate-While-Idle, Archetype B) Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Add a human-in-the-loop gate so a single leaf session can pause mid-pipeline awaiting an external human decision, park in durable state (pod → zero), and resume with the decision injected — preserving context across one or more gates before a verdict.
-
-**Architecture:** Additive on top of the leaf-session contract + gate-7 resume + the async queue/KEDA substrate. An agent calls a `request_approval` tool (ends the turn well-formed, records a durable `gate-request` entry, parks). `runLeaf` writes an `awaiting_approval` gate marker; the session sits in Redis. An external approver writes a `decisionRef` file (echoing `gateId`) and re-invokes the same `sessionId`; `runLeaf` resumes, records a durable `gate-decision` entry, re-seeds a continuation prompt (approve/reject) or returns `aborted`, and runs to a verdict. All pure gate logic lives in `gate.ts` (fully unit-tested); `runLeaf` wiring is exercised by the live smoke. Every existing path is untouched.
-
-**Tech Stack:** TypeScript (ESM, `.js` import specifiers), Node 20, vitest, pnpm workspaces (`@sh/*`), Pi coding agent (`@earendil-works/pi-coding-agent`), Redis Streams, Knative + KEDA on Kind.
-
-## Global Constraints
-
-- **Spec:** `docs/specs/2026-06-28-human-gate-design.md` — every task implements part of it.
-- **No change to any existing path:** sync `POST /runs`, async enqueue, cron-dispatch, `leaf-queue`, the KEDA `ScaledJob`, `submit_verdict`, the leaf-job runner loop, and the heartbeat/dead-letter machinery stay behavior-identical. A leaf that never calls `request_approval` behaves exactly as today.
-- **Decisions (spec §1 B1–B5):** agent-declared gate, external decision authority + re-invocation (B1); continuation-prompt resume, no tool-result injection (B2); `decisionRef` file transport + re-invoke-by-`sessionId` trigger (B3); no harness-side timeout — park indefinitely (B4); actions `approve`/`reject`/`abort` (B5).
-- **`gateId`** is a per-session monotonic integer = count of prior `gate-request` entries (0, 1, 2, …). A decision applies only when `decision.gateId` matches the pending gate's `gateId`.
-- **Two marker kinds:** the **gate marker** (`awaiting_approval`, non-terminal) is written by **`runLeaf`** to `gateRef` (default `<resultRef>.gate`). The **terminal** marker (`done`/`failed`/`aborted`) is written by the queue runner (async) or conveyed by the HTTP response (sync), at `<resultRef>.status`. They are distinct files.
-- **Auto-approve mode is NOT built** (shaped-for only).
-- **TDD:** write the failing test first; pure logic in `gate.ts` is unit-tested; `realProduceVerdict` wiring is verified by the live smoke (consistent with the existing code, which carries the same note).
-- **DCO:** every commit uses `git commit -s`. Conventional prefixes (`feat:`, `test:`, `docs:`). Attribution only where needed: `Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>`.
-- **Branch:** `feat/human-gate` (already created; spec already committed there).
-- **Run unit tests from the repo root:** `pnpm --filter @sh/harness test` (harness) / `pnpm --filter @sh/knative-server test` (server). Single file: `pnpm --filter @sh/harness exec vitest run test/<file>`.
-
----
-
-## File Structure
-
-**Create:**
-- `harness/src/gate.ts` — all pure gate logic: types, `validateDecision`, `readDecision`, entry-type constants + predicates/extractors, `computeGateState`, `continuationPrompt`, `decideSeed`.
-- `harness/src/request-approval-tool.ts` — `requestApprovalExtension` + `GateCapture` + `GateSink`.
-- `harness/src/gate-marker.ts` — `GateMarker` type, `deriveGateRef`, `writeGateMarker`, `readGateMarker`.
-- `harness/test/gate.test.ts`, `harness/test/request-approval-tool.test.ts`, `harness/test/gate-marker.test.ts`.
-- `deploy/knative/leaf-gate-smoke.sh` — gated live gate.
-
-**Modify:**
-- `harness/src/run-leaf.ts` — `LeafEnvelope` (+`gateRef`/`decisionRef`), `LeafResult` (+`paused`/`aborted`), `LeafItem` (+`require_approval`), `buildLeafPrompt` (gate instruction), `LeafCapture`, `runLeaf` outer (capture → gate marker / paused / aborted), `realProduceVerdict` (gate front-end wiring).
-- `harness/src/classify-outcome.ts` — `Outcome.marker` status union +`aborted`; `paused`/`aborted` branches.
-- `harness/src/done-marker.ts` — `DoneMarker.status` +`aborted`.
-- `packages/knative-server/src/server.ts` — status endpoint reports `awaiting_approval` from the gate marker.
-- `harness/test/run-leaf.test.ts`, `harness/test/classify-outcome.test.ts`, `packages/knative-server/test/run-leaf-async-route.test.ts` — extend.
-
----
-
-## Task 1: Gate types, decision validation, and entry helpers (`gate.ts` part 1)
-
-**Files:**
-- Create: `harness/src/gate.ts`
-- Test: `harness/test/gate.test.ts`
-
-**Interfaces:**
-- Produces: `GateAction = "approve"|"reject"|"abort"`; `interface GateRequest { gateId: number; summary: string; proposed_action: string }`; `interface Decision { gateId: number; action: GateAction; feedback?: string }`; `interface GateDecision { gateId: number; action: GateAction; feedback?: string }`; `GATE_REQUEST_ENTRY_TYPE = "gate-request"`; `GATE_DECISION_ENTRY_TYPE = "gate-decision"`; `validateDecision(obj: unknown): { ok: true; value: Decision } | { ok: false; error: string }`; `readDecision(decisionRef: string): Decision | null`; `isGateRequestEntry(entry: unknown): boolean`; `isGateDecisionEntry(entry: unknown): boolean`; `gateRequestFromEntry(entry: unknown): GateRequest | null`; `gateDecisionFromEntry(entry: unknown): GateDecision | null`.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/gate.test.ts
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  validateDecision, readDecision,
-  isGateRequestEntry, isGateDecisionEntry, gateRequestFromEntry, gateDecisionFromEntry,
-  GATE_REQUEST_ENTRY_TYPE, GATE_DECISION_ENTRY_TYPE,
-} from "../src/gate";
-
-let dir: string;
-beforeEach(() => { dir = mkdtempSync(join(tmpdir(), "gate-")); });
-afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
-
-describe("validateDecision", () => {
-  it("accepts approve/reject/abort with a numeric gateId", () => {
-    expect(validateDecision({ gateId: 0, action: "approve" })).toEqual({
-      ok: true, value: { gateId: 0, action: "approve", feedback: undefined },
-    });
-    expect(validateDecision({ gateId: 2, action: "reject", feedback: "do X" })).toEqual({
-      ok: true, value: { gateId: 2, action: "reject", feedback: "do X" },
-    });
-    expect(validateDecision({ gateId: 1, action: "abort" }).ok).toBe(true);
-  });
-  it("rejects a bad action, missing gateId, or non-object", () => {
-    expect(validateDecision({ gateId: 0, action: "maybe" }).ok).toBe(false);
-    expect(validateDecision({ action: "approve" }).ok).toBe(false);
-    expect(validateDecision(null).ok).toBe(false);
-  });
-});
-
-describe("readDecision", () => {
-  it("reads and validates a decision file; null on missing/garbled/invalid", () => {
-    const p = join(dir, "d.json");
-    writeFileSync(p, JSON.stringify({ gateId: 0, action: "approve" }));
-    expect(readDecision(p)).toEqual({ gateId: 0, action: "approve", feedback: undefined });
-    expect(readDecision(join(dir, "nope.json"))).toBeNull();
-    writeFileSync(p, "{not json");
-    expect(readDecision(p)).toBeNull();
-    writeFileSync(p, JSON.stringify({ gateId: 0, action: "nope" }));
-    expect(readDecision(p)).toBeNull();
-  });
-});
-
-describe("entry helpers", () => {
-  const req = { type: "custom", customType: GATE_REQUEST_ENTRY_TYPE, data: { gateId: 0, summary: "s", proposed_action: "a" } };
-  const dec = { type: "custom", customType: GATE_DECISION_ENTRY_TYPE, data: { gateId: 0, action: "approve" } };
-  it("recognizes and extracts gate-request entries", () => {
-    expect(isGateRequestEntry(req)).toBe(true);
-    expect(isGateRequestEntry(dec)).toBe(false);
-    expect(gateRequestFromEntry(req)).toEqual({ gateId: 0, summary: "s", proposed_action: "a" });
-    expect(gateRequestFromEntry(dec)).toBeNull();
-  });
-  it("recognizes and extracts gate-decision entries", () => {
-    expect(isGateDecisionEntry(dec)).toBe(true);
-    expect(gateDecisionFromEntry(dec)).toEqual({ gateId: 0, action: "approve", feedback: undefined });
-    expect(gateDecisionFromEntry(req)).toBeNull();
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/gate.test.ts`
-Expected: FAIL — `Cannot find module '../src/gate'`.
-
-- [ ] **Step 3: Write minimal implementation**
-
-```typescript
-// harness/src/gate.ts
-import { readFileSync } from "node:fs";
-
-export type GateAction = "approve" | "reject" | "abort";
-
-export interface GateRequest {
-  gateId: number;
-  summary: string;
-  proposed_action: string;
-}
-
-export interface Decision {
-  gateId: number;
-  action: GateAction;
-  feedback?: string;
-}
-
-/** Same shape as Decision; persisted as a durable custom entry to mark a gate consumed. */
-export type GateDecision = Decision;
-
-export const GATE_REQUEST_ENTRY_TYPE = "gate-request";
-export const GATE_DECISION_ENTRY_TYPE = "gate-decision";
-
-export function validateDecision(
-  obj: unknown,
-): { ok: true; value: Decision } | { ok: false; error: string } {
-  if (typeof obj !== "object" || obj === null) return { ok: false, error: "decision must be an object" };
-  const o = obj as Record<string, unknown>;
-  if (typeof o.gateId !== "number" || !Number.isInteger(o.gateId) || o.gateId < 0) {
-    return { ok: false, error: "gateId must be a non-negative integer" };
-  }
-  if (o.action !== "approve" && o.action !== "reject" && o.action !== "abort") {
-    return { ok: false, error: 'action must be "approve", "reject", or "abort"' };
-  }
-  if (o.feedback !== undefined && typeof o.feedback !== "string") {
-    return { ok: false, error: "feedback must be a string when present" };
-  }
-  return { ok: true, value: { gateId: o.gateId, action: o.action, feedback: o.feedback as string | undefined } };
-}
-
-/** Read + validate the orchestrator-written decision file. Null on missing/garbled/invalid. */
-export function readDecision(decisionRef: string): Decision | null {
-  try {
-    const r = validateDecision(JSON.parse(readFileSync(decisionRef, "utf8")));
-    return r.ok ? r.value : null;
-  } catch {
-    return null;
-  }
-}
-
-type CustomEntry = { type?: string; customType?: string; data?: unknown };
-
-export function isGateRequestEntry(entry: unknown): boolean {
-  const e = entry as CustomEntry | null;
-  return !!e && e.type === "custom" && e.customType === GATE_REQUEST_ENTRY_TYPE;
-}
-
-export function isGateDecisionEntry(entry: unknown): boolean {
-  const e = entry as CustomEntry | null;
-  return !!e && e.type === "custom" && e.customType === GATE_DECISION_ENTRY_TYPE;
-}
-
-export function gateRequestFromEntry(entry: unknown): GateRequest | null {
-  if (!isGateRequestEntry(entry)) return null;
-  const d = (entry as CustomEntry).data as Record<string, unknown> | undefined;
-  if (!d || typeof d.gateId !== "number" || typeof d.summary !== "string" || typeof d.proposed_action !== "string") {
-    return null;
-  }
-  return { gateId: d.gateId, summary: d.summary, proposed_action: d.proposed_action };
-}
-
-export function gateDecisionFromEntry(entry: unknown): GateDecision | null {
-  if (!isGateDecisionEntry(entry)) return null;
-  const r = validateDecision((entry as CustomEntry).data);
-  return r.ok ? r.value : null;
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/gate.test.ts`
-Expected: PASS (3 describes).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/gate.ts harness/test/gate.test.ts
-git commit -s -m "feat(gate): Add gate types, decision validation, and entry helpers"
-```
-
----
-
-## Task 2: Gate-state computation + continuation prompt (`gate.ts` part 2)
-
-**Files:**
-- Modify: `harness/src/gate.ts`
-- Test: `harness/test/gate.test.ts` (extend)
-
-**Interfaces:**
-- Consumes: `GateRequest`, `GateDecision`, the entry helpers (Task 1).
-- Produces: `interface GateState { gateRequests: GateRequest[]; gateDecisions: GateDecision[]; pendingGate: GateRequest | null; lastDecision: GateDecision | null; nextGateId: number }`; `computeGateState(entries: unknown[]): GateState`; `continuationPrompt(action: "approve" | "reject", feedback?: string): string`.
-
-- [ ] **Step 1: Write the failing test** (append to `harness/test/gate.test.ts`)
-
-```typescript
-import { computeGateState, continuationPrompt } from "../src/gate";
-
-function reqEntry(gateId: number) {
-  return { type: "custom", customType: "gate-request", data: { gateId, summary: `s${gateId}`, proposed_action: `a${gateId}` } };
-}
-function decEntry(gateId: number, action = "approve", feedback?: string) {
-  return { type: "custom", customType: "gate-decision", data: { gateId, action, feedback } };
-}
-
-describe("computeGateState", () => {
-  it("no gates → no pending, nextGateId 0", () => {
-    const s = computeGateState([{ type: "user" }]);
-    expect(s.pendingGate).toBeNull();
-    expect(s.lastDecision).toBeNull();
-    expect(s.nextGateId).toBe(0);
-  });
-  it("one undecided request → it is pending, nextGateId 1", () => {
-    const s = computeGateState([reqEntry(0)]);
-    expect(s.pendingGate).toEqual({ gateId: 0, summary: "s0", proposed_action: "a0" });
-    expect(s.nextGateId).toBe(1);
-  });
-  it("decided request → no pending, lastDecision set", () => {
-    const s = computeGateState([reqEntry(0), decEntry(0, "approve")]);
-    expect(s.pendingGate).toBeNull();
-    expect(s.lastDecision).toEqual({ gateId: 0, action: "approve", feedback: undefined });
-  });
-  it("second request after a decided first → second is pending, nextGateId 2", () => {
-    const s = computeGateState([reqEntry(0), decEntry(0), reqEntry(1)]);
-    expect(s.pendingGate?.gateId).toBe(1);
-    expect(s.nextGateId).toBe(2);
-  });
-});
-
-describe("continuationPrompt", () => {
-  it("approve mentions APPROVED and submit_verdict", () => {
-    const p = continuationPrompt("approve", "looks good");
-    expect(p).toContain("APPROVED");
-    expect(p).toContain("looks good");
-    expect(p).toContain("submit_verdict");
-  });
-  it("reject mentions REJECTED and revise", () => {
-    const p = continuationPrompt("reject", "fix the query");
-    expect(p).toContain("REJECTED");
-    expect(p).toContain("fix the query");
-    expect(p.toLowerCase()).toContain("revise");
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/gate.test.ts`
-Expected: FAIL — `computeGateState`/`continuationPrompt` not exported.
-
-- [ ] **Step 3: Write minimal implementation** (append to `harness/src/gate.ts`)
-
-```typescript
-export interface GateState {
-  gateRequests: GateRequest[];
-  gateDecisions: GateDecision[];
-  pendingGate: GateRequest | null;
-  lastDecision: GateDecision | null;
-  nextGateId: number;
-}
-
-/** Derive gate state from the durable session entries (the .entry payloads from store.read). */
-export function computeGateState(entries: unknown[]): GateState {
-  const gateRequests = entries.map(gateRequestFromEntry).filter((r): r is GateRequest => r !== null);
-  const gateDecisions = entries.map(gateDecisionFromEntry).filter((d): d is GateDecision => d !== null);
-  const decidedIds = new Set(gateDecisions.map((d) => d.gateId));
-  // At most one gate is unanswered at a time (gates are sequential); pick the latest undecided.
-  let pendingGate: GateRequest | null = null;
-  for (const r of gateRequests) {
-    if (!decidedIds.has(r.gateId)) pendingGate = r;
-  }
-  const lastDecision = gateDecisions.length ? gateDecisions[gateDecisions.length - 1] : null;
-  return { gateRequests, gateDecisions, pendingGate, lastDecision, nextGateId: gateRequests.length };
-}
-
-export function continuationPrompt(action: "approve" | "reject", feedback?: string): string {
-  if (action === "approve") {
-    return [
-      `Human decision: APPROVED.${feedback ? ` ${feedback}` : ""}`,
-      `Proceed with the proposed action. When finished, call submit_verdict exactly once, then stop.`,
-    ].join("\n");
-  }
-  return [
-    `Human decision: REJECTED. ${feedback ?? "No feedback provided."}`,
-    `Revise accordingly. You may call request_approval again when ready, or call submit_verdict when done.`,
-  ].join("\n");
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/gate.test.ts`
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/gate.ts harness/test/gate.test.ts
-git commit -s -m "feat(gate): Add gate-state computation and continuation prompt"
-```
-
----
-
-## Task 3: The seed/decision state machine (`decideSeed`)
-
-**Files:**
-- Modify: `harness/src/gate.ts`
-- Test: `harness/test/gate.test.ts` (extend)
-
-**Interfaces:**
-- Consumes: `GateState`, `Decision`, `GateDecision`, `continuationPrompt` (Tasks 1–2).
-- Produces: `type SeedDecision = { kind: "paused"; gate: GateRequest } | { kind: "abort"; record: GateDecision | null } | { kind: "seed"; prompt: string; record: GateDecision | null }`; `decideSeed(state: GateState, decision: Decision | null, freshPrompt: string): SeedDecision`.
-
-- [ ] **Step 1: Write the failing test** (append to `harness/test/gate.test.ts`)
-
-```typescript
-import { decideSeed } from "../src/gate";
-
-const FRESH = "FRESH_PROMPT";
-function state(entries: unknown[]) { return computeGateState(entries); }
-
-describe("decideSeed", () => {
-  it("fresh (no gates) → seed the fresh prompt, no record", () => {
-    expect(decideSeed(state([]), null, FRESH)).toEqual({ kind: "seed", prompt: FRESH, record: null });
-  });
-  it("pending gate + matching approve → seed continuation + record decision", () => {
-    const r = decideSeed(state([reqEntry(0)]), { gateId: 0, action: "approve" }, FRESH);
-    expect(r.kind).toBe("seed");
-    if (r.kind === "seed") {
-      expect(r.prompt).toContain("APPROVED");
-      expect(r.record).toEqual({ gateId: 0, action: "approve", feedback: undefined });
-    }
-  });
-  it("pending gate + matching reject → seed continuation with feedback", () => {
-    const r = decideSeed(state([reqEntry(0)]), { gateId: 0, action: "reject", feedback: "redo" }, FRESH);
-    expect(r.kind).toBe("seed");
-    if (r.kind === "seed") expect(r.prompt).toContain("redo");
-  });
-  it("pending gate + matching abort → abort + record", () => {
-    expect(decideSeed(state([reqEntry(0)]), { gateId: 0, action: "abort" }, FRESH)).toEqual({
-      kind: "abort", record: { gateId: 0, action: "abort", feedback: undefined },
-    });
-  });
-  it("pending gate + no decision → paused", () => {
-    expect(decideSeed(state([reqEntry(0)]), null, FRESH)).toEqual({
-      kind: "paused", gate: { gateId: 0, summary: "s0", proposed_action: "a0" },
-    });
-  });
-  it("pending gate + gateId mismatch → paused (stale decision ignored)", () => {
-    expect(decideSeed(state([reqEntry(1)]), { gateId: 0, action: "approve" }, FRESH).kind).toBe("paused");
-  });
-  it("already-decided this gate (double resume) → seed continuation, record null (no re-record)", () => {
-    // The decision entry for gate 0 already exists, so the gate is no longer pending.
-    const r = decideSeed(state([reqEntry(0), decEntry(0, "approve")]), { gateId: 0, action: "approve" }, FRESH);
-    expect(r.kind).toBe("seed");
-    if (r.kind === "seed") { expect(r.prompt).toContain("APPROVED"); expect(r.record).toBeNull(); }
-  });
-  it("already-aborted session (no pending, last decision abort) → terminal abort, record null", () => {
-    expect(decideSeed(state([reqEntry(0), decEntry(0, "abort")]), null, FRESH)).toEqual({
-      kind: "abort", record: null,
-    });
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/gate.test.ts`
-Expected: FAIL — `decideSeed` not exported.
-
-- [ ] **Step 3: Write minimal implementation** (append to `harness/src/gate.ts`)
-
-```typescript
-export type SeedDecision =
-  | { kind: "paused"; gate: GateRequest }
-  | { kind: "abort"; record: GateDecision | null }
-  | { kind: "seed"; prompt: string; record: GateDecision | null };
-
-/**
- * Decide what a runLeaf invocation should do, given the durable gate state, the (optional) decision
- * read from decisionRef, and the fresh job-mode prompt. Pure: the caller performs the side effects
- * (append `record`, run `session.prompt(prompt)`, set capture flags). See spec §3.
- */
-export function decideSeed(state: GateState, decision: Decision | null, freshPrompt: string): SeedDecision {
-  const { pendingGate, lastDecision, gateDecisions } = state;
-  const decidedIds = new Set(gateDecisions.map((d) => d.gateId));
-
-  if (pendingGate) {
-    if (decision && decision.gateId === pendingGate.gateId) {
-      const record: GateDecision | null = decidedIds.has(pendingGate.gateId)
-        ? null
-        : { gateId: decision.gateId, action: decision.action, feedback: decision.feedback };
-      if (decision.action === "abort") return { kind: "abort", record };
-      return { kind: "seed", prompt: continuationPrompt(decision.action, decision.feedback), record };
-    }
-    return { kind: "paused", gate: pendingGate };
-  }
-
-  // No pending gate. A prior abort is terminal; otherwise re-derive the last continuation, else fresh.
-  if (lastDecision?.action === "abort") return { kind: "abort", record: null };
-  const prompt = lastDecision ? continuationPrompt(lastDecision.action, lastDecision.feedback) : freshPrompt;
-  return { kind: "seed", prompt, record: null };
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/gate.test.ts`
-Expected: PASS (all gate describes).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/gate.ts harness/test/gate.test.ts
-git commit -s -m "feat(gate): Add decideSeed state machine (pause/abort/seed + idempotency)"
-```
-
----
-
-## Task 4: `request_approval` tool extension
-
-**Files:**
-- Create: `harness/src/request-approval-tool.ts`
-- Test: `harness/test/request-approval-tool.test.ts`
-
-**Interfaces:**
-- Consumes: `GateRequest`, `GATE_REQUEST_ENTRY_TYPE` (Task 1).
-- Produces: `interface GateCapture { gate?: GateRequest; aborted?: boolean }`; `interface GateSink { appendCustomEntry(customType: string, data?: unknown): string }`; `requestApprovalExtension(capture: GateCapture, sink: GateSink | undefined, nextGateId: number): ExtensionFactory`.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/request-approval-tool.test.ts
-import { describe, it, expect } from "vitest";
-import { requestApprovalExtension, type GateCapture } from "../src/request-approval-tool";
-
-function fakePi() {
-  const tools: any[] = [];
-  return { api: { registerTool: (t: any) => tools.push(t), on: () => {} } as any, tools };
-}
-
-describe("requestApprovalExtension", () => {
-  it("registers a request_approval tool", () => {
-    const { api, tools } = fakePi();
-    requestApprovalExtension({}, undefined, 0)(api);
-    expect(tools).toHaveLength(1);
-    expect(tools[0].name).toBe("request_approval");
-  });
-
-  it("captures the gate (with nextGateId) and appends a durable gate-request entry", async () => {
-    const capture: GateCapture = {};
-    const appended: Array<{ t: string; d: unknown }> = [];
-    const sink = { appendCustomEntry: (t: string, d?: unknown) => { appended.push({ t, d }); return "id"; } };
-    const { api, tools } = fakePi();
-    requestApprovalExtension(capture, sink, 3)(api);
-    const res = await tools[0].execute("call-1", { summary: "did X", proposed_action: "do Y" }, undefined, undefined, {} as any);
-    expect(capture.gate).toEqual({ gateId: 3, summary: "did X", proposed_action: "do Y" });
-    expect(appended).toEqual([{ t: "gate-request", d: { gateId: 3, summary: "did X", proposed_action: "do Y" } }]);
-    expect(res.isError).toBeFalsy();
-  });
-
-  it("rejects empty summary/proposed_action and does not capture or append", async () => {
-    const capture: GateCapture = {};
-    const appended: unknown[] = [];
-    const sink = { appendCustomEntry: (t: string, d?: unknown) => { appended.push({ t, d }); return "id"; } };
-    const { api, tools } = fakePi();
-    requestApprovalExtension(capture, sink, 0)(api);
-    const res = await tools[0].execute("c", { summary: "", proposed_action: "y" }, undefined, undefined, {} as any);
-    expect(capture.gate).toBeUndefined();
-    expect(appended).toHaveLength(0);
-    expect(res.isError).toBe(true);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/request-approval-tool.test.ts`
-Expected: FAIL — module not found.
-
-- [ ] **Step 3: Write minimal implementation**
-
-```typescript
-// harness/src/request-approval-tool.ts
-import type { ExtensionAPI, ExtensionFactory } from "@earendil-works/pi-coding-agent";
-import { GATE_REQUEST_ENTRY_TYPE, type GateRequest } from "./gate.js";
-
-export interface GateCapture {
-  gate?: GateRequest;
-  aborted?: boolean;
-}
-
-/** Minimal slice of SessionManager the tool needs to persist the gate request durably. */
-export interface GateSink {
-  appendCustomEntry(customType: string, data?: unknown): string;
-}
-
-const params = {
-  type: "object",
-  properties: {
-    summary: { type: "string", description: "A short summary of what you have done / decided so far (the human reads this)" },
-    proposed_action: { type: "string", description: "The action you propose to take next, pending sign-off" },
-  },
-  required: ["summary", "proposed_action"],
-};
-
-/**
- * Registers the `request_approval` tool. On a valid call it (1) captures the gate in-memory with the
- * caller-supplied `nextGateId` and (2) — when a `sink` is provided — appends a durable `gate-request`
- * custom entry, so a resumed session can detect the pending gate. The tool returns a benign result so
- * the assistant turn ends well-formed (no dangling tool call); runLeaf parks at the loop boundary.
- */
-export function requestApprovalExtension(
-  capture: GateCapture,
-  sink: GateSink | undefined,
-  nextGateId: number,
-): ExtensionFactory {
-  return (pi: ExtensionAPI) => {
-    pi.registerTool({
-      name: "request_approval",
-      label: "Request approval",
-      description:
-        "Request human approval before proceeding. Provide a summary of what you've done and the " +
-        "action you propose. Call this at most once, then stop; the session pauses and resumes with " +
-        "the human's decision.",
-      parameters: params,
-      async execute(_id, args) {
-        const summary = (args as { summary?: unknown })?.summary;
-        const proposed_action = (args as { proposed_action?: unknown })?.proposed_action;
-        if (typeof summary !== "string" || summary.length === 0 ||
-            typeof proposed_action !== "string" || proposed_action.length === 0) {
-          return { isError: true, content: [{ type: "text", text: "Invalid request_approval: summary and proposed_action must be non-empty strings" }] };
-        }
-        const gate: GateRequest = { gateId: nextGateId, summary, proposed_action };
-        capture.gate = gate;
-        sink?.appendCustomEntry(GATE_REQUEST_ENTRY_TYPE, gate);
-        return { content: [{ type: "text", text: "Approval requested; the session will pause and resume with the human decision." }] };
-      },
-    } as any);
-  };
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/request-approval-tool.test.ts`
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/request-approval-tool.ts harness/test/request-approval-tool.test.ts
-git commit -s -m "feat(gate): Add request_approval tool extension"
-```
-
----
-
-## Task 5: Gate marker I/O (`gate-marker.ts`)
-
-**Files:**
-- Create: `harness/src/gate-marker.ts`
-- Test: `harness/test/gate-marker.test.ts`
-
-**Interfaces:**
-- Produces: `interface GateMarker { status: "awaiting_approval"; sessionId: string; gateId: number; gate: { summary: string; proposed_action: string }; ts: string }`; `deriveGateRef(resultRef: string, override?: string): string`; `writeGateMarker(path: string, marker: GateMarker): void`; `readGateMarker(path: string): GateMarker | null`.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/gate-marker.test.ts
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { deriveGateRef, writeGateMarker, readGateMarker, type GateMarker } from "../src/gate-marker";
-
-let dir: string;
-beforeEach(() => { dir = mkdtempSync(join(tmpdir(), "gatemk-")); });
-afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
-
-describe("deriveGateRef", () => {
-  it("defaults to <resultRef>.gate and honors an override", () => {
-    expect(deriveGateRef("/work/r/out.json")).toBe("/work/r/out.json.gate");
-    expect(deriveGateRef("/work/r/out.json", "/work/r/custom.gate")).toBe("/work/r/custom.gate");
-  });
-});
-
-describe("gate marker write/read", () => {
-  it("round-trips an awaiting_approval marker (and creates parent dirs)", () => {
-    const p = join(dir, "nested", "out.json.gate");
-    const m: GateMarker = {
-      status: "awaiting_approval", sessionId: "run/i1", gateId: 0,
-      gate: { summary: "s", proposed_action: "a" }, ts: "2026-06-28T00:00:00.000Z",
-    };
-    writeGateMarker(p, m);
-    expect(existsSync(p)).toBe(true);
-    expect(readGateMarker(p)).toEqual(m);
-  });
-  it("returns null for a missing/garbled file", () => {
-    expect(readGateMarker(join(dir, "nope.gate"))).toBeNull();
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/gate-marker.test.ts`
-Expected: FAIL — module not found.
-
-- [ ] **Step 3: Write minimal implementation**
-
-```typescript
-// harness/src/gate-marker.ts
-import { writeFileSync, renameSync, readFileSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-
-export interface GateMarker {
-  status: "awaiting_approval";
-  sessionId: string;
-  gateId: number;
-  gate: { summary: string; proposed_action: string };
-  ts: string;
-}
-
-export function deriveGateRef(resultRef: string, override?: string): string {
-  return override && override.length > 0 ? override : `${resultRef}.gate`;
-}
-
-/** Write atomically (temp + rename) so a reader never observes a partial marker. */
-export function writeGateMarker(path: string, marker: GateMarker): void {
-  const tmp = `${path}.tmp`;
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(tmp, JSON.stringify(marker));
-  renameSync(tmp, path);
-}
-
-export function readGateMarker(path: string): GateMarker | null {
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as GateMarker;
-  } catch {
-    return null;
-  }
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/gate-marker.test.ts`
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/gate-marker.ts harness/test/gate-marker.test.ts
-git commit -s -m "feat(gate): Add awaiting_approval gate marker I/O"
-```
-
----
-
-## Task 6: `classifyOutcome` + `DoneMarker` for paused/aborted
-
-**Files:**
-- Modify: `harness/src/classify-outcome.ts`, `harness/src/done-marker.ts`
-- Test: `harness/test/classify-outcome.test.ts` (extend)
-
-**Interfaces:**
-- Consumes: `LeafResult` (extended in Task 7 with `paused`/`aborted` — this task references those statuses; if Task 7 has not run yet, add the two `LeafResult` variants to `run-leaf.ts` as the first step here so the types compile, then Task 7 builds on them).
-- Produces: `Outcome.marker` status union becomes `"done" | "failed" | "aborted"`; `classifyOutcome` handles `paused` (`{ ack: true, marker: null, retryable: false }`) and `aborted` (`{ ack: true, marker: { status: "aborted", reason: null }, retryable: false }`). `DoneMarker.status` becomes `"done" | "failed" | "aborted"`.
-
-> **Ordering note:** This task depends on `LeafResult` having `paused`/`aborted`. Do Task 7 Step 3's `LeafResult` edit first, OR add those two variants here before editing `classify-outcome.ts`. The plan assumes Task 7 runs before Task 6 is reviewed; if executing strictly in order, add the `LeafResult` variants as Step 0 here.
-
-- [ ] **Step 1: Write the failing test** (append to `harness/test/classify-outcome.test.ts`)
-
-```typescript
-  it("paused → ack, no terminal marker (runLeaf wrote the gate marker)", () => {
-    expect(classifyOutcome({ status: "paused", gateRef: "/out.gate", gateId: 0 })).toEqual({
-      ack: true, marker: null, retryable: false,
-    });
-  });
-  it("aborted → ack + aborted terminal marker", () => {
-    expect(classifyOutcome({ status: "aborted" })).toEqual({
-      ack: true, marker: { status: "aborted", reason: null }, retryable: false,
-    });
-  });
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/classify-outcome.test.ts`
-Expected: FAIL — type error / branch missing (`paused`/`aborted` not handled).
-
-- [ ] **Step 3: Edit `done-marker.ts` (status union)**
-
-```typescript
-export interface DoneMarker {
-  status: "done" | "failed" | "aborted";
-  sessionId: string;
-  reason: string | null;
-  ts: string;
-}
-```
-
-- [ ] **Step 4: Edit `classify-outcome.ts`**
-
-```typescript
-import type { LeafResult } from "./run-leaf.js";
-
-export interface Outcome {
-  ack: boolean;
-  marker: { status: "done" | "failed" | "aborted"; reason: string | null } | null;
-  retryable: boolean;
-}
-
-/**
- * Decide what the leaf-job does with a queue entry given the leaf's terminal result.
- * - done / aborted / deterministic failures → ack (write a terminal marker where applicable).
- * - paused → ack with NO terminal marker (runLeaf already wrote the awaiting_approval gate marker;
- *   resume is a fresh re-invocation, not a redelivery).
- * - "error" (possibly transient) → no marker, no ack, retryable (reclaim).
- *   (A process crash never returns here at all → entry stays pending → reclaimed.)
- */
-export function classifyOutcome(result: LeafResult): Outcome {
-  if (result.status === "done") {
-    return { ack: true, marker: { status: "done", reason: null }, retryable: false };
-  }
-  if (result.status === "paused") {
-    return { ack: true, marker: null, retryable: false };
-  }
-  if (result.status === "aborted") {
-    return { ack: true, marker: { status: "aborted", reason: null }, retryable: false };
-  }
-  if (result.reason === "error") {
-    return { ack: false, marker: null, retryable: true };
-  }
-  return { ack: true, marker: { status: "failed", reason: result.reason }, retryable: false };
-}
-```
-
-- [ ] **Step 5: Run test to verify it passes**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/classify-outcome.test.ts`
-Expected: PASS (existing rows + the two new ones).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add harness/src/classify-outcome.ts harness/src/done-marker.ts harness/test/classify-outcome.test.ts
-git commit -s -m "feat(gate): classifyOutcome handles paused (ack, no marker) and aborted"
-```
-
----
-
-## Task 7: `run-leaf.ts` — envelope/result/capture/prompt + outer capture handling
-
-**Files:**
-- Modify: `harness/src/run-leaf.ts`
-- Test: `harness/test/run-leaf.test.ts` (extend)
-
-**Interfaces:**
-- Consumes: `deriveGateRef`, `writeGateMarker` (Task 5); `GateCapture` (Task 4); `validateVerdict` (existing).
-- Produces: `LeafEnvelope` gains `gateRef?: string` + `decisionRef?: string`; `LeafItem` gains `require_approval?: boolean`; `LeafResult` gains `{ status: "paused"; gateRef: string; gateId: number }` and `{ status: "aborted" }`; `LeafCapture = VerdictCapture & GateCapture`; `ProduceVerdict`'s capture param becomes `LeafCapture`; `buildLeafPrompt(item, workspaceRef?)` appends a gate instruction when `item.require_approval`.
-
-- [ ] **Step 1: Write the failing test** (append to `harness/test/run-leaf.test.ts`)
-
-```typescript
-import { existsSync, readFileSync as rf } from "node:fs";
-
-describe("runLeaf gate outcomes", () => {
-  it("capture.gate → writes the awaiting_approval gate marker and returns paused", async () => {
-    const env = envelope();
-    const produceVerdict = async (_i, _e, _c, capture) => {
-      capture.gate = { gateId: 0, summary: "did X", proposed_action: "do Y" };
-    };
-    const res = await runLeaf(env, undefined, { produceVerdict });
-    expect(res).toEqual({ status: "paused", gateRef: `${env.resultRef}.gate`, gateId: 0 });
-    expect(existsSync(env.resultRef)).toBe(false); // no verdict written
-    const m = JSON.parse(rf(`${env.resultRef}.gate`, "utf8"));
-    expect(m).toMatchObject({ status: "awaiting_approval", gateId: 0, gate: { summary: "did X", proposed_action: "do Y" } });
-  });
-
-  it("capture.aborted → returns aborted, writes no verdict and no gate marker", async () => {
-    const env = envelope();
-    const produceVerdict = async (_i, _e, _c, capture) => { capture.aborted = true; };
-    const res = await runLeaf(env, undefined, { produceVerdict });
-    expect(res).toEqual({ status: "aborted" });
-    expect(existsSync(env.resultRef)).toBe(false);
-    expect(existsSync(`${env.resultRef}.gate`)).toBe(false);
-  });
-
-  it("honors an explicit gateRef override", async () => {
-    const env = { ...envelope(), gateRef: join(dir, "custom.gate") };
-    const produceVerdict = async (_i, _e, _c, capture) => {
-      capture.gate = { gateId: 1, summary: "s", proposed_action: "a" };
-    };
-    const res = await runLeaf(env, undefined, { produceVerdict });
-    expect(res).toEqual({ status: "paused", gateRef: env.gateRef, gateId: 1 });
-    expect(existsSync(env.gateRef)).toBe(true);
-  });
-});
-
-describe("buildLeafPrompt with require_approval", () => {
-  it("adds a request_approval instruction when the item requires approval", () => {
-    const p = buildLeafPrompt({ item_id: "i1", file: "a.py", pattern: "eval(", require_approval: true });
-    expect(p).toContain("request_approval");
-  });
-  it("omits the gate instruction by default", () => {
-    const p = buildLeafPrompt({ item_id: "i1", file: "a.py", pattern: "eval(" });
-    expect(p).not.toContain("request_approval");
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/run-leaf.test.ts`
-Expected: FAIL — `paused`/`aborted` not in `LeafResult`; `runLeaf` does not write a gate marker; `require_approval` not handled.
-
-- [ ] **Step 3: Edit `run-leaf.ts` — imports, types, capture, prompt, outer handling**
-
-Add imports near the top (after the existing imports):
-
-```typescript
-import { deriveGateRef, writeGateMarker } from "./gate-marker.js";
-import type { GateCapture } from "./request-approval-tool.js";
-```
-
-Replace the `LeafItem` interface:
-
-```typescript
-export interface LeafItem { item_id: string; file: string; pattern: string; require_approval?: boolean }
-```
-
-Add the optional envelope fields to `LeafEnvelope` (after `tenant?`):
-
-```typescript
-  gateRef?: string;           // overrides the derived <resultRef>.gate marker path (design §2.4)
-  decisionRef?: string;       // present on a resume invocation; the decision file to apply (design §2.3)
-```
-
-Replace the `LeafResult` type:
-
-```typescript
-export type LeafResult =
-  | { status: "done"; resultRef: string }
-  | { status: "paused"; gateRef: string; gateId: number }
-  | { status: "aborted" }
-  | { status: "failed"; reason: "no_verdict" | "invalid_verdict" | "bad_inputs" | "error"; message?: string };
-```
-
-Add the combined capture type and update `ProduceVerdict` (after `LeafResult`):
-
-```typescript
-export type LeafCapture = VerdictCapture & GateCapture;
-
-export type ProduceVerdict = (
-  item: LeafItem,
-  env: LeafEnvelope,
-  config: TurnConfig | undefined,
-  capture: LeafCapture,
-) => Promise<void>;
-```
-
-(`VerdictCapture` is already imported from `./submit-verdict-tool.js`.)
-
-Replace `buildLeafPrompt` to append the gate instruction conditionally:
-
-```typescript
-export function buildLeafPrompt(item: LeafItem, workspaceRef?: string): string {
-  const filePath = workspaceRef ? `${workspaceRef.replace(/\/+$/, "")}/${item.file}` : item.file;
-  const lines = [
-    `You are reviewing one candidate finding in a sandboxed workspace.`,
-    `Item id: ${item.item_id}`,
-    `File (read this exact absolute path with the read tool): ${filePath}`,
-    `Pattern of interest: ${item.pattern}`,
-    `Read the file, decide whether the pattern is present and relevant.`,
-  ];
-  if (item.require_approval) {
-    lines.push(
-      `Before reporting, you MUST call the request_approval tool exactly once with a short summary`,
-      `of what you found and the proposed_action ("submit verdict <X>"); then stop and wait.`,
-    );
-  }
-  lines.push(
-    `Report by calling the submit_verdict tool exactly once with item_id="${item.item_id}". Do not do anything else.`,
-  );
-  return lines.join("\n");
-}
-```
-
-Replace the body of `runLeaf` between the `produce(...)` call and the verdict handling:
-
-```typescript
-export async function runLeaf(
-  env: LeafEnvelope,
-  config?: TurnConfig,
-  deps?: { produceVerdict?: ProduceVerdict },
-): Promise<LeafResult> {
-  const item = readItem(env.inputsRef);
-  if (!item) return { status: "failed", reason: "bad_inputs" };
-
-  const capture: LeafCapture = {};
-  const produce = deps?.produceVerdict ?? realProduceVerdict;
-  try {
-    await produce(item, env, config, capture);
-  } catch (err) {
-    return { status: "failed", reason: "error", message: err instanceof Error ? err.message : String(err) };
-  }
-
-  // Gate outcomes take precedence over verdict handling.
-  if (capture.aborted) return { status: "aborted" };
-  if (capture.gate) {
-    const gateRef = deriveGateRef(env.resultRef, env.gateRef);
-    writeGateMarker(gateRef, {
-      status: "awaiting_approval",
-      sessionId: env.sessionId,
-      gateId: capture.gate.gateId,
-      gate: { summary: capture.gate.summary, proposed_action: capture.gate.proposed_action },
-      ts: new Date().toISOString(),
-    });
-    return { status: "paused", gateRef, gateId: capture.gate.gateId };
-  }
-
-  if (!capture.verdict) return { status: "failed", reason: "no_verdict" };
-  const v = validateVerdict(capture.verdict);
-  if (!v.ok) return { status: "failed", reason: "invalid_verdict", message: v.error };
-
-  mkdirSync(dirname(env.resultRef), { recursive: true });
-  writeFileSync(env.resultRef, JSON.stringify(v.value));
-  return { status: "done", resultRef: env.resultRef };
-}
-```
-
-Update `readItem` to carry `require_approval` through:
-
-```typescript
-function readItem(inputsRef: string): LeafItem | null {
-  try {
-    const o = JSON.parse(readFileSync(inputsRef, "utf8"));
-    if (o && typeof o.item_id === "string" && typeof o.file === "string" && typeof o.pattern === "string") {
-      return { item_id: o.item_id, file: o.file, pattern: o.pattern, require_approval: o.require_approval === true };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm --filter @sh/harness exec vitest run test/run-leaf.test.ts`
-Expected: PASS (existing verdict tests + the new gate/abort/prompt tests).
-
-- [ ] **Step 5: Run the full harness suite (regression)**
-
-Run: `pnpm --filter @sh/harness test`
-Expected: PASS (Task 6 classify tests now compile against the new `LeafResult`).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add harness/src/run-leaf.ts harness/test/run-leaf.test.ts
-git commit -s -m "feat(gate): runLeaf writes the gate marker, returns paused/aborted; prompt gate instruction"
-```
-
----
-
-## Task 8: `realProduceVerdict` gate front-end wiring
-
-**Files:**
-- Modify: `harness/src/run-leaf.ts`
-
-**Interfaces:**
-- Consumes: `computeGateState`, `decideSeed`, `readDecision`, `GATE_DECISION_ENTRY_TYPE` (Tasks 1–3); `requestApprovalExtension` (Task 4).
-- Produces: no new exports — `realProduceVerdict` now applies the gate state machine. **Not unit-tested** (it builds a real Redis-backed session); verified by the live smoke (Task 10), consistent with the existing "Exercised by the Kind smoke" note.
-
-- [ ] **Step 1: Add imports**
-
-```typescript
-import { computeGateState, decideSeed, readDecision, GATE_DECISION_ENTRY_TYPE } from "./gate.js";
-import { requestApprovalExtension } from "./request-approval-tool.js";
-```
-
-- [ ] **Step 2: Rewrite `realProduceVerdict` to apply the gate front-end**
-
-Replace the existing `realProduceVerdict` body. The change inserts the gate front-end after the verdict fast-path and before wiring the agent session; it computes `seedPrompt` via `decideSeed`, short-circuits on paused/abort, appends the gate-decision record when present, and seeds the chosen prompt.
-
-```typescript
-export const realProduceVerdict: ProduceVerdict = async (item, env, config, capture) => {
-  const cwd = config?.cwd ?? process.cwd();
-  const { provider, modelId } = resolveModelSelection({
-    model: env.model ?? config?.model,
-    provider: env.provider ?? config?.provider,
-  });
-  const baseModel = requireModel(provider, modelId);
-  const model = applyModelGateway(baseModel as { headers?: Record<string, unknown> }, config);
-
-  const sid = leafSessionId(env);
-  const store = new RedisSessionBackend<FileEntry>(config?.redisUrl ?? "redis://localhost:6379");
-  const backend = new BufferedRedisBackend(store);
-  const isVerdictEntry = (e: unknown) =>
-    (e as { type?: string }).type === "custom" &&
-    (e as { customType?: string }).customType === VERDICT_ENTRY_TYPE;
-
-  const prior = await store.read(sid);
-  const resuming = prior.length > 0;
-  const sessionManager = resuming
-    ? await SessionManager.openFromCheckpoint(sid, backend, cwd)
-    : SessionManager.create(cwd, undefined, { id: sid }, backend);
-
-  // Verdict fast-path (unchanged): recover a previously-submitted verdict on resume.
-  if (resuming) {
-    const row = await store.latestWhere(sid, isVerdictEntry);
-    const recovered = verdictFromCustomEntry(row?.entry);
-    if (recovered) {
-      capture.verdict = recovered;
-      await backend.flush();
-      return;
-    }
-  }
-
-  // Gate front-end (design §3): decide whether to pause, abort, or seed a prompt.
-  const gateState = computeGateState(prior.map((p) => p.entry));
-  const decision = env.decisionRef ? readDecision(env.decisionRef) : null;
-  const seed = decideSeed(gateState, decision, buildLeafPrompt(item, env.workspaceRef));
-
-  if (seed.kind === "abort") {
-    if (seed.record) sessionManager.appendCustomEntry(GATE_DECISION_ENTRY_TYPE, seed.record);
-    capture.aborted = true;
-    await backend.flush();
-    return;
-  }
-  if (seed.kind === "paused") {
-    capture.gate = seed.gate; // re-report the pending gate; runLeaf (re)writes the marker
-    await backend.flush();
-    return;
-  }
-  // seed.kind === "seed": record the decision (once) before running the continuation/fresh turn.
-  if (seed.record) sessionManager.appendCustomEntry(GATE_DECISION_ENTRY_TYPE, seed.record);
-
-  const agentDir = getAgentDir();
-  const settingsManager = SettingsManager.create(cwd, agentDir);
-  const resourceLoader = new DefaultResourceLoader({
-    cwd,
-    agentDir,
-    settingsManager,
-    extensionFactories: [
-      submitVerdictExtension(capture, sessionManager),
-      requestApprovalExtension(capture, sessionManager, gateState.nextGateId),
-      k8sSandboxExtension(),
-      flushExtension(backend),
-      checkpointExtension(store, sessionManager),
-    ],
-  });
-  await resourceLoader.reload();
-
-  const { session } = await createAgentSession({
-    sessionManager,
-    model: model as never,
-    resourceLoader,
-    settingsManager,
-  });
-
-  try {
-    await session.prompt(seed.prompt);
-    if (!capture.verdict && !capture.gate) {
-      const row = await store.latestWhere(sid, isVerdictEntry);
-      const recovered = verdictFromCustomEntry(row?.entry);
-      if (recovered) capture.verdict = recovered;
-    }
-  } finally {
-    await backend.flush();
-  }
-};
-```
-
-- [ ] **Step 3: Typecheck + full harness suite (no behavior regression)**
-
-Run: `pnpm --filter @sh/harness test`
-Expected: PASS — all existing tests green (the gate front-end is inert when no gate entries/decision exist: `decideSeed` returns `{ kind: "seed", prompt: buildLeafPrompt(...) }`, reproducing today's behavior).
-
-- [ ] **Step 4: Build the package (catch type errors in the real wiring)**
-
-Run: `pnpm --filter @sh/harness build` (or the repo's typecheck: `pnpm -r exec tsc --noEmit` if `build` is absent)
-Expected: no type errors.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/run-leaf.ts
-git commit -s -m "feat(gate): wire gate front-end into realProduceVerdict (pause/abort/continue)"
-```
-
----
-
-## Task 9: Status endpoint reports `awaiting_approval`
-
-**Files:**
-- Modify: `packages/knative-server/src/server.ts`
-- Test: `packages/knative-server/test/run-leaf-async-route.test.ts` (extend)
-
-**Interfaces:**
-- Consumes: `readGateMarker`, `deriveGateRef` (Task 5).
-- Produces: `GET /run-leaf/status` — when no terminal marker is present and a `gateMarker` query param is supplied (and within the work root), returns `{ status: "awaiting_approval", gateId }`; otherwise unchanged (`done`/`failed`/`aborted` from the terminal marker, else `queued`).
-
-- [ ] **Step 1: Write the failing test** (append to `packages/knative-server/test/run-leaf-async-route.test.ts`)
-
-First, extend the existing `vi.mock("@sh/harness/done-marker", …)` block's sibling: add a mock for the gate marker module near the other mocks at the top of the file:
-
-```typescript
-vi.mock("@sh/harness/gate-marker", () => ({
-  readGateMarker: vi.fn(),
-  deriveGateRef: (r: string, o?: string) => o ?? `${r}.gate`,
-}));
-import { readGateMarker } from "@sh/harness/gate-marker";
-const mockedReadGate = vi.mocked(readGateMarker);
-```
-
-Then add the test cases:
-
-```typescript
-  it("status returns awaiting_approval from the gate marker when no terminal marker yet", async () => {
-    readDoneMarker.mockReturnValue(null);
-    mockedReadGate.mockReturnValue({
-      status: "awaiting_approval", sessionId: "run/i1", gateId: 0,
-      gate: { summary: "s", proposed_action: "a" }, ts: "t",
-    });
-    const r = await req("GET", "/run-leaf/status?doneMarker=/work/out.status&gateMarker=/work/out.json.gate");
-    expect(r.status).toBe(200);
-    expect(r.json).toMatchObject({ status: "awaiting_approval", gateId: 0 });
-  });
-
-  it("status rejects a gateMarker outside the work root (path traversal)", async () => {
-    readDoneMarker.mockReturnValue(null);
-    const r = await req("GET", "/run-leaf/status?doneMarker=/work/out.status&gateMarker=/etc/shadow");
-    expect(r.status).toBe(403);
-  });
-
-  it("status still returns queued when neither terminal nor gate marker is present", async () => {
-    readDoneMarker.mockReturnValue(null);
-    mockedReadGate.mockReturnValue(null);
-    const r = await req("GET", "/run-leaf/status?doneMarker=/work/out.status&gateMarker=/work/out.json.gate");
-    expect(r.json).toMatchObject({ status: "queued" });
-  });
-```
-
-> Adapt the mock declarations to the file's existing structure (it already mocks `@sh/harness/done-marker` and imports `readDoneMarker`). Place the new `vi.mock` beside it, before `startServer` is imported.
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm --filter @sh/knative-server exec vitest run test/run-leaf-async-route.test.ts`
-Expected: FAIL — status returns `queued` (not `awaiting_approval`); no path guard on `gateMarker`.
-
-- [ ] **Step 3: Edit `server.ts`**
-
-Add the import (beside the existing done-marker import):
-
-```typescript
-import { readGateMarker } from "@sh/harness/gate-marker";
-```
-
-Add a small confinement helper and extend `handleLeafStatus`:
-
-```typescript
-// Confine an untrusted marker path to the work root (path-traversal guard). Returns null if outside.
-function confineToWorkRoot(p: string): string | null {
-  const resolved = resolvePath(p);
-  if (resolved !== WORK_ROOT && !resolved.startsWith(`${WORK_ROOT}/`)) return null;
-  return resolved;
-}
-
-function handleLeafStatus(url: URL, res: ServerResponse): void {
-  const doneMarker = url.searchParams.get("doneMarker");
-  if (!doneMarker) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "doneMarker_required" })); return; }
-  const resolved = confineToWorkRoot(doneMarker);
-  if (!resolved) { res.writeHead(403, JSON_HEADERS).end(JSON.stringify({ error: "doneMarker_forbidden" })); return; }
-
-  const marker = readDoneMarker(resolved);
-  if (marker) {
-    res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: marker.status, reason: marker.reason ?? undefined }));
-    return;
-  }
-
-  // No terminal marker yet — if a gate marker path is supplied, report awaiting_approval.
-  const gateMarker = url.searchParams.get("gateMarker");
-  if (gateMarker) {
-    const g = confineToWorkRoot(gateMarker);
-    if (!g) { res.writeHead(403, JSON_HEADERS).end(JSON.stringify({ error: "gateMarker_forbidden" })); return; }
-    const gm = readGateMarker(g);
-    if (gm) {
-      res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: gm.status, gateId: gm.gateId }));
-      return;
-    }
-  }
-
-  // Best-effort non-terminal state for visibility.
-  res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: "queued" }));
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm --filter @sh/knative-server exec vitest run test/run-leaf-async-route.test.ts`
-Expected: PASS (existing status tests + the three new ones).
-
-- [ ] **Step 5: Full server suite (regression)**
-
-Run: `pnpm --filter @sh/knative-server test`
-Expected: PASS.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add packages/knative-server/src/server.ts packages/knative-server/test/run-leaf-async-route.test.ts
-git commit -s -m "feat(gate): status endpoint reports awaiting_approval from the gate marker"
-```
-
----
-
-## Task 10: Live gate smoke (`leaf-gate-smoke.sh`)
-
-**Files:**
-- Create: `deploy/knative/leaf-gate-smoke.sh`
-
-**Interfaces:**
-- Consumes: the async deploy (KEDA + `leaf-scaledjob.yaml`, Redis, sandbox-0, `/work` PVC, ksvc), `deploy/knative/lib.sh` (provides `$NS`, `$BASE`, `$HOST_HEADER`), the leaf-orchestrator pod for in-cluster `kubectl exec` writes to `/work`. The `controller` (not a subagent) runs this gate.
-- Produces: a gated end-to-end proof of pause → scale-to-zero → resume-approve → reject-then-approve → abort → idempotent resume (spec §7.2).
-
-> This task's deliverable is verified by **running the script on the Kind `sh-knative` cluster**, not by a unit test. The image must be rebuilt + kind-loaded + pods recreated so the new gate code runs in-cluster (see the run note below). Per CLAUDE.md context budget, the controller redirects verbose `kubectl`/build output to `/tmp/kagenti/human-gate/` and analyzes logs in subagents.
-
-- [ ] **Step 1: Create the smoke script**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/leaf-gate-smoke.sh
-# Gated Kind smoke for the human-gate (design §7.2). Proves: pause (awaiting_approval marker),
-# scale-to-zero while parked, resume-approve to verdict, reject-then-approve, abort, idempotent resume.
-# Prereq: setup-kind.sh (incl. KEDA) done; image rebuilt with the gate code; leaf-pvc.yaml +
-#   leaf-orchestrator.yaml + leaf-scaledjob.yaml applied; sandbox-0 up.
-# Usage: GATE_LIVE_SMOKE=1 bash deploy/knative/leaf-gate-smoke.sh
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-[ "${GATE_LIVE_SMOKE:-0}" = "1" ] || { echo "SKIP (set GATE_LIVE_SMOKE=1)"; exit 0; }
-
-ORCH=leaf-orchestrator; SBOX="${KAGENTI_SANDBOX_POD:-sandbox-0}"
-RUN="grun-$$"; INPUTS="/work/$RUN/inputs"; RES="/work/$RUN/results"; SBOX_REPO="/workspace/$RUN/repo"
-MODEL="${SH_MODEL:-claude-haiku-4-5}"
-trap 'kubectl -n "$NS" exec "$SBOX" -- sh -c "rm -rf /workspace/$RUN" 2>/dev/null || true' EXIT
-claim() { echo ""; echo "--- Claim $1: $2 ---"; }
-oexec() { kubectl -n "$NS" exec "$ORCH" -- "$@"; }
-leaf_job_pods() { kubectl get pods -n "$NS" -l scaledjob.keda.sh/name=leaf-worker --field-selector=status.phase=Running --no-headers 2>/dev/null | wc -l | tr -d ' '; }
-
-# Seed one gated item (require_approval:true) and the fixture repo file.
-oexec mkdir -p "$INPUTS" "$RES"
-oexec sh -c "cat > $INPUTS/i1.json" <<JSON
-{ "item_id": "i1", "file": "a.py", "pattern": "eval(", "require_approval": true }
-JSON
-kubectl -n "$NS" exec "$SBOX" -- sh -c "mkdir -p $SBOX_REPO && printf 'x = eval(\"1+1\")\n' > $SBOX_REPO/a.py"
-
-# Dispatch async; substitute resume fields per call.
-dispatch() { # $1=extra-json
-  jq -nc --arg s "$RUN/i1" --arg m "$MODEL" --arg in "$INPUTS/i1.json" --arg out "$RES/i1.json" --arg ws "$SBOX_REPO" \
-    --argjson extra "${1:-{}}" \
-    '{sessionId:$s, model:$m, inputsRef:$in, resultRef:$out, workspaceRef:$ws, async:true} + $extra' \
-  | curl -s --max-time 30 -H "$HOST_HEADER" -H "Content-Type: application/json" -d @- "$BASE/run-leaf"
-}
-write_decision() { # $1=action $2=feedback?
-  jq -nc --argjson g 0 --arg a "$1" --arg f "${2:-}" '{gateId:$g, action:$a} + (if $f=="" then {} else {feedback:$f} end)' \
-  | oexec sh -c "cat > $RES/i1.json.decision"
-}
-gate_marker() { oexec sh -c "cat $RES/i1.json.gate 2>/dev/null || true"; }
-result() { oexec sh -c "cat $RES/i1.json 2>/dev/null || true"; }
-done_marker() { oexec sh -c "cat $RES/i1.json.status 2>/dev/null || true"; }
-wait_for() { local f="$1" n=0; until oexec sh -c "test -f $f"; do n=$((n+1)); [ $n -gt 60 ] && { echo "TIMEOUT $f"; exit 1; }; sleep 2; done; }
-
-claim 1 "Pause: dispatch a gated leaf -> awaiting_approval gate marker, no result"
-dispatch >/dev/null
-wait_for "$RES/i1.json.gate"
-gate_marker | grep -q '"status":"awaiting_approval"' || { echo "FAIL: no awaiting_approval marker"; exit 1; }
-gate_marker | grep -q '"gateId":0' || { echo "FAIL: gateId 0 expected"; exit 1; }
-oexec sh -c "test ! -f $RES/i1.json" || { echo "FAIL: result written before approval"; exit 1; }
-echo "OK gate marker present, no verdict"
-
-claim 2 "Scale-to-zero while parked"
-n=0; until [ "$(leaf_job_pods)" = "0" ]; do n=$((n+1)); [ $n -gt 60 ] && { echo "FAIL: pods did not scale to zero"; exit 1; }; sleep 5; done
-echo "OK leaf-job pods at zero while gate pending"
-
-claim 3 "Resume-approve -> verdict"
-write_decision approve
-dispatch '{"decisionRef":"'"$RES"'/i1.json.decision"}' >/dev/null
-wait_for "$RES/i1.json.status"
-result | grep -q '"verdict":"FLAGGED"' || { echo "FAIL: expected FLAGGED verdict after approve"; exit 1; }
-done_marker | grep -q '"status":"done"' || { echo "FAIL: expected done marker"; exit 1; }
-echo "OK approved -> FLAGGED verdict, done"
-
-claim 4 "Idempotent resume: re-invoke with the same consumed decision -> still done, no change"
-dispatch '{"decisionRef":"'"$RES"'/i1.json.decision"}' >/dev/null
-wait_for "$RES/i1.json.status"
-done_marker | grep -q '"status":"done"' || { echo "FAIL: terminal state changed on re-invoke"; exit 1; }
-echo "OK idempotent re-invoke stable"
-
-# Abort scenario on a fresh run id.
-RUN="grun-abort-$$"; INPUTS="/work/$RUN/inputs"; RES="/work/$RUN/results"; SBOX_REPO="/workspace/$RUN/repo"
-oexec mkdir -p "$INPUTS" "$RES"
-oexec sh -c "cat > $INPUTS/i1.json" <<JSON
-{ "item_id": "i1", "file": "a.py", "pattern": "eval(", "require_approval": true }
-JSON
-kubectl -n "$NS" exec "$SBOX" -- sh -c "mkdir -p $SBOX_REPO && printf 'x = eval(\"1+1\")\n' > $SBOX_REPO/a.py"
-
-claim 5 "Abort -> aborted marker, no verdict"
-dispatch >/dev/null
-wait_for "$RES/i1.json.gate"
-write_decision abort
-dispatch '{"decisionRef":"'"$RES"'/i1.json.decision"}' >/dev/null
-wait_for "$RES/i1.json.status"
-done_marker | grep -q '"status":"aborted"' || { echo "FAIL: expected aborted marker"; exit 1; }
-oexec sh -c "test ! -f $RES/i1.json" || { echo "FAIL: verdict written on abort"; exit 1; }
-echo "OK aborted, no verdict"
-
-echo ""; echo "ALL GATE SMOKE CLAIMS PASSED"
-```
-
-- [ ] **Step 2: Make it executable and commit (the run is the verification, performed by the controller)**
-
-```bash
-chmod +x deploy/knative/leaf-gate-smoke.sh
-git add deploy/knative/leaf-gate-smoke.sh
-git commit -s -m "test(gate): Add gated live human-gate smoke (pause/approve/reject/abort/idempotent)"
-```
-
-- [ ] **Step 3: (Controller-run) Rebuild image, reload, run the smoke**
-
-> Run by the controller, NOT a subagent (long live gate). Redirect to `/tmp/kagenti/human-gate/`.
-
-```bash
-mkdir -p /tmp/kagenti/human-gate
-# Rebuild + load the image so the new gate code runs in-cluster (IfNotPresent → must recreate pods):
-docker build -t dev.local/serverless-harness:local . > /tmp/kagenti/human-gate/build.log 2>&1; echo "EXIT:$?"
-kind load docker-image dev.local/serverless-harness:local --name sh-knative > /tmp/kagenti/human-gate/load.log 2>&1; echo "EXIT:$?"
-kubectl delete pod -n default -l serving.knative.dev/service=serverless-harness --ignore-not-found > /dev/null 2>&1
-# Run the gate (cap the duration; analyze the log in a subagent):
-GATE_LIVE_SMOKE=1 bash deploy/knative/leaf-gate-smoke.sh > /tmp/kagenti/human-gate/smoke.log 2>&1; echo "EXIT:$?"
-grep -E "ALL GATE SMOKE|FAIL|TIMEOUT" /tmp/kagenti/human-gate/smoke.log
-```
-
-Expected: `ALL GATE SMOKE CLAIMS PASSED`, exit 0.
-
----
-
-## Self-Review
-
-**1. Spec coverage**
-
-| Spec section | Task |
-|---|---|
-| §2.1 `request_approval` tool + durable gate-request + benign result | T4 |
-| §2.2 `awaiting_approval` gate marker (atomic, gateRef) | T5; written by T7 |
-| §2.3 decision file + `gateId` echo + ignore-on-mismatch | T1 (`readDecision`/`validateDecision`), T3 (mismatch → paused) |
-| §2.4 envelope `gateRef`/`decisionRef` | T7 |
-| §2.5 resume trigger = re-invoke by `sessionId` (sync/async) | existing path; exercised T10 |
-| §2.6 `LeafResult` `paused`/`aborted`; gate marker by `runLeaf`; sync prompt return | T7 |
-| §3 resume state machine (branches a/b/c, gateId idempotency) | T2 (`computeGateState`), T3 (`decideSeed`), T8 (wiring) |
-| §3.1 continuation re-seed + crash-mid-resume safety | T2 (`continuationPrompt`), T3, T8 |
-| §4 `classifyOutcome` paused→ack/no-marker, aborted→ack+marker; two-marker model | T6 |
-| §4 status endpoint reports `awaiting_approval` | T9 |
-| §5 failure modes / idempotency / no timeout | T3 (already-aborted terminal, double-resume), T8, T10 |
-| §6 components 1–11 | T1–T10 |
-| §7.1 unit tests | T1–T7, T9 |
-| §7.2 live gate (6 scenarios) | T10 |
-| §8 nothing-else-changes (auto-approve not built, no watcher) | enforced across tasks (no new endpoint, leaf-job-runner untouched) |
-
-No gaps. Auto-approve and harness timeout are correctly absent (spec defers them).
-
-**2. Placeholder scan:** No `TBD`/`TODO`/"handle edge cases"/"similar to". Every code step shows full code. The two non-unit-tested deliverables (T8 wiring, T10 smoke) are explicitly verified by the live gate, matching the existing `realProduceVerdict` convention.
-
-**3. Type consistency:**
-- `GateRequest`/`Decision`/`GateDecision`/`GateAction` defined in T1, consumed unchanged in T2/T3/T4/T8.
-- `GATE_REQUEST_ENTRY_TYPE`/`GATE_DECISION_ENTRY_TYPE` defined T1, used T4 (request) and T8 (decision).
-- `GateCapture` defined T4, intersected into `LeafCapture` T7, set by `requestApprovalExtension` (T4) and read by `runLeaf` (T7).
-- `SeedDecision` kinds (`paused`/`abort`/`seed`) produced T3, consumed T8.
-- `LeafResult` `paused`/`aborted` added T7, consumed by `classifyOutcome` T6 (ordering note in T6 covers the dependency).
-- `deriveGateRef`/`writeGateMarker`/`readGateMarker`/`GateMarker` defined T5, used by `runLeaf` (T7) and `server.ts` (T9).
-- `computeGateState` returns `nextGateId` (T2), passed to `requestApprovalExtension` (T8).
-
-Consistent end-to-end.
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-28-registry-hardening-hygiene.md b/docs/superpowers/plans/2026-06-28-registry-hardening-hygiene.md
deleted file mode 100644
index 805bbb1..0000000
--- a/docs/superpowers/plans/2026-06-28-registry-hardening-hygiene.md
+++ /dev/null
@@ -1,345 +0,0 @@
-# Registry + Hardening Hygiene Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Register the built leaf-session backend track in the milestone registry, align `server.ts`'s entrypoint idiom, and bring the leaf-worker `ScaledJob` + Knative service up to the cron-dispatch securityContext baseline — all verified by the existing gate smoke.
-
-**Architecture:** Three independent, additive changes. (1) docs-only registry table; (2) a 2-line `server.ts` change to the canonical `fileURLToPath` entrypoint idiom; (3) securityContext stanzas on two K8s manifests plus a Knative feature-flag enablement, with `readOnlyRootFilesystem` decided empirically by the live gate (set `HOME=/tmp` + a writable `/tmp` emptyDir so the Pi agent's config writes land in a writable mount; fall back to `false` per-pod if needed).
-
-**Tech Stack:** TypeScript (ESM, `.js` specifiers), Node 20, vitest, pnpm workspaces, Knative Serving + Kourier, KEDA, Kind. Spec: `docs/specs/2026-06-28-registry-hardening-hygiene-design.md`.
-
-## Global Constraints
-
-- **No behavioral change** to `runLeaf`, the gate state machine, the leaf-session contract, `leaf-queue`, KEDA scaling metadata, or `submit_verdict`. This bundle is registry docs + an entrypoint idiom + pod securityContext only.
-- **Non-fs hardening is unconditional** on both pods: `runAsNonRoot: true`, `runAsUser: 65532`, `seccompProfile: { type: RuntimeDefault }` (pod), `allowPrivilegeEscalation: false`, `capabilities: { drop: ["ALL"] }` (container). Reason for `runAsUser: 65532`: the harness image has no `USER` (runs as root), so `runAsNonRoot` alone would refuse to start.
-- **`readOnlyRootFilesystem` is empirical (Option 1):** attempt `true` with `HOME=/tmp` + a writable `/tmp` `emptyDir`; if the live gate shows a pod needs un-redirectable root-fs writes, set `readOnlyRootFilesystem: false` on that pod only (keep `true` on cron-dispatch) and add an inline comment explaining why.
-- **`fsGroup: 65532`** on both pods so uid 65532 can write the `leaf-work` `/work` PVC.
-- **Image build MUST use `docker buildx build --load` AND verify the image contains the change before `kind load`** (a prior session's active buildx builder used the `docker-container` driver, which never loaded the result into the local image store — `:local` silently stayed stale). Verify with: `docker run --rm --entrypoint sh dev.local/serverless-harness:local -c '<grep for the change>'`.
-- **Live gate (`GATE_LIVE_SMOKE=1 deploy/knative/leaf-gate-smoke.sh`) must pass all 6 claims** with the hardened pods. The controller runs the live gate — never a subagent.
-- **Deferred (NOT in this plan):** reclaimer-churn tuning.
-- **DCO:** `git commit -s` on every commit. Conventional prefixes. Branch: `chore/registry-hardening` (already created; spec already committed there). Attribution `Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>` where needed.
-- Unit test commands (from repo root): `pnpm --filter @sh/knative-server test`, `pnpm --filter @sh/harness test`.
-
----
-
-## File Structure
-
-**Modify:**
-- `docs/specs/README.md` — add the "Leaf-Session Backend (BUILT)" section (Task 1).
-- `packages/knative-server/src/server.ts` — `isMainModule` idiom (Task 2).
-- `deploy/knative/leaf-scaledjob.yaml` — leaf-worker securityContext + HOME + /tmp emptyDir (Task 3).
-- `deploy/knative/service.yaml` — ksvc securityContext + HOME + /tmp emptyDir (Task 3).
-- `deploy/knative/setup-kind.sh` — enable `kubernetes.podspec-securitycontext` feature flag (Task 3).
-
-No new files. No test files (Task 1 is docs; Task 2 is covered by the existing server suite; Task 3 is verified by the live gate).
-
----
-
-## Task 1: Register the built leaf-session backend track
-
-**Files:**
-- Modify: `docs/specs/README.md`
-
-**Interfaces:** none (docs only).
-
-- [ ] **Step 1: Read the current registry to find the insertion point**
-
-Run: `grep -n "^## Phase" docs/specs/README.md`
-Expected: lines for `## Phase 1 — …` and `## Phase 2 — …`. Insert the new section **between** the end of the Phase-1 section and the `## Phase 2` heading (after the Phase-1 collision note, before `---` + `## Phase 2`).
-
-- [ ] **Step 2: Insert the new section**
-
-Insert this block immediately before the `## Phase 2 — Zero-Trust Credential Plane` section's preceding `---` separator:
-
-```markdown
----
-
-## Leaf-Session Backend (BUILT)
-
-The MVP leaf-session contract and the three pipeline archetypes it was tested against
-([Pipeline Archetypes](2026-06-26-pipeline-archetypes-requirements.md)) — all shipped. These realize
-the [Capability Charter](2026-06-26-leaf-session-backend-capability-charter.md) §5 MVP core and §8
-promote-post-MVP (human-gate, cron trigger). They are the **MVP/charter track**, distinct from the
-`M`-numbered built harness (Phase 1) and the `Z`-numbered credential plane (Phase 2).
-
-| Slice | Spec | PR(s) |
-|----|-------|-------|
-| MVP leaf-session invocation contract (run-to-completion, structured output, volume envelope) + gate-7 durable resume | [`2026-06-26-mvp-leaf-session-contract-design.md`](2026-06-26-mvp-leaf-session-contract-design.md) | #10, #11 |
-| Async leaf completion (KEDA `ScaledJob` + Redis Streams queue, done-marker) | [`2026-06-27-async-leaf-completion-design.md`](2026-06-27-async-leaf-completion-design.md) | #12 |
-| Scheduled leaf dispatch (cron trigger on-ramp, Archetype C) | [`2026-06-28-scheduled-leaf-dispatch-design.md`](2026-06-28-scheduled-leaf-dispatch-design.md) | #13 |
-| Human-gate (gate-while-idle, Archetype B) | [`2026-06-28-human-gate-design.md`](2026-06-28-human-gate-design.md) | #14 |
-
-All three archetypes (A parallel-fan-out, B human-gate, C scheduled) from the evidence base are now
-built. Hardening hygiene across these is tracked in
-[`2026-06-28-registry-hardening-hygiene-design.md`](2026-06-28-registry-hardening-hygiene-design.md).
-```
-
-- [ ] **Step 3: Verify the doc renders and links resolve**
-
-Run: `grep -n "Leaf-Session Backend (BUILT)" docs/specs/README.md && for f in 2026-06-26-mvp-leaf-session-contract-design 2026-06-27-async-leaf-completion-design 2026-06-28-scheduled-leaf-dispatch-design 2026-06-28-human-gate-design 2026-06-28-registry-hardening-hygiene-design; do test -f "docs/specs/$f.md" && echo "OK $f" || echo "MISSING $f"; done`
-Expected: the heading line + five `OK` lines (every linked spec exists).
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add docs/specs/README.md
-git commit -s -m "docs(registry): Register the built leaf-session backend track (MVP + archetypes A/B/C)"
-```
-
----
-
-## Task 2: Align `server.ts` entrypoint idiom
-
-**Files:**
-- Modify: `packages/knative-server/src/server.ts`
-
-**Interfaces:**
-- Consumes: `import.meta.url`, `process.argv[1]`.
-- Produces: no exported API change; `isMainModule` now uses the exact `fileURLToPath` comparison (matches `cron-dispatch.ts:75`).
-
-- [ ] **Step 1: Confirm the existing test asserts no auto-start on import (the invariant)**
-
-Run: `pnpm --filter @sh/knative-server test`
-Expected: PASS (29 tests). The suite imports `startServer` from `server.ts`; it passes today because the guard is false under vitest. This run is the RED-equivalent baseline — after the change it must still pass (no port-bind on import).
-
-- [ ] **Step 2: Add the `fileURLToPath` import**
-
-In `packages/knative-server/src/server.ts`, add to the imports at the top (after line 2, `import { resolve as resolvePath } from "node:path";`):
-
-```ts
-import { fileURLToPath } from "node:url";
-```
-
-- [ ] **Step 3: Replace the `isMainModule` guard**
-
-Replace lines 184-186:
-
-```ts
-const isMainModule =
-  typeof process.argv[1] === "string" &&
-  process.argv[1].includes("knative-server");
-```
-
-with:
-
-```ts
-// Exact entrypoint match (matches cron-dispatch.ts / leaf-job.ts) — avoids a fragile substring
-// match that would misfire for any argv path containing "knative-server".
-const isMainModule = process.argv[1] === fileURLToPath(import.meta.url);
-```
-
-- [ ] **Step 4: Verify the suite still passes (no auto-start on import)**
-
-Run: `pnpm --filter @sh/knative-server test`
-Expected: PASS (29 tests). If a test hangs or reports a port-in-use, the guard is wrong — revert and reconsider.
-
-- [ ] **Step 5: Typecheck**
-
-Run: `pnpm --filter @sh/knative-server build` (or `pnpm --filter @sh/knative-server exec tsc --noEmit` if no build script)
-Expected: no type errors.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add packages/knative-server/src/server.ts
-git commit -s -m "refactor(server): Use exact fileURLToPath entrypoint idiom (matches cron-dispatch)"
-```
-
----
-
-## Task 3: securityContext hardening on leaf-worker + Knative service
-
-**Files:**
-- Modify: `deploy/knative/leaf-scaledjob.yaml`, `deploy/knative/service.yaml`, `deploy/knative/setup-kind.sh`
-
-**Interfaces:** Kubernetes pod/container `securityContext`; Knative `config-features` flag `kubernetes.podspec-securitycontext`.
-
-> **This task's deliverable (the manifest + flag edits) is reviewable statically; correctness is verified by the controller-run live gate in Step 6.** There is no unit test.
-
-- [ ] **Step 1: Harden the leaf-worker `ScaledJob`**
-
-In `deploy/knative/leaf-scaledjob.yaml`, under `spec.jobTargetRef.template.spec` add a pod-level `securityContext` (sibling of `restartPolicy`/`serviceAccountName`/`containers`):
-
-```yaml
-        restartPolicy: Never
-        serviceAccountName: serverless-harness
-        securityContext:
-          runAsNonRoot: true
-          runAsUser: 65532          # image has no USER (runs as root); runAsNonRoot alone would refuse to start
-          fsGroup: 65532            # so uid 65532 can write the leaf-work /work PVC
-          seccompProfile: { type: RuntimeDefault }
-        containers:
-          - name: leaf-job
-```
-
-Add a container-level `securityContext` to the `leaf-job` container (sibling of `command`/`resources`/`env`):
-
-```yaml
-            command: ["node", "--import", "tsx", "src/leaf-job.ts"]
-            securityContext:
-              allowPrivilegeEscalation: false
-              readOnlyRootFilesystem: true   # tsx/node + the Pi agent config write to /tmp (HOME below); fall back to false if a pod needs more
-              capabilities: { drop: ["ALL"] }
-```
-
-Add `HOME=/tmp` to the container `env` (so the Pi agent's `getAgentDir()`/config writes land in the writable `/tmp` emptyDir, not the read-only root fs). Insert as the first env entry:
-
-```yaml
-            env:
-              - name: HOME
-                value: /tmp
-              - name: REDIS_URL
-```
-
-Add a `/tmp` writable mount to `volumeMounts` and a `tmp` `emptyDir` to `volumes`:
-
-```yaml
-            volumeMounts:
-              - name: work
-                mountPath: /work
-              - name: tmp
-                mountPath: /tmp
-        volumes:
-          - name: work
-            persistentVolumeClaim:
-              claimName: leaf-work
-          - name: tmp
-            emptyDir: {}
-```
-
-- [ ] **Step 2: Harden the Knative service**
-
-In `deploy/knative/service.yaml`, under `spec.template.spec` add a pod-level `securityContext` (sibling of `containerConcurrency`/`serviceAccountName`/`containers`):
-
-```yaml
-      containerConcurrency: 1
-      timeoutSeconds: 300
-      serviceAccountName: serverless-harness
-      securityContext:
-        runAsNonRoot: true
-        runAsUser: 65532
-        fsGroup: 65532
-        seccompProfile: { type: RuntimeDefault }
-      containers:
-        - image: dev.local/serverless-harness:local
-```
-
-Add the container-level `securityContext` (sibling of `ports`/`env`/`resources`):
-
-```yaml
-        - image: dev.local/serverless-harness:local
-          securityContext:
-            allowPrivilegeEscalation: false
-            readOnlyRootFilesystem: true
-            capabilities: { drop: ["ALL"] }
-          ports:
-            - containerPort: 8080
-```
-
-Add `HOME=/tmp` as the first `env` entry:
-
-```yaml
-          env:
-            - name: HOME
-              value: /tmp
-            - name: REDIS_URL
-```
-
-Add the `/tmp` mount + `tmp` emptyDir volume:
-
-```yaml
-          volumeMounts:
-            - name: work
-              mountPath: /work
-            - name: tmp
-              mountPath: /tmp
-      volumes:
-        - name: work
-          persistentVolumeClaim:
-            claimName: leaf-work
-            readOnly: false
-        - name: tmp
-          emptyDir: {}
-```
-
-- [ ] **Step 3: Enable the Knative securityContext feature flag in `setup-kind.sh`**
-
-In `deploy/knative/setup-kind.sh`, extend the existing `config-features` patch (currently enabling the two PVC flags) to also enable `kubernetes.podspec-securitycontext`. Replace the patch's `--patch '{"data":{...}}'` value so it reads:
-
-```bash
-  --patch '{"data":{"kubernetes.podspec-persistent-volume-claim":"enabled","kubernetes.podspec-persistent-volume-write":"enabled","kubernetes.podspec-securitycontext":"enabled"}}'
-```
-
-(This stays a single idempotent `kubectl patch ... --type merge`.)
-
-- [ ] **Step 4: Static validation (no cluster)**
-
-Run: `for f in leaf-scaledjob service; do python3 -c "import yaml,sys; list(yaml.safe_load_all(open('deploy/knative/$f.yaml'))); print('YAML OK $f')"; done && bash -n deploy/knative/setup-kind.sh && echo "SH OK"`
-Expected: `YAML OK leaf-scaledjob`, `YAML OK service`, `SH OK`. (If `python3`/`yaml` is unavailable, use `kubectl apply --dry-run=client -f` against each file once the cluster context is set in Step 6.)
-
-- [ ] **Step 5: Commit the manifest changes**
-
-```bash
-git add deploy/knative/leaf-scaledjob.yaml deploy/knative/service.yaml deploy/knative/setup-kind.sh
-git commit -s -m "chore(deploy): Harden leaf-worker + ksvc securityContext (non-root, drop caps, read-only rootfs)"
-```
-
-- [ ] **Step 6: (Controller-run) Live verification — rebuild, redeploy, gate**
-
-> Run by the controller, NOT a subagent. Redirect verbose output to `/tmp/kagenti/registry-hardening/` and analyze in subagents per CLAUDE.md context budget.
-
-```bash
-export KUBECONFIG=~/.kube/config; kubectl config use-context kind-sh-knative
-mkdir -p /tmp/kagenti/registry-hardening
-
-# 1. Build WITH --load and VERIFY the image carries the server.ts change before loading:
-docker buildx build --load -t dev.local/serverless-harness:local . > /tmp/kagenti/registry-hardening/build.log 2>&1; echo "build:$?"
-docker run --rm --entrypoint sh dev.local/serverless-harness:local -c 'grep -c "fileURLToPath(import.meta.url)" /app/packages/knative-server/src/server.ts'
-#   → must print 1 (NOT 0). If 0, the build did not load — do not proceed.
-kind load docker-image dev.local/serverless-harness:local --name sh-knative > /tmp/kagenti/registry-hardening/load.log 2>&1; echo "load:$?"
-
-# 2. Apply the feature flag + hardened manifests, recreate ksvc pods:
-bash deploy/knative/setup-kind.sh > /tmp/kagenti/registry-hardening/setup.log 2>&1; echo "setup:$?"   # idempotent; applies the securitycontext flag
-kubectl apply -f deploy/knative/service.yaml > /tmp/kagenti/registry-hardening/svc.log 2>&1; echo "svc:$?"
-kubectl apply -f deploy/knative/leaf-scaledjob.yaml > /tmp/kagenti/registry-hardening/sj.log 2>&1; echo "sj:$?"
-kubectl delete pod -n default -l serving.knative.dev/service=serverless-harness --ignore-not-found
-
-# 3. Run the gate (all 6 claims must pass under the hardened pods):
-GATE_LIVE_SMOKE=1 SH_MODEL=claude-haiku-4-5 bash deploy/knative/leaf-gate-smoke.sh > /tmp/kagenti/registry-hardening/smoke.log 2>&1; echo "SMOKE:$?"
-grep -E "OK |FAIL|TIMEOUT|ALL GATE SMOKE" /tmp/kagenti/registry-hardening/smoke.log
-```
-
-Expected: `ALL GATE SMOKE CLAIMS PASSED`, `SMOKE:0`.
-
-**If a pod CrashLoops or the gate fails on a securityContext cause** (read the pod's events/logs: `kubectl describe pod` / `kubectl logs`): diagnose which constraint broke it.
-- Knative rejects the service securityContext field → confirm the flag patch applied (`kubectl get cm config-features -n knative-serving -o yaml | grep securitycontext`); if a specific field is still gated, enable the matching flag in `setup-kind.sh` and re-apply.
-- `/work` write denied for uid 65532 → confirm `fsGroup: 65532` is present on the failing pod.
-- Read-only rootfs error from the agent writing outside `/tmp` → set `readOnlyRootFilesystem: false` on **that pod only** (keep `true` on the other if it passed), add an inline comment `# agent writes to <path> on rootfs; read-only rootfs deferred for this pod`, re-commit (amend Step 5's commit or a new fixup commit), rebuild only if a manifest-only change (no rebuild needed for YAML), re-apply, and re-run the gate until green.
-
-- [ ] **Step 7: Record the live result**
-
-Append the gate outcome (and any `readOnlyRootFilesystem` fallback decision) to `.superpowers/sdd/progress.md`.
-
----
-
-## Self-Review
-
-**1. Spec coverage:**
-
-| Spec section | Task |
-|---|---|
-| §1 Registry update (Leaf-Session Backend BUILT table) | T1 |
-| §2 `isMainModule` exact idiom + no-auto-start invariant | T2 |
-| §3 securityContext: non-fs hardening (both pods), fsGroup, HOME=/tmp + /tmp emptyDir, readOnlyRootFilesystem empirical, Knative feature flag | T3 (Steps 1-3) |
-| §4 Verification: buildx --load + verify-before-load, live gate 6/6, fallback on read-only-rootfs | T3 Step 6; T2 unit (no auto-start) |
-| §5 Out of scope (no reclaimer tuning, no behavior change, only the two pods) | honored — no task touches runLeaf/queue/KEDA metadata/cron-dispatch/sandbox-0 |
-
-No gaps.
-
-**2. Placeholder scan:** No `TBD`/`TODO`/"handle edge cases"/"similar to". Every step shows the exact markdown/TS/YAML/commands. The one empirical branch (`readOnlyRootFilesystem` fallback) is a concrete, conditional instruction with the exact field + comment to write, not a placeholder.
-
-**3. Consistency:** `runAsUser`/`fsGroup` `65532`, `seccompProfile: RuntimeDefault`, `capabilities: drop ["ALL"]`, `HOME=/tmp` + `tmp` emptyDir, and the `kubernetes.podspec-securitycontext` flag are identical across both pods and match the cron-dispatch baseline (`leaf-cron.yaml`). The `fileURLToPath(import.meta.url)` idiom matches `cron-dispatch.ts:75`. The build/verify command greps for the exact string introduced in T2.
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-06-28-scheduled-leaf-dispatch.md b/docs/superpowers/plans/2026-06-28-scheduled-leaf-dispatch.md
deleted file mode 100644
index f35022f..0000000
--- a/docs/superpowers/plans/2026-06-28-scheduled-leaf-dispatch.md
+++ /dev/null
@@ -1,516 +0,0 @@
-# Scheduled Leaf Dispatch (Archetype C) Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Add a Kubernetes `CronJob` "start signal" that, on each fire, dispatches a static, config-defined list of leaf sessions onto the **unchanged** async path (`POST /runs {async:true}`), keyed by a fire identity so retries resume and each fire is a fresh run.
-
-**Architecture:** A thin `cron-dispatch` entrypoint (same harness image) reads an item list from a mounted ConfigMap and its own Kubernetes Job name (the *fire id*, via the downward API), substitutes the fire id into each envelope's `sessionId`/`resultRef`, and POSTs each as `{async:true}` to the in-cluster Knative service. Everything downstream (the `leaf-queue`, KEDA `ScaledJob`, `runLeaf`, done-marker) is reused unchanged. A native `CronJob` is the discrete scheduler (KEDA's cron scaler is window-based and the wrong primitive).
-
-**Tech Stack:** TypeScript (ESM, `tsx`, `noEmit`), pnpm workspaces, Node global `fetch`, vitest, Knative Serving + KEDA on Kind, Kubernetes `CronJob`/`ConfigMap`.
-
-## Global Constraints
-
-- **No change to the async contract, `leaf-queue`, KEDA `ScaledJob`, or `runLeaf`.** This slice is purely a new client of `POST /runs {async:true}`. (spec §1, §2)
-- **The harness makes no work-selection decisions.** The dispatched list is operator-supplied config; no dynamic ingestion / scanning. (spec §1 charter fit, §8)
-- **Fire identity = the dispatcher pod's Kubernetes Job name**, read via the downward API label `metadata.labels['job-name']` (confirmed present on k8s v1.34). Stable across a Job's pod retries; unique per scheduled fire. (spec §3.2)
-- **`__FIRE__`** is the only template token; the dispatcher replaces **every** occurrence in **every** string field of each envelope with the fire id; non-string / non-matching fields pass through verbatim. (spec §3.1)
-- **Idempotency:** each fire = a fresh run (new Job name → new `sessionId`s, fire-stamped `resultRef`); a retried dispatcher re-POSTs identical `sessionId`s → idempotent resume/overwrite. (spec §3.3)
-- **Dispatch success = HTTP `202` with body `status:"accepted"`.** On any non-`202`/error, log and continue the remaining items, then exit non-zero so the CronJob records a failed fire. All accepted → exit 0. No new envelope validation (the server returns `400` for malformed). (spec §3.4)
-- **Reuse the harness image** (`dev.local/serverless-harness:local`); no new container image. The dispatcher reuses the existing `serverless-harness` ServiceAccount (no new RBAC). (spec §2, §8)
-- **In-cluster invocation:** POST to the Knative service's cluster-local address `http://serverless-harness.default.svc.cluster.local` (no manual `Host` header needed — Knative routes the cluster-local host). This pins the address the spec §5 deferred to the plan and supersedes its tentative kourier-internal+Host suggestion.
-- **DCO:** every commit uses `git commit -s`; no `Co-Authored-By`. Conventional-commit prefixes.
-- Tests are vitest under `packages/knative-server/test/**/*.test.ts`. The dispatch logic is pure (injected `post`), so unit tests need no cluster and no Redis.
-
----
-
-## File Structure
-
-- `packages/knative-server/src/cron-dispatch.ts` — NEW. Exports the pure dispatch logic (`applyFire`, `dispatchAll`, `loadConfig`, `exitCodeFor`) + a guarded `main()` entrypoint (`buildPost` + env wiring).
-- `packages/knative-server/test/cron-dispatch.test.ts` — NEW. Unit tests for the pure logic (injected `post`, temp-file config).
-- `deploy/knative/leaf-cron.yaml` — NEW. Two `---`-separated docs: the `leaf-cron-config` ConfigMap (item list) and the `leaf-cron` CronJob (schedule + dispatcher pod).
-- `deploy/knative/leaf-cron-smoke.sh` — NEW. Gated (`CRON_LIVE_SMOKE=1`) live gate.
-
----
-
-### Task 1: `cron-dispatch` core logic (pure, unit-tested)
-
-**Files:**
-- Create: `packages/knative-server/src/cron-dispatch.ts`
-- Test: `packages/knative-server/test/cron-dispatch.test.ts`
-
-**Interfaces:**
-- Produces:
-  - `function applyFire(envelope: Record<string, unknown>, fireId: string): Record<string, unknown>` — returns a copy with every string value's `__FIRE__` occurrences replaced by `fireId`; non-string values pass through.
-  - `function dispatchAll(items: Record<string, unknown>[], fireId: string, post: (env: Record<string, unknown>) => Promise<boolean>): Promise<{ total: number; accepted: number; failed: number }>` — for each item, `post({ ...applyFire(item, fireId), async: true })`; `true` → accepted, `false`/throw → failed; **always attempts every item**; returns the tally.
-  - `function loadConfig(path: string): Record<string, unknown>[]` — `JSON.parse(readFileSync(path,"utf8")).items`; throws if the file is missing or `items` is not an array.
-  - `function exitCodeFor(result: { failed: number }): number` — `result.failed > 0 ? 1 : 0`.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// packages/knative-server/test/cron-dispatch.test.ts
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { applyFire, dispatchAll, loadConfig, exitCodeFor } from "../src/cron-dispatch";
-
-describe("applyFire", () => {
-  it("substitutes every __FIRE__ occurrence in string fields and passes others through", () => {
-    const out = applyFire(
-      { sessionId: "nightly/__FIRE__/i1", resultRef: "/work/nightly/__FIRE__/results/i1.json", inputsRef: "/work/nightly/inputs/i1.json", model: "claude-haiku-4-5" },
-      "fire-42",
-    );
-    expect(out).toEqual({
-      sessionId: "nightly/fire-42/i1",
-      resultRef: "/work/nightly/fire-42/results/i1.json",
-      inputsRef: "/work/nightly/inputs/i1.json",
-      model: "claude-haiku-4-5",
-    });
-  });
-  it("does not mutate the input object", () => {
-    const input = { sessionId: "s/__FIRE__" };
-    applyFire(input, "f1");
-    expect(input.sessionId).toBe("s/__FIRE__");
-  });
-});
-
-describe("dispatchAll", () => {
-  const ITEMS = [
-    { sessionId: "n/__FIRE__/i1", resultRef: "/work/n/__FIRE__/i1.json" },
-    { sessionId: "n/__FIRE__/i2", resultRef: "/work/n/__FIRE__/i2.json" },
-  ];
-
-  it("posts every item once with async:true and __FIRE__ substituted; all accepted", async () => {
-    const seen: Record<string, unknown>[] = [];
-    const post = vi.fn(async (env: Record<string, unknown>) => { seen.push(env); return true; });
-    const r = await dispatchAll(ITEMS, "fire-1", post);
-    expect(r).toEqual({ total: 2, accepted: 2, failed: 0 });
-    expect(post).toHaveBeenCalledTimes(2);
-    expect(seen[0]).toMatchObject({ sessionId: "n/fire-1/i1", resultRef: "/work/n/fire-1/i1.json", async: true });
-    expect(seen[1]).toMatchObject({ sessionId: "n/fire-1/i2", async: true });
-  });
-
-  it("counts a rejected post as failed but still attempts the rest", async () => {
-    const post = vi.fn()
-      .mockResolvedValueOnce(false)
-      .mockResolvedValueOnce(true);
-    const r = await dispatchAll(ITEMS, "fire-1", post as any);
-    expect(r).toEqual({ total: 2, accepted: 1, failed: 1 });
-    expect(post).toHaveBeenCalledTimes(2);
-  });
-
-  it("counts a thrown post as failed and continues", async () => {
-    const post = vi.fn()
-      .mockRejectedValueOnce(new Error("network"))
-      .mockResolvedValueOnce(true);
-    const r = await dispatchAll(ITEMS, "fire-1", post as any);
-    expect(r).toEqual({ total: 2, accepted: 1, failed: 1 });
-    expect(post).toHaveBeenCalledTimes(2);
-  });
-
-  it("posts nothing for an empty list", async () => {
-    const post = vi.fn(async () => true);
-    const r = await dispatchAll([], "fire-1", post);
-    expect(r).toEqual({ total: 0, accepted: 0, failed: 0 });
-    expect(post).not.toHaveBeenCalled();
-  });
-});
-
-describe("exitCodeFor", () => {
-  it("returns 0 when nothing failed", () => { expect(exitCodeFor({ failed: 0 })).toBe(0); });
-  it("returns 1 when any item failed", () => { expect(exitCodeFor({ failed: 1 })).toBe(1); });
-});
-
-describe("loadConfig", () => {
-  let dir: string;
-  beforeEach(() => { dir = mkdtempSync(join(tmpdir(), "cron-")); });
-  afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
-  it("reads the items array", () => {
-    const p = join(dir, "schedule.json");
-    writeFileSync(p, JSON.stringify({ items: [{ sessionId: "a" }, { sessionId: "b" }] }));
-    expect(loadConfig(p)).toEqual([{ sessionId: "a" }, { sessionId: "b" }]);
-  });
-  it("throws when items is missing or not an array", () => {
-    const p = join(dir, "bad.json");
-    writeFileSync(p, JSON.stringify({ nope: true }));
-    expect(() => loadConfig(p)).toThrow();
-  });
-  it("throws when the file is missing", () => {
-    expect(() => loadConfig(join(dir, "absent.json"))).toThrow();
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `pnpm -C packages/knative-server exec vitest run test/cron-dispatch.test.ts`
-Expected: FAIL — cannot find module `../src/cron-dispatch`.
-
-- [ ] **Step 3: Write the implementation (pure logic + exports only — no `main()` yet)**
-
-```typescript
-// packages/knative-server/src/cron-dispatch.ts
-import { readFileSync } from "node:fs";
-
-/** Replace every __FIRE__ in each string field with fireId; non-strings pass through. Pure, non-mutating. */
-export function applyFire(envelope: Record<string, unknown>, fireId: string): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(envelope)) {
-    out[k] = typeof v === "string" ? v.split("__FIRE__").join(fireId) : v;
-  }
-  return out;
-}
-
-/**
- * Dispatch every config item as an async leaf. Each item is fire-substituted and POSTed with
- * async:true via the injected `post` (returns true iff the dispatch was accepted). Every item is
- * attempted even if earlier ones fail; a thrown post counts as a failure.
- */
-export async function dispatchAll(
-  items: Record<string, unknown>[],
-  fireId: string,
-  post: (env: Record<string, unknown>) => Promise<boolean>,
-): Promise<{ total: number; accepted: number; failed: number }> {
-  let accepted = 0;
-  let failed = 0;
-  for (const item of items) {
-    const env = { ...applyFire(item, fireId), async: true };
-    try {
-      (await post(env)) ? accepted++ : failed++;
-    } catch {
-      failed++;
-    }
-  }
-  return { total: items.length, accepted, failed };
-}
-
-export function exitCodeFor(result: { failed: number }): number {
-  return result.failed > 0 ? 1 : 0;
-}
-
-export function loadConfig(path: string): Record<string, unknown>[] {
-  const parsed = JSON.parse(readFileSync(path, "utf8"));
-  if (!Array.isArray(parsed?.items)) throw new Error("cron config: 'items' must be an array");
-  return parsed.items as Record<string, unknown>[];
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `pnpm -C packages/knative-server exec vitest run test/cron-dispatch.test.ts`
-Expected: PASS (10 tests).
-
-- [ ] **Step 5: Run the full knative-server suite to confirm no regression**
-
-Run: `pnpm -C packages/knative-server exec vitest run`
-Expected: PASS (existing 15 + 10 new = 25).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add packages/knative-server/src/cron-dispatch.ts packages/knative-server/test/cron-dispatch.test.ts
-git commit -s -m "feat(knative-server): cron-dispatch core (applyFire/dispatchAll/loadConfig)"
-```
-
----
-
-### Task 2: `cron-dispatch` entrypoint (`buildPost` + guarded `main`)
-
-**Files:**
-- Modify: `packages/knative-server/src/cron-dispatch.ts` (append `buildPost` + `main` + main-module guard)
-
-**Interfaces:**
-- Consumes: `applyFire`/`dispatchAll`/`loadConfig`/`exitCodeFor` (Task 1).
-- Produces: a runnable entrypoint `node --import tsx src/cron-dispatch.ts` that reads `JOB_NAME` (fire id), `CRON_CONFIG` (config path), `SH_SERVICE_URL`, POSTs each item, logs a summary, and `process.exit(exitCodeFor(result))`. Not unit-tested (real `fetch`/env) — verified by the existing suite still importing cleanly + the Task 4 live gate, mirroring `leaf-job.ts`.
-
-- [ ] **Step 1: Append the entrypoint to `cron-dispatch.ts`**
-
-Append to `packages/knative-server/src/cron-dispatch.ts`:
-
-```typescript
-import { fileURLToPath } from "node:url";
-
-/** Build the real POST function: fetch the in-cluster Knative service; accepted == 202 + {status:"accepted"}. */
-function buildPost(): (env: Record<string, unknown>) => Promise<boolean> {
-  const base = process.env.SH_SERVICE_URL ?? "http://serverless-harness.default.svc.cluster.local";
-  return async (env) => {
-    const res = await fetch(`${base}/run-leaf`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(env),
-    });
-    if (res.status !== 202) {
-      console.error(`dispatch rejected: HTTP ${res.status}`);
-      return false;
-    }
-    const body = await res.json().catch(() => ({}) as Record<string, unknown>);
-    return (body as Record<string, unknown>).status === "accepted";
-  };
-}
-
-async function main(): Promise<void> {
-  const fireId = process.env.JOB_NAME ?? `manual-${process.pid}`;
-  const configPath = process.env.CRON_CONFIG ?? "/config/schedule.json";
-  const items = loadConfig(configPath);
-  const result = await dispatchAll(items, fireId, buildPost());
-  console.log(`cron-dispatch: ${result.accepted}/${result.total} accepted, ${result.failed} failed (fire=${fireId})`);
-  process.exit(exitCodeFor(result));
-}
-
-// Only run when invoked as the entrypoint (so tests can import the pure helpers above).
-const isMainModule = process.argv[1] === fileURLToPath(import.meta.url);
-if (isMainModule) {
-  main().catch((err) => {
-    console.error("cron-dispatch error:", err);
-    process.exit(1);
-  });
-}
-```
-
-- [ ] **Step 2: Verify the suite still passes (no auto-run on import, no breakage)**
-
-Run: `pnpm -C packages/knative-server exec vitest run`
-Expected: PASS (25). The `isMainModule` guard means importing `cron-dispatch` in the test does NOT execute `main()` (no fetch/fs/exit during tests). If any test now hangs or the process exits, the guard is wrong — fix it before continuing.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add packages/knative-server/src/cron-dispatch.ts
-git commit -s -m "feat(knative-server): cron-dispatch entrypoint (POST async to in-cluster ksvc)"
-```
-
----
-
-### Task 3: `leaf-cron.yaml` — ConfigMap + CronJob (one manifest)
-
-**Files:**
-- Create: `deploy/knative/leaf-cron.yaml`
-
-**Interfaces:**
-- Consumes: the `cron-dispatch` entrypoint (Task 2), the `dev.local/serverless-harness:local` image, the `serverless-harness` ServiceAccount.
-- Produces: a `leaf-cron-config` ConfigMap (the item list with `__FIRE__` templates) and a `leaf-cron` CronJob that runs the dispatcher per fire.
-
-- [ ] **Step 1: Write the manifest**
-
-```yaml
-# deploy/knative/leaf-cron.yaml
-# Archetype C: a CronJob that dispatches a static, config-defined list of leaf sessions onto the
-# unchanged async path. Operator workflow: edit + `kubectl apply -f deploy/knative/leaf-cron.yaml`;
-# fire on demand with `kubectl create job --from=cronjob/leaf-cron <name>`.
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: leaf-cron-config
-  namespace: default
-data:
-  schedule.json: |
-    { "items": [
-      { "sessionId": "nightly/__FIRE__/i1", "inputsRef": "/work/nightly/inputs/i1.json",
-        "resultRef": "/work/nightly/__FIRE__/results/i1.json",
-        "workspaceRef": "/workspace/nightly/repo", "model": "claude-haiku-4-5" },
-      { "sessionId": "nightly/__FIRE__/i2", "inputsRef": "/work/nightly/inputs/i2.json",
-        "resultRef": "/work/nightly/__FIRE__/results/i2.json",
-        "workspaceRef": "/workspace/nightly/repo", "model": "claude-haiku-4-5" },
-      { "sessionId": "nightly/__FIRE__/i3", "inputsRef": "/work/nightly/inputs/i3.json",
-        "resultRef": "/work/nightly/__FIRE__/results/i3.json",
-        "workspaceRef": "/workspace/nightly/repo", "model": "claude-haiku-4-5" }
-    ] }
----
-apiVersion: batch/v1
-kind: CronJob
-metadata:
-  name: leaf-cron
-  namespace: default
-spec:
-  schedule: "0 2 * * *"          # daily 02:00; operator edits to taste. Fire on demand via `kubectl create job --from`.
-  concurrencyPolicy: Forbid       # don't start a new dispatcher while the previous fire's dispatcher runs
-  jobTemplate:
-    spec:
-      backoffLimit: 1             # one retry of the dispatcher; idempotent because the fire id is stable
-      template:
-        spec:
-          restartPolicy: Never
-          serviceAccountName: serverless-harness
-          containers:
-            - name: cron-dispatch
-              image: dev.local/serverless-harness:local
-              imagePullPolicy: IfNotPresent
-              workingDir: /app/packages/knative-server
-              command: ["node", "--import", "tsx", "src/cron-dispatch.ts"]
-              env:
-                - name: JOB_NAME    # the fire id — stable across this Job's pod retries, unique per fire
-                  valueFrom: { fieldRef: { fieldPath: "metadata.labels['job-name']" } }
-                - name: CRON_CONFIG
-                  value: /config/schedule.json
-                - name: SH_SERVICE_URL
-                  value: http://serverless-harness.default.svc.cluster.local
-              volumeMounts:
-                - name: config
-                  mountPath: /config
-              resources:
-                requests: { memory: 128Mi, cpu: 50m }
-                limits: { memory: 256Mi, cpu: 200m }
-          volumes:
-            - name: config
-              configMap:
-                name: leaf-cron-config
-```
-
-- [ ] **Step 2: Validate the manifest parses and is API-valid (no apply)**
-
-Run: `python3 -c "import yaml; list(yaml.safe_load_all(open('deploy/knative/leaf-cron.yaml'))); print('YAML_OK')"`
-Expected: `YAML_OK`.
-Run: `KUBECONFIG=~/.kube/config kubectl apply --dry-run=server -f deploy/knative/leaf-cron.yaml`
-Expected: `configmap/leaf-cron-config created (server dry run)` and `cronjob.batch/leaf-cron created (server dry run)` (validates the schedule expression and the downward-API fieldPath against the live API server). If the `job-name` label fieldPath is rejected, switch to `metadata.labels['batch.kubernetes.io/job-name']` and re-run.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add deploy/knative/leaf-cron.yaml
-git commit -s -m "feat(cron): leaf-cron CronJob + config for scheduled leaf dispatch"
-```
-
-> Live validation (real fire → dispatch → completion → idempotent retry) happens in Task 4.
-
----
-
-### Task 4: Live gate — scheduled dispatch, completion, idempotent retry
-
-**Files:**
-- Create: `deploy/knative/leaf-cron-smoke.sh`
-
-**Interfaces:**
-- Consumes: everything above + the deployed async path (KEDA + ScaledJob) + `sandbox-0` + the `leaf-work` PVC + the existing `deploy/knative/fixtures/{inputs,repo}` + `lib.sh` (`NS`, `ok`, `ko`, `PASS`, `FAIL`).
-- Produces: a gated pass/fail proving spec §6.2 claims 1–3.
-
-- [ ] **Step 1: Write the gated smoke script**
-
-```bash
-# deploy/knative/leaf-cron-smoke.sh
-#!/usr/bin/env bash
-# Gated Kind smoke for scheduled leaf dispatch (Archetype C, design §6.2). Proves: the CronJob's
-# dispatcher enqueues a config list onto the async path (leaves complete with correct verdicts) and
-# a re-run of the SAME fire is idempotent (same fire-stamped paths, no second run dir).
-# Deterministic: fires with `kubectl create job --from=cronjob/leaf-cron` (no waiting on a cron tick).
-# Prereq: async path deployed (KEDA + ScaledJob); image rebuilt with cron-dispatch.ts; leaf-cron.yaml
-#   applied; sandbox-0 + leaf-work PVC up.
-# Usage: CRON_LIVE_SMOKE=1 bash deploy/knative/leaf-cron-smoke.sh
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-[ "${CRON_LIVE_SMOKE:-0}" = "1" ] || { echo "SKIP (set CRON_LIVE_SMOKE=1)"; exit 0; }
-
-ORCH=leaf-orchestrator; SBOX="${KAGENTI_SANDBOX_POD:-sandbox-0}"
-FIRE="cronfire-$$"                       # the manual fire id (becomes the Job name → JOB_NAME label)
-NRES="/work/nightly/$FIRE/results"        # fire-stamped result dir the config templates produce
-ITEMS="i1 i2 i3"
-declare -A EXPECT=( [i1]=FLAGGED [i2]=CLEAR [i3]=CLEAR )
-trap 'kubectl -n "$NS" delete job "$FIRE" --force --grace-period=0 >/dev/null 2>&1 || true; kubectl -n "$NS" exec "$SBOX" -- sh -c "rm -rf /workspace/nightly" 2>/dev/null || true' EXIT
-oexec() { kubectl -n "$NS" exec "$ORCH" -- "$@"; }
-claim() { echo ""; echo "--- Claim $1: $2 ---"; }
-fire_and_wait() {  # create a Job named $FIRE from the cronjob, wait for the dispatcher to finish
-  kubectl -n "$NS" delete job "$FIRE" --force --grace-period=0 >/dev/null 2>&1 || true
-  kubectl -n "$NS" create job --from=cronjob/leaf-cron "$FIRE" >/dev/null
-  kubectl -n "$NS" wait --for=condition=complete "job/$FIRE" --timeout=120s >/dev/null 2>&1 \
-    || kubectl -n "$NS" wait --for=condition=failed "job/$FIRE" --timeout=5s >/dev/null 2>&1 || true
-}
-
-echo "=== Scheduled leaf dispatch smoke (fire=$FIRE) ==="
-kubectl -n "$NS" wait --for=condition=Ready "pod/$ORCH" --timeout=90s >/dev/null
-kubectl -n "$NS" wait --for=condition=Ready "pod/$SBOX" --timeout=90s >/dev/null
-for _ in $(seq 1 30); do oexec sh -c 'command -v jq >/dev/null' && break; sleep 2; done
-# seed fixtures at the fixed paths the config references
-oexec mkdir -p /work/nightly/inputs
-kubectl -n "$NS" cp ./fixtures/inputs/. "$ORCH:/work/nightly/inputs"
-kubectl -n "$NS" exec "$SBOX" -- mkdir -p /workspace/nightly/repo
-kubectl -n "$NS" cp ./fixtures/repo/. "$SBOX:/workspace/nightly/repo"
-
-# Claim 1: schedule validity (the CronJob exists / applied clean)
-claim 1 "CronJob applied and present"
-if kubectl -n "$NS" get cronjob leaf-cron >/dev/null 2>&1; then ok "leaf-cron CronJob present"; else ko "leaf-cron CronJob missing"; fi
-
-# Claim 2: a fire dispatches the list; leaves complete with correct verdicts under the fire-stamped dir
-claim 2 "Fire dispatches list; leaves complete with correct verdicts"
-fire_and_wait
-cov_ok=1
-for id in $ITEMS; do
-  got=""
-  for _ in $(seq 1 60); do
-    if oexec test -f "$NRES/$id.json.status"; then got=$(oexec sh -c "jq -r .status $NRES/$id.json.status"); break; fi
-    sleep 5
-  done
-  v=$(oexec sh -c "jq -r .verdict $NRES/$id.json 2>/dev/null" 2>/dev/null || echo "")
-  if [ "$got" = "done" ] && [ "$v" = "${EXPECT[$id]}" ]; then echo "    $id done verdict=$v"; else echo "    $id status=$got verdict=$v (want ${EXPECT[$id]})"; cov_ok=0; fi
-done
-[ "$cov_ok" = 1 ] && ok "all dispatched leaves completed with correct verdicts" || ko "missing/incorrect"
-
-# Claim 3: re-running the SAME fire id is idempotent — same fire-stamped dir, no second run directory
-claim 3 "Idempotent retry: same fire id → same paths, no duplicate run dir"
-before=$(oexec sh -c 'ls -1d /work/nightly/cronfire-* 2>/dev/null | wc -l' | tr -d ' ')
-fire_and_wait
-after=$(oexec sh -c 'ls -1d /work/nightly/cronfire-* 2>/dev/null | wc -l' | tr -d ' ')
-still_done=1
-for id in $ITEMS; do
-  s=$(oexec sh -c "jq -r .status $NRES/$id.json.status" 2>/dev/null || echo "")
-  [ "$s" = "done" ] || still_done=0
-done
-if [ "$before" = "$after" ] && [ "$still_done" = 1 ]; then ok "re-fire reused id (dirs: $before→$after), markers still done"; else ko "dirs $before→$after still_done=$still_done"; fi
-
-echo ""; echo "=== Results: $PASS passed, $FAIL failed ==="
-if [ "$FAIL" -gt 0 ]; then echo "CRON SMOKE FAIL"; exit 1; else echo "CRON SMOKE PASS"; exit 0; fi
-```
-
-- [ ] **Step 2: Make executable and syntax-check; confirm the gate is honored**
-
-Run: `chmod +x deploy/knative/leaf-cron-smoke.sh && bash -n deploy/knative/leaf-cron-smoke.sh && echo SYNTAX_OK`
-Expected: `SYNTAX_OK`.
-Run: `bash deploy/knative/leaf-cron-smoke.sh; echo "EXIT:$?"`
-Expected: prints `SKIP (set CRON_LIVE_SMOKE=1)` and `EXIT:0`.
-
-- [ ] **Step 3: Rebuild image (adds cron-dispatch.ts), apply, run the live gate**
-
-Redirect verbose output to logs (CLAUDE.md context-budget); analyze failures in a subagent.
-
-```bash
-export LOG_DIR=/tmp/kagenti/leaf-cron; mkdir -p $LOG_DIR
-# rebuild + reload so the image contains src/cron-dispatch.ts
-docker build --load -t dev.local/serverless-harness:local . > $LOG_DIR/build.log 2>&1 && kind load docker-image dev.local/serverless-harness:local --name sh-knative >> $LOG_DIR/build.log 2>&1; echo "build:EXIT:$?"
-# apply the cron manifest (ConfigMap + CronJob) and ensure the async path + sandbox are present
-kubectl apply -f deploy/knative/leaf-cron.yaml > $LOG_DIR/apply.log 2>&1; echo "apply:EXIT:$?"
-kubectl apply -f deploy/knative/leaf-scaledjob.yaml -f deploy/knative/leaf-pvc.yaml -f deploy/knative/leaf-orchestrator.yaml >> $LOG_DIR/apply.log 2>&1
-CRON_LIVE_SMOKE=1 bash deploy/knative/leaf-cron-smoke.sh > $LOG_DIR/smoke.log 2>&1; echo "smoke:EXIT:$?"
-```
-
-Expected: `/tmp/kagenti/leaf-cron/smoke.log` ends with `CRON SMOKE PASS` (3 claims). If a claim fails, analyze the log + the dispatcher pod log (`kubectl logs job/cronfire-<pid>`) + `kubectl get jobs,pods -l scaledjob.keda.sh/name=leaf-worker` in a subagent — do not read whole logs in the main context. (The dispatcher pod's own log shows the per-item accept/reject summary.)
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/leaf-cron-smoke.sh
-git commit -s -m "test(cron): gated live smoke — scheduled dispatch, completion, idempotent retry"
-```
-
----
-
-## Self-Review
-
-**Spec coverage (design §1–§9):**
-- §2 architecture (CronJob → dispatcher → POST async → unchanged path) → Tasks 2 (entrypoint) + 3 (CronJob). ✓
-- §3.1 config (ConfigMap, `__FIRE__` template, co-located with CronJob) → Task 3 manifest + Task 1 `applyFire`/`loadConfig`. ✓
-- §3.2 fire id = Job name via downward API → Task 3 env `JOB_NAME` + Task 2 `main`. ✓
-- §3.3 idempotency (fresh run per fire, retried dispatcher resumes) → Task 1 substitution (stable per fire id) + Task 4 Claim 3 (live proof). ✓
-- §3.4 dispatch result → exit code (202+accepted = success; non-202 continue+exit non-zero) → Task 1 `dispatchAll`/`exitCodeFor` + Task 2 `buildPost`. ✓
-- §4 CronJob-not-KEDA-cron → Task 3 (native CronJob). ✓
-- §5 in-cluster invocation (cluster-local ksvc URL) → Task 2 `buildPost` default + Global Constraints. ✓
-- §6.1 unit coverage → Task 1 (10 tests). §6.2 live gate (3 claims) → Task 4. ✓
-- §7 non-precluding extension → no code (config shape already supports it). §8 scope/YAGNI; §9 prereqs (no setup-kind change) → honored (no new install). ✓
-
-**Placeholder scan:** none — every code/YAML/command step is concrete. The Task 3 dry-run names the exact fallback (`batch.kubernetes.io/job-name`) if the `job-name` fieldPath is rejected.
-
-**Type consistency:** `applyFire`/`dispatchAll`/`loadConfig`/`exitCodeFor` signatures defined in Task 1 are consumed unchanged by Task 2's `main`. The `post` abstraction (`(env) => Promise<boolean>`) is produced by `buildPost` (Task 2) and injected into `dispatchAll` (Task 1) — same shape. `JOB_NAME`/`CRON_CONFIG`/`SH_SERVICE_URL` env names match between Task 2 (`main`/`buildPost`) and Task 3 (CronJob env). The config item field names (`sessionId`/`inputsRef`/`resultRef`/`workspaceRef`/`model`) and the `__FIRE__` token match between Task 1 tests, Task 3 ConfigMap, and Task 4's expected `resultRef` path (`/work/nightly/$FIRE/results/$id.json`).
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-07-02-p0prime-ocp-fs-free-deployment.md b/docs/superpowers/plans/2026-07-02-p0prime-ocp-fs-free-deployment.md
deleted file mode 100644
index 9466f73..0000000
--- a/docs/superpowers/plans/2026-07-02-p0prime-ocp-fs-free-deployment.md
+++ /dev/null
@@ -1,609 +0,0 @@
-# P0′ — OpenShift Deployment of the FS-Free Harness (P1 slice) Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Make the merged FS-free two-tier harness (P1) deploy and pass its full leaf smoke on the live OpenShift 4.20.8 cluster, with a durable RWO sandbox — by reframing the never-applied, pre-P1 OCP overlay + `setup-ocp.sh` to the `Sandbox`-CR world.
-
-**Architecture:** FS-free harness Knative Service (GHCR image, mounts only `/tmp`) resolves `sandbox-0` via `KAGENTI_SANDBOX_NAME` + the Sandbox CR's `.status.selector` and `kubectl exec`s tool ops into it. The sandbox pod is created by the agent-sandbox v0.5.0 controller from a `Sandbox` CR whose `volumeClaimTemplates` back `/workspace` with a durable RWO EBS PVC. OCP-specific divergences (non-root SCC, pre-baked tool image) live entirely in the `overlays/ocp` kustomize overlay + `setup-ocp.sh`; the shared base manifests are untouched.
-
-**Tech Stack:** OpenShift 4.20.8 / Knative Serving v1.17 (OpenShift Serverless), agent-sandbox v0.5.0 (`sandboxes.agents.x-k8s.io`), AWS EBS `gp3-csi` (RWO), kustomize (JSON6902 patch), bash, Redis.
-
-**Spec:** [`docs/specs/2026-07-02-p0prime-ocp-fs-free-deployment-design.md`](../../specs/2026-07-02-p0prime-ocp-fs-free-deployment-design.md)
-
-## Global Constraints
-
-- **Branch:** `docs/p0prime-ocp-fs-free-deployment` (already created off `main` @ `d199484`). Do all work here.
-- **DCO on every commit:** `git commit -s -m "<subject>" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"`. Never `Co-authored-by`.
-- **Never `git add -A`.** The tree is intentionally dirty (`experiments/RESULTS.md`, `.worktrees/`). `git add` **explicit paths only**.
-- **Live cluster:** `export KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig` in every shell that touches the cluster. Namespace: **`default`**. Cluster is OCP 4.20.8; Serverless + KEDA already installed; agent-sandbox controller is **not** installed.
-- **Context budget:** redirect any command with >5 lines of output to `/tmp/sh/p0prime/*.log` (`mkdir -p /tmp/sh/p0prime` first) and analyze logs via a subagent — never read a full build/smoke/kubectl dump into the main context.
-- **Smoke model:** `SH_MODEL=claude-haiku-4-5` unless overridden.
-- **Scope fence:** touch only these 5 files — `deploy/knative/sandbox.Dockerfile`, `deploy/knative/overlays/ocp/kustomization.yaml`, `deploy/knative/overlays/ocp/patch-sandbox.yaml`, `deploy/knative/setup-ocp.sh`, `deploy/knative/README-ocp.md`. Do **not** edit `leaf-orchestrator.yaml`, the gate/cron/async smokes, `lib.sh`, `setup-kind.sh`, `README-kind.md`, or `service.yaml` (the harness SA + exec RBAC ship in `service.yaml`, reused as-is from the working Kind path).
-
-## File Structure
-
-| File | Responsibility | Change |
-|------|----------------|--------|
-| `deploy/knative/sandbox.Dockerfile` | Pre-baked OCP sandbox tool image | Add `ripgrep` (leaf `find`/`grep` route to `rg`) |
-| `deploy/knative/overlays/ocp/patch-sandbox.yaml` | OCP divergence for the sandbox pod | Rewrite as a **JSON6902 patch onto the `Sandbox` CR**: non-root `securityContext` + `fsGroup` + SA + `sleep infinity` + pre-baked image; **keep the durable PVC** (no `emptyDir`) |
-| `deploy/knative/overlays/ocp/kustomization.yaml` | OCP overlay wiring | Drop deleted `leaf-pvc.yaml`; retarget patch to `Sandbox` CR; drop dead `alpine` image transform; fix header comments |
-| `deploy/knative/setup-ocp.sh` | One-shot OCP bring-up | Create sandbox SA + grant `nonroot-v2`; install agent-sandbox v0.5.0 controller; poll Sandbox readiness; tolerate a pre-existing `llm-credentials` secret; retire `leaf-work` wording |
-| `deploy/knative/README-ocp.md` | OCP operator docs | Replace `leaf-work` PVC references with durable-PVC-via-CR + controller-install step |
-
----
-
-### Task 1: Add `ripgrep` to the pre-baked sandbox image
-
-**Files:**
-- Modify: `deploy/knative/sandbox.Dockerfile:16` (and the two stale comments)
-
-**Interfaces:**
-- Produces: the in-cluster-built `serverless-harness-sandbox` image now has `rg` on `PATH`, satisfying `packages/k8s-sandbox/src/operations.ts` (glob `rg --files`) and `grep-tool.ts` (`rg --line-number`).
-
-- [ ] **Step 1: Add `ripgrep` to the `apk add` line**
-
-Change line 16 from:
-```dockerfile
-RUN apk add --no-cache bash coreutils findutils grep
-```
-to:
-```dockerfile
-RUN apk add --no-cache bash coreutils findutils grep ripgrep
-```
-
-- [ ] **Step 2: Fix the two now-inaccurate comments**
-
-In the top comment block, change the PATH line (≈line 13) to name ripgrep and why:
-```dockerfile
-# execution into this pod via `kubectl exec`, so it needs bash + GNU coreutils,
-# findutils, grep and ripgrep (the agent's find/grep tools shell out to `rg`) on PATH.
-```
-In the `/workspace` comment block (≈lines 20-22), drop the stale "emptyDir over /workspace" clause — the OCP overlay now backs `/workspace` with the Sandbox CR's durable PVC (fsGroup-owned), not an emptyDir:
-```dockerfile
-# OpenShift assigns the pod a non-root UID; the OCP overlay pins runAsUser/fsGroup
-# 65532 and backs /workspace with the Sandbox CR's durable PVC (fsGroup-owned, so
-# writable). The chgrp/chmod below is belt-and-suspenders for GID-0 arbitrary-UID use.
-```
-
-- [ ] **Step 3: Verify the Dockerfile is well-formed and includes ripgrep**
-
-Run:
-```bash
-grep -n 'ripgrep' deploy/knative/sandbox.Dockerfile; echo "EXIT:$?"
-```
-Expected: line 16 prints, `EXIT:0`.
-
-Optional local build sanity check (only if a container runtime is present; the authoritative build is in-cluster in Task 6):
-```bash
-if command -v podman >/dev/null || command -v docker >/dev/null; then
-  RT=$(command -v podman || command -v docker)
-  "$RT" build -f deploy/knative/sandbox.Dockerfile -t sh-sandbox-test deploy/knative \
-    >/tmp/sh/p0prime/sandbox-local-build.log 2>&1 && \
-  "$RT" run --rm --entrypoint rg sh-sandbox-test --version | head -1 || \
-  echo "local build unavailable/failed — verified in-cluster in Task 6 (see log)"
-fi
-```
-Expected: `ripgrep 14.x` prints, or the "verified in-cluster" fallback line.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/sandbox.Dockerfile
-git commit -s -m "fix(ocp): add ripgrep to the pre-baked sandbox image" \
-  -m "The agent's find/grep tools shell out to rg inside the sandbox; the OCP
-image omitted ripgrep, so the full leaf smoke would crash on the first search." \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 2: Reframe the OCP overlay onto the `Sandbox` CR (durable PVC, non-root)
-
-**Files:**
-- Rewrite: `deploy/knative/overlays/ocp/patch-sandbox.yaml`
-- Modify: `deploy/knative/overlays/ocp/kustomization.yaml`
-
-**Interfaces:**
-- Consumes: base `deploy/knative/sandbox.yaml` (`Sandbox` CR `sandbox-0`, container `sandbox` at `podTemplate.spec.containers[0]`, image `alpine:3.20`, `volumeClaimTemplates[workspace]` RWO 1Gi).
-- Produces: a rendered `Sandbox` CR whose pod runs as UID 65532 (non-root, `nonroot-v2`), `fsGroup: 65532`, `serviceAccountName: serverless-harness-sandbox`, `command: [sleep infinity]`, image = the internal-registry pullspec, `/workspace` on the durable PVC (no emptyDir). Consumed by `setup-ocp.sh` render/apply (Task 3) and the live deploy (Tasks 5-6). The pullspec literal `image-registry.openshift-image-registry.svc:5000/default/serverless-harness-sandbox:latest` MUST match `setup-ocp.sh`'s `render_overlay` sed.
-
-- [ ] **Step 1: Rewrite `patch-sandbox.yaml` as a JSON6902 patch onto the Sandbox CR**
-
-Replace the entire file with (a JSON6902 op list — kustomize strategic-merge can't reliably merge a container inside a CRD `podTemplate`, so we use explicit paths):
-```yaml
-# OpenShift variant of the sandbox pod, applied as a JSON6902 patch onto the
-# Sandbox CR (agents.x-k8s.io/v1beta1). The base (Kind) runs `apk add ...` as root
-# at start-up — blocked by OCP SCCs. Here: tools are pre-baked into the image
-# (sandbox.Dockerfile), so the command is just `sleep infinity`; the image is the
-# in-cluster-built internal-registry pullspec; the pod runs non-root (UID 65532,
-# admitted by nonroot-v2 on the serverless-harness-sandbox SA) with fsGroup 65532
-# so the Sandbox CR's durable /workspace PVC (from volumeClaimTemplates) is writable.
-# NOTE: we deliberately do NOT touch volumeClaimTemplates/volumeMounts — /workspace
-# stays on the durable RWO PVC (the point of P0′), not an emptyDir.
-- op: replace
-  path: /spec/podTemplate/spec/containers/0/image
-  value: image-registry.openshift-image-registry.svc:5000/default/serverless-harness-sandbox:latest
-- op: replace
-  path: /spec/podTemplate/spec/containers/0/command
-  value: ["sleep", "infinity"]
-- op: add
-  path: /spec/podTemplate/spec/serviceAccountName
-  value: serverless-harness-sandbox
-- op: add
-  path: /spec/podTemplate/spec/securityContext
-  value:
-    runAsUser: 65532
-    runAsNonRoot: true
-    fsGroup: 65532
-    seccompProfile:
-      type: RuntimeDefault
-- op: add
-  path: /spec/podTemplate/spec/containers/0/securityContext
-  value:
-    allowPrivilegeEscalation: false
-    capabilities:
-      drop: ["ALL"]
-```
-
-- [ ] **Step 2: Fix `kustomization.yaml` — resources, patch target, image transform, comments**
-
-Edit `deploy/knative/overlays/ocp/kustomization.yaml`:
-
-(a) Remove the deleted PVC from `resources` (lines 28-32 become):
-```yaml
-resources:
-  - ../../redis.yaml
-  - ../../sandbox.yaml
-  - ../../service.yaml
-```
-
-(b) Drop the dead `alpine` image transform (the sandbox image is now set in the JSON6902 patch; the built-in `images` transformer cannot reach a CRD's `podTemplate` path anyway). The `images:` block becomes just the harness entry:
-```yaml
-images:
-  - name: dev.local/serverless-harness
-    newName: ghcr.io/kagenti/serverless-harness
-    newTag: latest
-```
-
-(c) Retarget the patch from a non-existent `Pod` to the `Sandbox` CR (lines 42-47 become):
-```yaml
-patches:
-  - path: patch-sandbox.yaml
-    target:
-      group: agents.x-k8s.io
-      version: v1beta1
-      kind: Sandbox
-      name: sandbox-0
-```
-
-(d) Fix the header comment block (lines 9-24) to describe the real design — replace the "Sandbox image ... referenced by its internal-registry pullspec" / "writable /workspace emptyDir" / "pre-baked sandbox image ... sets USER 65532 itself, so its pod needs no SCC grant" / "leaf-work PVC" paragraphs with:
-```yaml
-#   - Sandbox image + pod: the pre-baked image (sandbox.Dockerfile) and the
-#     non-root securityContext are set via a JSON6902 patch onto the Sandbox CR
-#     (patch-sandbox.yaml): runAsUser/fsGroup 65532, seccomp RuntimeDefault,
-#     drop ALL caps, and serviceAccountName serverless-harness-sandbox. The
-#     command is `sleep infinity` (no root apk-add).
-#
-# Both tiers run non-root: setup-ocp.sh grants nonroot-v2 to the harness SA
-# (serverless-harness) AND the sandbox SA (serverless-harness-sandbox), since the
-# GHCR harness image declares no USER and the SCC does not reliably inject a UID.
-#
-# The sandbox's /workspace is backed by the Sandbox CR's durable RWO PVC
-# (volumeClaimTemplates) — the only mode AWS EBS / gp3-csi offers. RWX is a P2
-# concern on the sandbox tier, never the harness. There is no leaf-work PVC after P1.
-```
-
-- [ ] **Step 3: Render the overlay locally and verify it is correct**
-
-Run (kustomize via `oc`/`kubectl`, or standalone `kustomize`):
-```bash
-mkdir -p /tmp/sh/p0prime
-(oc kustomize --load-restrictor LoadRestrictionsNone deploy/knative/overlays/ocp \
-  || kubectl kustomize --load-restrictor LoadRestrictionsNone deploy/knative/overlays/ocp) \
-  > /tmp/sh/p0prime/render.yaml 2> /tmp/sh/p0prime/render.err; echo "EXIT:$?"
-```
-Expected: `EXIT:0` (no "leaf-pvc.yaml" load error, no "no matches for target" patch error).
-
-- [ ] **Step 4: Assert the rendered Sandbox CR is correct**
-
-Run:
-```bash
-cd /tmp/sh/p0prime
-echo "== leaf-work must be ABSENT =="; grep -c 'leaf-work\|leaf-pvc' render.yaml   # expect 0
-echo "== emptyDir must be ABSENT =="; grep -c 'emptyDir' render.yaml               # expect 0
-echo "== durable PVC template PRESENT =="; grep -c 'volumeClaimTemplates' render.yaml # expect 1
-echo "== non-root + fsGroup + SA + image + sleep =="
-grep -E 'runAsUser: 65532|fsGroup: 65532|serviceAccountName: serverless-harness-sandbox|serverless-harness-sandbox:latest|- sleep' render.yaml
-```
-Expected: first grep `0`, second `0`, third `≥1`, and all five patterns in the last grep print.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add deploy/knative/overlays/ocp/kustomization.yaml deploy/knative/overlays/ocp/patch-sandbox.yaml
-git commit -s -m "fix(ocp): reframe overlay onto the Sandbox CR with a durable PVC" \
-  -m "P1 deleted leaf-pvc.yaml and moved the sandbox working set to the Sandbox
-CR's volumeClaimTemplates. The pre-P1 overlay still referenced leaf-pvc.yaml
-(kustomize build failed), patched a non-existent Pod, and overrode /workspace
-to emptyDir (defeating durability). Patch the Sandbox CR podTemplate via JSON6902
-instead: non-root 65532 + fsGroup + nonroot-v2 SA + pre-baked image, PVC intact." \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 3: Wire the missing pieces into `setup-ocp.sh`
-
-**Files:**
-- Modify: `deploy/knative/setup-ocp.sh`
-
-**Interfaces:**
-- Consumes: the corrected overlay (Task 2), the ripgrep image (Task 1), the `wait_for_crd` / `apply_stdin` / `run_cmd` / `log_*` helpers already in the script.
-- Produces: an end-to-end bring-up that installs the agent-sandbox controller, creates + SCC-grants the sandbox SA, applies the overlay, waits for the Sandbox pod Ready via `.status.selector`, and tolerates a pre-provisioned `llm-credentials` secret.
-
-- [ ] **Step 1: Tolerate a pre-existing `llm-credentials` secret (user provides it)**
-
-Replace the hard-fail guard (lines 359-375, the `# 4. LLM credentials secret` block body) so that when neither env var is set it *uses an existing secret* instead of exiting:
-```bash
-create_secret() {
-  local args=(--from-literal=api-key="${ANTHROPIC_API_KEY:-${ANTHROPIC_AUTH_TOKEN:-}}")
-  [ -n "${ANTHROPIC_BASE_URL:-}" ]   && args+=(--from-literal=base-url="$ANTHROPIC_BASE_URL")
-  [ -n "${ANTHROPIC_AUTH_TOKEN:-}" ] && args+=(--from-literal=auth-token="$ANTHROPIC_AUTH_TOKEN")
-  $KUBECTL create secret generic llm-credentials -n "$NAMESPACE" "${args[@]}" \
-    --dry-run=client -o yaml | $KUBECTL apply -f -
-}
-if [ -n "${ANTHROPIC_API_KEY:-}" ] || [ -n "${ANTHROPIC_AUTH_TOKEN:-}" ]; then
-  if $DRY_RUN; then
-    log_info "[dry-run] would create/update secret llm-credentials in $NAMESPACE (values redacted)"
-  else
-    create_secret >/dev/null
-    log_success "Secret llm-credentials ready (from environment)"
-  fi
-elif $KUBECTL get secret llm-credentials -n "$NAMESPACE" &>/dev/null; then
-  log_success "Secret llm-credentials already present in $NAMESPACE — using it"
-else
-  log_error "No ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN in env and no llm-credentials secret in $NAMESPACE."
-  log_error "Provide one, or pre-create: oc create secret generic llm-credentials -n $NAMESPACE --from-literal=api-key=..."
-  $DRY_RUN || exit 1
-fi
-```
-
-- [ ] **Step 2: Create the sandbox SA and grant it `nonroot-v2` (extend section 5)**
-
-After the existing harness SCC grant (line 392, end of the `# 5.` block), append:
-```bash
-log_info "Ensuring sandbox ServiceAccount + nonroot-v2 SCC (serverless-harness-sandbox) in $NAMESPACE"
-$KUBECTL create serviceaccount serverless-harness-sandbox -n "$NAMESPACE" \
-  --dry-run=client -o yaml | apply_stdin >/dev/null
-if [ "$KUBECTL" = "oc" ]; then
-  run_cmd oc adm policy add-scc-to-user nonroot-v2 -z serverless-harness-sandbox -n "$NAMESPACE"
-else
-  log_warn "kubectl in use — cannot grant SCC; run: oc adm policy add-scc-to-user nonroot-v2 -z serverless-harness-sandbox -n $NAMESPACE"
-fi
-```
-
-- [ ] **Step 3: Install the agent-sandbox controller before the overlay apply**
-
-Insert a new section immediately **before** `# 6. Apply the data-plane overlay` (line 394), so the `sandboxes.agents.x-k8s.io` CRD exists when the overlay's Sandbox CR is applied:
-```bash
-# ============================================================================
-# 5b. agent-sandbox controller (Sandbox CRD) — kubernetes-sigs v0.5.0
-# ============================================================================
-# The harness resolves + execs into the sandbox pod; the pod is created by this
-# controller from the Sandbox CR (applied via the overlay below). Mirrors
-# setup-kind.sh step 5.
-echo
-if $KUBECTL get crd sandboxes.agents.x-k8s.io &>/dev/null; then
-  log_success "agent-sandbox CRD already present — skipping controller install"
-else
-  log_info "Installing agent-sandbox controller (kubernetes-sigs v0.5.0)"
-  run_cmd $KUBECTL apply --server-side -f \
-    "https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.5.0/manifest.yaml"
-  wait_for_crd sandboxes.agents.x-k8s.io 180
-fi
-if ! $DRY_RUN; then
-  $KUBECTL -n agent-sandbox-system rollout status deploy/agent-sandbox-controller --timeout=180s \
-    >"$LOG_DIR/agent-sandbox-rollout.log" 2>&1 \
-    && log_success "agent-sandbox controller ready" \
-    || log_warn "agent-sandbox controller not ready yet (see $LOG_DIR/agent-sandbox-rollout.log)"
-fi
-```
-
-- [ ] **Step 4: Poll the Sandbox pod Ready after the overlay apply**
-
-Insert a new section immediately **after** the overlay-apply block (after line 420, before `# 7. Wait for the harness Knative Service`):
-```bash
-# ============================================================================
-# 6b. Wait for the Sandbox pod (controller publishes .status.selector first)
-# ============================================================================
-echo
-if ! $DRY_RUN; then
-  log_info "Waiting for Sandbox sandbox-0 .status.selector, then pod Ready (up to ~2m)..."
-  SEL=""
-  for _ in $(seq 1 60); do
-    SEL="$($KUBECTL -n "$NAMESPACE" get sandbox sandbox-0 -o jsonpath='{.status.selector}' 2>/dev/null || true)"
-    [ -n "$SEL" ] && break
-    sleep 2
-  done
-  if [ -n "$SEL" ]; then
-    $KUBECTL -n "$NAMESPACE" wait --for=condition=Ready pod -l "$SEL" --timeout=180s \
-      >"$LOG_DIR/sandbox-wait.log" 2>&1 \
-      && log_success "Sandbox pod Ready" \
-      || { log_error "Sandbox pod not Ready (see $LOG_DIR/sandbox-wait.log)"; \
-           $KUBECTL -n "$NAMESPACE" get pod sandbox-0 -o wide 2>/dev/null || true; exit 1; }
-  else
-    log_error "Sandbox sandbox-0 never published .status.selector — is the controller running?"
-    exit 1
-  fi
-fi
-```
-
-- [ ] **Step 5: Retire `leaf-work` wording (header, usage, StorageClass preflight)**
-
-Make these text-only edits (behavior unchanged):
-- Line 10 header comment: `#   - Redis, sandbox, LLM secret and the harness Knative Service` (drop "leaf-work PVC,").
-- Line 66 usage text: `(Knative + Kourier), Redis, the sandbox pod, the LLM secret,` (drop "the leaf-work PVC,").
-- Lines 152-161 StorageClass preflight — rephrase around the durable sandbox PVC:
-```bash
-# StorageClass preflight — the sandbox's durable /workspace PVC (Sandbox CR
-# volumeClaimTemplates, ReadWriteOnce) needs a (default) StorageClass to bind.
-DEFAULT_SC="$($KUBECTL get storageclass -o jsonpath='{range .items[?(@.metadata.annotations.storageclass\.kubernetes\.io/is-default-class=="true")]}{.metadata.name}{end}' 2>/dev/null || echo "")"
-if [ -n "$DEFAULT_SC" ]; then
-  log_success "Default StorageClass: $DEFAULT_SC (sandbox /workspace PVC is ReadWriteOnce)"
-elif [ "$($KUBECTL get storageclass --no-headers 2>/dev/null | wc -l | tr -d ' ')" != "0" ]; then
-  log_warn "No default StorageClass; the sandbox /workspace PVC may stay Pending unless one is set."
-else
-  log_error "No StorageClass found — the sandbox /workspace PVC cannot bind. Install a storage provisioner first."
-  $DRY_RUN || exit 1
-fi
-```
-
-- [ ] **Step 6: Syntax-check and dry-run render**
-
-Run:
-```bash
-bash -n deploy/knative/setup-ocp.sh; echo "SYNTAX_EXIT:$?"
-export KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig
-./deploy/knative/setup-ocp.sh --dry-run > /tmp/sh/p0prime/setup-dryrun.log 2>&1; echo "DRYRUN_EXIT:$?"
-grep -nE 'agent-sandbox|serverless-harness-sandbox|sandbox-0|leaf-work' /tmp/sh/p0prime/setup-dryrun.log | head -30
-```
-Expected: `SYNTAX_EXIT:0`; the dry-run shows the controller install, the sandbox SA + SCC grant, the Sandbox `.status.selector` poll, and **no** `leaf-work` mentions. (A subagent should confirm the dry-run manifest preview renders the corrected Sandbox CR.)
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add deploy/knative/setup-ocp.sh
-git commit -s -m "feat(ocp): install agent-sandbox controller + await Sandbox in setup-ocp.sh" \
-  -m "Adds the missing agent-sandbox v0.5.0 controller install, the sandbox SA +
-nonroot-v2 grant, and the Sandbox .status.selector -> pod-Ready poll (mirrors
-setup-kind.sh). Tolerates a pre-provisioned llm-credentials secret. Retires the
-post-P1 leaf-work PVC wording." \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 4: Refresh `README-ocp.md`
-
-**Files:**
-- Modify: `deploy/knative/README-ocp.md` (lines 6, 15, 66, 147, 177, 186; add a controller-install bullet)
-
-**Interfaces:**
-- Consumes: nothing at runtime — operator-facing docs must match Tasks 1-3.
-
-- [ ] **Step 1: Replace every `leaf-work` PVC reference with the durable-sandbox-PVC reality**
-
-Concretely:
-- Line 6: `` `leaf-work` PVC, `` → drop it (the intro sentence lists what the script deploys; the durable sandbox PVC is provisioned by the controller from the CR, not a standalone PVC).
-- Line 15 (prereq bullet): change to `- A default **StorageClass** for the sandbox's durable `/workspace` PVC (the script fails fast if none).`
-- Line 66 (components table row): change `` | `leaf-work` PVC | `ReadWriteOnce`, cluster-default StorageClass. | `` → `` | Sandbox `/workspace` PVC | `ReadWriteOnce` (Sandbox CR `volumeClaimTemplates`), cluster-default StorageClass. | ``
-- Line 147 (storage/RWX note): change `` `leaf-work` is `ReadWriteOnce`. `` → `The sandbox's `/workspace` PVC is `ReadWriteOnce`.` and keep the EBS/RWX caveat, adding: "RWX, if ever needed for a shared sandbox pool, lives on the sandbox tier (P2) — never the harness."
-- Line 177 (troubleshooting row): change `` | `leaf-work` PVC stuck `Pending` | `` → `` | Sandbox `/workspace` PVC stuck `Pending` | ``
-- Line 186 (teardown command): change `pvc/leaf-work` → `sandbox/sandbox-0` (deleting the Sandbox CR reclaims its PVC), i.e. `oc delete sandbox sandbox-0 deployment/redis svc/redis secret/llm-credentials -n default`.
-
-- [ ] **Step 2: Add a controller-install note**
-
-Add a bullet near the components/prereqs describing the new step:
-```markdown
-- **agent-sandbox controller** (kubernetes-sigs v0.5.0) is installed by the script
-  (`sandboxes.agents.x-k8s.io`); it creates the `sandbox-0` pod from the Sandbox CR
-  and provisions its durable `/workspace` PVC. The harness resolves the pod via the
-  CR's `.status.selector` and `kubectl exec`s tool calls into it.
-```
-
-- [ ] **Step 3: Verify no stale references remain**
-
-Run:
-```bash
-grep -nE 'leaf-work|leaf-pvc' deploy/knative/README-ocp.md; echo "EXIT:$?"
-```
-Expected: no matches, `EXIT:1`.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/README-ocp.md
-git commit -s -m "docs(ocp): update README-ocp for the FS-free Sandbox-CR deploy" \
-  -m "Replace the removed leaf-work PVC with the durable sandbox /workspace PVC
-(Sandbox CR volumeClaimTemplates) and document the agent-sandbox controller step." \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 5: Stage-1 walking skeleton — verify controller propagation on the live cluster
-
-Purpose: prove the agent-sandbox **v0.5.0 controller propagates** `podTemplate` `securityContext`/`fsGroup`/`serviceAccountName` **and** `volumeClaimTemplates` on OCP, and that the EBS PVC is writable by the pinned non-root UID — **before** wiring the harness. Uses stock `alpine:3.20` (no ripgrep needed; the skeleton doesn't run a leaf), so it doesn't depend on the in-cluster image build. **No code commit** — this is a live go/no-go gate.
-
-**Files:** none (live cluster only).
-
-- [ ] **Step 1: Set kubeconfig and prep log dir**
-
-```bash
-export KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig
-mkdir -p /tmp/sh/p0prime
-oc get clusterversion -o jsonpath='{.items[0].status.desired.version}{"\n"}'   # expect 4.20.8
-```
-
-- [ ] **Step 2: Install the agent-sandbox controller**
-
-```bash
-oc apply --server-side -f \
-  "https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.5.0/manifest.yaml" \
-  > /tmp/sh/p0prime/skel-controller.log 2>&1; echo "EXIT:$?"
-oc wait --for=condition=Established crd/sandboxes.agents.x-k8s.io --timeout=120s; echo "CRD:$?"
-oc -n agent-sandbox-system rollout status deploy/agent-sandbox-controller --timeout=180s \
-  > /tmp/sh/p0prime/skel-rollout.log 2>&1; echo "ROLLOUT:$?"
-```
-Expected: `EXIT:0`, `CRD:0`, `ROLLOUT:0`.
-
-- [ ] **Step 3: Create the sandbox SA + grant nonroot-v2**
-
-```bash
-oc create serviceaccount serverless-harness-sandbox -n default --dry-run=client -o yaml | oc apply -f -
-oc adm policy add-scc-to-user nonroot-v2 -z serverless-harness-sandbox -n default
-```
-
-- [ ] **Step 4: Apply a minimal walking-skeleton Sandbox CR (stock alpine, non-root, durable PVC)**
-
-```bash
-oc apply -f - <<'EOF'
-apiVersion: agents.x-k8s.io/v1beta1
-kind: Sandbox
-metadata:
-  name: sandbox-0
-  namespace: default
-  labels: { app: sandbox }
-spec:
-  volumeClaimTemplates:
-    - metadata: { name: workspace }
-      spec:
-        accessModes: ["ReadWriteOnce"]
-        resources: { requests: { storage: 1Gi } }
-  podTemplate:
-    spec:
-      serviceAccountName: serverless-harness-sandbox
-      securityContext:
-        runAsUser: 65532
-        runAsNonRoot: true
-        fsGroup: 65532
-        seccompProfile: { type: RuntimeDefault }
-      containers:
-        - name: sandbox
-          image: alpine:3.20
-          command: ["sleep", "infinity"]
-          workingDir: /workspace
-          securityContext:
-            allowPrivilegeEscalation: false
-            capabilities: { drop: ["ALL"] }
-          volumeMounts:
-            - { name: workspace, mountPath: /workspace }
-EOF
-echo "APPLY:$?"
-```
-Expected: `APPLY:0`.
-
-- [ ] **Step 5: Wait for the pod, then verify propagation + writability**
-
-```bash
-SEL=""
-for _ in $(seq 1 60); do
-  SEL="$(oc -n default get sandbox sandbox-0 -o jsonpath='{.status.selector}' 2>/dev/null || true)"
-  [ -n "$SEL" ] && break; sleep 2
-done
-echo "SELECTOR=[$SEL]"
-oc -n default wait --for=condition=Ready pod -l "$SEL" --timeout=180s; echo "READY:$?"
-echo "== runs as 65532? =="; oc -n default get pod sandbox-0 -o jsonpath='{.spec.securityContext.runAsUser}{"\n"}'
-echo "== PVC bound? =="; oc -n default get pvc -l app=sandbox -o wide 2>/dev/null || oc -n default get pvc
-echo "== /workspace writable? =="; oc -n default exec sandbox-0 -- sh -c 'id; touch /workspace/.probe && echo WRITE_OK && rm /workspace/.probe'
-```
-Expected: non-empty `SELECTOR`; `READY:0`; `runAsUser` = `65532`; a `Bound` PVC on `gp3-csi`; `id` shows `uid=65532`; `WRITE_OK` prints.
-
-- [ ] **Step 6: Analyze + decide (subagent)**
-
-Dispatch a subagent to read `/tmp/sh/p0prime/skel-*.log` and the step-5 output and confirm: controller Ready, selector published, pod non-root 65532, PVC Bound, `/workspace` writable. **Decision gate:** if propagation failed (e.g. the controller dropped `fsGroup`/`runAsUser`/`serviceAccountName`), STOP and apply the spec §7 mitigation (patch the generated pod directly, or move the field to one the controller honors) — revise Task 2's patch and re-run this task before Task 6.
-
-- [ ] **Step 7: Tear down the skeleton (so Task 6's overlay applies clean)**
-
-```bash
-oc -n default delete sandbox sandbox-0
-oc -n default delete pvc -l app=sandbox --ignore-not-found
-oc -n default get pvc | grep -i workspace || echo "pvc cleaned"
-```
-
----
-
-### Task 6: Full deploy + leaf smoke on the live cluster (definition of done)
-
-Purpose: run the corrected `setup-ocp.sh` end-to-end and pass `leaf-smoke.sh` through the Route. **No code commit** unless the run surfaces a fix (then a small follow-up commit on the same branch).
-
-**Files:** none (live cluster), unless a fix is needed.
-
-- [ ] **Step 1: Preconditions — kubeconfig + llm-credentials present**
-
-```bash
-export KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig
-oc get secret llm-credentials -n default >/dev/null 2>&1 && echo "SECRET_OK" || \
-  echo "MISSING — ask the user to create llm-credentials in ns default before proceeding"
-```
-Expected: `SECRET_OK` (the user provisions it). If missing, pause and request it.
-
-- [ ] **Step 2: Run the full OCP setup**
-
-```bash
-export LOG_DIR=/tmp/sh/p0prime
-./deploy/knative/setup-ocp.sh > /tmp/sh/p0prime/setup-run.log 2>&1; echo "SETUP_EXIT:$?"
-tail -20 /tmp/sh/p0prime/setup-run.log
-```
-Expected: `SETUP_EXIT:0`; tail shows `ksvc/serverless-harness Ready` and a printed Route URL. (Subagent analyzes `setup-run.log` + `$LOG_DIR/*.log` — controller install, sandbox build with ripgrep, overlay apply, Sandbox pod Ready, ksvc Ready. Never read the full build log inline.)
-
-- [ ] **Step 3: Capture the Route URL**
-
-```bash
-KSVC_URL="$(oc get ksvc serverless-harness -n default -o jsonpath='{.status.url}')"; echo "KSVC_URL=$KSVC_URL"
-```
-Expected: an `https://serverless-harness-default.apps.rosso1.kubestellar.org` URL.
-
-- [ ] **Step 4: Run the full leaf smoke via the Route**
-
-```bash
-cd deploy/knative
-export KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig
-KSVC_URL="$KSVC_URL" SH_MODEL=claude-haiku-4-5 ./leaf-smoke.sh \
-  > /tmp/sh/p0prime/leaf-smoke.log 2>&1; echo "SMOKE_EXIT:$?"
-tail -30 /tmp/sh/p0prime/leaf-smoke.log
-```
-Expected: `SMOKE_EXIT:0`; tail shows all claims passing.
-
-- [ ] **Step 5: Verify the smoke result (subagent)**
-
-Dispatch a subagent to grep `/tmp/sh/p0prime/leaf-smoke.log` for `ok/ko`/`WRONG`/`FAIL` and confirm the definition-of-done claims: FS-free envelope (claim 0), workspace isolation (1), parallel fan-out with verdicts **i1→FLAGGED, i2→CLEAR, i3→CLEAR** (2-3), per-call model routing (4), malformed→HTTP 400 (5), idempotent re-invoke (6), crash/resume from Redis (7 — now genuinely exercising durable-PVC survival), scale-to-zero (8). Return the pass/fail line for each claim, not the whole log.
-
-- [ ] **Step 6: If green — record the result**
-
-Append a short entry to the plan's status (or note for the PR body) that the full leaf smoke passed on OCP 4.20.8 with the corrected overlay + controller install. If any claim failed, capture the specific failure via subagent, apply the minimal fix on this branch (DCO-signed commit touching only the in-scope files), and re-run from the failing step.
-
----
-
-## Self-Review
-
-**Spec coverage** (spec §5.3 changeset + §5.4 sequence + §6 verification):
-- §5.3 `sandbox.Dockerfile` ripgrep → Task 1. ✅
-- §5.3 `kustomization.yaml` (drop leaf-pvc, retarget patch, image transform) → Task 2 Step 2. ✅
-- §5.3 `patch-sandbox.yaml` (Sandbox CR, securityContext, SA, sleep, no emptyDir) → Task 2 Step 1. ✅
-- §5.3 `setup-ocp.sh` (controller install, Sandbox poll, sandbox SA+SCC, llm-credentials presence) → Task 3. ✅
-- §5.3 `README-ocp.md` → Task 4. ✅
-- §5.2 non-root + fsGroup + nonroot-v2 SA → Task 2 (patch) + Task 3 Step 2 (SA/SCC). ✅
-- §5.4 deploy sequence (controller before overlay; Sandbox poll after) → Task 3 Steps 3-4. ✅
-- §6 Stage-1 walking skeleton → Task 5. §6 Stage-2 full deploy + leaf smoke → Task 6. ✅
-- §7 controller-propagation risk → Task 5 Step 6 decision gate. §7 kustomize-CRD gotcha → JSON6902 in Task 2. ✅
-
-**Placeholder scan:** No TBD/TODO/"handle edge cases"; every code step shows the actual content. The one JSON6902-vs-strategic-merge choice from the spec is resolved to JSON6902 in Task 2. ✅
-
-**Type/naming consistency:** SA name `serverless-harness-sandbox`, Sandbox name `sandbox-0`, CRD `sandboxes.agents.x-k8s.io` (group `agents.x-k8s.io`, version `v1beta1`), image pullspec literal, `.status.selector`, UID/fsGroup `65532`, namespace `default` — used identically across Tasks 2, 3, 5, 6 and matched to the base `sandbox.yaml` and `setup-ocp.sh` `render_overlay` sed. ✅
-
-**Out of scope (unchanged):** `leaf-orchestrator.yaml`, gate/cron/async smokes, `lib.sh`, `setup-kind.sh`, `README-kind.md`, `service.yaml` (harness SA + exec RBAC reused from the working Kind path); GHCR-pull of the sandbox image (post-merge follow-up); P2 RWX/pool; P3 Kata.
-
----
-
-*Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>*
diff --git a/docs/superpowers/plans/2026-07-02-p1-fs-free-harness.md b/docs/superpowers/plans/2026-07-02-p1-fs-free-harness.md
deleted file mode 100644
index 6b23595..0000000
--- a/docs/superpowers/plans/2026-07-02-p1-fs-free-harness.md
+++ /dev/null
@@ -1,1352 +0,0 @@
-# P1 — FS-Free Harness Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Make the credentialed harness perform no filesystem I/O — move the leaf envelope (inputs, verdict, done-marker) and the human-gate markers off the `/work` PVC (inline in the HTTP request/response + a single Redis result record), and move the sandbox working set from `emptyDir` to a durable agent-sandbox `Sandbox` CR.
-
-**Architecture:** The harness (Knative Service + KEDA async worker) becomes a network-only "brain": inputs arrive inline in `POST /runs`, the sync verdict returns inline, the async verdict + gate/done state live in one Redis key `leaf:result:<sessionId>` with a TTL, and `GET /runs/status?sessionId=…` reads that key. The sandbox ("hands") is the sole filesystem: a `Sandbox` CR (`agents.x-k8s.io/v1alpha1`) with `spec.volumeClaimTemplates` durable RWO storage, and the harness resolves the sandbox pod via the CR's `.status.selector` label selector instead of a hardcoded pod name.
-
-**Tech Stack:** TypeScript (ES modules, `.js` import specifiers), pnpm workspaces (`harness`, `packages/*`), Vitest, node-redis v4, Knative Serving, KEDA `ScaledJob` + Redis Streams, kubernetes-sigs/agent-sandbox, `kubectl` (shelled out).
-
-Spec: [`docs/specs/2026-07-02-p1-fs-free-harness-design.md`](../../specs/2026-07-02-p1-fs-free-harness-design.md). Issues: epic #49, P1 #45.
-
-## Global Constraints
-
-- **Every commit is DCO-signed with the AI attribution trailer** — exactly:
-  `git commit -s -m "<subject>" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"`.
-  Never use `Co-authored-by`.
-- **`git add` explicit paths only, never `git add -A`** (the working tree carries unrelated dirty files).
-- **ES-module import specifiers keep the `.js` extension** (e.g. `import { x } from "./verdict.js"`) even though the source is `.ts` — this repo compiles with `tsc`/`tsgo` NodeNext.
-- **Per-package test command:** `cd <pkg> && pnpm exec vitest run test/<file>.test.ts` (optionally `-t "<name>"`). **Per-package typecheck:** `cd <pkg> && pnpm exec tsc --noEmit`. Package dirs: `harness`, `packages/knative-server`, `packages/k8s-sandbox`.
-- **Clean-break wire contract:** the old file-based fields (`inputsRef`, `resultRef`, `doneMarkerRef`, `gateRef`, `decisionRef`) are removed, not dual-supported. No live external consumer exists.
-- **`workspaceRef` stays** — it is a path *inside the sandbox pod*, never opened by the harness process.
-- **Redis result key:** `leaf:result:<leafSessionId>` where `leafSessionId({sessionId, tenant})` is the existing tenant-prefixed-then-sanitized id from `run-leaf.ts`.
-- **Default result TTL:** env `LEAF_RESULT_TTL_SECONDS`, default `86400`.
-
----
-
-## File Structure
-
-**New files**
-- `harness/src/leaf-result-store.ts` — Redis result record type, key builder, `LeafResult → record` mapping, `writeResult`/`readResult`, and a real `RedisResultStore` client. (Task 1)
-- `harness/test/leaf-result-store.test.ts` — unit tests with an in-memory fake. (Task 1)
-- `packages/k8s-sandbox/src/resolve-pod.ts` — pure kubectl arg builders + `resolveSandboxConfig` (selector-based pod resolution). (Task 5)
-- `packages/k8s-sandbox/test/resolve-pod.test.ts` — unit tests with a fake `run`. (Task 5)
-
-**Modified files**
-- `harness/src/run-leaf.ts` — inline `item`/`decision` envelope; verdict/gate returned inline; drop all `node:fs`. (Task 2)
-- `harness/src/classify-outcome.ts` — collapse to `{ack, retryable}`; record written for all non-retryable. (Task 3)
-- `harness/src/leaf-job-runner.ts` — write the Redis result record instead of a file marker. (Task 3)
-- `packages/knative-server/src/leaf-job.ts` — dead-letter reap writes a Redis failed record; pass the store to `processOne`. (Task 3)
-- `packages/knative-server/src/server.ts` — parse inline `item`/`decision`; sync writes + returns the record; `/runs/status?sessionId`; drop `WORK_ROOT`. (Task 4)
-- `harness/src/run-turn.ts`, `harness/src/run-leaf.ts` — resolve sandbox config async, pass to the extension. (Task 5)
-- `packages/k8s-sandbox/src/index.ts` — export `resolveSandboxConfig`. (Task 5)
-- `deploy/knative/service.yaml`, `leaf-scaledjob.yaml`, `sandbox.yaml` — remove `/work`, add sandbox-name + TTL env + RBAC; `Sandbox` CR. (Task 7)
-- `deploy/knative/leaf-pvc.yaml` — **deleted**. (Task 7)
-- `deploy/knative/cron-dispatch` caller + `leaf-smoke.sh`, `leaf-async-smoke.sh`, `lib.sh`. (Task 8)
-
-**Deleted files**
-- `harness/src/done-marker.ts`, `harness/src/gate-marker.ts` (+ their tests). (Task 6)
-
----
-
-## Task 1: Redis result store module
-
-**Files:**
-- Create: `harness/src/leaf-result-store.ts`
-- Test: `harness/test/leaf-result-store.test.ts`
-
-**Interfaces:**
-- Consumes: `Verdict` from `./verdict.js`; `LeafResult` (type-only) from `./run-leaf.js` (defined in Task 2 — this is a `import type`, no runtime cycle).
-- Produces:
-  - `interface LeafResultRecord { status: "done"|"failed"|"aborted"|"paused"; verdict: Verdict|null; gate: {gateId:number; summary:string; proposed_action:string}|null; reason: string|null; sessionId: string; ts: string }`
-  - `interface RedisLike { set(key:string, value:string, opts?:{EX?:number}): Promise<unknown>; get(key:string): Promise<string|null> }`
-  - `resultKey(leafSessionId: string): string`
-  - `toResultRecord(result: LeafResult, rawSessionId: string, ts: string): LeafResultRecord`
-  - `writeResult(redis: RedisLike, leafSessionId: string, record: LeafResultRecord, ttlSeconds: number): Promise<void>`
-  - `readResult(redis: RedisLike, leafSessionId: string): Promise<LeafResultRecord|null>`
-  - `class RedisResultStore implements RedisLike` with `constructor(url?)`, `set`, `get`, `close()`.
-
-- [ ] **Step 1: Write the failing test**
-
-Create `harness/test/leaf-result-store.test.ts`:
-
-```typescript
-import { describe, it, expect } from "vitest";
-import {
-  resultKey, toResultRecord, writeResult, readResult, type RedisLike, type LeafResultRecord,
-} from "../src/leaf-result-store";
-import type { LeafResult } from "../src/run-leaf";
-
-function fakeRedis(): RedisLike & { store: Map<string, string>; ttl: Map<string, number> } {
-  const store = new Map<string, string>();
-  const ttl = new Map<string, number>();
-  return {
-    store, ttl,
-    async set(key, value, opts) { store.set(key, value); if (opts?.EX) ttl.set(key, opts.EX); },
-    async get(key) { return store.get(key) ?? null; },
-  };
-}
-
-describe("resultKey", () => {
-  it("namespaces by leaf session id", () => {
-    expect(resultKey("run-1-i1")).toBe("leaf:result:run-1-i1");
-  });
-});
-
-describe("toResultRecord", () => {
-  it("maps done → verdict-bearing record", () => {
-    const r: LeafResult = { status: "done", verdict: { item_id: "i1", verdict: "FLAGGED", reason: "x" } };
-    expect(toResultRecord(r, "run-1/i1", "T")).toEqual({
-      status: "done", verdict: { item_id: "i1", verdict: "FLAGGED", reason: "x" },
-      gate: null, reason: null, sessionId: "run-1/i1", ts: "T",
-    });
-  });
-  it("maps paused → gate-bearing record", () => {
-    const r: LeafResult = { status: "paused", gateId: 1, gate: { summary: "s", proposed_action: "a" } };
-    expect(toResultRecord(r, "run-1/i1", "T")).toMatchObject({
-      status: "paused", gate: { gateId: 1, summary: "s", proposed_action: "a" }, verdict: null,
-    });
-  });
-  it("maps failed → reason-bearing record", () => {
-    const r: LeafResult = { status: "failed", reason: "no_verdict" };
-    expect(toResultRecord(r, "s", "T")).toMatchObject({ status: "failed", reason: "no_verdict" });
-  });
-});
-
-describe("writeResult / readResult", () => {
-  it("round-trips a record and sets the TTL", async () => {
-    const redis = fakeRedis();
-    const rec: LeafResultRecord = { status: "done", verdict: { item_id: "i1", verdict: "CLEAR", reason: "ok" }, gate: null, reason: null, sessionId: "run-1/i1", ts: "T" };
-    await writeResult(redis, "run-1-i1", rec, 3600);
-    expect(redis.ttl.get("leaf:result:run-1-i1")).toBe(3600);
-    expect(await readResult(redis, "run-1-i1")).toEqual(rec);
-  });
-  it("returns null for a missing key", async () => {
-    expect(await readResult(fakeRedis(), "nope")).toBeNull();
-  });
-  it("returns null for a garbled value", async () => {
-    const redis = fakeRedis();
-    await redis.set("leaf:result:x", "{not json", {});
-    expect(await readResult(redis, "x")).toBeNull();
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd harness && pnpm exec vitest run test/leaf-result-store.test.ts`
-Expected: FAIL — cannot resolve `../src/leaf-result-store` (module not found).
-
-- [ ] **Step 3: Write the implementation**
-
-Create `harness/src/leaf-result-store.ts`:
-
-```typescript
-import { createClient, type RedisClientType } from "redis";
-import type { Verdict } from "./verdict.js";
-import type { LeafResult } from "./run-leaf.js";
-
-export interface LeafResultRecord {
-  status: "done" | "failed" | "aborted" | "paused";
-  verdict: Verdict | null;
-  gate: { gateId: number; summary: string; proposed_action: string } | null;
-  reason: string | null;
-  sessionId: string; // RAW (un-sanitized) id, for caller correlation
-  ts: string;
-}
-
-/** Minimal structural Redis surface — lets unit tests inject an in-memory fake. */
-export interface RedisLike {
-  set(key: string, value: string, opts?: { EX?: number }): Promise<unknown>;
-  get(key: string): Promise<string | null>;
-}
-
-export function resultKey(leafSessionId: string): string {
-  return `leaf:result:${leafSessionId}`;
-}
-
-/** Map a terminal LeafResult to the persisted record. `rawSessionId` is the un-sanitized envelope id. */
-export function toResultRecord(result: LeafResult, rawSessionId: string, ts: string): LeafResultRecord {
-  const base: LeafResultRecord = { status: "failed", verdict: null, gate: null, reason: null, sessionId: rawSessionId, ts };
-  if (result.status === "done") return { ...base, status: "done", verdict: result.verdict };
-  if (result.status === "paused") {
-    return { ...base, status: "paused", gate: { gateId: result.gateId, summary: result.gate.summary, proposed_action: result.gate.proposed_action } };
-  }
-  if (result.status === "aborted") return { ...base, status: "aborted" };
-  return { ...base, status: "failed", reason: result.reason };
-}
-
-export async function writeResult(redis: RedisLike, leafSessionId: string, record: LeafResultRecord, ttlSeconds: number): Promise<void> {
-  await redis.set(resultKey(leafSessionId), JSON.stringify(record), { EX: ttlSeconds });
-}
-
-export async function readResult(redis: RedisLike, leafSessionId: string): Promise<LeafResultRecord | null> {
-  const raw = await redis.get(resultKey(leafSessionId));
-  if (!raw) return null;
-  try { return JSON.parse(raw) as LeafResultRecord; } catch { return null; }
-}
-
-/** Real client used by the server and async worker. Reuses REDIS_URL, connects lazily. */
-export class RedisResultStore implements RedisLike {
-  private client: RedisClientType;
-  private ready: Promise<void>;
-  constructor(url = process.env.REDIS_URL ?? "redis://127.0.0.1:6379") {
-    this.client = createClient({ url }) as RedisClientType;
-    this.ready = this.client.connect().then(() => undefined);
-  }
-  async set(key: string, value: string, opts?: { EX?: number }): Promise<unknown> {
-    await this.ready;
-    return opts?.EX ? this.client.set(key, value, { EX: opts.EX }) : this.client.set(key, value);
-  }
-  async get(key: string): Promise<string | null> {
-    await this.ready;
-    return this.client.get(key);
-  }
-  async close(): Promise<void> {
-    await this.ready;
-    await this.client.close();
-  }
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `cd harness && pnpm exec vitest run test/leaf-result-store.test.ts`
-Expected: PASS (all cases). Typecheck will fail until Task 2 defines `LeafResult` with the new shape — that is expected; do not fix here.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/leaf-result-store.ts harness/test/leaf-result-store.test.ts
-git commit -s -m "feat(harness): Redis leaf-result store (record, TTL, mapping)" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 2: FS-free `runLeaf` — inline envelope, verdict, and gate
-
-**Files:**
-- Modify: `harness/src/run-leaf.ts`
-- Test: `harness/test/run-leaf.test.ts` (update existing)
-
-**Interfaces:**
-- Consumes: `Verdict`, `validateVerdict` from `./verdict.js`; `Decision`, `validateDecision`, `computeGateState`, `decideSeed`, `readDecision`(removed), `GATE_DECISION_ENTRY_TYPE` from `./gate.js`.
-- Produces (relied on by Tasks 1, 3, 4):
-  - `interface LeafItem { item_id: string; file: string; pattern: string; require_approval?: boolean }`
-  - `interface LeafEnvelope { sessionId: string; item: LeafItem; decision?: Decision; model?: string; provider?: string; workspaceRef?: string; maxTurns?: number; async?: boolean; tenant?: string }`
-  - `type LeafResult = { status: "done"; verdict: Verdict } | { status: "paused"; gateId: number; gate: { summary: string; proposed_action: string } } | { status: "aborted" } | { status: "failed"; reason: "no_verdict"|"invalid_verdict"|"bad_inputs"|"error"; message?: string }`
-  - `validateItem(o: unknown): LeafItem | null`
-  - `leafSessionId(env: { sessionId: string; tenant?: string }): string` (unchanged signature)
-  - `runLeaf(env, config?, deps?): Promise<LeafResult>`
-
-- [ ] **Step 1: Update the failing tests**
-
-Open `harness/test/run-leaf.test.ts`. Replace file-envelope usages with the inline shape and assert inline results. Ensure these cases exist (add/replace as needed):
-
-```typescript
-// bad inputs: no item
-it("fails with bad_inputs when item is missing", async () => {
-  const r = await runLeaf({ sessionId: "s" } as any, undefined, { produceVerdict: async () => {} });
-  expect(r).toEqual({ status: "failed", reason: "bad_inputs" });
-});
-
-// done: verdict returned inline (no resultRef)
-it("returns the verdict inline on success", async () => {
-  const env = { sessionId: "run/i1", item: { item_id: "i1", file: "f", pattern: "p" } };
-  const r = await runLeaf(env, undefined, {
-    produceVerdict: async (_i, _e, _c, cap) => { cap.verdict = { item_id: "i1", verdict: "FLAGGED", reason: "x" }; },
-  });
-  expect(r).toEqual({ status: "done", verdict: { item_id: "i1", verdict: "FLAGGED", reason: "x" } });
-});
-
-// paused: gate returned inline (no gateRef, no file written)
-it("returns the gate inline when paused", async () => {
-  const env = { sessionId: "run/i1", item: { item_id: "i1", file: "f", pattern: "p", require_approval: true } };
-  const r = await runLeaf(env, undefined, {
-    produceVerdict: async (_i, _e, _c, cap) => { cap.gate = { gateId: 2, summary: "s", proposed_action: "a" }; },
-  });
-  expect(r).toEqual({ status: "paused", gateId: 2, gate: { summary: "s", proposed_action: "a" } });
-});
-
-it("returns aborted when the capture is aborted", async () => {
-  const env = { sessionId: "run/i1", item: { item_id: "i1", file: "f", pattern: "p" } };
-  const r = await runLeaf(env, undefined, { produceVerdict: async (_i, _e, _c, cap) => { cap.aborted = true; } });
-  expect(r).toEqual({ status: "aborted" });
-});
-
-it("fails with no_verdict when nothing is captured", async () => {
-  const env = { sessionId: "run/i1", item: { item_id: "i1", file: "f", pattern: "p" } };
-  const r = await runLeaf(env, undefined, { produceVerdict: async () => {} });
-  expect(r).toEqual({ status: "failed", reason: "no_verdict" });
-});
-
-it("fails with invalid_verdict when the captured verdict is off-shape", async () => {
-  const env = { sessionId: "run/i1", item: { item_id: "i1", file: "f", pattern: "p" } };
-  const r = await runLeaf(env, undefined, { produceVerdict: async (_i, _e, _c, cap) => { cap.verdict = { item_id: "" } as any; } });
-  expect(r.status).toBe("failed");
-  if (r.status === "failed") expect(r.reason).toBe("invalid_verdict");
-});
-```
-
-Also update `validateItem` coverage:
-
-```typescript
-import { validateItem } from "../src/run-leaf";
-describe("validateItem", () => {
-  it("accepts a well-formed item", () => {
-    expect(validateItem({ item_id: "i", file: "f", pattern: "p" })).toEqual({ item_id: "i", file: "f", pattern: "p", require_approval: false });
-  });
-  it("rejects a missing field and non-objects", () => {
-    expect(validateItem({ item_id: "i", file: "f" })).toBeNull();
-    expect(validateItem(null)).toBeNull();
-  });
-});
-```
-
-- [ ] **Step 2: Run tests to verify they fail**
-
-Run: `cd harness && pnpm exec vitest run test/run-leaf.test.ts`
-Expected: FAIL — `validateItem` not exported / `LeafResult.verdict` not present / envelope type errors.
-
-- [ ] **Step 3: Rewrite `run-leaf.ts`**
-
-Apply these edits to `harness/src/run-leaf.ts`:
-
-**3a.** Replace the top imports (lines 1–2 and the gate imports) — remove all `node:fs`/`node:path` and marker imports, add `validateDecision`:
-
-```typescript
-import {
-  createAgentSession,
-  DefaultResourceLoader,
-  getAgentDir,
-  SessionManager,
-  SettingsManager,
-  type FileEntry,
-} from "@earendil-works/pi-coding-agent";
-import { RedisSessionBackend } from "@sh/session-backend";
-import { k8sSandboxExtension } from "@sh/k8s-sandbox";
-import { resolveModelSelection, requireModel, applyModelGateway, type TurnConfig } from "./run-turn.js";
-import { BufferedRedisBackend } from "./buffered-redis-backend.js";
-import { flushExtension } from "./flush-extension.js";
-import { checkpointExtension } from "./checkpoint-extension.js";
-import { submitVerdictExtension, VERDICT_ENTRY_TYPE, type VerdictCapture } from "./submit-verdict-tool.js";
-import { validateVerdict, type Verdict } from "./verdict.js";
-import type { GateCapture } from "./request-approval-tool.js";
-import { computeGateState, decideSeed, validateDecision, type Decision, GATE_DECISION_ENTRY_TYPE } from "./gate.js";
-import { requestApprovalExtension } from "./request-approval-tool.js";
-```
-
-(Removed: `readFileSync, writeFileSync, mkdirSync`, `dirname`, `deriveGateRef, writeGateMarker`, `computeGateState … readDecision` — `readDecision` is dropped; keep `computeGateState, decideSeed, GATE_DECISION_ENTRY_TYPE`.)
-
-**3b.** Replace the `LeafItem` / `LeafEnvelope` / `LeafResult` block (old lines 48–74):
-
-```typescript
-export interface LeafItem { item_id: string; file: string; pattern: string; require_approval?: boolean }
-
-export interface LeafEnvelope {
-  sessionId: string;
-  item: LeafItem;             // inputs inline (was inputsRef)
-  decision?: Decision;        // resume/approve only (was decisionRef)
-  model?: string;
-  provider?: string;
-  workspaceRef?: string;      // absolute path INSIDE the sandbox pod (harness never opens it)
-  maxTurns?: number;
-  async?: boolean;            // when true, the HTTP layer enqueues instead of running inline
-  tenant?: string;            // namespaces the session id
-}
-
-/** The Pi/Redis session id for a leaf: tenant-prefixed (if any), then sanitized. */
-export function leafSessionId(env: { sessionId: string; tenant?: string }): string {
-  return toSessionId(env.tenant ? `${env.tenant}/${env.sessionId}` : env.sessionId);
-}
-
-export type LeafResult =
-  | { status: "done"; verdict: Verdict }
-  | { status: "paused"; gateId: number; gate: { summary: string; proposed_action: string } }
-  | { status: "aborted" }
-  | { status: "failed"; reason: "no_verdict" | "invalid_verdict" | "bad_inputs" | "error"; message?: string };
-```
-
-**3c.** Replace `readItem` (old lines 114–124) with `validateItem`:
-
-```typescript
-export function validateItem(o: unknown): LeafItem | null {
-  const x = o as Record<string, unknown> | null;
-  if (x && typeof x.item_id === "string" && typeof x.file === "string" && typeof x.pattern === "string") {
-    return { item_id: x.item_id, file: x.file, pattern: x.pattern, require_approval: x.require_approval === true };
-  }
-  return null;
-}
-```
-
-**3d.** Replace the `runLeaf` body (old lines 126–163) — inline inputs, inline verdict/gate, no FS:
-
-```typescript
-export async function runLeaf(
-  env: LeafEnvelope,
-  config?: TurnConfig,
-  deps?: { produceVerdict?: ProduceVerdict },
-): Promise<LeafResult> {
-  const item = validateItem(env.item);
-  if (!item) return { status: "failed", reason: "bad_inputs" };
-
-  const capture: LeafCapture = {};
-  const produce = deps?.produceVerdict ?? realProduceVerdict;
-  try {
-    await produce(item, env, config, capture);
-  } catch (err) {
-    return { status: "failed", reason: "error", message: err instanceof Error ? err.message : String(err) };
-  }
-
-  // Gate outcomes take precedence over verdict handling.
-  if (capture.aborted) return { status: "aborted" };
-  if (capture.gate) {
-    return {
-      status: "paused",
-      gateId: capture.gate.gateId,
-      gate: { summary: capture.gate.summary, proposed_action: capture.gate.proposed_action },
-    };
-  }
-
-  if (!capture.verdict) return { status: "failed", reason: "no_verdict" };
-  const v = validateVerdict(capture.verdict);
-  if (!v.ok) return { status: "failed", reason: "invalid_verdict", message: v.error };
-  return { status: "done", verdict: v.value };
-}
-```
-
-**3e.** In `realProduceVerdict`, replace the decision read (old line 215) — read the inline decision instead of a file:
-
-```typescript
-  const dv = env.decision ? validateDecision(env.decision) : null;
-  const decision = dv && dv.ok ? dv.value : null;
-  const seed = decideSeed(gateState, decision, buildLeafPrompt(item, env.workspaceRef));
-```
-
-(Everything else in `realProduceVerdict` — the session setup, gate seed handling, the `allowVerdict` guard, the extension list — is unchanged in this task. The `k8sSandboxExtension()` call stays as-is; Task 5 changes it.)
-
-- [ ] **Step 4: Run tests to verify they pass**
-
-Run: `cd harness && pnpm exec vitest run test/run-leaf.test.ts`
-Expected: PASS.
-
-- [ ] **Step 5: Re-run the result-store test (now that `LeafResult` exists in its new shape)**
-
-Run: `cd harness && pnpm exec vitest run test/leaf-result-store.test.ts`
-Expected: PASS.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add harness/src/run-leaf.ts harness/test/run-leaf.test.ts
-git commit -s -m "feat(harness): inline leaf envelope, verdict, and gate (no fs in runLeaf)" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 3: Async worker writes the Redis result record
-
-**Files:**
-- Modify: `harness/src/classify-outcome.ts`
-- Modify: `harness/src/leaf-job-runner.ts`
-- Modify: `packages/knative-server/src/leaf-job.ts`
-- Test: `harness/test/classify-outcome.test.ts`, `harness/test/leaf-job-runner.test.ts` (update existing)
-
-**Interfaces:**
-- Consumes: `LeafResult`, `LeafEnvelope`, `leafSessionId` from `./run-leaf.js`; `RedisLike`, `LeafResultRecord`, `toResultRecord`, `writeResult`, `RedisResultStore` from `./leaf-result-store.js`; `WorkQueue` from `@sh/work-queue`.
-- Produces:
-  - `interface Outcome { ack: boolean; retryable: boolean }`
-  - `classifyOutcome(result: LeafResult): Outcome`
-  - `LeafJobDeps` gains `resultStore: RedisLike; ttlSeconds: number` and drops `writeMarker`.
-  - `processOne(deps): Promise<"done"|"failed"|"paused"|"aborted"|"deadletter"|"idle"|"retry">` (unchanged return union).
-
-- [ ] **Step 1: Update the failing tests**
-
-Rewrite `harness/test/classify-outcome.test.ts`:
-
-```typescript
-import { describe, it, expect } from "vitest";
-import { classifyOutcome } from "../src/classify-outcome";
-import type { LeafResult } from "../src/run-leaf";
-
-describe("classifyOutcome", () => {
-  it("acks a done result (non-retryable)", () => {
-    expect(classifyOutcome({ status: "done", verdict: { item_id: "i", verdict: "CLEAR", reason: "r" } }))
-      .toEqual({ ack: true, retryable: false });
-  });
-  it("acks a paused result (resume is a fresh invocation)", () => {
-    expect(classifyOutcome({ status: "paused", gateId: 1, gate: { summary: "s", proposed_action: "a" } }))
-      .toEqual({ ack: true, retryable: false });
-  });
-  it("acks an aborted result", () => {
-    expect(classifyOutcome({ status: "aborted" })).toEqual({ ack: true, retryable: false });
-  });
-  it("acks a deterministic failure", () => {
-    expect(classifyOutcome({ status: "failed", reason: "no_verdict" })).toEqual({ ack: true, retryable: false });
-  });
-  it("retries a transient error without acking", () => {
-    expect(classifyOutcome({ status: "failed", reason: "error" })).toEqual({ ack: false, retryable: true });
-  });
-});
-```
-
-In `harness/test/leaf-job-runner.test.ts`, replace the `writeMarker` capture with an in-memory `resultStore` and assert the record. Representative cases (adapt the existing `deps` builder):
-
-```typescript
-import type { RedisLike, LeafResultRecord } from "../src/leaf-result-store";
-function fakeStore() {
-  const m = new Map<string, string>();
-  const store: RedisLike = { async set(k, v) { m.set(k, v); }, async get(k) { return m.get(k) ?? null; } };
-  return { store, get: (id: string) => { const r = m.get(`leaf:result:${id}`); return r ? JSON.parse(r) as LeafResultRecord : null; } };
-}
-
-it("writes a done record and acks", async () => {
-  const { store, get } = fakeStore();
-  const queue = /* existing fake queue that claims one entry with envelope {sessionId:'run/i1', item:{...}} */;
-  const outcome = await processOne({
-    queue, consumerId: "c", resultStore: store, ttlSeconds: 3600,
-    runLeaf: async () => ({ status: "done", verdict: { item_id: "i1", verdict: "FLAGGED", reason: "x" } }),
-    now: () => "T",
-  });
-  expect(outcome).toBe("done");
-  expect(get("run-i1")).toMatchObject({ status: "done", sessionId: "run/i1" });
-});
-
-it("does not write a record and does not ack on transient error (retry)", async () => {
-  const { store, get } = fakeStore();
-  const queue = /* fake queue, one entry */;
-  const outcome = await processOne({
-    queue, consumerId: "c", resultStore: store, ttlSeconds: 3600,
-    runLeaf: async () => ({ status: "failed", reason: "error" }), now: () => "T",
-  });
-  expect(outcome).toBe("retry");
-  expect(get("run-i1")).toBeNull();
-});
-```
-
-(Keep the existing dead-letter test but assert a failed **record** via `get(...)` instead of a marker file. The envelope in the fake queue must now use `item` inline and `sessionId: "run/i1"` → `leafSessionId` sanitizes to `run-i1`.)
-
-- [ ] **Step 2: Run tests to verify they fail**
-
-Run: `cd harness && pnpm exec vitest run test/classify-outcome.test.ts test/leaf-job-runner.test.ts`
-Expected: FAIL — `Outcome.marker` gone / `resultStore` not in `LeafJobDeps`.
-
-- [ ] **Step 3: Rewrite `classify-outcome.ts`**
-
-```typescript
-import type { LeafResult } from "./run-leaf.js";
-
-export interface Outcome {
-  ack: boolean;
-  retryable: boolean;
-}
-
-/**
- * Decide what the leaf-job does with a queue entry given the leaf's terminal result.
- * - done / paused / aborted / deterministic failures → ack (a result record is written by the caller).
- * - "error" (possibly transient) → no ack, retryable (entry stays pending → reclaimed).
- *   (A process crash never returns here → entry stays pending → reclaimed.)
- */
-export function classifyOutcome(result: LeafResult): Outcome {
-  if (result.status === "failed" && result.reason === "error") {
-    return { ack: false, retryable: true };
-  }
-  return { ack: true, retryable: false };
-}
-```
-
-- [ ] **Step 4: Rewrite `leaf-job-runner.ts`**
-
-```typescript
-// harness/src/leaf-job-runner.ts
-import type { WorkQueue } from "@sh/work-queue";
-import { classifyOutcome } from "./classify-outcome.js";
-import { leafSessionId, type LeafEnvelope, type LeafResult } from "./run-leaf.js";
-import { toResultRecord, writeResult, type RedisLike } from "./leaf-result-store.js";
-
-export interface LeafJobDeps {
-  queue: WorkQueue;
-  runLeaf: (env: LeafEnvelope) => Promise<LeafResult>;
-  resultStore: RedisLike;
-  ttlSeconds: number;
-  consumerId: string;
-  maxAttempts?: number;
-  minIdleMs?: number;
-  blockMs?: number;
-  heartbeatMs?: number;
-  now?: () => string;
-  setHeartbeat?: (fn: () => void, ms: number) => unknown;
-  clearHeartbeat?: (h: unknown) => void;
-}
-
-/**
- * Claim and process at most one queue entry.
- * - "idle": nothing to claim.
- * - "deadletter": delivery count exceeded → failed result record + ack, runLeaf not run.
- * - "done"/"failed"/"paused"/"aborted": runLeaf reached this terminal/parked state → write the
- *   result record + ack.
- * - "retry": transient error → NO record, NOT acked (entry stays pending for reclaim).
- */
-export async function processOne(
-  deps: LeafJobDeps,
-): Promise<"done" | "failed" | "paused" | "aborted" | "deadletter" | "idle" | "retry"> {
-  const maxAttempts = deps.maxAttempts ?? 3;
-  const minIdleMs = deps.minIdleMs ?? 90_000;
-  const blockMs = deps.blockMs ?? 5_000;
-  const heartbeatMs = deps.heartbeatMs ?? 30_000;
-  const now = deps.now ?? (() => new Date().toISOString());
-  const setHb = deps.setHeartbeat ?? ((fn, ms) => setInterval(fn, ms));
-  const clearHb = deps.clearHeartbeat ?? ((h) => clearInterval(h as ReturnType<typeof setInterval>));
-
-  const claimed = await deps.queue.claim(deps.consumerId, { minIdleMs, blockMs });
-  if (!claimed) return "idle";
-
-  const env = claimed.envelope as LeafEnvelope;
-  const sid = leafSessionId(env);
-
-  if (claimed.deliveryCount > maxAttempts) {
-    await writeResult(deps.resultStore, sid,
-      toResultRecord({ status: "failed", reason: "error" }, env.sessionId, now()), deps.ttlSeconds);
-    await deps.queue.ack(claimed.entryId);
-    return "deadletter";
-  }
-
-  const hb = setHb(() => { void deps.queue.touch(claimed.entryId, deps.consumerId); }, heartbeatMs);
-  let result: LeafResult;
-  try {
-    result = await deps.runLeaf(env);
-  } finally {
-    clearHb(hb);
-  }
-
-  const outcome = classifyOutcome(result);
-  if (outcome.retryable) return "retry";
-
-  await writeResult(deps.resultStore, sid, toResultRecord(result, env.sessionId, now()), deps.ttlSeconds);
-  if (outcome.ack) {
-    await deps.queue.ack(claimed.entryId);
-    return result.status;
-  }
-  return "retry";
-}
-```
-
-- [ ] **Step 5: Update `leaf-job.ts` entrypoint**
-
-In `packages/knative-server/src/leaf-job.ts`: remove the `done-marker` import; add the result store; write a failed record on dead-letter; pass the store + ttl to `processOne`.
-
-Replace the import (old line 4):
-
-```typescript
-import { runLeaf, leafSessionId, type LeafEnvelope } from "@sh/harness/run-leaf";
-import { RedisResultStore, toResultRecord, writeResult } from "@sh/harness/leaf-result-store";
-```
-
-Add near the constants (after line 10):
-
-```typescript
-const RESULT_TTL_SECONDS = parseInt(process.env.LEAF_RESULT_TTL_SECONDS ?? "86400", 10);
-```
-
-In `main()`, after `const q = new RedisWorkQueue(...)`, add the store:
-
-```typescript
-  const resultStore = new RedisResultStore(process.env.REDIS_URL);
-```
-
-Replace the dead-letter marker write (old lines 34–42 body) with:
-
-```typescript
-    if (envelope && typeof envelope === "object") {
-      const env = envelope as LeafEnvelope;
-      try {
-        await writeResult(resultStore, leafSessionId(env),
-          toResultRecord({ status: "failed", reason: "error" }, env.sessionId, new Date().toISOString()), RESULT_TTL_SECONDS);
-      } catch { /* best-effort record write */ }
-    } else {
-      console.warn(`reaper: entry ${entryId} dead-lettered with unrecoverable envelope`);
-    }
-```
-
-Replace the `processOne` call args (old lines 59–63):
-
-```typescript
-    const outcome = await processOne({
-      queue: q,
-      runLeaf: (env: LeafEnvelope) => runLeaf(env, buildConfig()),
-      resultStore,
-      ttlSeconds: RESULT_TTL_SECONDS,
-      consumerId,
-    });
-```
-
-Add `await resultStore.close();` alongside each `await q.close();` on the terminal paths (after the retry `q.close()` and the clean-exit `q.close()`).
-
-- [ ] **Step 6: Run tests to verify they pass**
-
-Run: `cd harness && pnpm exec vitest run test/classify-outcome.test.ts test/leaf-job-runner.test.ts`
-Expected: PASS.
-Run: `cd packages/knative-server && pnpm exec tsc --noEmit`
-Expected: no errors from `leaf-job.ts`.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add harness/src/classify-outcome.ts harness/src/leaf-job-runner.ts packages/knative-server/src/leaf-job.ts harness/test/classify-outcome.test.ts harness/test/leaf-job-runner.test.ts
-git commit -s -m "feat(worker): write leaf verdict/done state to Redis result record" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 4: Sync route + `/runs/status` on Redis
-
-**Files:**
-- Modify: `packages/knative-server/src/server.ts`
-- Test: `packages/knative-server/test/run-leaf-route.test.ts`, `run-leaf-async-route.test.ts`, `server.test.ts` (update existing)
-
-**Interfaces:**
-- Consumes: `runLeaf`, `leafSessionId`, `validateItem`, `type LeafEnvelope`, `type LeafResult` from `@sh/harness/run-leaf`; `RedisResultStore`, `toResultRecord`, `writeResult`, `readResult` from `@sh/harness/leaf-result-store`; `RedisWorkQueue` from `@sh/work-queue`.
-- Produces: HTTP behavior only. `isLeafEnvelope(o)` now requires `sessionId` string + `validateItem(o.item)` non-null.
-
-- [ ] **Step 1: Update the failing tests**
-
-In `run-leaf-route.test.ts`, change the envelope shape and the mocked result, and the 400 case:
-
-```typescript
-it("400s on a malformed envelope (missing item)", async () => {
-  const r = await post("/runs", { sessionId: "s" });
-  expect(r.status).toBe(400);
-});
-
-it("returns the verdict inline on a valid envelope", async () => {
-  runLeaf.mockResolvedValue({ status: "done", verdict: { item_id: "i1", verdict: "CLEAR", reason: "ok" } });
-  const r = await post("/runs", { sessionId: "run/i1", item: { item_id: "i1", file: "f", pattern: "p" } });
-  expect(r.status).toBe(200);
-  expect(r.json).toEqual({ status: "done", verdict: { item_id: "i1", verdict: "CLEAR", reason: "ok" } });
-  expect(runLeaf).toHaveBeenCalledOnce();
-});
-```
-
-Because the server now constructs a real `RedisResultStore`, mock the store module so the route tests stay hermetic (no live redis). At the top of `run-leaf-route.test.ts` and `server.test.ts`:
-
-```typescript
-vi.mock("@sh/harness/leaf-result-store", async (orig) => {
-  const actual = await orig<typeof import("@sh/harness/leaf-result-store")>();
-  const mem = new Map<string, string>();
-  class FakeStore { async set(k: string, v: string) { mem.set(k, v); } async get(k: string) { return mem.get(k) ?? null; } async close() {} }
-  return { ...actual, RedisResultStore: FakeStore };
-});
-```
-
-Add a status test in `server.test.ts`:
-
-```typescript
-it("GET /runs/status returns queued when no record exists", async () => {
-  const r = await (await fetch(`${base}/runs/status?sessionId=run/none`)).json();
-  expect(r).toEqual({ status: "queued" });
-});
-it("GET /runs/status returns the record after a sync run", async () => {
-  runLeaf.mockResolvedValue({ status: "done", verdict: { item_id: "i1", verdict: "FLAGGED", reason: "x" } });
-  await post("/runs", { sessionId: "run/i1", item: { item_id: "i1", file: "f", pattern: "p" } });
-  const r = await (await fetch(`${base}/runs/status?sessionId=run/i1`)).json();
-  expect(r).toMatchObject({ status: "done", verdict: { item_id: "i1", verdict: "FLAGGED" } });
-});
-```
-
-In `run-leaf-async-route.test.ts`, assert the 202 shape is `{ status: "accepted", sessionId }` (drop `resultRef`/`doneMarker`).
-
-- [ ] **Step 2: Run tests to verify they fail**
-
-Run: `cd packages/knative-server && pnpm exec vitest run`
-Expected: FAIL — old envelope/response assertions and status endpoint.
-
-- [ ] **Step 3: Rewrite `server.ts`**
-
-Key edits (replace the corresponding regions):
-
-**3a.** Imports (old lines 1–8):
-
-```typescript
-import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
-import { fileURLToPath } from "node:url";
-import { runTurn, type TurnConfig } from "@sh/harness/run-turn";
-import { runLeaf, leafSessionId, validateItem, type LeafEnvelope } from "@sh/harness/run-leaf";
-import { RedisWorkQueue } from "@sh/work-queue";
-import { RedisResultStore, toResultRecord, writeResult, readResult } from "@sh/harness/leaf-result-store";
-```
-
-**3b.** Replace `WORK_ROOT` constant (old line 13) with the TTL and drop the path root:
-
-```typescript
-const RESULT_TTL_SECONDS = parseInt(process.env.LEAF_RESULT_TTL_SECONDS ?? "86400", 10);
-```
-
-**3c.** Replace `isLeafEnvelope` (old lines 72–74):
-
-```typescript
-function isLeafEnvelope(o: any): o is LeafEnvelope {
-  return o && typeof o.sessionId === "string" && validateItem(o.item) !== null;
-}
-```
-
-**3d.** Add a lazy result store alongside `getQueue()`:
-
-```typescript
-let resultStore: RedisResultStore | undefined;
-function getResultStore(): RedisResultStore {
-  if (!resultStore) resultStore = new RedisResultStore(process.env.REDIS_URL);
-  return resultStore;
-}
-```
-
-**3e.** Replace `handleEnqueueLeafParsed` (old lines 82–91):
-
-```typescript
-async function handleEnqueueLeafParsed(body: any, res: ServerResponse): Promise<void> {
-  if (!isLeafEnvelope(body)) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "envelope_invalid" })); return; }
-  const q = getQueue();
-  await q.ensureGroup();
-  await q.enqueue(body);
-  res.writeHead(202, JSON_HEADERS).end(JSON.stringify({ status: "accepted", sessionId: body.sessionId }));
-}
-```
-
-**3f.** Replace `handleRunLeafParsed` (old lines 93–97) — write the record, return inline:
-
-```typescript
-async function handleRunLeafParsed(body: any, _raw: string, res: ServerResponse): Promise<void> {
-  if (!isLeafEnvelope(body)) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "envelope_invalid" })); return; }
-  const result = await runLeaf(body, buildConfig());
-  await writeResult(getResultStore(), leafSessionId(body), toResultRecord(result, body.sessionId, new Date().toISOString()), RESULT_TTL_SECONDS);
-  res.writeHead(200, JSON_HEADERS).end(JSON.stringify(result));
-}
-```
-
-**3g.** Replace `confineToWorkRoot` + `handleLeafStatus` (old lines 99–132) with a Redis-backed status handler:
-
-```typescript
-async function handleLeafStatus(url: URL, res: ServerResponse): Promise<void> {
-  const sessionId = url.searchParams.get("sessionId");
-  if (!sessionId) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: "sessionId_required" })); return; }
-  const tenant = url.searchParams.get("tenant") ?? undefined;
-  const record = await readResult(getResultStore(), leafSessionId({ sessionId, tenant }));
-  if (!record) { res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: "queued" })); return; }
-  if (record.status === "done") { res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: "done", verdict: record.verdict })); return; }
-  if (record.status === "paused") { res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: "paused", gateId: record.gate?.gateId, gate: record.gate })); return; }
-  if (record.status === "failed") { res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: "failed", reason: record.reason ?? undefined })); return; }
-  res.writeHead(200, JSON_HEADERS).end(JSON.stringify({ status: record.status }));
-}
-```
-
-**3h.** Update the status route dispatch (old lines 159–163) to call the now-async handler:
-
-```typescript
-  if (req.method === "GET" && (url.startsWith("/runs/status") || url.startsWith("/run-leaf/status"))) {
-    if (url.startsWith("/run-leaf/status")) warnDeprecatedRoute("/run-leaf/status");
-    handleLeafStatus(new URL(url, "http://localhost"), res).catch((err) => {
-      if (!res.headersSent) res.writeHead(500, JSON_HEADERS).end(JSON.stringify({ error: String(err) }));
-    });
-    return;
-  }
-```
-
-(The `POST /runs` route dispatch, `/turn`, `/health`, deprecation aliases, and `SIGTERM` handling are unchanged. Remove the now-unused `resolve as resolvePath` import and the `readDoneMarker`/`deriveDoneMarkerPath`/`readGateMarker` imports.)
-
-- [ ] **Step 4: Run tests to verify they pass**
-
-Run: `cd packages/knative-server && pnpm exec vitest run`
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add packages/knative-server/src/server.ts packages/knative-server/test/run-leaf-route.test.ts packages/knative-server/test/run-leaf-async-route.test.ts packages/knative-server/test/server.test.ts
-git commit -s -m "feat(server): inline /runs contract + Redis-backed /runs/status" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 5: Sandbox pod resolution by label selector
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/resolve-pod.ts`
-- Test: `packages/k8s-sandbox/test/resolve-pod.test.ts`
-- Modify: `packages/k8s-sandbox/src/index.ts`, `harness/src/run-leaf.ts`, `harness/src/run-turn.ts`
-
-**Interfaces:**
-- Consumes: `resolveConfig`, `type K8sSandboxConfig` from `./config.js`.
-- Produces:
-  - `buildSelectorArgs(name: string, namespace: string, context?: string): string[]`
-  - `buildPodNameArgs(selector: string, namespace: string, context?: string): string[]`
-  - `type RunKubectl = (args: string[]) => Promise<string>`
-  - `resolveSandboxConfig(env: NodeJS.ProcessEnv, headCwd: string, run?: RunKubectl): Promise<K8sSandboxConfig | null>`
-
-- [ ] **Step 1: Write the failing test**
-
-Create `packages/k8s-sandbox/test/resolve-pod.test.ts`:
-
-```typescript
-import { describe, it, expect } from "vitest";
-import { buildSelectorArgs, buildPodNameArgs, resolveSandboxConfig } from "../src/resolve-pod.js";
-
-describe("arg builders", () => {
-  it("builds selector args with jsonpath and optional context", () => {
-    expect(buildSelectorArgs("sandbox-0", "default")).toEqual(["get", "sandbox", "sandbox-0", "-n", "default", "-o", "jsonpath={.status.selector}"]);
-    expect(buildSelectorArgs("s", "ns", "kind-x")).toContain("--context");
-  });
-  it("builds pod-name args filtered to Running", () => {
-    expect(buildPodNameArgs("app=sandbox", "default")).toEqual(["get", "pod", "-n", "default", "-l", "app=sandbox", "--field-selector=status.phase=Running", "-o", "jsonpath={.items[0].metadata.name}"]);
-  });
-});
-
-describe("resolveSandboxConfig", () => {
-  it("short-circuits to KAGENTI_SANDBOX_POD without any kubectl call", async () => {
-    let called = false;
-    const cfg = await resolveSandboxConfig({ KAGENTI_SANDBOX_POD: "sbx-0" }, "/head", async () => { called = true; return ""; });
-    expect(cfg?.pod).toBe("sbx-0");
-    expect(called).toBe(false);
-  });
-  it("returns null when neither POD nor NAME is set", async () => {
-    expect(await resolveSandboxConfig({}, "/head", async () => "")).toBeNull();
-  });
-  it("resolves the pod via selector when NAME is set", async () => {
-    const calls: string[][] = [];
-    const run = async (args: string[]) => { calls.push(args); return args[1] === "sandbox" ? "app=sandbox,agents.x-k8s.io/sandbox=s" : "s-abc123"; };
-    const cfg = await resolveSandboxConfig({ KAGENTI_SANDBOX_NAME: "s", KAGENTI_SANDBOX_NAMESPACE: "team1" }, "/head", run);
-    expect(cfg).toEqual({ pod: "s-abc123", namespace: "team1", context: undefined, podCwd: "/workspace", headCwd: "/head" });
-    expect(calls[0]).toContain("sandbox");
-    expect(calls[1]).toContain("-l");
-  });
-  it("throws when the Sandbox has no selector yet", async () => {
-    await expect(resolveSandboxConfig({ KAGENTI_SANDBOX_NAME: "s" }, "/head", async () => "")).rejects.toThrow(/selector/);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd packages/k8s-sandbox && pnpm exec vitest run test/resolve-pod.test.ts`
-Expected: FAIL — module not found.
-
-- [ ] **Step 3: Write `resolve-pod.ts`**
-
-```typescript
-import { spawn } from "node:child_process";
-import { resolveConfig, type K8sSandboxConfig } from "./config.js";
-
-/** Pure: kubectl args to read a Sandbox's status.selector (a label-selector string). */
-export function buildSelectorArgs(name: string, namespace: string, context?: string): string[] {
-  const args = ["get", "sandbox", name, "-n", namespace];
-  if (context) args.push("--context", context);
-  args.push("-o", "jsonpath={.status.selector}");
-  return args;
-}
-
-/** Pure: kubectl args to read the first Running pod name matching a label selector. */
-export function buildPodNameArgs(selector: string, namespace: string, context?: string): string[] {
-  const args = ["get", "pod", "-n", namespace, "-l", selector, "--field-selector=status.phase=Running"];
-  if (context) args.push("--context", context);
-  args.push("-o", "jsonpath={.items[0].metadata.name}");
-  return args;
-}
-
-export type RunKubectl = (args: string[]) => Promise<string>;
-
-const defaultRun: RunKubectl = (args) =>
-  new Promise((resolve, reject) => {
-    const child = spawn("kubectl", args, { stdio: ["ignore", "pipe", "pipe"] });
-    const out: Buffer[] = [];
-    const err: Buffer[] = [];
-    child.stdout.on("data", (d: Buffer) => out.push(d));
-    child.stderr.on("data", (d: Buffer) => err.push(d));
-    child.on("error", reject);
-    child.on("close", (code) =>
-      code === 0
-        ? resolve(Buffer.concat(out).toString().trim())
-        : reject(new Error(`kubectl ${args.join(" ")} failed (${code}): ${Buffer.concat(err).toString().trim()}`)),
-    );
-  });
-
-/**
- * Resolve sandbox config from env. Precedence:
- *  1. KAGENTI_SANDBOX_POD (explicit pod name) — no kubectl call (fallback / tests).
- *  2. KAGENTI_SANDBOX_NAME — resolve the pod from the Sandbox CR's `.status.selector`.
- *  3. neither — null (extension stays off; local tools stand).
- * Resolution runs once per leaf-session at extension init; a sandbox restart is picked up on the
- * next invocation (design §6.2).
- */
-export async function resolveSandboxConfig(
-  env: NodeJS.ProcessEnv,
-  headCwd: string,
-  run: RunKubectl = defaultRun,
-): Promise<K8sSandboxConfig | null> {
-  const direct = resolveConfig(env, headCwd);
-  if (direct) return direct;
-
-  const name = env.KAGENTI_SANDBOX_NAME;
-  if (!name) return null;
-
-  const namespace = env.KAGENTI_SANDBOX_NAMESPACE ?? "default";
-  const context = env.KAGENTI_SANDBOX_CONTEXT || undefined;
-
-  const selector = (await run(buildSelectorArgs(name, namespace, context))).trim();
-  if (!selector) throw new Error(`Sandbox/${name} has no .status.selector yet`);
-  const pod = (await run(buildPodNameArgs(selector, namespace, context))).trim();
-  if (!pod) throw new Error(`no Running pod for selector '${selector}'`);
-
-  return { pod, namespace, context, podCwd: env.KAGENTI_SANDBOX_CWD ?? "/workspace", headCwd };
-}
-```
-
-- [ ] **Step 4: Export from `index.ts`**
-
-Add to `packages/k8s-sandbox/src/index.ts`:
-
-```typescript
-export { buildSelectorArgs, buildPodNameArgs, resolveSandboxConfig, type RunKubectl } from "./resolve-pod.js";
-```
-
-- [ ] **Step 5: Wire into `run-leaf.ts` and `run-turn.ts`**
-
-In `harness/src/run-leaf.ts`, change the import and the extension call. Import:
-
-```typescript
-import { k8sSandboxExtension, resolveSandboxConfig } from "@sh/k8s-sandbox";
-```
-
-In `realProduceVerdict`, just before building `resourceLoader`, resolve the config:
-
-```typescript
-  const sandboxConfig = await resolveSandboxConfig(process.env, cwd);
-```
-
-and change the extension entry from `k8sSandboxExtension(),` to:
-
-```typescript
-      k8sSandboxExtension({ config: sandboxConfig }),
-```
-
-In `harness/src/run-turn.ts`, apply the same two changes: import `resolveSandboxConfig`, resolve `const sandboxConfig = await resolveSandboxConfig(process.env, <the cwd used there>);` before the extension list, and pass `k8sSandboxExtension({ config: sandboxConfig })` at line 151. (Use the same `cwd`/head-dir variable already in scope in `run-turn.ts`.)
-
-- [ ] **Step 6: Run tests + typecheck**
-
-Run: `cd packages/k8s-sandbox && pnpm exec vitest run && pnpm exec tsc --noEmit`
-Run: `cd harness && pnpm exec vitest run && pnpm exec tsc --noEmit`
-Expected: PASS / no errors.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add packages/k8s-sandbox/src/resolve-pod.ts packages/k8s-sandbox/src/index.ts packages/k8s-sandbox/test/resolve-pod.test.ts harness/src/run-leaf.ts harness/src/run-turn.ts
-git commit -s -m "feat(k8s-sandbox): resolve sandbox pod via Sandbox CR status.selector" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 6: Delete the dead filesystem modules
-
-**Files:**
-- Delete: `harness/src/done-marker.ts`, `harness/test/done-marker.test.ts`
-- Delete: `harness/src/gate-marker.ts`, `harness/test/gate-marker.test.ts`
-
-**Interfaces:** none produced. Verifies nothing references the deleted modules.
-
-- [ ] **Step 1: Verify no references remain**
-
-Run: `cd /path/to/serverless-harness && grep -rn "done-marker\|gate-marker\|writeDoneMarker\|readDoneMarker\|writeGateMarker\|readGateMarker\|deriveDoneMarkerPath\|deriveGateRef" harness packages --include="*.ts" | grep -v "test/done-marker\|test/gate-marker"`
-Expected: **no output** (empty). If anything prints, fix that reference first (it belongs to Task 3 or 4).
-
-- [ ] **Step 2: Delete the modules and their tests**
-
-```bash
-git rm harness/src/done-marker.ts harness/test/done-marker.test.ts harness/src/gate-marker.ts harness/test/gate-marker.test.ts
-```
-
-- [ ] **Step 3: Run the full harness suite + typecheck**
-
-Run: `cd harness && pnpm exec vitest run && pnpm exec tsc --noEmit`
-Expected: PASS / no errors (no import of the removed files).
-
-- [ ] **Step 4: Commit**
-
-```bash
-git commit -s -m "chore(harness): remove filesystem done/gate marker modules (superseded by Redis)" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 7: Deploy manifests — remove `/work`, add durable Sandbox CR
-
-**Files:**
-- Modify: `deploy/knative/service.yaml`
-- Modify: `deploy/knative/leaf-scaledjob.yaml`
-- Modify: `deploy/knative/sandbox.yaml`
-- Delete: `deploy/knative/leaf-pvc.yaml`
-- Modify: the deploy driver that applies manifests + installs cluster deps (see Step 5).
-
-**Interfaces:** cluster resources only. No code.
-
-- [ ] **Step 1: `service.yaml` — drop `/work`, switch to sandbox NAME, add TTL + RBAC**
-
-In `deploy/knative/service.yaml`:
-- Remove the `KAGENTI_SANDBOX_POD` env entry; add:
-  ```yaml
-            - name: KAGENTI_SANDBOX_NAME
-              value: "sandbox-0"
-            - name: LEAF_RESULT_TTL_SECONDS
-              value: "86400"
-  ```
-- Delete the `work` `volumeMount` (keep the `tmp` mount) and the `work` volume (keep the `tmp` emptyDir). Remove the multi-line `# Shared leaf-session work volume …` comment.
-- In the `serverless-harness-sandbox` Role, add a rule so the harness can read the Sandbox CR:
-  ```yaml
-    - apiGroups: ["agents.x-k8s.io"]
-      resources: ["sandboxes"]
-      verbs: ["get", "list"]
-  ```
-
-- [ ] **Step 2: `leaf-scaledjob.yaml` — drop `/work`, switch env**
-
-In `deploy/knative/leaf-scaledjob.yaml`:
-- Replace the `KAGENTI_SANDBOX_POD` env with `KAGENTI_SANDBOX_NAME: "sandbox-0"` and add `LEAF_RESULT_TTL_SECONDS: "86400"`.
-- Delete the `work` `volumeMount` (keep `tmp`) and the `work` volume (keep the `tmp` emptyDir).
-
-- [ ] **Step 3: `sandbox.yaml` — convert the bare Pod to a durable `Sandbox` CR**
-
-Replace the entire contents of `deploy/knative/sandbox.yaml`:
-
-```yaml
-apiVersion: agents.x-k8s.io/v1alpha1
-kind: Sandbox
-metadata:
-  name: sandbox-0
-  namespace: default
-  labels:
-    app: sandbox
-spec:
-  volumeClaimTemplates:
-    - metadata:
-        name: workspace
-      spec:
-        accessModes: ["ReadWriteOnce"]
-        resources:
-          requests:
-            storage: 1Gi
-  podTemplate:
-    spec:
-      containers:
-        - name: sandbox
-          image: alpine:3.20
-          command: ["/bin/sh", "-c", "apk add --no-cache bash coreutils findutils grep ripgrep && mkdir -p /workspace && exec sleep infinity"]
-          workingDir: /workspace
-          volumeMounts:
-            - name: workspace
-              mountPath: /workspace
-          resources:
-            requests:
-              memory: "64Mi"
-              cpu: "50m"
-            limits:
-              memory: "256Mi"
-```
-
-- [ ] **Step 4: Delete the shared work PVC**
-
-```bash
-git rm deploy/knative/leaf-pvc.yaml
-```
-
-- [ ] **Step 5: Install agent-sandbox as a cluster dependency**
-
-Find the deploy driver that applies these manifests (search the smoke/deploy scripts):
-
-Run: `grep -rn "leaf-pvc.yaml\|sandbox.yaml\|kubectl apply -f deploy/knative\|kubectl apply -k" deploy .github 2>/dev/null`
-
-In that driver, **before** applying `sandbox.yaml`, install the agent-sandbox controller + CRDs and stop applying the deleted PVC. Add (using the pinned release manifest — confirm the current URL/tag from the agent-sandbox releases page):
-
-```bash
-# agent-sandbox controller + CRDs (kubernetes-sigs/agent-sandbox)
-kubectl apply --server-side -f https://github.com/kubernetes-sigs/agent-sandbox/releases/latest/download/install.yaml
-kubectl -n agent-sandbox-system rollout status deploy/agent-sandbox-controller-manager --timeout=180s
-kubectl wait --for=condition=Established crd/sandboxes.agents.x-k8s.io --timeout=120s
-```
-
-Remove any line that applies `deploy/knative/leaf-pvc.yaml`. Ensure `sandbox.yaml` is applied after the CRD is Established, and that the driver waits for the sandbox pod to be Running by label (not by the fixed name), e.g.:
-
-```bash
-kubectl -n default wait --for=condition=Ready pod -l app=sandbox --timeout=180s
-```
-
-- [ ] **Step 6: Render-lint the manifests**
-
-Run: `for f in deploy/knative/service.yaml deploy/knative/leaf-scaledjob.yaml deploy/knative/sandbox.yaml; do kubectl apply --dry-run=client -f "$f" >/dev/null && echo "OK $f" || echo "BAD $f"; done`
-Expected: `OK` for service and scaledjob. `sandbox.yaml` may print `BAD` if the CRD is not installed in the current context — that is acceptable at this step; it is validated live in Task 9.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add deploy/knative/service.yaml deploy/knative/leaf-scaledjob.yaml deploy/knative/sandbox.yaml <the deploy driver file>
-git commit -s -m "feat(deploy): FS-free harness pods + durable agent-sandbox Sandbox CR" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 8: Callers + smoke drivers (inline contract, red-team grep, durability)
-
-**Files:**
-- Modify: `packages/knative-server/src/cron-dispatch.ts` (+ its test if envelope-shaped)
-- Modify: `deploy/knative/leaf-smoke.sh`, `deploy/knative/leaf-async-smoke.sh`, `deploy/knative/lib.sh`
-
-**Interfaces:** the smoke drivers must construct the inline `item` envelope and read verdicts from the response / `/runs/status`.
-
-- [ ] **Step 1: `cron-dispatch.ts`**
-
-`dispatchAll`/`applyFire` are envelope-shape-agnostic (they operate on arbitrary string fields), so no code change is required for the mechanics. Update the doc comment near `buildPost`/`loadConfig` to note items now carry an inline `item` object rather than `inputsRef`/`resultRef`. If `cron-dispatch.test.ts` builds envelopes with `inputsRef`/`resultRef`, update those fixtures to the inline shape (`{ sessionId, item: { item_id, file, pattern } }`).
-
-Run: `cd packages/knative-server && pnpm exec vitest run test/cron-dispatch.test.ts`
-Expected: PASS.
-
-- [ ] **Step 2: `leaf-smoke.sh` — inline item, verdict from the response**
-
-Rewrite `dispatch_sid`/`dispatch` to send the inline `item` and drop `inputsRef`/`resultRef`. The fixtures (`i1`/`i2`/`i3` → file+pattern) are known to the smoke, so build them inline:
-
-```bash
-# dispatch_item <sessionId> <item_id> <file> <pattern> [model] -> echoes terminal JSON from /runs
-dispatch_item() {
-  local sid="$1" id="$2" file="$3" pat="$4" model="${5:-$MODEL}"
-  local body
-  body=$(jq -nc --arg s "$sid" --arg m "$model" --arg id "$id" --arg f "$file" --arg p "$pat" --arg ws "$SBOX_REPO" \
-    '{sessionId:$s, model:$m, workspaceRef:$ws, item:{item_id:$id, file:$f, pattern:$p}}')
-  curl -s --max-time 240 -H "$HOST_HEADER" -H "Content-Type: application/json" -d "$body" "$BASE/runs"
-}
-```
-
-Update the verdict check to read the inline response `.verdict.verdict` instead of exec-ing into the PVC to read a result file. For each item, compare `$(echo "$resp" | jq -r '.verdict.verdict')` against `${EXPECT[$id]}`. Remove all `oexec … $RES/$id.json` reads and any `seed_work_dirs`/`INPUTS`/`RES` PVC plumbing. Keep seeding the **repo into the sandbox** (`SBOX_REPO`, via `sexec`) — Claim 0 still requires the repo to exist only in the sandbox.
-
-- [ ] **Step 3: `leaf-async-smoke.sh` — poll `/runs/status?sessionId`**
-
-Replace the done-marker/result-file polling with status polling:
-
-```bash
-# poll_status <sessionId> -> echoes final status JSON (done|failed|aborted) or times out
-poll_status() {
-  local sid="$1" i=0 resp status
-  while [ "$i" -lt 60 ]; do
-    resp=$(curl -s -H "$HOST_HEADER" "$BASE/runs/status?sessionId=$(jq -rn --arg s "$sid" '$s|@uri')")
-    status=$(echo "$resp" | jq -r '.status')
-    case "$status" in done|failed|aborted) echo "$resp"; return 0;; esac
-    i=$((i+1)); sleep 2
-  done
-  echo "$resp"; return 1
-}
-```
-
-Send the async envelope with the inline `item` + `async:true`, then `poll_status "$sid"` and assert `.verdict.verdict`. Remove all `$RES/$id.json.status` and `$RES/$id.json` reads.
-
-- [ ] **Step 4: `lib.sh` — drop `seed_work_dirs`**
-
-Remove the `seed_work_dirs` helper (no `/work` dirs to seed). Leave the `/turn` helper (line ~56) unchanged. If other smoke scripts call `seed_work_dirs`, remove those calls.
-
-- [ ] **Step 5: Add the red-team grep to the smoke (acceptance gate)**
-
-Add near the top of `leaf-smoke.sh` (after `claim` is defined) a static assertion that the harness path is FS-free:
-
-```bash
-claim 0 "harness is FS-free (no /work mount, no fs writes in the envelope path)"
-if grep -rqE 'mountPath:\s*/work|claimName:\s*leaf-work' deploy/knative/service.yaml deploy/knative/leaf-scaledjob.yaml; then
-  echo "FAIL: a /work mount remains in the harness/worker manifests"; exit 1
-fi
-if grep -rqE 'writeFileSync|readFileSync|mkdirSync' harness/src/run-leaf.ts harness/src/leaf-job-runner.ts; then
-  echo "FAIL: filesystem I/O remains in the leaf envelope path"; exit 1
-fi
-echo "PASS: no /work mount, no fs I/O in the envelope path"
-```
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add packages/knative-server/src/cron-dispatch.ts deploy/knative/leaf-smoke.sh deploy/knative/leaf-async-smoke.sh deploy/knative/lib.sh
-git commit -s -m "test(smoke): inline-item envelope, verdict from response/Redis, FS-free red-team grep" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 9: Live Kind verification (acceptance)
-
-**Files:** none (runs the smoke on a real Kind cluster).
-
-**Interfaces:** validates the four acceptance criteria from spec §10 end-to-end, including the real `.status.selector` shape.
-
-- [ ] **Step 1: Deploy to Kind**
-
-Build/push the image and apply manifests via the deploy driver (the same one edited in Task 7). Follow the repo's existing Kind deploy path (see the driver / `deploy/knative/README` if present). Confirm the controller and sandbox are up:
-
-```bash
-kubectl wait --for=condition=Established crd/sandboxes.agents.x-k8s.io --timeout=120s
-kubectl -n default get sandbox sandbox-0 -o jsonpath='{.status.selector}'; echo
-kubectl -n default wait --for=condition=Ready pod -l app=sandbox --timeout=180s
-```
-
-Expected: `.status.selector` prints a non-empty **string** label selector. If it prints a JSON object instead (`{"matchLabels":…}`), adjust `buildSelectorArgs`/`resolveSandboxConfig` in Task 5 to render `-l key=value` pairs from `matchLabels`, then re-run Task 5's tests and redeploy.
-
-- [ ] **Step 2: Run the sync smoke (Claims 0–N)**
-
-Run the sync smoke and capture output to a log (context budget):
-
-```bash
-LOG_DIR=/tmp/sh/p1; mkdir -p $LOG_DIR
-bash deploy/knative/leaf-smoke.sh > $LOG_DIR/leaf-smoke.log 2>&1; echo "EXIT:$?"
-```
-
-Expected: `EXIT:0`. Verify the red-team claim and the i1/i2/i3 verdicts passed (grep the log for `PASS`/`FAIL`).
-
-- [ ] **Step 3: Run the async smoke**
-
-```bash
-bash deploy/knative/leaf-async-smoke.sh > $LOG_DIR/leaf-async-smoke.log 2>&1; echo "EXIT:$?"
-```
-
-Expected: `EXIT:0`; verdicts retrieved via `/runs/status?sessionId`.
-
-- [ ] **Step 4: Durability check (sandbox PVC survives a pod restart)**
-
-```bash
-POD=$(kubectl -n default get pod -l app=sandbox -o jsonpath='{.items[0].metadata.name}')
-kubectl -n default exec "$POD" -- sh -c 'echo durable-$$ > /workspace/durable-marker.txt; cat /workspace/durable-marker.txt'
-kubectl -n default delete pod "$POD"
-kubectl -n default wait --for=condition=Ready pod -l app=sandbox --timeout=180s
-NEWPOD=$(kubectl -n default get pod -l app=sandbox -o jsonpath='{.items[0].metadata.name}')
-kubectl -n default exec "$NEWPOD" -- cat /workspace/durable-marker.txt
-```
-
-Expected: the marker file survives on the recreated pod (proves `volumeClaimTemplates` durability).
-
-- [ ] **Step 5: Confirm the harness pods mount nothing writable**
-
-```bash
-kubectl -n default get pods -o json | jq -r '.items[] | select(.metadata.labels["serving.knative.dev/service"]=="serverless-harness" or (.metadata.name|test("leaf-worker"))) | .spec.volumes[].name' | sort -u
-```
-
-Expected: only `tmp` (emptyDir) — no `work` / `leaf-work`.
-
-- [ ] **Step 6: Final full-suite run + commit any fixups**
-
-Run: `pnpm -r test`
-Expected: all packages green.
-
-If Step 1 forced a `buildSelectorArgs` adjustment, commit it:
-
-```bash
-git add packages/k8s-sandbox/src/resolve-pod.ts packages/k8s-sandbox/test/resolve-pod.test.ts
-git commit -s -m "fix(k8s-sandbox): render matchLabels selector for the deployed Sandbox CRD" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Self-Review (completed during authoring)
-
-**Spec coverage** — every spec section maps to a task: §3.1 inline request → T2/T4; §3.2 inline sync verdict → T2/T4; §3.3 async 202 → T4; §3.4 `/runs/status?sessionId[&tenant]` → T4; §4 Redis result store + TTL → T1 (module), T3/T4 (writers); §5 gate off FS (marker→Redis, decision→inline) → T2 (inline decision + inline gate result), T3/T4 (paused record); §6 Sandbox CR + selector exec → T5, T7; §6.3 carried scope (single Sandbox; controller as dep) → T7; §7 deploy edits → T7; §8 callers → T8; §9 testing (unit, red-team grep, durability, gate) → T1–T5 units, T8 grep, T9 durability; §10 acceptance → T9.
-
-**Placeholder scan** — no TBD/TODO; every code step shows complete code. The one deliberately open item (whether `.status.selector` serializes as a string vs `LabelSelector` object) is handled with an explicit live-verification branch in T9 Step 1, per spec §6.2.
-
-**Type consistency** — `LeafResult` (T2) is consumed by `toResultRecord`/`classifyOutcome` (T1/T3) with matching variants (`done.verdict`, `paused.gateId`+`paused.gate`, `failed.reason`); `leafSessionId` reused by T3/T4 for the Redis key; `RedisLike` (T1) is the injected type in T3/T4 and implemented by `RedisResultStore` (T1); `resolveSandboxConfig` (T5) returns the existing `K8sSandboxConfig` consumed unchanged by the exec transports.
diff --git a/docs/superpowers/plans/2026-07-02-p2-shared-sandbox-pool.md b/docs/superpowers/plans/2026-07-02-p2-shared-sandbox-pool.md
deleted file mode 100644
index 0e81fd4..0000000
--- a/docs/superpowers/plans/2026-07-02-p2-shared-sandbox-pool.md
+++ /dev/null
@@ -1,1046 +0,0 @@
-# P2 — Shared Sandbox Pool + Routing Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Scale Archetype A from one sandbox to a static pool of N sandbox pods, with each short-lived leaf harness load-balanced onto the least-loaded pod via Redis leases, its repo lazily converged to a pinned git ref, and its work isolated in a per-leaf git worktree — the harness still touching no filesystem.
-
-**Architecture:** `@sh/k8s-sandbox` gains a pure kubectl pod-lister; the harness gains a Redis lease store (expiry-scored sorted sets, atomic Lua acquire), a pool selector that picks the least-loaded pod under a soft cap and returns a lease handle, and a converge module that (via sandbox `exec`) fetches the ref into a shared `/workspace/repo` object store and adds a per-leaf `git worktree` at `/workspace/leaves/<leafSessionId>`. `run-leaf.ts` swaps its single-pod `resolveSandboxConfig` call for pool selection + converge + heartbeat + release, deriving `workspaceRef` from the worktree path. Deploy provisions N `Sandbox` CRs sharing a common pod label.
-
-**Tech Stack:** TypeScript (ES modules, `.js` import specifiers), pnpm workspaces (`harness`, `packages/*`), Vitest, node-redis v6 (sorted sets + `eval`/Lua), kubernetes-sigs/agent-sandbox `Sandbox` CR (`agents.x-k8s.io/v1beta1`), Knative Serving, KEDA, `kubectl` (shelled out).
-
-Spec: [`docs/specs/2026-07-02-p2-shared-sandbox-pool-design.md`](../../specs/2026-07-02-p2-shared-sandbox-pool-design.md). Issues: epic #49, P2 #46. Depends on P1 (#45, merged).
-
-## Global Constraints
-
-- **Every commit is DCO-signed with the AI attribution trailer** — exactly:
-  `git commit -s -m "<subject>" -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"`.
-  Never use `Co-authored-by`.
-- **`git add` explicit paths only, never `git add -A`** (the working tree carries unrelated dirty files: `experiments/RESULTS.md`, `.worktrees/`).
-- **PR/commit subjects have no `(scope)` parens** and a Capitalized prefix is fine (`docs:`, `feat:`, `fix:` conventional prefixes are used in this repo).
-- **ES-module import specifiers keep the `.js` extension** (e.g. `import { x } from "./sandbox-lease.js"`) even though the source is `.ts` — this repo compiles with `tsc`/`tsgo` NodeNext.
-- **Per-package test command:** `cd <pkg> && pnpm exec vitest run test/<file>.test.ts` (optionally `-t "<name>"`). **Per-package typecheck:** `cd <pkg> && pnpm exec tsc --noEmit`. Package dirs: `harness`, `packages/k8s-sandbox`.
-- **Work on branch `docs/p2-shared-sandbox-pool`** (already created off `main`; the spec commit lives there).
-- **Soft capacity cap** (spec D5): rare concurrent overshoot is acceptable; do not add a hard CAS beyond the single-`eval` acquire.
-- **FS-free harness contract (P1) is preserved:** every filesystem mutation (converge, worktree add/remove) is issued as a sandbox `exec`; the harness process opens no paths.
-- **Config knobs (env, with defaults):** `KAGENTI_SANDBOX_POOL_SELECTOR` (label selector; unset ⇒ fall back to single-pod `KAGENTI_SANDBOX_POD`/`_NAME`), `KAGENTI_SANDBOX_CAP` (default `20`), `KAGENTI_SANDBOX_LEASE_TTL_MS` (default `60000`), `KAGENTI_SANDBOX_HEARTBEAT_MS` (default `20000`), `KAGENTI_SANDBOX_NAMESPACE` (default `default`), `KAGENTI_SANDBOX_CWD` (default `/workspace`), `REDIS_URL` (default `redis://127.0.0.1:6379`).
-- **Worktree/lease id = `leafSessionId(env)`** — the existing tenant-prefixed-then-sanitized leaf id from `run-leaf.ts` (unique per leaf).
-
----
-
-## File Structure
-
-**New files**
-- `packages/k8s-sandbox/src/pool.ts` — pure `buildPoolPodsArgs` + `parsePodNames`, and `listPoolPods` (Running pod names by label). (Task 1)
-- `packages/k8s-sandbox/test/pool.test.ts` — unit tests with a fake `RunKubectl`. (Task 1)
-- `harness/src/sandbox-lease.ts` — `leaseKey`, pure `activeCount`, `ACQUIRE_LUA`, `LeaseStore` interface, `RedisLeaseStore`. (Task 2)
-- `harness/test/sandbox-lease.test.ts` — unit tests for the pure parts. (Task 2)
-- `harness/src/select-sandbox.ts` — pure `orderByLoad`, `SandboxPoolSaturatedError`, `selectPoolSandbox`. (Task 3)
-- `harness/test/select-sandbox.test.ts` — unit tests with fakes. (Task 3)
-- `harness/src/converge.ts` — pure `leafWorkspaceRef`/`buildConvergeScript`/`buildCleanupScript`, and `convergeWorkspace`/`cleanupWorkspace`. (Task 4)
-- `harness/test/converge.test.ts` — unit tests for the pure builders. (Task 4)
-- `deploy/knative/sandbox-pool.yaml` — N `Sandbox` CRs with the common pool label. (Task 6)
-- `harness/test/pool-live-smoke.test.ts` — gated (`POOL_LIVE_SMOKE=1`) live-redis + live-cluster smoke. (Task 7)
-
-**Modified files**
-- `packages/k8s-sandbox/src/resolve-pod.ts` — export the shared default kubectl runner as `defaultRunKubectl`. (Task 1)
-- `packages/k8s-sandbox/src/index.ts` — export the pool API. (Task 1)
-- `harness/src/run-leaf.ts` — add `repoUrl`/`ref` to `LeafEnvelope`; swap single-pod resolve for select+converge+heartbeat+release; derive `workspaceRef`. (Task 5)
-- `deploy/knative/service.yaml` — set `KAGENTI_SANDBOX_POOL_SELECTOR`; keep `KAGENTI_SANDBOX_POD` as a test override. (Task 6)
-- `deploy/knative/kustomization.yaml` (+ `overlays/ocp/…`) — reference `sandbox-pool.yaml` instead of the single `sandbox.yaml`. (Task 6)
-
----
-
-### Task 1: Pool pod discovery (`@sh/k8s-sandbox`)
-
-**Files:**
-- Create: `packages/k8s-sandbox/src/pool.ts`
-- Create: `packages/k8s-sandbox/test/pool.test.ts`
-- Modify: `packages/k8s-sandbox/src/resolve-pod.ts` (export the default runner)
-- Modify: `packages/k8s-sandbox/src/index.ts` (export pool API)
-
-**Interfaces:**
-- Consumes: `RunKubectl = (args: string[]) => Promise<string>` from `./resolve-pod.js`.
-- Produces: `buildPoolPodsArgs(selector, namespace, context?) => string[]`, `parsePodNames(stdout: string) => string[]`, `listPoolPods(selector, namespace, context?, run?) => Promise<string[]>`, and `defaultRunKubectl: RunKubectl`.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// packages/k8s-sandbox/test/pool.test.ts
-import { describe, it, expect } from "vitest";
-import { buildPoolPodsArgs, parsePodNames, listPoolPods } from "../src/pool.js";
-
-describe("buildPoolPodsArgs", () => {
-  it("lists Running pods by selector with a per-name jsonpath", () => {
-    expect(buildPoolPodsArgs("app=sandbox", "default")).toEqual([
-      "get", "pod", "-n", "default", "-l", "app=sandbox",
-      "--field-selector=status.phase=Running",
-      "-o", "jsonpath={range .items[*]}{.metadata.name}{'\\n'}{end}",
-    ]);
-  });
-  it("adds --context when provided", () => {
-    expect(buildPoolPodsArgs("app=sandbox", "team1", "kind-x")).toContain("--context");
-  });
-});
-
-describe("parsePodNames", () => {
-  it("splits, trims, and drops blanks", () => {
-    expect(parsePodNames("sandbox-0-0\nsandbox-1-0\n\n  sandbox-2-0  \n")).toEqual([
-      "sandbox-0-0", "sandbox-1-0", "sandbox-2-0",
-    ]);
-  });
-  it("returns [] for empty output", () => {
-    expect(parsePodNames("")).toEqual([]);
-  });
-});
-
-describe("listPoolPods", () => {
-  it("runs the built args and parses the result", async () => {
-    const calls: string[][] = [];
-    const run = async (args: string[]) => { calls.push(args); return "sandbox-0-0\nsandbox-1-0\n"; };
-    const pods = await listPoolPods("app=sandbox", "default", undefined, run);
-    expect(pods).toEqual(["sandbox-0-0", "sandbox-1-0"]);
-    expect(calls[0]).toEqual(buildPoolPodsArgs("app=sandbox", "default"));
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd packages/k8s-sandbox && pnpm exec vitest run test/pool.test.ts`
-Expected: FAIL — `Cannot find module '../src/pool.js'`.
-
-- [ ] **Step 3: Export the shared kubectl runner from `resolve-pod.ts`**
-
-In `packages/k8s-sandbox/src/resolve-pod.ts`, rename the private `defaultRun` to an exported `defaultRunKubectl` (update its one internal use in `resolveSandboxConfig`'s default parameter):
-
-```typescript
-// was: const defaultRun: RunKubectl = (args) => …
-export const defaultRunKubectl: RunKubectl = (args) =>
-  new Promise((resolve, reject) => {
-    const child = spawn("kubectl", args, { stdio: ["ignore", "pipe", "pipe"] });
-    const out: Buffer[] = [];
-    const err: Buffer[] = [];
-    child.stdout.on("data", (d: Buffer) => out.push(d));
-    child.stderr.on("data", (d: Buffer) => err.push(d));
-    child.on("error", reject);
-    child.on("close", (code) =>
-      code === 0
-        ? resolve(Buffer.concat(out).toString().trim())
-        : reject(new Error(`kubectl ${args.join(" ")} failed (${code}): ${Buffer.concat(err).toString().trim()}`)),
-    );
-  });
-```
-
-And update the signature default: `run: RunKubectl = defaultRunKubectl,`.
-
-- [ ] **Step 4: Write the implementation**
-
-```typescript
-// packages/k8s-sandbox/src/pool.ts
-import { type RunKubectl, defaultRunKubectl } from "./resolve-pod.js";
-
-/** Pure: kubectl args to list Running pod names matching a label selector (one name per line). */
-export function buildPoolPodsArgs(selector: string, namespace: string, context?: string): string[] {
-  const args = ["get", "pod", "-n", namespace, "-l", selector, "--field-selector=status.phase=Running"];
-  if (context) args.push("--context", context);
-  args.push("-o", "jsonpath={range .items[*]}{.metadata.name}{'\\n'}{end}");
-  return args;
-}
-
-/** Pure: parse newline-separated pod names from kubectl stdout. */
-export function parsePodNames(stdout: string): string[] {
-  return stdout.split("\n").map((s) => s.trim()).filter(Boolean);
-}
-
-/** List Running pod names in the pool (all pods matching the shared pool label). */
-export async function listPoolPods(
-  selector: string,
-  namespace: string,
-  context?: string,
-  run: RunKubectl = defaultRunKubectl,
-): Promise<string[]> {
-  return parsePodNames(await run(buildPoolPodsArgs(selector, namespace, context)));
-}
-```
-
-Add to `packages/k8s-sandbox/src/index.ts`:
-
-```typescript
-export { buildPoolPodsArgs, parsePodNames, listPoolPods } from "./pool.js";
-export { defaultRunKubectl } from "./resolve-pod.js";
-```
-
-- [ ] **Step 5: Run tests + typecheck to verify they pass**
-
-Run: `cd packages/k8s-sandbox && pnpm exec vitest run test/pool.test.ts && pnpm exec tsc --noEmit`
-Expected: PASS (all pool tests green, no type errors).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add packages/k8s-sandbox/src/pool.ts packages/k8s-sandbox/test/pool.test.ts \
-        packages/k8s-sandbox/src/resolve-pod.ts packages/k8s-sandbox/src/index.ts
-git commit -s -m "feat: add pool pod discovery to k8s-sandbox" \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 2: Redis lease store (`harness`)
-
-**Files:**
-- Create: `harness/src/sandbox-lease.ts`
-- Create: `harness/test/sandbox-lease.test.ts`
-
-**Interfaces:**
-- Produces: `leaseKey(pod: string) => string`; `activeCount(members: {value: string; score: number}[], now: number) => number`; `ACQUIRE_LUA: string`; `interface LeaseStore { load(pod): Promise<number>; acquire(pod, cap, runId, ttlMs): Promise<boolean>; heartbeat(pod, runId, ttlMs): Promise<void>; release(pod, runId): Promise<void> }`; `class RedisLeaseStore implements LeaseStore` (ctor `(url?, now?)`, plus `close()`).
-- Note: the pure parts (`leaseKey`, `activeCount`) are unit-tested here; `RedisLeaseStore`'s Lua acquire is validated against live Redis in Task 7 (the repo runs Redis via docker for integration, never a Lua fake).
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/sandbox-lease.test.ts
-import { describe, it, expect } from "vitest";
-import { leaseKey, activeCount } from "../src/sandbox-lease.js";
-
-describe("leaseKey", () => {
-  it("namespaces per pod", () => {
-    expect(leaseKey("sandbox-1-0")).toBe("sh:sandbox:sandbox-1-0:leases");
-  });
-});
-
-describe("activeCount", () => {
-  const now = 1_000_000;
-  it("counts only members whose expiry is strictly in the future", () => {
-    const members = [
-      { value: "a", score: now - 1 },   // expired
-      { value: "b", score: now },       // expired (boundary: not > now)
-      { value: "c", score: now + 1 },   // active
-      { value: "d", score: now + 500 }, // active
-    ];
-    expect(activeCount(members, now)).toBe(2);
-  });
-  it("is 0 for an empty set", () => {
-    expect(activeCount([], now)).toBe(0);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd harness && pnpm exec vitest run test/sandbox-lease.test.ts`
-Expected: FAIL — `Cannot find module '../src/sandbox-lease.js'`.
-
-- [ ] **Step 3: Write the implementation**
-
-```typescript
-// harness/src/sandbox-lease.ts
-import { createClient, type RedisClientType } from "redis";
-
-/** Redis key holding the per-pod lease set (member = leaf id, score = expiry ms). */
-export function leaseKey(pod: string): string {
-  return `sh:sandbox:${pod}:leases`;
-}
-
-/** Pure: count members whose expiry (score, ms) is still in the future. */
-export function activeCount(members: { value: string; score: number }[], now: number): number {
-  return members.filter((m) => m.score > now).length;
-}
-
-/**
- * Atomic acquire. KEYS[1]=leaseKey. ARGV = [now, cap, runId, expiry].
- * Sweeps expired members, then adds {runId -> expiry} iff active < cap.
- * Returns 1 (acquired) or 0 (full). Crash reclaim is implicit: a dead leaf's
- * member ages past its expiry and is swept by the next acquire (spec §4.1).
- */
-export const ACQUIRE_LUA = `
-redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ARGV[1])
-if redis.call('ZCARD', KEYS[1]) < tonumber(ARGV[2]) then
-  redis.call('ZADD', KEYS[1], ARGV[4], ARGV[3])
-  return 1
-end
-return 0`;
-
-export interface LeaseStore {
-  /** Active (non-expired) lease count for a pod; sweeps expired as a side effect. */
-  load(pod: string): Promise<number>;
-  /** Try to take a lease under the soft cap. */
-  acquire(pod: string, cap: number, runId: string, ttlMs: number): Promise<boolean>;
-  /** Refresh a held lease's expiry (called on an interval while the leaf runs). */
-  heartbeat(pod: string, runId: string, ttlMs: number): Promise<void>;
-  /** Drop a held lease. */
-  release(pod: string, runId: string): Promise<void>;
-}
-
-/** Real node-redis-backed lease store. Connects lazily; reuses REDIS_URL. */
-export class RedisLeaseStore implements LeaseStore {
-  private client: RedisClientType;
-  private ready: Promise<void>;
-  constructor(url = process.env.REDIS_URL ?? "redis://127.0.0.1:6379", private now: () => number = Date.now) {
-    this.client = createClient({ url }) as RedisClientType;
-    this.ready = this.client.connect().then(() => undefined);
-  }
-  async load(pod: string): Promise<number> {
-    await this.ready;
-    await this.client.zRemRangeByScore(leaseKey(pod), "-inf", this.now());
-    return this.client.zCard(leaseKey(pod));
-  }
-  async acquire(pod: string, cap: number, runId: string, ttlMs: number): Promise<boolean> {
-    await this.ready;
-    const now = this.now();
-    const res = await this.client.eval(ACQUIRE_LUA, {
-      keys: [leaseKey(pod)],
-      arguments: [String(now), String(cap), runId, String(now + ttlMs)],
-    });
-    return res === 1;
-  }
-  async heartbeat(pod: string, runId: string, ttlMs: number): Promise<void> {
-    await this.ready;
-    await this.client.zAdd(leaseKey(pod), { score: this.now() + ttlMs, value: runId });
-  }
-  async release(pod: string, runId: string): Promise<void> {
-    await this.ready;
-    await this.client.zRem(leaseKey(pod), runId);
-  }
-  async close(): Promise<void> {
-    await this.ready;
-    await this.client.close();
-  }
-}
-```
-
-- [ ] **Step 4: Run tests + typecheck to verify they pass**
-
-Run: `cd harness && pnpm exec vitest run test/sandbox-lease.test.ts && pnpm exec tsc --noEmit`
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/sandbox-lease.ts harness/test/sandbox-lease.test.ts
-git commit -s -m "feat: add Redis sandbox lease store" \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 3: Pool selector (`harness`)
-
-**Files:**
-- Create: `harness/src/select-sandbox.ts`
-- Create: `harness/test/select-sandbox.test.ts`
-
-**Interfaces:**
-- Consumes: `listPoolPods`, `resolveSandboxConfig`, `type RunKubectl`, `type K8sSandboxConfig` from `@sh/k8s-sandbox`; `LeaseStore`, `RedisLeaseStore` from `./sandbox-lease.js`.
-- Produces:
-  - `orderByLoad(loads: {pod: string; active: number}[]) => string[]` (pure, ascending by load, stable).
-  - `class SandboxPoolSaturatedError extends Error`.
-  - `interface SelectedSandbox { config: K8sSandboxConfig; heartbeat(): Promise<void>; release(): Promise<void> }`.
-  - `selectPoolSandbox(env, headCwd, runId, opts: {cap, ttlMs}, deps?) => Promise<SelectedSandbox | null>` — `null` means *no sandbox configured* (run local tools); throws `SandboxPoolSaturatedError` when a pool is configured but every pod is at cap.
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/select-sandbox.test.ts
-import { describe, it, expect } from "vitest";
-import { orderByLoad, selectPoolSandbox, SandboxPoolSaturatedError } from "../src/select-sandbox.js";
-import type { LeaseStore } from "../src/sandbox-lease.js";
-
-describe("orderByLoad", () => {
-  it("sorts ascending by active load, stable on ties", () => {
-    expect(orderByLoad([
-      { pod: "c", active: 2 }, { pod: "a", active: 0 }, { pod: "b", active: 0 },
-    ])).toEqual(["a", "b", "c"]);
-  });
-});
-
-function fakeLease(loads: Record<string, number>, cap: number): LeaseStore & { acquired: string[] } {
-  const counts = { ...loads };
-  const acquired: string[] = [];
-  return {
-    acquired,
-    async load(pod) { return counts[pod] ?? 0; },
-    async acquire(pod, c, _runId) {
-      if ((counts[pod] ?? 0) < c) { counts[pod] = (counts[pod] ?? 0) + 1; acquired.push(pod); return true; }
-      return false;
-    },
-    async heartbeat() {},
-    async release() {},
-  };
-}
-
-describe("selectPoolSandbox", () => {
-  const opts = { cap: 2, ttlMs: 60000 };
-
-  it("returns null when no sandbox is configured at all", async () => {
-    const res = await selectPoolSandbox({} as NodeJS.ProcessEnv, "/head", "leaf-1", opts, {
-      listPods: async () => [],
-    });
-    expect(res).toBeNull();
-  });
-
-  it("falls back to single-pod resolution when no pool selector is set", async () => {
-    const env = { KAGENTI_SANDBOX_POD: "sandbox-x" } as unknown as NodeJS.ProcessEnv;
-    const res = await selectPoolSandbox(env, "/head", "leaf-1", opts, {});
-    expect(res?.config.pod).toBe("sandbox-x");
-  });
-
-  it("picks the least-loaded pod and acquires a lease", async () => {
-    const env = { KAGENTI_SANDBOX_POOL_SELECTOR: "app=sandbox" } as unknown as NodeJS.ProcessEnv;
-    const lease = fakeLease({ "sandbox-0-0": 2, "sandbox-1-0": 0 }, opts.cap);
-    const res = await selectPoolSandbox(env, "/head", "leaf-1", opts, {
-      listPods: async () => ["sandbox-0-0", "sandbox-1-0"],
-      lease,
-    });
-    expect(res?.config.pod).toBe("sandbox-1-0");
-    expect(lease.acquired).toEqual(["sandbox-1-0"]);
-  });
-
-  it("throws SandboxPoolSaturatedError when every pod is at cap", async () => {
-    const env = { KAGENTI_SANDBOX_POOL_SELECTOR: "app=sandbox" } as unknown as NodeJS.ProcessEnv;
-    const lease = fakeLease({ "sandbox-0-0": 2, "sandbox-1-0": 2 }, opts.cap);
-    await expect(selectPoolSandbox(env, "/head", "leaf-1", opts, {
-      listPods: async () => ["sandbox-0-0", "sandbox-1-0"],
-      lease,
-    })).rejects.toBeInstanceOf(SandboxPoolSaturatedError);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd harness && pnpm exec vitest run test/select-sandbox.test.ts`
-Expected: FAIL — `Cannot find module '../src/select-sandbox.js'`.
-
-- [ ] **Step 3: Write the implementation**
-
-```typescript
-// harness/src/select-sandbox.ts
-import { listPoolPods, resolveSandboxConfig, type RunKubectl, type K8sSandboxConfig } from "@sh/k8s-sandbox";
-import { RedisLeaseStore, type LeaseStore } from "./sandbox-lease.js";
-
-/** Pure: pods ordered ascending by active load (stable — ties keep input order). */
-export function orderByLoad(loads: { pod: string; active: number }[]): string[] {
-  return loads
-    .map((l, i) => ({ ...l, i }))
-    .sort((a, b) => a.active - b.active || a.i - b.i)
-    .map((l) => l.pod);
-}
-
-/** Thrown when a pool is configured but every pod is at the soft cap. */
-export class SandboxPoolSaturatedError extends Error {
-  constructor(selector: string) {
-    super(`sandbox pool '${selector}' saturated: all pods at capacity`);
-    this.name = "SandboxPoolSaturatedError";
-  }
-}
-
-export interface SelectedSandbox {
-  config: K8sSandboxConfig;
-  heartbeat: () => Promise<void>;
-  release: () => Promise<void>;
-}
-
-export interface SelectDeps {
-  listPods?: (selector: string, namespace: string, context?: string, run?: RunKubectl) => Promise<string[]>;
-  lease?: LeaseStore;
-  run?: RunKubectl;
-}
-
-/**
- * Choose a sandbox pod for a leaf.
- *  - No `KAGENTI_SANDBOX_POOL_SELECTOR` ⇒ fall back to single-pod resolution
- *    (`KAGENTI_SANDBOX_POD`/`_NAME`); returns null if that too is unset (run local tools).
- *  - Pool configured ⇒ list Running pods, pick least-loaded under the soft cap, acquire a lease.
- *    Throws SandboxPoolSaturatedError if all pods are full.
- */
-export async function selectPoolSandbox(
-  env: NodeJS.ProcessEnv,
-  headCwd: string,
-  runId: string,
-  opts: { cap: number; ttlMs: number },
-  deps: SelectDeps = {},
-): Promise<SelectedSandbox | null> {
-  const selector = env.KAGENTI_SANDBOX_POOL_SELECTOR;
-  if (!selector) {
-    const config = await resolveSandboxConfig(env, headCwd, deps.run);
-    return config ? { config, heartbeat: async () => {}, release: async () => {} } : null;
-  }
-
-  const namespace = env.KAGENTI_SANDBOX_NAMESPACE ?? "default";
-  const context = env.KAGENTI_SANDBOX_CONTEXT || undefined;
-  const podCwd = env.KAGENTI_SANDBOX_CWD ?? "/workspace";
-  const list = deps.listPods ?? listPoolPods;
-  const lease = deps.lease ?? new RedisLeaseStore(env.REDIS_URL);
-
-  const pods = await list(selector, namespace, context, deps.run);
-  if (pods.length === 0) throw new Error(`no Running pods for pool selector '${selector}'`);
-
-  const loads = await Promise.all(pods.map(async (pod) => ({ pod, active: await lease.load(pod) })));
-  for (const pod of orderByLoad(loads)) {
-    if (await lease.acquire(pod, opts.cap, runId, opts.ttlMs)) {
-      const config: K8sSandboxConfig = { pod, namespace, context, podCwd, headCwd };
-      return {
-        config,
-        heartbeat: () => lease.heartbeat(pod, runId, opts.ttlMs),
-        release: () => lease.release(pod, runId),
-      };
-    }
-  }
-  throw new SandboxPoolSaturatedError(selector);
-}
-```
-
-- [ ] **Step 4: Run tests + typecheck to verify they pass**
-
-Run: `cd harness && pnpm exec vitest run test/select-sandbox.test.ts && pnpm exec tsc --noEmit`
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/select-sandbox.ts harness/test/select-sandbox.test.ts
-git commit -s -m "feat: add least-loaded sandbox pool selector" \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 4: Repo converge + worktree (`harness`)
-
-**Files:**
-- Create: `harness/src/converge.ts`
-- Create: `harness/test/converge.test.ts`
-
-**Interfaces:**
-- Consumes: `type ExecInPod` from `@sh/k8s-sandbox` (`(command, opts?) => Promise<{stdout: Buffer; exitCode: number | null}>`).
-- Produces:
-  - `leafWorkspaceRef(runId: string) => string` → `/workspace/leaves/<runId>`.
-  - `buildConvergeScript(repoUrl, ref, runId) => string` (pure shell; single-quote-escapes inputs).
-  - `buildCleanupScript(runId) => string` (pure).
-  - `convergeWorkspace(exec: ExecInPod, repoUrl, ref, runId) => Promise<string>` (returns the workspace ref; throws on non-zero exit).
-  - `cleanupWorkspace(exec: ExecInPod, runId) => Promise<void>` (best-effort; never throws).
-
-- [ ] **Step 1: Write the failing test**
-
-```typescript
-// harness/test/converge.test.ts
-import { describe, it, expect } from "vitest";
-import {
-  leafWorkspaceRef, buildConvergeScript, buildCleanupScript, convergeWorkspace,
-} from "../src/converge.js";
-
-describe("leafWorkspaceRef", () => {
-  it("is /workspace/leaves/<runId>", () => {
-    expect(leafWorkspaceRef("run-a-item-1")).toBe("/workspace/leaves/run-a-item-1");
-  });
-});
-
-describe("buildConvergeScript", () => {
-  const s = buildConvergeScript("https://git.example/r.git", "abc123", "leaf-1");
-  it("clones only when absent (idempotent) and fetches the ref under a flock", () => {
-    expect(s).toContain('[ -d "$REPO/.git" ] || git clone');
-    expect(s).toContain("flock 9");
-    expect(s).toContain("fetch --quiet origin");
-  });
-  it("adds a per-leaf worktree at the fetched commit and prints the path", () => {
-    expect(s).toContain("worktree add");
-    expect(s).toContain("/workspace/leaves/leaf-1");
-    expect(s).toContain('printf');
-  });
-  it("single-quote-escapes inputs to resist injection", () => {
-    const evil = buildConvergeScript("https://x/r.git'; rm -rf /; '", "main", "leaf-1");
-    expect(evil).toContain(`'https://x/r.git'\\''; rm -rf /; '\\'''`);
-  });
-});
-
-describe("convergeWorkspace", () => {
-  it("returns trimmed stdout as the workspace ref on success", async () => {
-    const exec = async () => ({ stdout: Buffer.from("/workspace/leaves/leaf-1\n"), exitCode: 0 });
-    expect(await convergeWorkspace(exec, "u", "r", "leaf-1")).toBe("/workspace/leaves/leaf-1");
-  });
-  it("throws on non-zero exit", async () => {
-    const exec = async () => ({ stdout: Buffer.from(""), exitCode: 1 });
-    await expect(convergeWorkspace(exec, "u", "r", "leaf-1")).rejects.toThrow(/converge failed/);
-  });
-});
-
-describe("buildCleanupScript", () => {
-  it("removes the leaf worktree and prunes", () => {
-    const c = buildCleanupScript("leaf-1");
-    expect(c).toContain("worktree remove");
-    expect(c).toContain("/workspace/leaves/leaf-1");
-    expect(c).toContain("worktree prune");
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd harness && pnpm exec vitest run test/converge.test.ts`
-Expected: FAIL — `Cannot find module '../src/converge.js'`.
-
-- [ ] **Step 3: Write the implementation**
-
-```typescript
-// harness/src/converge.ts
-import type { ExecInPod } from "@sh/k8s-sandbox";
-
-/** Single-quote-escape a string for safe interpolation into a bash command. */
-function sq(s: string): string {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-
-/** The per-leaf worktree path inside the sandbox pod. */
-export function leafWorkspaceRef(runId: string): string {
-  return `/workspace/leaves/${runId}`;
-}
-
-/**
- * Ref-pinned lazy converge (spec §5): clone /workspace/repo once, fetch the target ref under a
- * per-pod flock (serializes concurrent converges), then add a per-leaf detached worktree at the
- * fetched commit. Idempotent — a pod already holding the ref and worktree is a no-op. Prints the
- * worktree path on stdout.
- */
-export function buildConvergeScript(repoUrl: string, ref: string, runId: string): string {
-  const LEAF = leafWorkspaceRef(runId);
-  return [
-    `set -eu`,
-    `REPO=/workspace/repo; LOCK=/workspace/.sh-fetch.lock; LEAF=${sq(LEAF)}`,
-    `mkdir -p /workspace/leaves`,
-    `[ -d "$REPO/.git" ] || git clone --quiet ${sq(repoUrl)} "$REPO"`,
-    `( flock 9; git -C "$REPO" fetch --quiet origin ${sq(ref)} ) 9>"$LOCK"`,
-    `COMMIT=$(git -C "$REPO" rev-parse FETCH_HEAD)`,
-    `[ -d "$LEAF" ] || git -C "$REPO" worktree add --quiet --detach "$LEAF" "$COMMIT"`,
-    `printf '%s' "$LEAF"`,
-  ].join("\n");
-}
-
-/** Remove the per-leaf worktree and prune orphans (best-effort; never fails the leaf). */
-export function buildCleanupScript(runId: string): string {
-  const LEAF = leafWorkspaceRef(runId);
-  return [
-    `set -u`,
-    `REPO=/workspace/repo; LEAF=${sq(LEAF)}`,
-    `git -C "$REPO" worktree remove --force "$LEAF" 2>/dev/null || rm -rf "$LEAF"`,
-    `git -C "$REPO" worktree prune 2>/dev/null || true`,
-  ].join("\n");
-}
-
-/** Run the converge script in the pod; return the worktree ref. Throws on non-zero exit. */
-export async function convergeWorkspace(
-  exec: ExecInPod, repoUrl: string, ref: string, runId: string,
-): Promise<string> {
-  const { stdout, exitCode } = await exec(buildConvergeScript(repoUrl, ref, runId), { timeout: 300 });
-  if (exitCode !== 0) throw new Error(`converge failed (exit ${exitCode})`);
-  return stdout.toString().trim() || leafWorkspaceRef(runId);
-}
-
-/** Best-effort worktree cleanup; swallows errors so it never masks a verdict. */
-export async function cleanupWorkspace(exec: ExecInPod, runId: string): Promise<void> {
-  try { await exec(buildCleanupScript(runId), { timeout: 60 }); } catch { /* ignore */ }
-}
-```
-
-- [ ] **Step 4: Run tests + typecheck to verify they pass**
-
-Run: `cd harness && pnpm exec vitest run test/converge.test.ts && pnpm exec tsc --noEmit`
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add harness/src/converge.ts harness/test/converge.test.ts
-git commit -s -m "feat: add ref-pinned converge and per-leaf worktree helpers" \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 5: Wire pool selection into the leaf runner (`harness`)
-
-**Files:**
-- Modify: `harness/src/run-leaf.ts` (add `repoUrl`/`ref` to `LeafEnvelope`; replace sandbox resolution in `realProduceVerdict`)
-- Modify: `harness/test/run-leaf.test.ts` (add an envelope-shape test; existing tests must still pass)
-
-**Interfaces:**
-- Consumes: `selectPoolSandbox` from `./select-sandbox.js`; `convergeWorkspace`, `cleanupWorkspace` from `./converge.js`; `kubectlExecInPod` from `@sh/k8s-sandbox`.
-- Produces: `LeafEnvelope` gains optional `repoUrl?: string; ref?: string`. `realProduceVerdict` now selects a pool pod (or falls back / runs local), converges when `repoUrl`+`ref` are present, heartbeats during the run, and releases + cleans up in `finally`.
-
-- [ ] **Step 1: Write the failing test**
-
-Add to `harness/test/run-leaf.test.ts`:
-
-```typescript
-import { describe, it, expect } from "vitest";
-import type { LeafEnvelope } from "../src/run-leaf.js";
-
-describe("LeafEnvelope repo ref fields", () => {
-  it("accepts optional repoUrl and ref", () => {
-    const env: LeafEnvelope = {
-      sessionId: "run-a/item-1",
-      item: { item_id: "item-1", file: "a.ts", pattern: "x" },
-      repoUrl: "https://git.example/r.git",
-      ref: "abc123",
-    };
-    expect(env.repoUrl).toBe("https://git.example/r.git");
-    expect(env.ref).toBe("abc123");
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd harness && pnpm exec vitest run test/run-leaf.test.ts -t "repo ref fields"`
-Expected: FAIL — TypeScript error: `repoUrl`/`ref` not assignable (property does not exist on `LeafEnvelope`). (Vitest reports the type/compile failure.)
-
-- [ ] **Step 3: Add the envelope fields**
-
-In `harness/src/run-leaf.ts`, extend `LeafEnvelope` (after the `workspaceRef` line):
-
-```typescript
-export interface LeafEnvelope {
-  sessionId: string;
-  item: LeafItem;
-  decision?: Decision;
-  model?: string;
-  provider?: string;
-  workspaceRef?: string;      // derived from the worktree in P2 when repoUrl+ref are given
-  repoUrl?: string;           // P2: git remote to converge the sandbox repo copy from
-  ref?: string;               // P2: commit/branch/tag the leaf's worktree is pinned to
-  maxTurns?: number;
-  async?: boolean;
-  tenant?: string;
-}
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `cd harness && pnpm exec vitest run test/run-leaf.test.ts -t "repo ref fields"`
-Expected: PASS.
-
-- [ ] **Step 5: Replace sandbox resolution in `realProduceVerdict`**
-
-Add imports at the top of `harness/src/run-leaf.ts`:
-
-```typescript
-import { kubectlExecInPod } from "@sh/k8s-sandbox";
-import { selectPoolSandbox } from "./select-sandbox.js";
-import { convergeWorkspace, cleanupWorkspace } from "./converge.js";
-```
-
-Replace the region **from the gate front-end down to the end of the function** (currently starting at the `// Gate front-end (design §3):` comment, ~line 197, through the closing of `realProduceVerdict`) with the following. This selects the pool pod *after* the verdict fast-path (so a recovered verdict never leases a pod), converges when a repo ref is supplied, derives `workspaceRef`, heartbeats during the run, and releases + cleans up in `finally`:
-
-```typescript
-  // --- P2: choose a sandbox pod (pool lease) before building the prompt/session. Placed after the
-  // verdict fast-path so a recovered verdict does not lease a pod. Returns null ⇒ no sandbox
-  // configured (local tools). Throws SandboxPoolSaturatedError when a configured pool is full.
-  const selected = await selectPoolSandbox(process.env, cwd, sid, {
-    cap: Number(process.env.KAGENTI_SANDBOX_CAP ?? "20"),
-    ttlMs: Number(process.env.KAGENTI_SANDBOX_LEASE_TTL_MS ?? "60000"),
-  });
-  const converging = selected != null && !!env.repoUrl && !!env.ref;
-  let heartbeat: ReturnType<typeof setInterval> | undefined;
-
-  try {
-    // Ref-pinned lazy converge (spec §5): fetch the ref into the shared object store and add this
-    // leaf's worktree; workspaceRef becomes the derived worktree path. All FS work happens in the
-    // pod via exec — the harness opens nothing.
-    let workspaceRef = env.workspaceRef;
-    if (converging) {
-      const exec = kubectlExecInPod(selected!.config);
-      workspaceRef = await convergeWorkspace(exec, env.repoUrl!, env.ref!, sid);
-      const hbMs = Number(process.env.KAGENTI_SANDBOX_HEARTBEAT_MS ?? "20000");
-      heartbeat = setInterval(() => { void selected!.heartbeat(); }, hbMs);
-    }
-
-    // Gate front-end (design §3): decide whether to pause, abort, or seed a prompt.
-    const gateState = computeGateState(prior.map((p) => p.entry));
-    const dv = env.decision ? validateDecision(env.decision) : null;
-    const decision = dv && dv.ok ? dv.value : null;
-    const seed = decideSeed(gateState, decision, buildLeafPrompt(item, workspaceRef));
-
-    if (seed.kind === "abort") {
-      if (seed.record) sessionManager.appendCustomEntry(GATE_DECISION_ENTRY_TYPE, seed.record);
-      capture.aborted = true;
-      await backend.flush();
-      return;
-    }
-    if (seed.kind === "paused") {
-      capture.gate = seed.gate;
-      await backend.flush();
-      return;
-    }
-    if (seed.record) sessionManager.appendCustomEntry(GATE_DECISION_ENTRY_TYPE, seed.record);
-
-    const allowVerdict =
-      !item.require_approval || gateState.gateDecisions.length > 0 || seed.record != null;
-
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    const resourceLoader = new DefaultResourceLoader({
-      cwd,
-      agentDir,
-      settingsManager,
-      extensionFactories: [
-        ...(allowVerdict ? [submitVerdictExtension(capture, sessionManager)] : []),
-        requestApprovalExtension(capture, sessionManager, gateState.nextGateId),
-        k8sSandboxExtension({ config: selected?.config ?? null }),
-        flushExtension(backend),
-        checkpointExtension(store, sessionManager),
-      ],
-    });
-    await resourceLoader.reload();
-
-    const { session } = await createAgentSession({
-      sessionManager,
-      model: model as never,
-      resourceLoader,
-      settingsManager,
-    });
-
-    try {
-      await session.prompt(seed.prompt);
-      if (!capture.verdict && !capture.gate) {
-        const row = await store.latestWhere(sid, isVerdictEntry);
-        const recovered = verdictFromCustomEntry(row?.entry);
-        if (recovered) capture.verdict = recovered;
-      }
-    } finally {
-      await backend.flush();
-    }
-  } finally {
-    if (heartbeat) clearInterval(heartbeat);
-    if (converging) await cleanupWorkspace(kubectlExecInPod(selected!.config), sid);
-    if (selected) await selected.release();
-  }
-```
-
-Note: the old lines that resolved `sandboxConfig` via `resolveSandboxConfig(process.env, cwd)` and passed `{ config: sandboxConfig }` to `k8sSandboxExtension` are removed — pool selection replaces them, and single-pod behavior is preserved by `selectPoolSandbox`'s fallback branch.
-
-- [ ] **Step 6: Run the full harness suite + typecheck**
-
-Run: `cd harness && pnpm exec vitest run && pnpm exec tsc --noEmit`
-Expected: PASS — all existing run-leaf tests still green (single-pod fallback unchanged), plus the new envelope test.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add harness/src/run-leaf.ts harness/test/run-leaf.test.ts
-git commit -s -m "feat: route leaves to a sandbox pool with lease and converge" \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 6: Deploy the sandbox pool (`deploy/knative`)
-
-**Files:**
-- Create: `deploy/knative/sandbox-pool.yaml` (N `Sandbox` CRs with the shared pool label)
-- Modify: `deploy/knative/service.yaml` (env: pool selector)
-- Modify: `deploy/knative/kustomization.yaml` and `deploy/knative/overlays/ocp/kustomization.yaml` (swap `sandbox.yaml` → `sandbox-pool.yaml`)
-
-**Interfaces:**
-- Produces: a pool of Running pods labeled `sh.kagenti.io/sandbox-pool=default`; the harness Service configured with `KAGENTI_SANDBOX_POOL_SELECTOR=sh.kagenti.io/sandbox-pool=default`. N=3 for the PoC (edit this file to scale — spec D4).
-
-- [ ] **Step 1: Author the pool manifest**
-
-Create `deploy/knative/sandbox-pool.yaml` — three CRs identical to the P1 `sandbox.yaml` body except for the name and the added common pod label. (Shown for `sandbox-0`; repeat verbatim for `sandbox-1` and `sandbox-2`, changing only `metadata.name`.)
-
-```yaml
-apiVersion: agents.x-k8s.io/v1beta1
-kind: Sandbox
-metadata:
-  name: sandbox-0
-  namespace: default
-  labels:
-    app: sandbox
-spec:
-  volumeClaimTemplates:
-    - metadata:
-        name: workspace
-      spec:
-        accessModes: ["ReadWriteOnce"]
-        resources:
-          requests:
-            storage: 1Gi
-  podTemplate:
-    metadata:
-      labels:
-        sh.kagenti.io/sandbox-pool: default    # <-- pool discovery label (harness selects on this)
-    spec:
-      containers:
-        - name: sandbox
-          image: alpine:3.20
-          command: ["/bin/sh", "-c", "apk add --no-cache bash coreutils findutils grep ripgrep git && mkdir -p /workspace && exec sleep infinity"]
-          workingDir: /workspace
-          volumeMounts:
-            - name: workspace
-              mountPath: /workspace
-          resources:
-            requests:
-              memory: "64Mi"
-              cpu: "50m"
-            limits:
-              memory: "256Mi"
----
-# ... sandbox-1 (metadata.name: sandbox-1) ...
----
-# ... sandbox-2 (metadata.name: sandbox-2) ...
-```
-
-Note the `command` adds `git` to the `apk add` list (converge needs it). The OCP overlay (`overlays/ocp/patch-sandbox.yaml`) already swaps to the prebaked GHCR image running as UID 65532 — extend that patch to target all three CR names (`sandbox-0..2`); the GHCR sandbox image must include `git`.
-
-- [ ] **Step 2: Set the pool selector env on the harness Service**
-
-In `deploy/knative/service.yaml`, replace the `KAGENTI_SANDBOX_NAME` env entry with the pool selector, and keep `KAGENTI_SANDBOX_POD` documented as a single-pod override (commented out):
-
-```yaml
-            - name: KAGENTI_SANDBOX_POOL_SELECTOR
-              value: "sh.kagenti.io/sandbox-pool=default"
-            # - name: KAGENTI_SANDBOX_POD      # single-pod test override (bypasses pool selection)
-            #   value: "sandbox-0-0"
-```
-
-- [ ] **Step 3: Reference the pool manifest in kustomize**
-
-In `deploy/knative/kustomization.yaml`, replace `- sandbox.yaml` with `- sandbox-pool.yaml` under `resources:`. Do the same in `deploy/knative/overlays/ocp/kustomization.yaml` if it lists the sandbox resource, and point the OCP sandbox patch at `sandbox-0..2`.
-
-- [ ] **Step 4: Validate the kustomize renders**
-
-Run (redirect per Context Budget rules — do not inline the render):
-```bash
-mkdir -p /tmp/sh
-kubectl kustomize deploy/knative > /tmp/sh/render-base.log 2>&1; echo "EXIT:$?"
-kubectl kustomize deploy/knative/overlays/ocp > /tmp/sh/render-ocp.log 2>&1; echo "EXIT:$?"
-```
-Expected: both `EXIT:0`. Spot-check with a subagent (not an inline read): "grep `/tmp/sh/render-base.log` for `kind: Sandbox` — expect 3 CRs named sandbox-0..2, each with `sh.kagenti.io/sandbox-pool: default` in the podTemplate labels; and confirm the Service has `KAGENTI_SANDBOX_POOL_SELECTOR`."
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add deploy/knative/sandbox-pool.yaml deploy/knative/service.yaml \
-        deploy/knative/kustomization.yaml deploy/knative/overlays/ocp/
-git commit -s -m "feat: provision a static N-pod sandbox pool" \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-### Task 7: Integration + gated live smoke
-
-**Files:**
-- Create: `harness/test/pool-live-smoke.test.ts` (gated by `POOL_LIVE_SMOKE=1`)
-
-**Interfaces:**
-- Consumes: `RedisLeaseStore`, `ACQUIRE_LUA` from `../src/sandbox-lease.js`.
-- Produces: a gated test proving the real Lua acquire enforces the cap and reclaims expired leases against live Redis, plus a documented cluster smoke procedure.
-
-- [ ] **Step 1: Write the gated live-redis lease test**
-
-```typescript
-// harness/test/pool-live-smoke.test.ts
-import { describe, it, expect } from "vitest";
-import { RedisLeaseStore, leaseKey } from "../src/sandbox-lease.js";
-
-// Gate: only runs with a live Redis (docker) and POOL_LIVE_SMOKE=1.
-const live = process.env.POOL_LIVE_SMOKE === "1";
-const url = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-
-describe.skipIf(!live)("RedisLeaseStore (live redis)", () => {
-  it("enforces the soft cap and reclaims expired leases", async () => {
-    const pod = `smoke-${process.pid}`;
-    // Controllable clock so we can expire a lease deterministically.
-    let now = 1_000_000;
-    const store = new RedisLeaseStore(url, () => now);
-    try {
-      // Fresh key.
-      // @ts-expect-error reach the raw client for test cleanup only
-      await store["client"].del(leaseKey(pod));
-
-      expect(await store.acquire(pod, 2, "a", 1000)).toBe(true);
-      expect(await store.acquire(pod, 2, "b", 1000)).toBe(true);
-      expect(await store.acquire(pod, 2, "c", 1000)).toBe(false); // at cap
-      expect(await store.load(pod)).toBe(2);
-
-      now += 2000; // both leases expire
-      expect(await store.acquire(pod, 2, "c", 1000)).toBe(true); // reclaimed slot
-      expect(await store.load(pod)).toBe(1);
-    } finally {
-      await store.release(pod, "c");
-      await store.close();
-    }
-  });
-});
-```
-
-- [ ] **Step 2: Run it gated (docker Redis), then confirm it skips without the gate**
-
-```bash
-docker run -d --rm -p 6379:6379 --name sh-redis-smoke redis:7 > /tmp/sh/redis.log 2>&1; echo "EXIT:$?"
-cd harness && POOL_LIVE_SMOKE=1 pnpm exec vitest run test/pool-live-smoke.test.ts 2>&1 | tail -20
-# and unset gate → the suite is skipped:
-pnpm exec vitest run test/pool-live-smoke.test.ts 2>&1 | tail -5
-docker stop sh-redis-smoke > /dev/null 2>&1; echo "EXIT:$?"
-```
-Expected: gated run PASS (cap enforced, reclaim works); ungated run reports the suite skipped.
-
-- [ ] **Step 3: Cluster smoke on Kind (N=2), analyzed via subagent**
-
-Bring up the pool on the existing Kind cluster and dispatch concurrent leaves, redirecting output per Context Budget rules:
-
-```bash
-kubectl apply -k deploy/knative > /tmp/sh/pool-apply.log 2>&1; echo "EXIT:$?"
-kubectl -n default get pods -l sh.kagenti.io/sandbox-pool=default \
-  > /tmp/sh/pool-pods.log 2>&1; echo "EXIT:$?"
-# Dispatch 4 leaves concurrently at the SAME ref via the leaf-orchestrator/dispatch path
-# (see the async-leaf smoke for the dispatch invocation), tee to /tmp/sh/pool-dispatch.log.
-```
-Then dispatch a subagent (Context Budget Rule 2) to analyze the logs and Redis:
-> "Read `/tmp/sh/pool-pods.log`: expect ≥2 Running pods labeled `sh.kagenti.io/sandbox-pool=default`. From `/tmp/sh/pool-dispatch.log` confirm all 4 leaves returned a verdict. Then `kubectl exec` into each pool pod and `ls /workspace/leaves` — report which leaf worktrees landed on which pod (expect them spread across ≥2 pods, not all on one). Report PASS/FAIL and any error lines."
-
-Expected: leaves spread across pods; all return verdicts; each leaf's worktree exists under `/workspace/leaves/` on exactly one pod.
-
-- [ ] **Step 4: Cluster smoke — mixed-ref consistency + crash reclaim (subagent-analyzed)**
-
-> Dispatch two leaves at DIFFERENT commits that land on the same pod; via `kubectl exec`, confirm each worktree's `git rev-parse HEAD` matches its own envelope ref (proves the shared object store + per-worktree pinning). Then delete one pool pod mid-run (`kubectl delete pod <p>`); confirm the in-flight leaf resumes (existing Redis resume) and re-acquires on a surviving pod, and that its lease on the deleted pod is gone after TTL (`ZCARD sh:sandbox:<deleted>:leases` → 0). Report PASS/FAIL with the observed commits and lease counts.
-
-- [ ] **Step 5: Gated OCP live smoke (per-sandbox RWO, `SH_MODEL=claude-haiku-4-5`)**
-
-Using `KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig`, apply the OCP overlay and run the same dispatch through the Route (reuse the P0′ leaf-smoke `$CURL_OPTS`/`-k` TLS handling). Redirect to `/tmp/sh/ocp-pool-smoke.log`; analyze via subagent. Expected: N:M fan-out completes with correct verdicts on OCP 4.20.8; each sandbox pod holds its own RWO PVC repo copy (no RWX).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add harness/test/pool-live-smoke.test.ts
-git commit -s -m "test: add gated sandbox-pool live smoke" \
-  -m "Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Self-Review
-
-**1. Spec coverage** (against `2026-07-02-p2-shared-sandbox-pool-design.md`):
-- §3 Pool topology (N `Sandbox` CRs, own RWO PVC, common label) → Task 6. ✅
-- §4 Routing (K8s discovery + Redis load), §4.1 expiry-scored leases + implicit reclaim, §4.2 atomic Lua acquire/release, §4.3 saturation → Tasks 1 (discovery), 2 (lease/Lua), 3 (selector + `SandboxPoolSaturatedError`). ✅
-- §5 Repo lifecycle (shared object store, per-leaf worktree, flock, cleanup/prune) → Task 4. ✅
-- §6 FS-free contract + leaf-flow sequence (select → converge → run → cleanup → release, heartbeat during run) → Task 5. ✅
-- §7 Envelope `repoUrl`/`ref`, derived `workspaceRef` → Task 5. ✅
-- §8 Deploy (`KAGENTI_SANDBOX_POOL_SELECTOR`, keep `KAGENTI_SANDBOX_POD` override, OCP overlay) → Task 6. ✅
-- §9 Isolation is an explicit non-goal → no task (correct); soft cap honored (Task 2/3). ✅
-- §10 Failure modes (crash reclaim, pod removed, saturation, fetch failure) → Tasks 2/3/4 + Task 7 crash-reclaim smoke. ✅
-- §11 Testing (unit lease/ordering/converge; integration Kind N=2–3 mixed-ref + crash; gated OCP smoke) → Tasks 1–4 units + Task 7. ✅
-
-**2. Placeholder scan:** No `TBD`/`TODO`/"handle errors"/"similar to Task N". Every code step shows complete code; the one repeated YAML block (sandbox-1/2) is explicitly "repeat verbatim, change only `metadata.name`". ✅
-
-**3. Type consistency:** `RunKubectl`, `K8sSandboxConfig`, `ExecInPod`, `LeaseStore`, `SelectedSandbox`, `leafWorkspaceRef`, `selectPoolSandbox`, `convergeWorkspace`/`cleanupWorkspace`, `leafSessionId`(=`sid`) names match across Tasks 1–5. `activeCount`/`ACQUIRE_LUA` (Task 2) are consistent between the pure test and the class. `orderByLoad` used identically in Task 3 test and impl. ✅
-
-No gaps found.
-
----
-
-## Notes carried from spec (do not re-decide)
-
-- Eager pod pre-warm, Kata isolation, the ~20:1 ratio, autoscaling, and RWX/fleet-wide-single-repo are **P3/future** — out of scope here (spec §13).
-- `git fetch origin <ref>` assumes the ref is fetchable (branch/tag, or a SHA the server allows); the PoC controls the target repo. Fetch-by-arbitrary-SHA hardening is a documented future refinement, not part of P2.
diff --git a/docs/superpowers/plans/2026-07-03-e6-workload-parameterization.md b/docs/superpowers/plans/2026-07-03-e6-workload-parameterization.md
deleted file mode 100644
index 2a31aa2..0000000
--- a/docs/superpowers/plans/2026-07-03-e6-workload-parameterization.md
+++ /dev/null
@@ -1,623 +0,0 @@
-# E6 Workload-Parameterized Sandbox-Load — Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Replace E6's trivial marker-check leaf with real Archetype-A code-review variants (L0/L1/L2), report the harness→sandbox sharing ratio N as a *curve over per-leaf sandbox work* (measured at C=1), and make the concurrency knee noise-robust by removing the harness `max-scale` confound, warming, multi-sampling, and using a sustained-decline `detectKnee`.
-
-**Architecture:** Pure analysis in `experiments/src/sharing.ts` (unit-tested): a new `buildRatioCurve` and a `patience`-based `detectKnee`. The git-daemon serves a new `work` ref carrying three code fixtures of increasing size. The E6 bash driver runs two phases against a pinned sandbox — Phase 1 measures per-leaf duty at C=1 on a warm pod (exec-timing delta per leaf, median of N samples) across L0/L1/L2 → the N curve; Phase 2 sweeps concurrency at the heaviest variant with the harness un-capped (`max-scale` raised) → the knee as a floor. No harness/leaf code changes.
-
-**Tech Stack:** TypeScript (ESM, vitest 2.x) for `@sh/experiments`; bash + `kubectl` + `jq` + `awk` drivers reusing `deploy/knative/lib.sh`; Knative Serving; `git daemon`; Redis.
-
-## Global Constraints
-
-- **DCO sign-off on every commit** (`git commit -s`); trailer `Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>` — **never** `Co-authored-by`.
-- **Never `git add -A`** — stage explicit paths only (`experiments/RESULTS.md` and `.worktrees/` are intentionally dirty; `.superpowers/` is git-ignored).
-- **Branch:** `feat/e6-workload-parameterization` (already created off main; spec + README already committed there at `b53dfdd`).
-- **`gh pr merge` is denied to this agent** — the user merges PRs.
-- **Off-by-default / gated:** the E6 driver no-ops (`SKIP`, exit 0, no cluster contact) unless `E6_LIVE=1`; exec timing stays behind `KAGENTI_EXEC_TIMING=1`.
-- **FS-free / contract untouched:** no changes to `harness/` or `packages/` — intensity is emergent + measured, not injected (spec D5).
-- **Model:** `SH_MODEL=claude-haiku-4-5` for live runs. **Cluster order:** Kind `sh-knative` (dev) → live OCP 4.20 (`KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig`, standing P3 stack).
-- **tsx import path** from a driver (CWD `deploy/knative/`) is `../../experiments/src/sharing.ts`.
-- **Context budget:** redirect long output to `/tmp/sh/*.log`; analyze via subagents.
-- **Exact converge paths:** shared repo `/workspace/repo`, per-pod lock `/workspace/.sh-fetch.lock`, per-leaf worktree `/workspace/leaves/<runId>`; `/runs` body is a `LeafEnvelope` (`sessionId`, `item:{item_id,file,pattern}`, `repoUrl`, `ref`, `model`); converge activates only when `repoUrl`+`ref` are both set.
-
-## File Structure
-
-- `experiments/src/sharing.ts` — **modify**: add `WorkloadPoint`/`RatioCurvePoint` + `buildRatioCurve`; change `detectKnee` signature to add `patience` + sustained-decline logic. (Preserve existing `LadderPoint`, `dutyCycle`, `derivedRatio`, `sanityFloorPass`, `worktreeConsistent`.)
-- `experiments/test/e6-saturation-structural.test.ts` — **modify**: update `detectKnee` tests to sustained-decline semantics; add `buildRatioCurve` tests.
-- `deploy/knative/gitd.yaml` — **modify**: after the marker branches, seed a `work` ref with `small.py`/`medium.py`/`large.py`.
-- `deploy/knative/lib.sh` — **modify**: add `count_exec_lines`, `median`, `set_scale`; extend `restore_ksvc_env` to reset scale annotations.
-- `deploy/knative/e6-saturation.sh` — **rewrite**: Phase 1 (N-vs-workload curve) + Phase 2 (concurrency sweep at L2, un-capped).
-- `deploy/knative/EXPERIMENTS.md` — **modify**: P3 section headline → N-vs-workload curve; supersede the single-N (L0 upper-bound) note.
-
----
-
-## Task 1: `buildRatioCurve` + types (sharing.ts)
-
-**Files:**
-- Modify: `experiments/src/sharing.ts`
-- Test: `experiments/test/e6-saturation-structural.test.ts`
-
-**Interfaces:**
-- Consumes: existing `dutyCycle(execBusyMs, wallMs)`, `derivedRatio(duty)` (both throw on ≤0).
-- Produces:
-  - `interface WorkloadPoint { label: string; execMs: number; execCount: number; wallMs: number }`
-  - `interface RatioCurvePoint { label: string; execCount: number; duty: number; n: number }`
-  - `buildRatioCurve(points: WorkloadPoint[]): RatioCurvePoint[]`
-
-- [ ] **Step 1: Write the failing test** — append to `experiments/test/e6-saturation-structural.test.ts`:
-
-```typescript
-import { buildRatioCurve, type WorkloadPoint } from "../src/sharing";
-
-describe("buildRatioCurve — N as a function of per-leaf sandbox work", () => {
-  it("maps each workload point to duty + N, N decreasing as sandbox work rises", () => {
-    const pts: WorkloadPoint[] = [
-      { label: "L0", execMs: 300, execCount: 2, wallMs: 12000 },
-      { label: "L1", execMs: 1200, execCount: 6, wallMs: 12000 },
-      { label: "L2", execMs: 3000, execCount: 14, wallMs: 12000 },
-    ];
-    const curve = buildRatioCurve(pts);
-    expect(curve.map((c) => c.label)).toEqual(["L0", "L1", "L2"]);
-    expect(curve[0].duty).toBeCloseTo(0.025, 3);
-    expect(curve[0].n).toBe(40); // 1/0.025
-    expect(curve[0].execCount).toBe(2);
-    // heavier sandbox work at equal wall => higher duty => lower N
-    expect(curve[2].duty).toBeGreaterThan(curve[0].duty);
-    expect(curve[2].n).toBeLessThan(curve[0].n);
-  });
-
-  it("propagates the dutyCycle guard (wallMs <= 0 throws)", () => {
-    expect(() => buildRatioCurve([{ label: "x", execMs: 1, execCount: 1, wallMs: 0 }])).toThrow();
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd experiments && npx vitest run test/e6-saturation-structural.test.ts -t buildRatioCurve`
-Expected: FAIL — `buildRatioCurve` is not exported.
-
-- [ ] **Step 3: Implement** — append to `experiments/src/sharing.ts`:
-
-```typescript
-export interface WorkloadPoint {
-  label: string;
-  execMs: number;    // sandbox-busy ms attributable to one leaf of this workload
-  execCount: number; // number of sandbox execs the leaf issued
-  wallMs: number;    // leaf wall-clock
-}
-
-export interface RatioCurvePoint {
-  label: string;
-  execCount: number;
-  duty: number;
-  n: number;
-}
-
-/** N ≈ 1/duty at each workload intensity — the sharing ratio as a curve over sandbox work. */
-export function buildRatioCurve(points: WorkloadPoint[]): RatioCurvePoint[] {
-  return points.map((p) => {
-    const duty = dutyCycle(p.execMs, p.wallMs);
-    return { label: p.label, execCount: p.execCount, duty, n: derivedRatio(duty) };
-  });
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `cd experiments && npx vitest run test/e6-saturation-structural.test.ts -t buildRatioCurve`
-Expected: PASS (2 cases).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add experiments/src/sharing.ts experiments/test/e6-saturation-structural.test.ts
-git commit -s -m "feat: Add buildRatioCurve (N as a curve over per-leaf sandbox work)
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 2: sustained-decline `detectKnee` (sharing.ts)
-
-**Files:**
-- Modify: `experiments/src/sharing.ts`
-- Test: `experiments/test/e6-saturation-structural.test.ts`
-
-**Interfaces:**
-- Produces: `detectKnee(points: LadderPoint[], degradeX: number, patience?: number): number` — `patience` defaults to 2. A rung is *healthy* if `p95Ms <= degradeX * baselineP95` **and** `throughput >=` the running-max throughput seen so far. The knee advances to each healthy rung; the scan breaks only after `patience` **consecutive** unhealthy rungs (so a single noisy dip does not collapse the knee). Still throws if no `c === 1` baseline.
-
-- [ ] **Step 1: Replace the `detectKnee` tests** — in `experiments/test/e6-saturation-structural.test.ts`, replace the existing `detectKnee` describe block with:
-
-```typescript
-describe("detectKnee — sustained-decline (noise-tolerant)", () => {
-  it("still returns the last healthy rung when the top rung blows past the latency bound", () => {
-    const series: LadderPoint[] = [
-      { c: 1, throughput: 1.0, p95Ms: 1000 },
-      { c: 2, throughput: 1.9, p95Ms: 1050 },
-      { c: 4, throughput: 3.6, p95Ms: 1200 },
-      { c: 8, throughput: 5.0, p95Ms: 1900 },
-      { c: 16, throughput: 5.1, p95Ms: 4200 }, // latency blowup (> 2x baseline)
-    ];
-    expect(detectKnee(series, 2)).toBe(8);
-  });
-
-  it("tolerates a single throughput dip within the latency bound (does not break early)", () => {
-    const series: LadderPoint[] = [
-      { c: 1, throughput: 1.0, p95Ms: 1000 },
-      { c: 2, throughput: 2.0, p95Ms: 1100 },
-      { c: 4, throughput: 1.8, p95Ms: 1200 }, // single dip below running-max 2.0
-      { c: 8, throughput: 2.6, p95Ms: 1500 }, // recovers
-    ];
-    expect(detectKnee(series, 2)).toBe(8);
-  });
-
-  it("breaks on a sustained decline (patience consecutive unhealthy rungs)", () => {
-    const series: LadderPoint[] = [
-      { c: 1, throughput: 1.0, p95Ms: 1000 },
-      { c: 2, throughput: 2.0, p95Ms: 1100 },
-      { c: 4, throughput: 1.5, p95Ms: 1200 }, // unhealthy 1
-      { c: 8, throughput: 1.4, p95Ms: 1300 }, // unhealthy 2 -> break
-      { c: 16, throughput: 3.0, p95Ms: 1400 }, // never reached
-    ];
-    expect(detectKnee(series, 2)).toBe(2);
-  });
-
-  it("throws when there is no c=1 baseline", () => {
-    expect(() => detectKnee([{ c: 2, throughput: 1, p95Ms: 1 }], 2)).toThrow(/baseline/);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd experiments && npx vitest run test/e6-saturation-structural.test.ts -t detectKnee`
-Expected: FAIL — the single-dip and sustained-decline cases fail against the current strict-break implementation.
-
-- [ ] **Step 3: Replace `detectKnee`** in `experiments/src/sharing.ts`:
-
-```typescript
-/**
- * The knee = the highest concurrency still "healthy": p95 within `degradeX` of the single-leaf
- * baseline AND throughput at/above the running max. Tolerates transient dips — breaks only after
- * `patience` consecutive unhealthy rungs (per-leaf latency variance makes a single rung dip). The
- * knee that c is the recommended KAGENTI_SANDBOX_CAP (a floor when no break occurs).
- */
-export function detectKnee(points: LadderPoint[], degradeX: number, patience = 2): number {
-  const baseline = points.find((p) => p.c === 1);
-  if (!baseline) throw new Error("detectKnee: no c=1 baseline point");
-  const bound = baseline.p95Ms * degradeX;
-  const sorted = [...points].sort((a, b) => a.c - b.c);
-  let knee = 1;
-  let best = baseline.throughput;
-  let unhealthy = 0;
-  for (let i = 1; i < sorted.length; i++) {
-    const cur = sorted[i];
-    const healthy = cur.p95Ms <= bound && cur.throughput >= best;
-    if (healthy) {
-      knee = cur.c;
-      best = cur.throughput;
-      unhealthy = 0;
-    } else if (++unhealthy >= patience) {
-      break;
-    }
-  }
-  return knee;
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `cd experiments && npx vitest run test/e6-saturation-structural.test.ts`
-Expected: PASS (all `detectKnee` + `buildRatioCurve` + existing duty/floor cases).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add experiments/src/sharing.ts experiments/test/e6-saturation-structural.test.ts
-git commit -s -m "fix: Make detectKnee noise-tolerant (sustained-decline, patience) (#62)
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 3: git-daemon `work` ref with code fixtures
-
-**Files:**
-- Modify: `deploy/knative/gitd.yaml`
-
-**Interfaces:**
-- Produces: a `work` ref on `git://gitd.<ns>.svc:9418/repo.git` containing `small.py` (contains `password`), `medium.py` (~80 lines, contains `eval(`), `large.py` (~240 lines, many `eval(`). Marker branches `branch-0..K-1` unchanged (E7 uses them).
-
-- [ ] **Step 1: Add the `work` ref to the seed script.** In `deploy/knative/gitd.yaml`, immediately **after** the `while [ "$i" -lt "$K" ]; do … done` marker-branch loop and **before** the `exec git daemon …` line, insert:
-
-```yaml
-              # E6 workload ref: real code-review fixtures of increasing size (small/medium/large)
-              # so leaf review scope (=> sandbox tool calls => duty) spans light..heavy.
-              git checkout -q --orphan work || git checkout -q -b work
-              git rm -rq --cached . 2>/dev/null || true
-              rm -f marker.txt
-              printf 'API_KEY = "abc123"\npassword = "hunter2"\n' > small.py
-              { echo "import os"; i=0; while [ "$i" -lt 40 ]; do echo "def f$i(x):"; echo "    return eval(x)  # finding $i"; i=$((i+1)); done; } > medium.py
-              { echo "import subprocess"; i=0; while [ "$i" -lt 120 ]; do echo "def g$i(x):"; echo "    return eval(x)  # scan $i"; i=$((i+1)); done; } > large.py
-              git add small.py medium.py large.py
-              git commit -qm "work fixtures"
-              git push -q origin work
-```
-
-- [ ] **Step 2: Validate the manifest renders**
-
-Run: `mkdir -p /tmp/sh && kubectl kustomize deploy/knative > /tmp/sh/kustomize-base.log 2>&1; echo "BASE:$?"` and `kubectl kustomize deploy/knative/overlays/ocp > /tmp/sh/kustomize-ocp.log 2>&1; echo "OCP:$?"`
-Expected: `BASE:0` and `OCP:0`. Confirm the seed change is present: `grep -c 'work fixtures' /tmp/sh/kustomize-base.log` ≥ 1.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add deploy/knative/gitd.yaml
-git commit -s -m "feat: Seed a work ref with code fixtures for E6 workload variants
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 4: lib.sh helpers (exec count, median, scale) + scale reset
-
-**Files:**
-- Modify: `deploy/knative/lib.sh`
-
-**Interfaces:**
-- Produces:
-  - `count_exec_lines <pod>` → echoes the number of `[exec-timing]` lines in the pod log.
-  - `median` → filter: reads numbers on stdin (one per line), echoes the median.
-  - `set_scale <min> <max>` → patches the ksvc min/max-scale annotations and waits Ready.
-  - `restore_ksvc_env` (extended) → also resets scale annotations to `min-scale=0`/`max-scale=5`.
-
-- [ ] **Step 1: Add `count_exec_lines`, `median`, `set_scale`.** Append after `sum_exec_ms` in `deploy/knative/lib.sh`:
-
-```bash
-# Count [exec-timing] lines in a harness pod log (needs KAGENTI_EXEC_TIMING=1). Usage: count_exec_lines <pod>
-count_exec_lines() {
-  kubectl -n "$NS" logs "$1" 2>/dev/null | grep -c '\[exec-timing\]'
-}
-
-# Median of integers read one-per-line on stdin (integer result). Usage: printf '%s\n' 3 1 2 | median
-median() {
-  sort -n | awk '{a[NR]=$1} END{ if(NR==0){print 0} else if(NR%2){print a[(NR+1)/2]} else {printf "%d", int((a[NR/2]+a[NR/2+1])/2)} }'
-}
-
-# Patch the ksvc min/max-scale annotations (a merge patch is safe for the annotations map) and wait
-# Ready. Usage: set_scale <min> <max>
-set_scale() {
-  kubectl patch ksvc "$KSVC" -n "$NS" --type=merge -p \
-    "{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"autoscaling.knative.dev/min-scale\":\"$1\",\"autoscaling.knative.dev/max-scale\":\"$2\"}}}}}" >/dev/null
-  wait_ksvc_ready
-}
-```
-
-- [ ] **Step 2: Extend `restore_ksvc_env` to reset scale.** Replace the body of `restore_ksvc_env` in `deploy/knative/lib.sh` with:
-
-```bash
-restore_ksvc_env() {
-  set_ksvc_env KAGENTI_SANDBOX_POD- KAGENTI_EXEC_TIMING- KAGENTI_SANDBOX_CAP- \
-    KAGENTI_SANDBOX_POOL_SELECTOR=sh.kagenti.io/sandbox-pool=default >/dev/null 2>&1 || true
-  # Reset the autoscaling annotations to the committed service.yaml defaults (min 0 / max 5).
-  kubectl patch ksvc "$KSVC" -n "$NS" --type=merge -p \
-    '{"spec":{"template":{"metadata":{"annotations":{"autoscaling.knative.dev/min-scale":"0","autoscaling.knative.dev/max-scale":"5"}}}}}' \
-    >/dev/null 2>&1 || true
-}
-```
-
-- [ ] **Step 3: Lint**
-
-Run: `shellcheck -x deploy/knative/lib.sh > /tmp/sh/shellcheck-lib.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0` (or only pre-existing warnings — state which).
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/lib.sh
-git commit -s -m "feat: Add lib.sh helpers count_exec_lines/median/set_scale + scale reset
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 5: Rewrite `e6-saturation.sh` (N-curve + un-capped sweep)
-
-**Files:**
-- Modify (rewrite): `deploy/knative/e6-saturation.sh`
-
-**Interfaces:**
-- Consumes: `lib.sh` (`ensure_port_forward`, `wait_gitd`, `wait_ksvc_ready`, `set_ksvc_env`, `set_scale`, `restore_ksvc_env`, `dispatch_converge`, `sum_exec_ms`, `count_exec_lines`, `median`, `now_ms`, `ok`/`ko`, `FAIL`); `sharing.ts` (`buildRatioCurve`, `detectKnee`, `sanityFloorPass`) via `npx tsx`; the git-daemon `work` ref.
-- Env: `E6_LIVE` (gate), `E6_SAMPLES` (default 3), `E6_LADDER` (default `1 2 4 8 16`), `E6_DEGRADE_X` (2), `E6_MIN_CONCURRENCY` (4), `E6_SWEEP_MAX_SCALE` (20), `KAGENTI_SANDBOX_POD` (pin, default `sandbox-0`), `SH_MODEL`, `KSVC`, `NS`, `KSVC_URL` (OCP Route).
-
-- [ ] **Step 1: Replace the whole file** `deploy/knative/e6-saturation.sh` with:
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/e6-saturation.sh
-# E6 (workload-parameterized, spec 2026-07-03-e6-workload-parameterized-sandbox-load):
-#  Phase 1 — N-vs-workload curve: per-leaf sandbox duty at C=1 on a WARM pod (exec-timing delta
-#    per leaf, median of E6_SAMPLES) across real code-review variants L0/L1/L2 -> N = 1/duty as a
-#    function of per-leaf sandbox work. This is confound-free (one leaf, no concurrency).
-#  Phase 2 — concurrency sweep at the HEAVIEST variant (L2) with the harness UN-CAPPED
-#    (max-scale raised so the sandbox, not the 5-pod harness cap, limits concurrency), warm,
-#    multi-sampled, fed to the sustained-decline detectKnee. Knee reported as a floor.
-# Gated by E6_LIVE=1. Records to EXPERIMENTS.md.
-# Usage: E6_LIVE=1 [E6_SAMPLES=3] [E6_SWEEP_MAX_SCALE=20] bash deploy/knative/e6-saturation.sh
-set -euo pipefail
-cd "$(dirname "$0")"
-# shellcheck disable=SC1091  # lib.sh is co-located; not available to shellcheck at lint time
-source ./lib.sh
-
-[ "${E6_LIVE:-0}" = "1" ] || { echo "SKIP (set E6_LIVE=1)"; exit 0; }
-# Restore ksvc env + scale on ANY exit; installed AFTER the gate so a SKIP run never touches the cluster.
-trap 'restore_ksvc_env' EXIT
-
-SAMPLES="${E6_SAMPLES:-3}"
-LADDER="${E6_LADDER:-1 2 4 8 16}"
-DEGRADE_X="${E6_DEGRADE_X:-2}"
-MIN_C="${E6_MIN_CONCURRENCY:-4}"
-SWEEP_MAX="${E6_SWEEP_MAX_SCALE:-20}"
-PIN="${KAGENTI_SANDBOX_POD:-sandbox-0}"
-WREF="work"
-# Archetype-A code-review variants of increasing review scope: "label:file:pattern".
-VARIANTS=("L0:small.py:password" "L1:medium.py:eval(" "L2:large.py:eval(")
-
-echo "--- E6: workload curve + un-capped sweep (samples=$SAMPLES pin=$PIN sweepMax=$SWEEP_MAX) ---"
-ensure_port_forward >/dev/null || true
-wait_gitd 120 || { echo "gitd not ready"; exit 1; }
-
-# Pin one sandbox, disable pool routing, enable exec timing; warm exactly one harness pod (min=max=1)
-# so C=1 has no cold start and a single stable pod owns the [exec-timing] log across samples.
-set_ksvc_env KAGENTI_SANDBOX_POD="$PIN" KAGENTI_SANDBOX_POOL_SELECTOR- KAGENTI_EXEC_TIMING=1 KAGENTI_SANDBOX_CAP=1000
-set_scale 1 1
-
-harness_pod() {
-  kubectl get pods -n "$NS" -l "serving.knative.dev/service=$KSVC" \
-    --field-selector=status.phase=Running --no-headers 2>/dev/null | awk 'NR==1{print $1}'
-}
-
-# --- Phase 1: N-vs-workload curve (C=1, warm, exec-timing DELTA per leaf, median of SAMPLES) ---
-CURVE_IN="[]"
-for v in "${VARIANTS[@]}"; do
-  IFS=: read -r label file pat <<<"$v"
-  ms_s=""; cnt_s=""; wall_s=""
-  for _ in $(seq 1 "$SAMPLES"); do
-    pod="$(harness_pod)"
-    before_ms="$(sum_exec_ms "$pod")"; before_cnt="$(count_exec_lines "$pod")"
-    t0=$(now_ms)
-    dispatch_converge "e6-$label-$RANDOM-$$" "$label" "$file" "$pat" "$WREF" >/dev/null 2>&1 || true
-    wall=$(( $(now_ms) - t0 ))
-    after_ms="$(sum_exec_ms "$pod")"; after_cnt="$(count_exec_lines "$pod")"
-    ms_s="$ms_s$(( after_ms - before_ms ))
-"; cnt_s="$cnt_s$(( after_cnt - before_cnt ))
-"; wall_s="$wall_s$wall
-"
-  done
-  medMs=$(printf '%s' "$ms_s"   | grep -v '^$' | median)
-  medCnt=$(printf '%s' "$cnt_s" | grep -v '^$' | median)
-  medWall=$(printf '%s' "$wall_s" | grep -v '^$' | median); [ "$medWall" -lt 1 ] && medWall=1
-  echo "  $label file=$file execCount=$medCnt execMs=$medMs wallMs=$medWall"
-  CURVE_IN=$(jq -c --arg l "$label" --argjson m "$medMs" --argjson c "$medCnt" --argjson w "$medWall" \
-    '. + [{label:$l, execMs:$m, execCount:$c, wallMs:$w}]' <<<"$CURVE_IN")
-done
-
-# shellcheck disable=SC2016  # single-quoted TypeScript literal, not bash expansion
-CURVE=$(npx tsx -e '
-  import { buildRatioCurve } from "../../experiments/src/sharing.ts";
-  process.stdout.write(JSON.stringify(buildRatioCurve(JSON.parse(process.argv[1]))));
-' "$CURVE_IN")
-echo "  RATIO_CURVE=$CURVE"
-
-# --- Phase 2: concurrency sweep at L2 (heaviest), harness UN-CAPPED + warm ---
-IFS=: read -r hl hf hp <<<"${VARIANTS[2]}"
-set_scale 1 "$SWEEP_MAX"
-
-run_rung() {  # $1=c ; echoes "<medianThroughput> <medianP95>"
-  local c="$1" thr_s="" p95_s="" i pids d t0 wall
-  for _ in $(seq 1 "$SAMPLES"); do
-    d="$(mktemp -d)"; pids=""; i=0; t0=$(now_ms)
-    while [ "$i" -lt "$c" ]; do
-      ( ts=$(now_ms); dispatch_converge "e6sw-$c-$RANDOM-$i-$$" "$hl" "$hf" "$hp" "$WREF" >/dev/null 2>&1 || true
-        echo $(( $(now_ms) - ts )) > "$d/$i.ms" ) & pids="$pids $!"
-      i=$((i + 1))
-    done
-    # shellcheck disable=SC2086
-    wait $pids
-    wall=$(( $(now_ms) - t0 )); [ "$wall" -lt 1 ] && wall=1
-    thr_s="$thr_s$(awk -v c="$c" -v w="$wall" 'BEGIN{printf "%.3f", c/(w/1000.0)}')
-"
-    if ls "$d"/*.ms >/dev/null 2>&1; then
-      p95_s="$p95_s$(cat "$d"/*.ms | sort -n | awk '{a[NR]=$1} END{printf "%d", a[int(NR*0.95+0.999)]?a[int(NR*0.95+0.999)]:a[NR]}')
-"
-    else p95_s="${p95_s}999999
-"; fi
-    rm -rf "$d"
-  done
-  # median throughput is a float; median() is integer-only, so pick the middle sorted float via awk.
-  local mthr mp95
-  mthr=$(printf '%s' "$thr_s" | grep -v '^$' | sort -n | awk '{a[NR]=$1} END{print (NR%2)?a[(NR+1)/2]:a[NR/2]}')
-  mp95=$(printf '%s' "$p95_s" | grep -v '^$' | median)
-  echo "$mthr $mp95"
-}
-
-POINTS="[]"
-for c in $LADDER; do
-  read -r thr p95 <<<"$(run_rung "$c")"
-  echo "  sweep c=$c throughput=$thr p95Ms=$p95"
-  POINTS=$(jq -c --argjson c "$c" --argjson t "$thr" --argjson p "$p95" \
-    '. + [{c:$c, throughput:$t, p95Ms:$p}]' <<<"$POINTS")
-done
-
-# shellcheck disable=SC2016
-read -r KNEE FLOOR <<<"$(npx tsx -e '
-  import { detectKnee, sanityFloorPass } from "../../experiments/src/sharing.ts";
-  const pts = JSON.parse(process.argv[1]);
-  const knee = detectKnee(pts, Number(process.argv[2]));
-  process.stdout.write(`${knee} ${sanityFloorPass(knee, Number(process.argv[3]))}`);
-' "$POINTS" "$DEGRADE_X" "$MIN_C")"
-echo "  knee(CAP floor)=$KNEE floorPass=$FLOOR maxScale=$SWEEP_MAX"
-
-echo "E6_RESULT ratioCurve=$CURVE knee=$KNEE floorPass=$FLOOR maxScale=$SWEEP_MAX pass=$([ "$FAIL" = 0 ] && echo yes || echo no)"
-{
-  echo ""
-  echo "### E6 run $(hostname 2>/dev/null || echo host)"
-  echo "- N-vs-workload curve (C=1, samples=$SAMPLES): $CURVE"
-  echo "- sweep points (L2 '$hf', max-scale=$SWEEP_MAX): $POINTS"
-  echo "- knee floor: $KNEE (floorPass=$FLOOR)"
-} >> EXPERIMENTS.md
-
-[ "$FAIL" = 0 ] || exit 1
-```
-
-- [ ] **Step 2: Lint**
-
-Run: `shellcheck -x deploy/knative/e6-saturation.sh > /tmp/sh/shellcheck-e6.log 2>&1; echo "EXIT:$?"`
-Expected: `EXIT:0` (scoped `# shellcheck disable=` comments are already inline for the known SC1091/SC2016/SC2086 cases).
-
-- [ ] **Step 3: Gate no-op check**
-
-Run: `bash deploy/knative/e6-saturation.sh; echo "EXIT:$?"`
-Expected: prints `SKIP (set E6_LIVE=1)` and `EXIT:0`, contacting no cluster (the trap is installed after the gate, so nothing is restored on the SKIP path).
-
-- [ ] **Step 4: Prove the tsx calls resolve** (deterministic, no cluster)
-
-Run:
-```
-cd deploy/knative && npx tsx -e 'import { buildRatioCurve, detectKnee, sanityFloorPass } from "../../experiments/src/sharing.ts"; console.log(typeof buildRatioCurve, typeof detectKnee, typeof sanityFloorPass)' 2>&1 | tail -2; echo "EXIT:${PIPESTATUS[0]}"
-```
-Expected: `function function function` and `EXIT:0`.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add deploy/knative/e6-saturation.sh
-git commit -s -m "feat: Rewrite E6 driver — N-vs-workload curve + un-capped noise-robust sweep
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 6: EXPERIMENTS.md headline update
-
-**Files:**
-- Modify: `deploy/knative/EXPERIMENTS.md`
-
-- [ ] **Step 1: Update the E6 subsection + supersede note.** In `deploy/knative/EXPERIMENTS.md`, replace the `## E6 — saturation curve (→ CAP + derived N)` subsection body (the descriptive paragraph under that heading, not the recorded run blocks) with:
-
-```markdown
-## E6 — sandbox-load characterization (N-vs-workload curve + knee floor)
-
-Reports the harness→sandbox sharing ratio **N as a curve over per-leaf sandbox work**, measured at
-C=1 on a warm pod across real Archetype-A code-review variants L0/L1/L2 (increasing review scope over
-the git-daemon `work` fixtures), each point tagged with the leaf's measured sandbox exec count. N is
-workload-dependent: the light L0 leaf is a near-empty-leaf **upper bound**; heavier leaves drive more
-sandbox execs → higher duty → lower N. A separate concurrency sweep at the heaviest variant, with the
-harness un-capped (`max-scale` raised so the sandbox — not the 5-pod harness cap — limits
-concurrency), warm and multi-sampled, feeds the sustained-decline `detectKnee`; the knee is reported
-as a floor. **Supersedes** the earlier single-N figure (N ≈ 29–48:1), which was the L0 (near-empty-leaf)
-upper bound measured with a trivial `marker.txt` leaf.
-```
-
-- [ ] **Step 2: Commit**
-
-```bash
-git add deploy/knative/EXPERIMENTS.md
-git commit -s -m "docs: Reframe E6 results as N-vs-workload curve (supersede single-N)
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 7: Gated live re-run (Kind → OCP) + record + PR
-
-Not a CI task — runs the new E6 on real clusters and records the curve. Both clusters have the P3 stack standing; the git-daemon needs re-applying to pick up the `work` ref.
-
-- [ ] **Step 1: Kind — refresh gitd, rebuild harness image, run E6 + E7**
-
-```bash
-kubectl config use-context kind-sh-knative
-kubectl apply -f deploy/knative/gitd.yaml && kubectl rollout restart deploy/gitd && kubectl rollout status deploy/gitd --timeout=120s
-# rebuild harness image with the current branch (exec-timing hook is already in main, but rebuild to be safe) — or reuse if unchanged
-# verify work ref serves the fixtures:
-kubectl exec sandbox-0 -- git ls-remote git://gitd.default.svc:9418/repo.git | grep -c 'refs/heads/work'   # expect 1
-mkdir -p /tmp/sh/live
-E6_LIVE=1 bash deploy/knative/e6-saturation.sh > /tmp/sh/live/e6-kind.log 2>&1; echo "E6:$?"
-E7_LIVE=1 bash deploy/knative/e7-converge-contention.sh > /tmp/sh/live/e7-kind.log 2>&1; echo "E7:$?"
-```
-Expected: `work` ref present; `E6:0`; `E7:0`. Dispatch a subagent to extract `RATIO_CURVE`/`E6_RESULT`/`E7_RESULT` and any `FAIL` from the logs (do not read full logs inline). Confirm the curve shows increasing `execCount` and decreasing N from L0→L2.
-
-- [ ] **Step 2: OCP — refresh gitd, run authoritative E6 + E7**
-
-```bash
-export KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig
-kubectl apply -f deploy/knative/gitd.yaml && kubectl rollout restart deploy/gitd -n default && kubectl rollout status deploy/gitd -n default --timeout=180s
-kubectl exec sandbox-0 -n default -- git ls-remote git://gitd.default.svc:9418/repo.git | grep -c 'refs/heads/work'   # expect 1
-export KSVC_URL="https://serverless-harness-default.apps.rosso1.kubestellar.org"
-E6_LIVE=1 bash deploy/knative/e6-saturation.sh > /tmp/sh/live/e6-ocp.log 2>&1; echo "E6:$?"
-E7_LIVE=1 bash deploy/knative/e7-converge-contention.sh > /tmp/sh/live/e7-ocp.log 2>&1; echo "E7:$?"
-```
-Expected: `E6:0`, `E7:0`; a clean N-vs-workload curve (L0 high N → L2 lower N) and a stable knee floor (no single-dip collapse). Analyze via subagent. If `/runs` errors with "Connection error", re-provision `llm-credentials` api-key-only.
-
-- [ ] **Step 2b: If OCP results already appended cleanly to `deploy/knative/EXPERIMENTS.md`,** trim to the authoritative OCP run + a one-line takeaway (the curve + the knee floor). Then commit:
-
-```bash
-git add deploy/knative/EXPERIMENTS.md
-git commit -s -m "docs: Record E6 N-vs-workload curve (Kind + authoritative OCP)
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
-- [ ] **Step 3: Push + open PR**
-
-```bash
-git push -u origin feat/e6-workload-parameterization
-gh pr create --base main --head feat/e6-workload-parameterization \
-  --title "P3.1: E6 workload-parameterized sandbox-load (N-vs-workload curve, #62)" \
-  --body "$(cat <<'EOF'
-Hardens P3's E6 (spec `docs/specs/2026-07-03-e6-workload-parameterized-sandbox-load-design.md`), resolving #62 and the workload-realism gap.
-
-- Real Archetype-A code-review variants L0/L1/L2 (git-daemon `work` fixtures) replace the trivial marker check.
-- N reported as a **curve over per-leaf sandbox work** (measured at C=1, warm, multi-sampled), each point tagged with exec count — supersedes the single optimistic N.
-- Concurrency sweep un-caps the harness (`max-scale`) so the sandbox is the limiter; warm + multi-sample + sustained-decline `detectKnee` remove the noise/max-scale confounds.
-- Live-verified on Kind + OCP.
-
-Assisted-By: Claude Code
-EOF
-)"
-```
-Then the user merges. Report the PR number and the recorded curve.
-
----
-
-## Self-Review
-
-**1. Spec coverage:**
-
-| Spec item | Task |
-|-----------|------|
-| §2 D1 N-vs-workload curve at C=1 | Task 1 (`buildRatioCurve`) + Task 5 Phase 1 |
-| §2 D2 / §3 L0/L1/L2 real code-review variants | Task 3 (fixtures) + Task 5 `VARIANTS` |
-| §4 instrumentation (exec count/ms/wall, warm, median) | Task 4 (`count_exec_lines`/`median`) + Task 5 Phase 1 (delta, warm min=max=1) |
-| §5 `buildRatioCurve` | Task 1 |
-| §5 sustained-decline `detectKnee` (`patience`) | Task 2 |
-| §6 raise max-scale / warm / multi-sample / heaviest variant | Task 4 (`set_scale`) + Task 5 Phase 2 |
-| §6 restore scale on exit | Task 4 (`restore_ksvc_env` extended) |
-| §6 E7 unchanged, marker refs kept | honored (Task 3 leaves `branch-*`; E7 untouched) |
-| §7 EXPERIMENTS.md headline = curve, supersede note | Task 6 + Task 7 Step 2b |
-| §8 unit + integration + gated live | Tasks 1/2 (unit) + Task 7 (live) |
-| §10 README registration | already committed (`b53dfdd`) |
-
-**2. Placeholder scan:** No `TBD`/`TODO`/"add error handling"/"similar to Task N". Every code step shows complete code. Fixture sizes (40/120 lines) are concrete.
-
-**3. Type consistency:** `WorkloadPoint{label,execMs,execCount,wallMs}` (Task 1) is exactly what Task 5 Phase 1 builds into `CURVE_IN` and feeds to `buildRatioCurve`. `LadderPoint{c,throughput,p95Ms}` (existing) is what Task 5 Phase 2 builds into `POINTS` and feeds to `detectKnee(points, degradeX, patience?)` (Task 2). `set_scale <min> <max>`, `count_exec_lines <pod>`, `median` (Task 4) are called with those signatures in Task 5. `dispatch_converge <sid> <item_id> <file> <pattern> <ref>` matches the existing lib.sh helper. tsx path `../../experiments/src/sharing.ts` consistent with CWD `deploy/knative/`.
-
-**Deviation flagged:** Task 5 drops P3's old "feed-back check" (pool spread at derived CAP) — the new sweep pins one sandbox with a raised max-scale (not pool mode), per spec §6, which does not carry the feed-back check forward. If a reviewer wants pool-spread re-verified, that belongs in a separate pool test, not this workload-characterization driver.
diff --git a/docs/superpowers/plans/2026-07-03-p3-sandbox-sharing-ratio-experiments.md b/docs/superpowers/plans/2026-07-03-p3-sandbox-sharing-ratio-experiments.md
deleted file mode 100644
index 9e7a51c..0000000
--- a/docs/superpowers/plans/2026-07-03-p3-sandbox-sharing-ratio-experiments.md
+++ /dev/null
@@ -1,1125 +0,0 @@
-# P3 Sandbox Sharing-Ratio Experiments Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Measure, on the runc runtime, the per-sandbox concurrency knee that sets `KAGENTI_SANDBOX_CAP` and the derived harness→sandbox provisioning ratio N, and validate live that mixed-ref converge on a shared pod stays commit-consistent.
-
-**Architecture:** Two experiments (E6 saturation curve, E7 converge contention + mixed-ref correctness) plus a feed-back check, driven by gated bash scripts against a hermetic in-cluster git-daemon load substrate. A tiny env-gated exec-timing hook in the sandbox transport lets a C=1 run compute the per-leaf duty cycle. Pure analysis functions (knee detection, duty cycle, floor gate, ref-consistency) are unit-tested in the `@sh/experiments` vitest workspace; the live drivers record authoritative numbers to `EXPERIMENTS.md`. No change to the harness model loop, lease protocol, or converge logic — P3 measures the P2 mechanism, it does not alter it.
-
-**Tech Stack:** TypeScript (ESM, vitest 2.x) for `@sh/k8s-sandbox` and `@sh/experiments`; bash + `kubectl` + `jq` + `awk` for the `deploy/knative/` drivers reusing `lib.sh`; agent-sandbox `v1beta1` `Sandbox` CRs; Knative Serving; Redis (`RedisLeaseStore`); `git daemon` for the load substrate.
-
-## Global Constraints
-
-- **Commits:** DCO sign-off on every commit (`git commit -s`). Attribution trailer `Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>` — **never** `Co-authored-by`.
-- **Staging:** never `git add -A`. Stage explicit paths only (the tree carries intentionally-dirty `experiments/RESULTS.md` and `.worktrees/`).
-- **Branch:** all work on `docs/p3-sandbox-sharing-experiments` (already created off `main`; this plan and the spec are already committed there).
-- **Feature-off-by-default:** the exec-timing hook is gated by `KAGENTI_EXEC_TIMING=1`, **off by default** — it must not change production behavior when unset.
-- **Model:** `SH_MODEL=claude-haiku-4-5` for all live leaf runs.
-- **Live gating:** live drivers no-op unless their gate env var is set (`E6_LIVE=1` / `E7_LIVE=1`), mirroring the existing `LEAF_LIVE_SMOKE` / `SH_RUN_LIVE` pattern.
-- **Cluster order (spec D5):** develop on Kind `sh-knative` (standing 3-pod pool); take authoritative numbers on live OCP 4.20 (`KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig`).
-- **Context budget:** redirect long command output to `/tmp/sh/*.log`; analyze via subagents, never read large logs inline.
-- **Exact converge paths (do not drift):** shared repo `/workspace/repo`, per-pod lock `/workspace/.sh-fetch.lock`, per-leaf worktree `/workspace/leaves/<runId>`. `/runs` body is a `LeafEnvelope`; the converge path activates only when **both** `repoUrl` and `ref` are set and a sandbox is selected.
-
----
-
-## File Structure
-
-**New files:**
-- `experiments/src/sharing.ts` — pure analysis: knee detection, duty cycle, derived ratio, sanity-floor gate, worktree/ref consistency, cap-respect check. One responsibility: turn raw experiment samples into verdicts + reportable numbers.
-- `experiments/test/e6-saturation-structural.test.ts` — unit tests for the E6 analysis (knee + duty cycle + floor) on synthetic series.
-- `experiments/test/e7-converge-contention-structural.test.ts` — unit tests for E7 analysis (ref-consistency) + a real-Redis never-over-cap assertion via `RedisLeaseStore`.
-- `deploy/knative/gitd.yaml` — in-cluster git-daemon Deployment + Service serving a seeded bare repo with K refs.
-- `deploy/knative/e6-saturation.sh` — E6 driver (ladder sweep + C=1 duty cycle + knee + floor gate + feed-back check).
-- `deploy/knative/e7-converge-contention.sh` — E7 driver (mixed-ref converge + contention profile + correctness gate + never-over-cap).
-
-**Modified files:**
-- `packages/k8s-sandbox/src/exec.ts` — add env-gated exec-timing emission (2 pure helpers + wiring).
-- `packages/k8s-sandbox/test/exec.test.ts` — tests for the 2 new pure helpers.
-- `deploy/knative/lib.sh` — new shared helpers (git-daemon deploy/wait, concurrent-leaf launcher, exec-timing capture, sandbox CPU sampler, pool-spread check).
-- `deploy/knative/setup-kind.sh` — issue #54: apply `sandbox-pool.yaml` (not `sandbox.yaml`) and wait for all N pool pods.
-- `deploy/knative/kustomization.yaml` and `deploy/knative/overlays/ocp/kustomization.yaml` — add `gitd.yaml` to resources.
-- `deploy/knative/EXPERIMENTS.md` — add the "P3 — sandbox sharing" results section (scaffold + how-to; filled by driver runs).
-- `experiments/RESULTS.md` — add a short P3 pointer section (authoritative numbers live in `EXPERIMENTS.md`).
-
----
-
-## Task 1: Env-gated exec-timing hook
-
-Adds an off-by-default per-exec timing line to the sandbox transport so a C=1 run can sum sandbox-busy time. Two pure helpers (unit-tested) plus wiring into the existing `close` handler.
-
-**Files:**
-- Modify: `packages/k8s-sandbox/src/exec.ts`
-- Test: `packages/k8s-sandbox/test/exec.test.ts`
-
-**Interfaces:**
-- Consumes: `K8sSandboxConfig` (has `.pod`, `.namespace`), the existing `kubectlExecInPod` closure.
-- Produces: `shouldEmitExecTiming(env: NodeJS.ProcessEnv): boolean`; `formatExecTiming(pod: string, ms: number, command: string): string` (single line, newline-terminated, format `[exec-timing] pod=<pod> ms=<ms> cmd=<first 60 chars, newlines→spaces>`).
-
-- [ ] **Step 1: Write the failing test**
-
-Add to `packages/k8s-sandbox/test/exec.test.ts`:
-
-```typescript
-import { describe, it, expect } from "vitest";
-import { shouldEmitExecTiming, formatExecTiming } from "../src/exec.js";
-
-describe("exec timing (env-gated)", () => {
-  it("is off unless KAGENTI_EXEC_TIMING=1", () => {
-    expect(shouldEmitExecTiming({})).toBe(false);
-    expect(shouldEmitExecTiming({ KAGENTI_EXEC_TIMING: "0" })).toBe(false);
-    expect(shouldEmitExecTiming({ KAGENTI_EXEC_TIMING: "1" })).toBe(true);
-  });
-
-  it("formats a single stable line, truncating and flattening the command", () => {
-    const line = formatExecTiming("sandbox-1", 42, "git -C /workspace/repo fetch\norigin branch-0");
-    expect(line).toBe(
-      "[exec-timing] pod=sandbox-1 ms=42 cmd=git -C /workspace/repo fetch origin branch-0\n",
-    );
-    const long = formatExecTiming("p", 1, "x".repeat(200));
-    expect(long).toBe(`[exec-timing] pod=p ms=1 cmd=${"x".repeat(60)}\n`);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd packages/k8s-sandbox && npx vitest run test/exec.test.ts -t "exec timing"`
-Expected: FAIL — `shouldEmitExecTiming is not a function` (not yet exported).
-
-- [ ] **Step 3: Add the two pure helpers to `exec.ts`**
-
-Insert after the `buildKubectlArgs` function (after line 26):
-
-```typescript
-/** True only when exec timing is explicitly enabled (off by default). */
-export function shouldEmitExecTiming(env: NodeJS.ProcessEnv): boolean {
-  return env.KAGENTI_EXEC_TIMING === "1";
-}
-
-/** One stable, newline-terminated timing line for a single exec. */
-export function formatExecTiming(pod: string, ms: number, command: string): string {
-  const cmd = command.slice(0, 60).replace(/\s+/g, " ");
-  return `[exec-timing] pod=${pod} ms=${ms} cmd=${cmd}\n`;
-}
-```
-
-- [ ] **Step 4: Wire timing into the `close` handler**
-
-In `kubectlExecInPod`, capture a start timestamp right after `spawn` (after line 34, before `const out: Buffer[] = [];`):
-
-```typescript
-      const startMs = Date.now();
-```
-
-Then in the `child.on("close", ...)` success branch, replace the single resolve line (line 70) so timing is emitted just before resolving on a clean exit:
-
-```typescript
-        if (timedOut) return reject(new Error(`timeout:${opts.timeout}`));
-        if (shouldEmitExecTiming(process.env)) {
-          process.stderr.write(formatExecTiming(config.pod, Date.now() - startMs, command));
-        }
-        resolve({ stdout: Buffer.concat(out), exitCode: code });
-```
-
-- [ ] **Step 5: Run tests to verify they pass**
-
-Run: `cd packages/k8s-sandbox && npx vitest run test/exec.test.ts`
-Expected: PASS (all existing tests plus the two new cases).
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add packages/k8s-sandbox/src/exec.ts packages/k8s-sandbox/test/exec.test.ts
-git commit -s -m "feat: Add env-gated per-exec timing to the sandbox transport
-
-Off by default (KAGENTI_EXEC_TIMING=1). Emits one [exec-timing] line per exec
-to stderr so a C=1 experiment run can sum sandbox-busy time and derive the
-per-leaf duty cycle. No production behavior change when unset.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 2: E6 analysis functions + structural test
-
-Pure functions that turn a saturation sweep into a knee (recommended CAP), a duty cycle, a derived ratio N, and a pass/fail floor verdict.
-
-**Files:**
-- Create: `experiments/src/sharing.ts`
-- Test: `experiments/test/e6-saturation-structural.test.ts`
-
-**Interfaces:**
-- Produces:
-  - `interface LadderPoint { c: number; throughput: number; p95Ms: number }`
-  - `detectKnee(points: LadderPoint[], degradeX: number): number` — highest `c` whose `p95Ms <= degradeX * baselineP95` (baseline = the `c===1` point) AND whose throughput is still rising vs the previous point; returns that `c` (the recommended CAP). Throws if no `c===1` baseline point is present.
-  - `dutyCycle(execBusyMs: number, wallMs: number): number` — `execBusyMs / wallMs`, clamped to `(0, 1]`; throws on `wallMs <= 0`.
-  - `derivedRatio(duty: number): number` — `1 / duty` rounded to 1 decimal; throws on `duty <= 0`.
-  - `sanityFloorPass(knee: number, minConcurrency: number): boolean` — `knee >= minConcurrency`.
-
-- [ ] **Step 1: Write the failing test**
-
-Create `experiments/test/e6-saturation-structural.test.ts`:
-
-```typescript
-import { describe, it, expect } from "vitest";
-import {
-  detectKnee,
-  dutyCycle,
-  derivedRatio,
-  sanityFloorPass,
-  type LadderPoint,
-} from "../src/sharing";
-
-describe("E6 — saturation analysis (structural)", () => {
-  // Throughput rises then plateaus; p95 stays flat then blows up past the knee.
-  const series: LadderPoint[] = [
-    { c: 1, throughput: 1.0, p95Ms: 1000 },
-    { c: 2, throughput: 1.9, p95Ms: 1050 },
-    { c: 4, throughput: 3.6, p95Ms: 1200 },
-    { c: 8, throughput: 5.0, p95Ms: 1900 },
-    { c: 16, throughput: 5.1, p95Ms: 4200 }, // plateau + latency blowup
-  ];
-
-  it("detects the knee as the last still-scaling point within the latency bound", () => {
-    // degradeX=2 => p95 bound = 2000ms; c=16 exceeds it and throughput plateaued.
-    expect(detectKnee(series, 2)).toBe(8);
-  });
-
-  it("throws when there is no c=1 baseline", () => {
-    expect(() => detectKnee([{ c: 2, throughput: 1, p95Ms: 1 }], 2)).toThrow(/baseline/);
-  });
-
-  it("computes duty cycle and derived ratio", () => {
-    expect(dutyCycle(250, 1000)).toBeCloseTo(0.25, 5);
-    expect(derivedRatio(0.25)).toBe(4.0);
-    expect(() => dutyCycle(1, 0)).toThrow();
-    expect(() => derivedRatio(0)).toThrow();
-  });
-
-  it("caps duty cycle at 1 and enforces the sanity floor", () => {
-    expect(dutyCycle(1500, 1000)).toBe(1);
-    expect(sanityFloorPass(8, 4)).toBe(true);
-    expect(sanityFloorPass(2, 4)).toBe(false);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `cd experiments && npx vitest run test/e6-saturation-structural.test.ts`
-Expected: FAIL — cannot resolve `../src/sharing`.
-
-- [ ] **Step 3: Implement `experiments/src/sharing.ts` (E6 portion)**
-
-```typescript
-export interface LadderPoint {
-  c: number;          // concurrent leaves at this rung
-  throughput: number; // aggregate leaves/sec
-  p95Ms: number;      // per-leaf p95 latency at this rung
-}
-
-/**
- * The knee = the highest concurrency that is still "healthy": p95 within
- * `degradeX` of the single-leaf baseline AND throughput still rising vs the
- * previous rung. That c is the recommended KAGENTI_SANDBOX_CAP.
- */
-export function detectKnee(points: LadderPoint[], degradeX: number): number {
-  const baseline = points.find((p) => p.c === 1);
-  if (!baseline) throw new Error("detectKnee: no c=1 baseline point");
-  const bound = baseline.p95Ms * degradeX;
-  const sorted = [...points].sort((a, b) => a.c - b.c);
-  let knee = 1;
-  for (let i = 1; i < sorted.length; i++) {
-    const cur = sorted[i];
-    const prev = sorted[i - 1];
-    const withinLatency = cur.p95Ms <= bound;
-    const stillScaling = cur.throughput > prev.throughput;
-    if (withinLatency && stillScaling) knee = cur.c;
-    else break;
-  }
-  return knee;
-}
-
-/** Fraction of wall-clock the sandbox was busy on this leaf's execs; in (0, 1]. */
-export function dutyCycle(execBusyMs: number, wallMs: number): number {
-  if (wallMs <= 0) throw new Error("dutyCycle: wallMs must be > 0");
-  return Math.min(1, execBusyMs / wallMs);
-}
-
-/** How many such leaves time-share one sandbox before it is continuously busy. */
-export function derivedRatio(duty: number): number {
-  if (duty <= 0) throw new Error("derivedRatio: duty must be > 0");
-  return Math.round((1 / duty) * 10) / 10;
-}
-
-/** CI floor: one sandbox must sustain at least `minConcurrency` healthy leaves. */
-export function sanityFloorPass(knee: number, minConcurrency: number): boolean {
-  return knee >= minConcurrency;
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `cd experiments && npx vitest run test/e6-saturation-structural.test.ts`
-Expected: PASS (4 cases).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add experiments/src/sharing.ts experiments/test/e6-saturation-structural.test.ts
-git commit -s -m "feat: Add E6 saturation analysis (knee, duty cycle, derived ratio, floor)
-
-Pure functions the E6 driver uses to turn a concurrency sweep into a recommended
-KAGENTI_SANDBOX_CAP (the knee), a per-leaf duty cycle, and the derived N ratio,
-guarded by a CI sanity floor.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 3: E7 analysis (ref-consistency) + real-Redis never-over-cap test
-
-Adds the mixed-ref correctness checker to `sharing.ts` and a structural test that also proves, against real Redis, that the existing `RedisLeaseStore` never grants more than the cap.
-
-**Files:**
-- Modify: `experiments/src/sharing.ts`
-- Test: `experiments/test/e7-converge-contention-structural.test.ts`
-
-**Interfaces:**
-- Consumes: `RedisLeaseStore` from `@sh/harness/sandbox-lease` (methods `acquire(pod, cap, runId, ttlMs)`, `load(pod)`, `release(pod, runId)`; key `sh:sandbox:<pod>:leases`).
-- Produces:
-  - `interface LeafObservation { runId: string; expectedRef: string; observedMarker: string }`
-  - `worktreeConsistent(obs: LeafObservation[]): { ok: boolean; mismatches: LeafObservation[] }` — every leaf's `observedMarker` must equal its `expectedRef` (proves each worktree pinned its own commit; no cross-contamination).
-
-- [ ] **Step 1: Write the failing test**
-
-Create `experiments/test/e7-converge-contention-structural.test.ts`:
-
-```typescript
-import { describe, it, expect, afterAll } from "vitest";
-import { worktreeConsistent, type LeafObservation } from "../src/sharing";
-import { RedisLeaseStore, leaseKey } from "@sh/harness/sandbox-lease";
-
-describe("E7 — mixed-ref consistency (structural)", () => {
-  it("passes when every leaf observed its own ref, fails on cross-contamination", () => {
-    const good: LeafObservation[] = [
-      { runId: "a", expectedRef: "branch-0", observedMarker: "branch-0" },
-      { runId: "b", expectedRef: "branch-1", observedMarker: "branch-1" },
-    ];
-    expect(worktreeConsistent(good).ok).toBe(true);
-
-    const bad: LeafObservation[] = [
-      { runId: "a", expectedRef: "branch-0", observedMarker: "branch-0" },
-      { runId: "b", expectedRef: "branch-1", observedMarker: "branch-0" }, // leaked sibling ref
-    ];
-    const r = worktreeConsistent(bad);
-    expect(r.ok).toBe(false);
-    expect(r.mismatches).toHaveLength(1);
-    expect(r.mismatches[0].runId).toBe("b");
-  });
-});
-
-const REDIS = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-describe("E7 — lease never exceeds cap (structural, real Redis)", () => {
-  const store = new RedisLeaseStore(REDIS);
-  const pod = `e7-cap-test-${process.pid}`;
-  afterAll(async () => {
-    // best-effort cleanup of the test pod's lease set
-    // (RedisLeaseStore has no delete-key; release each member we added)
-    for (const id of ["r0", "r1", "r2", "r3", "r4"]) await store.release(pod, id);
-  });
-
-  it("grants at most `cap` concurrent leases", async () => {
-    const cap = 3;
-    const results: boolean[] = [];
-    for (const id of ["r0", "r1", "r2", "r3", "r4"]) {
-      results.push(await store.acquire(pod, cap, id, 60_000));
-    }
-    expect(results.filter(Boolean).length).toBe(cap); // exactly 3 granted, 2 refused
-    expect(await store.load(pod)).toBe(cap);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Start Redis if needed: `docker run -d --rm -p 6379:6379 --name sh-redis redis:7 >/dev/null 2>&1 || true`
-Run: `cd experiments && npx vitest run test/e7-converge-contention-structural.test.ts`
-Expected: FAIL — `worktreeConsistent` is not exported.
-
-- [ ] **Step 3: Add `worktreeConsistent` to `experiments/src/sharing.ts`**
-
-Append:
-
-```typescript
-export interface LeafObservation {
-  runId: string;
-  expectedRef: string;   // the ref this leaf's envelope pinned
-  observedMarker: string; // marker.txt content read from its worktree
-}
-
-/** Every leaf must have seen its own ref's marker — no sibling leakage. */
-export function worktreeConsistent(obs: LeafObservation[]): {
-  ok: boolean;
-  mismatches: LeafObservation[];
-} {
-  const mismatches = obs.filter((o) => o.observedMarker !== o.expectedRef);
-  return { ok: mismatches.length === 0, mismatches };
-}
-```
-
-- [ ] **Step 4: Run test to verify it passes**
-
-Run: `cd experiments && npx vitest run test/e7-converge-contention-structural.test.ts`
-Expected: PASS (both describes). If the real-Redis block errors on connection, ensure Redis is running (Step 2).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add experiments/src/sharing.ts experiments/test/e7-converge-contention-structural.test.ts
-git commit -s -m "feat: Add E7 mixed-ref consistency check + real-Redis never-over-cap test
-
-worktreeConsistent asserts each leaf observed only its own ref's marker (no
-cross-contamination on a shared pod). The real-Redis test pins the P2 lease
-invariant: RedisLeaseStore grants at most cap concurrent leases.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 4: In-cluster git-daemon load substrate
-
-A hermetic `git://` server seeded with K refs, reachable by every pool pod, so leaves converge without GitHub egress.
-
-**Files:**
-- Create: `deploy/knative/gitd.yaml`
-- Modify: `deploy/knative/kustomization.yaml`, `deploy/knative/overlays/ocp/kustomization.yaml`
-
-**Interfaces:**
-- Produces: Service `gitd` (port 9418) → repo URL `git://gitd.<ns>.svc:9418/repo.git`, with refs `branch-0 … branch-{K-1}`; each ref's `marker.txt` contains exactly its branch name (e.g. `branch-2`). `E6_REFS`/`E7_REFS` drivers assume `K >= 16`.
-
-- [ ] **Step 1: Create `deploy/knative/gitd.yaml`**
-
-```yaml
-# deploy/knative/gitd.yaml
-# Hermetic in-cluster git-daemon load substrate for the P3 sharing-ratio experiments.
-# Seeds a bare repo with K refs (branch-0..branch-{K-1}); each ref's marker.txt holds its
-# own branch name so E7 can assert per-leaf commit consistency. Reachable pool-wide over
-# git:// so mixed-ref converge works across all sandboxes. Read-only, disposable.
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: gitd
-  namespace: default
-  labels: { app: gitd }
-spec:
-  replicas: 1
-  selector: { matchLabels: { app: gitd } }
-  template:
-    metadata: { labels: { app: gitd } }
-    spec:
-      containers:
-        - name: gitd
-          image: alpine/git:2.45.2
-          command: ["/bin/sh", "-c"]
-          args:
-            - |
-              set -eu
-              K="${GITD_REFS:-16}"
-              R=/srv/git/repo.git
-              mkdir -p "$R"
-              git init --bare -q "$R"
-              W=/tmp/seed
-              rm -rf "$W"; git clone -q "$R" "$W"
-              cd "$W"
-              git config user.email seed@gitd.local
-              git config user.name seed
-              i=0
-              while [ "$i" -lt "$K" ]; do
-                git checkout -q --orphan "branch-$i" || git checkout -q -b "branch-$i"
-                git rm -rq --cached . 2>/dev/null || true
-                printf 'branch-%s' "$i" > marker.txt
-                git add marker.txt
-                git commit -qm "branch-$i marker"
-                git push -q origin "branch-$i"
-                i=$((i + 1))
-              done
-              # Serve read-only; upload-pack (fetch) is enabled by --export-all.
-              exec git daemon --reuseaddr --verbose --export-all \
-                --base-path=/srv/git --listen=0.0.0.0 --port=9418 /srv/git
-          env:
-            - name: GITD_REFS
-              value: "16"
-          ports:
-            - containerPort: 9418
-          resources:
-            requests: { memory: "32Mi", cpu: "25m" }
-            limits: { memory: "128Mi" }
-      # No securityContext override: the OCP overlay's non-root SCC applies namespace-wide;
-      # git-daemon and git init run fine as an arbitrary non-root UID against /srv/git + /tmp.
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: gitd
-  namespace: default
-spec:
-  selector: { app: gitd }
-  ports:
-    - name: git
-      port: 9418
-      targetPort: 9418
-```
-
-- [ ] **Step 2: Add `gitd.yaml` to the base kustomization**
-
-In `deploy/knative/kustomization.yaml`, extend the `resources:` list:
-
-```yaml
-resources:
-  - redis.yaml
-  - sandbox-pool.yaml
-  - service.yaml
-  - gitd.yaml
-```
-
-- [ ] **Step 3: Add `gitd.yaml` to the OCP overlay**
-
-In `deploy/knative/overlays/ocp/kustomization.yaml`, extend the `resources:` list:
-
-```yaml
-resources:
-  - ../../redis.yaml
-  - ../../sandbox-pool.yaml
-  - ../../service.yaml
-  - ../../gitd.yaml
-```
-
-- [ ] **Step 4: Validate the manifests render**
-
-Run: `cd deploy/knative && kubectl kustomize . > /tmp/sh/kustomize-base.log 2>&1; echo "EXIT:$?"` then `kubectl kustomize overlays/ocp > /tmp/sh/kustomize-ocp.log 2>&1; echo "EXIT:$?"`
-Expected: EXIT:0 for both. Confirm `gitd` Deployment + Service appear: `grep -c "kind: Deployment" /tmp/sh/kustomize-base.log` ≥ 1.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add deploy/knative/gitd.yaml deploy/knative/kustomization.yaml deploy/knative/overlays/ocp/kustomization.yaml
-git commit -s -m "feat: Add in-cluster git-daemon load substrate for P3 experiments
-
-Hermetic git:// server seeded with K refs (branch-i/marker.txt=branch-i),
-reachable pool-wide so mixed-ref converge works across sandboxes without GitHub
-egress. Wired into the base and OCP kustomizations.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 5: Shared bash helpers in `lib.sh`
-
-Reusable helpers for the E6/E7 drivers. Verified by `shellcheck` (bash has no unit harness here); live behavior is exercised in Tasks 6–8 and the gated run (Task 10).
-
-**Files:**
-- Modify: `deploy/knative/lib.sh`
-
-**Interfaces (new functions, appended after `pod_seconds_from`):**
-- `gitd_repo_url` → echoes `git://gitd.${NS}.svc:9418/repo.git`.
-- `wait_gitd [timeout]` → waits until the `gitd` Deployment is Available; returns non-zero on timeout.
-- `dispatch_converge <sessionId> <item_id> <file> <pattern> <ref> [model]` → POST `/runs` with a **converge-path** envelope (`repoUrl`+`ref`, no `workspaceRef`); echoes terminal JSON.
-- `pod_cpu_seconds <pod>` → echoes cumulative container CPU-seconds for `pod` from `kubectl top` is too coarse; instead reads cgroup `cpuacct`/`cpu.stat` via exec (implementation below).
-- `sum_exec_ms <harness_pod>` → sums `ms=` from `[exec-timing]` lines in the harness pod log.
-- `pool_pod_counts` → echoes, one per line, `<pod> <activeLeaseCount>`-style Running pool pods (for spread checks): here just lists Running pool pod names.
-
-- [ ] **Step 1: Append the helpers to `deploy/knative/lib.sh`**
-
-```bash
-# --- P3 sharing-ratio experiment helpers ---------------------------------------------------
-
-# The hermetic git-daemon repo URL (see deploy/knative/gitd.yaml).
-gitd_repo_url() { echo "git://gitd.${NS}.svc:9418/repo.git"; }
-
-# Wait until the gitd Deployment is Available. Arg: timeout seconds (default 120).
-wait_gitd() {
-  kubectl -n "$NS" rollout status deploy/gitd --timeout="${1:-120}s" >/dev/null 2>&1
-}
-
-# POST /runs with a P2 converge-path envelope (repoUrl+ref => sandbox converges + worktrees).
-# Usage: dispatch_converge <sessionId> <item_id> <file> <pattern> <ref> [model]
-dispatch_converge() {
-  local sid="$1" id="$2" file="$3" pat="$4" ref="$5" model="${6:-${SH_MODEL:-claude-haiku-4-5}}"
-  local body
-  body=$(jq -nc --arg s "$sid" --arg id "$id" --arg f "$file" --arg p "$pat" \
-    --arg u "$(gitd_repo_url)" --arg r "$ref" --arg m "$model" \
-    '{sessionId:$s, item:{item_id:$id, file:$f, pattern:$p}, repoUrl:$u, ref:$r, model:$m}')
-  # shellcheck disable=SC2086
-  curl -s $CURL_OPTS --max-time 240 ${CURL_HDR[@]+"${CURL_HDR[@]}"} \
-    -H "Content-Type: application/json" -d "$body" "$BASE/runs"
-}
-
-# Sum ms= from [exec-timing] lines in a harness pod's log (needs KAGENTI_EXEC_TIMING=1).
-# Usage: sum_exec_ms <harness_pod>
-sum_exec_ms() {
-  kubectl -n "$NS" logs "$1" 2>/dev/null \
-    | awk -F'ms=' '/\[exec-timing\]/ {split($2,a," "); s+=a[1]} END{printf "%d", s+0}'
-}
-
-# List Running pool pod names (one per line). Pool selector defaults to the P2 label.
-pool_pod_counts() {
-  kubectl get pods -n "$NS" -l "${KAGENTI_SANDBOX_POOL_SELECTOR:-sh.kagenti.io/sandbox-pool=default}" \
-    --field-selector=status.phase=Running --no-headers 2>/dev/null | awk '{print $1}'
-}
-
-# Max active leases observed on any single pool pod, read from Redis in the redis pod.
-# Usage: max_leases_across_pool   (needs a redis pod reachable as deploy/pod "redis")
-max_leases_across_pool() {
-  local now; now=$(date +%s%3N)
-  local max=0
-  for pod in $(pool_pod_counts); do
-    local n
-    n=$(kubectl -n "$NS" exec deploy/redis -- \
-      redis-cli ZCOUNT "sh:sandbox:${pod}:leases" "$now" "+inf" 2>/dev/null | tr -d '[:space:]')
-    n="${n:-0}"; [ "$n" -gt "$max" ] && max="$n"
-  done
-  echo "$max"
-}
-```
-
-- [ ] **Step 2: Lint**
-
-Run: `shellcheck -x deploy/knative/lib.sh > /tmp/sh/shellcheck-lib.log 2>&1; echo "EXIT:$?"`
-Expected: EXIT:0 (or only pre-existing warnings unrelated to the new functions — inspect the log if non-zero).
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add deploy/knative/lib.sh
-git commit -s -m "feat: Add P3 experiment helpers to lib.sh (converge dispatch, timing, leases)
-
-dispatch_converge posts the P2 repoUrl+ref converge-path envelope; sum_exec_ms
-totals [exec-timing] ms from a harness pod log; max_leases_across_pool reads the
-P2 lease sets from Redis; plus gitd URL/wait and pool listing.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 6: E6 saturation driver
-
-Sweeps concurrent leaves against one pinned sandbox, computes the knee (CAP), the C=1 duty cycle (→ derived N), applies the sanity-floor gate, then runs the feed-back check on the pool at the derived CAP.
-
-**Files:**
-- Create: `deploy/knative/e6-saturation.sh`
-
-**Interfaces:**
-- Consumes: `lib.sh` helpers; the analysis functions via `node -e` calls into `experiments/src/sharing.ts` (run with `tsx`).
-- Env: `E6_LIVE` (gate), `E6_LADDER` (default `1 2 4 8 16`), `E6_DEGRADE_X` (default `2`), `E6_MIN_CONCURRENCY` (default `4`), `SH_MODEL`, `KSVC`, `NS`, `KSVC_URL` (OCP).
-
-- [ ] **Step 1: Create `deploy/knative/e6-saturation.sh`**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/e6-saturation.sh
-# E6: per-sandbox saturation curve. Pins one sandbox, sweeps concurrent leaves over
-# E6_LADDER, and reports the knee (recommended KAGENTI_SANDBOX_CAP) + the C=1 duty cycle
-# (=> derived provisioning ratio N). Gate: hard sanity floor (knee >= E6_MIN_CONCURRENCY);
-# the knee/N themselves are reported. Then a feed-back check runs the pool at the derived
-# CAP and asserts leases never exceed it. Records results to EXPERIMENTS.md.
-#
-# Usage: E6_LIVE=1 [E6_LADDER="1 2 4 8 16"] bash deploy/knative/e6-saturation.sh
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-[ "${E6_LIVE:-0}" = "1" ] || { echo "SKIP (set E6_LIVE=1)"; exit 0; }
-
-LADDER="${E6_LADDER:-1 2 4 8 16}"
-DEGRADE_X="${E6_DEGRADE_X:-2}"
-MIN_C="${E6_MIN_CONCURRENCY:-4}"
-PIN="${KAGENTI_SANDBOX_POD:-sandbox-0}"   # single-pod pin for the curve
-REF="branch-0"
-
-echo "--- E6: saturation (ladder='$LADDER' pin=$PIN degradeX=$DEGRADE_X floor=$MIN_C) ---"
-ensure_port_forward >/dev/null || true
-wait_gitd 120 || { echo "gitd not ready"; exit 1; }
-
-# Pin all leaves to one sandbox + enable exec timing; force a new revision and wait Ready.
-kubectl set env ksvc/"$KSVC" -n "$NS" \
-  KAGENTI_SANDBOX_POD="$PIN" KAGENTI_EXEC_TIMING=1 KAGENTI_SANDBOX_CAP=1000 >/dev/null
-wait_ksvc_ready
-
-# Fire C concurrent converge-leaves at ref branch-0; echo "<throughput> <p95ms>".
-run_rung() {
-  local c="$1" d; d="$(mktemp -d)"
-  local t0 t1 pids=""
-  t0=$(date +%s%3N)
-  local i=0
-  while [ "$i" -lt "$c" ]; do
-    ( ts=$(date +%s%3N)
-      dispatch_converge "e6-$c-$i-$$" "e6" "marker.txt" "$REF" "$REF" >/dev/null 2>&1
-      echo $(( $(date +%s%3N) - ts )) > "$d/$i.ms" ) & pids="$pids $!"
-    i=$((i + 1))
-  done
-  # shellcheck disable=SC2086
-  wait $pids
-  t1=$(date +%s%3N)
-  local wall=$(( t1 - t0 )); [ "$wall" -lt 1 ] && wall=1
-  local thr; thr=$(awk -v c="$c" -v w="$wall" 'BEGIN{printf "%.3f", c/(w/1000.0)}')
-  local p95; p95=$(cat "$d"/*.ms | sort -n | awk '{a[NR]=$1} END{printf "%d", a[int(NR*0.95+0.999)]?a[int(NR*0.95+0.999)]:a[NR]}')
-  rm -rf "$d"
-  echo "$thr $p95"
-}
-
-POINTS="[]"
-for c in $LADDER; do
-  read -r thr p95 <<<"$(run_rung "$c")"
-  echo "  c=$c throughput=$thr p95Ms=$p95"
-  POINTS=$(jq -c --argjson c "$c" --argjson t "$thr" --argjson p "$p95" \
-    '. + [{c:$c, throughput:$t, p95Ms:$p}]' <<<"$POINTS")
-done
-
-# C=1 duty cycle: sum exec ms from the (single) harness pod that served the c=1 leaf.
-HARNESS_POD=$(kubectl get pods -n "$NS" -l "serving.knative.dev/service=$KSVC" \
-  --field-selector=status.phase=Running --no-headers 2>/dev/null | awk 'NR==1{print $1}')
-EXEC_MS=$(sum_exec_ms "$HARNESS_POD"); EXEC_MS="${EXEC_MS:-0}"
-BASE_WALL=$(jq -r '.[0].p95Ms' <<<"$POINTS")   # c=1 p95 ~= the single leaf wall time
-
-# Compute knee, duty cycle, derived N, floor verdict via the tested analysis functions.
-read -r KNEE DUTY NRATIO FLOOR <<<"$(npx tsx -e '
-  import { detectKnee, dutyCycle, derivedRatio, sanityFloorPass } from "./experiments/src/sharing.ts";
-  const pts = JSON.parse(process.argv[1]);
-  const knee = detectKnee(pts, Number(process.argv[2]));
-  const duty = dutyCycle(Number(process.argv[3]), Number(process.argv[4]));
-  const n = derivedRatio(duty);
-  const floor = sanityFloorPass(knee, Number(process.argv[5]));
-  process.stdout.write(`${knee} ${duty.toFixed(3)} ${n} ${floor}`);
-' "$POINTS" "$DEGRADE_X" "$EXEC_MS" "$BASE_WALL" "$MIN_C")"
-
-echo "  knee(CAP)=$KNEE dutyCycle=$DUTY derivedN=$NRATIO floorPass=$FLOOR"
-
-# --- Feed-back check: pool at the derived CAP, leases never exceed it ---
-kubectl set env ksvc/"$KSVC" -n "$NS" \
-  KAGENTI_SANDBOX_POD- KAGENTI_SANDBOX_CAP="$KNEE" >/dev/null   # unpin, set CAP=knee
-wait_ksvc_ready
-BURST=$(( KNEE * 3 ))
-fb_pids=""
-for i in $(seq 1 "$BURST"); do
-  ( dispatch_converge "e6-fb-$i-$$" "e6" "marker.txt" "$REF" "$REF" >/dev/null 2>&1 ) & fb_pids="$fb_pids $!"
-done
-MAXL=0
-for _ in $(seq 1 30); do m=$(max_leases_across_pool); [ "$m" -gt "$MAXL" ] && MAXL="$m"; sleep 0.5; done
-# shellcheck disable=SC2086
-wait $fb_pids
-[ "$MAXL" -le "$KNEE" ] && ok "feed-back: max leases/pod $MAXL <= CAP $KNEE" \
-  || ko "feed-back: max leases/pod $MAXL exceeded CAP $KNEE"
-
-# --- Gate + record ---
-if [ "$FLOOR" = "true" ] && [ "$FAIL" = 0 ]; then GATE=yes; else GATE=no; fi
-echo "E6_RESULT knee=$KNEE dutyCycle=$DUTY derivedN=$NRATIO floorPass=$FLOOR maxLeases=$MAXL pass=$GATE"
-{
-  echo ""
-  echo "### E6 run $(cat /proc/sys/kernel/hostname 2>/dev/null || echo host)"
-  echo "- ladder: $LADDER"
-  echo "- points: $POINTS"
-  echo "- knee (recommended CAP): $KNEE"
-  echo "- duty cycle (C=1): $DUTY  =>  derived N ~= $NRATIO : 1"
-  echo "- sanity floor (>= $MIN_C): $FLOOR"
-  echo "- feed-back max leases/pod at CAP=$KNEE: $MAXL"
-  echo "- verdict: $GATE"
-} >> EXPERIMENTS.md
-
-[ "$GATE" = yes ] || exit 1
-```
-
-- [ ] **Step 2: Lint**
-
-Run: `shellcheck -x deploy/knative/e6-saturation.sh > /tmp/sh/shellcheck-e6.log 2>&1; echo "EXIT:$?"`
-Expected: EXIT:0 (or only benign warnings — inspect if non-zero).
-
-- [ ] **Step 3: Gate no-op check**
-
-Run: `bash deploy/knative/e6-saturation.sh; echo "EXIT:$?"`
-Expected: prints `SKIP (set E6_LIVE=1)` and EXIT:0 (no cluster contacted without the gate).
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/e6-saturation.sh
-git commit -s -m "feat: Add E6 saturation driver (knee/CAP + duty-cycle N + feed-back)
-
-Sweeps concurrent converge-leaves against one pinned sandbox, computes the knee
-(recommended CAP) and the C=1 duty cycle (derived N) via the tested analysis
-functions, gates on the sanity floor, then verifies the pool never exceeds the
-derived CAP. Gated by E6_LIVE=1; records to EXPERIMENTS.md.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 7: E7 converge-contention driver
-
-Runs C leaves converging **distinct** refs on one pinned pod; asserts mixed-ref correctness (hard gate) and reports the converge-wait contention profile.
-
-**Files:**
-- Create: `deploy/knative/e7-converge-contention.sh`
-
-**Interfaces:**
-- Consumes: `lib.sh` helpers; `worktreeConsistent` via `tsx`; the gitd refs `branch-0..branch-{K-1}`.
-- Env: `E7_LIVE` (gate), `E7_REFS` (default `8`), `SH_MODEL`, `KSVC`, `NS`, `KSVC_URL`.
-
-- [ ] **Step 1: Create `deploy/knative/e7-converge-contention.sh`**
-
-```bash
-#!/usr/bin/env bash
-# deploy/knative/e7-converge-contention.sh
-# E7: converge/fetch contention + mixed-ref correctness. Fires E7_REFS leaves that each
-# converge a DISTINCT ref (branch-0..branch-{E7_REFS-1}) on one pinned sandbox. Hard gate:
-# every leaf's worktree observed ONLY its own ref's marker (no cross-contamination) — this
-# is the live mixed-ref validation deferred from P2 Task 7. Reports converge-wait contention
-# (total exec ms under the shared /workspace/.sh-fetch.lock as concurrency rises).
-#
-# Usage: E7_LIVE=1 [E7_REFS=8] bash deploy/knative/e7-converge-contention.sh
-set -euo pipefail
-cd "$(dirname "$0")"
-source ./lib.sh
-
-[ "${E7_LIVE:-0}" = "1" ] || { echo "SKIP (set E7_LIVE=1)"; exit 0; }
-
-REFS="${E7_REFS:-8}"
-PIN="${KAGENTI_SANDBOX_POD:-sandbox-0}"
-
-echo "--- E7: converge contention + mixed-ref (refs=$REFS pin=$PIN) ---"
-ensure_port_forward >/dev/null || true
-wait_gitd 120 || { echo "gitd not ready"; exit 1; }
-kubectl set env ksvc/"$KSVC" -n "$NS" \
-  KAGENTI_SANDBOX_POD="$PIN" KAGENTI_EXEC_TIMING=1 KAGENTI_SANDBOX_CAP=1000 >/dev/null
-wait_ksvc_ready
-
-d="$(mktemp -d)"; pids=""; t0=$(date +%s%3N)
-i=0
-while [ "$i" -lt "$REFS" ]; do
-  ref="branch-$i"
-  # Each leaf reviews marker.txt for its OWN branch name; a correct verdict requires the
-  # worktree to be pinned at that ref. We capture the terminal JSON and (separately) read
-  # the marker the leaf's worktree actually held.
-  ( dispatch_converge "e7-$i-$$" "e7" "marker.txt" "$ref" "$ref" > "$d/$ref.json" 2>&1 ) & pids="$pids $!"
-  i=$((i + 1))
-done
-# shellcheck disable=SC2086
-wait $pids
-t1=$(date +%s%3N)
-
-# Read each leaf's worktree marker from the pinned pod (worktrees survive until cleanup;
-# we read via a fresh exec keyed by the runId path the harness derived).
-OBS="[]"
-i=0
-while [ "$i" -lt "$REFS" ]; do
-  ref="branch-$i"; sid="e7-$i-$$"
-  # toSessionId sanitizes sid; the worktree path is /workspace/leaves/<sanitized sid>.
-  wt="/workspace/leaves/${sid//[^A-Za-z0-9._-]/-}"
-  marker=$(kubectl -n "$NS" exec "$PIN" -- sh -c "cat '$wt/marker.txt' 2>/dev/null" | tr -d '[:space:]')
-  marker="${marker:-MISSING}"
-  OBS=$(jq -c --arg r "$sid" --arg e "$ref" --arg o "$marker" \
-    '. + [{runId:$r, expectedRef:$e, observedMarker:$o}]' <<<"$OBS")
-  i=$((i + 1))
-done
-
-# Hard correctness gate via the tested checker.
-CONSISTENT=$(npx tsx -e '
-  import { worktreeConsistent } from "./experiments/src/sharing.ts";
-  const r = worktreeConsistent(JSON.parse(process.argv[1]));
-  process.stdout.write(r.ok ? "ok" : "mismatch:" + JSON.stringify(r.mismatches));
-' "$OBS")
-
-[ "$CONSISTENT" = "ok" ] && ok "mixed-ref: every leaf saw only its own ref" \
-  || ko "mixed-ref cross-contamination: $CONSISTENT"
-
-CONVERGE_MS=$(sum_exec_ms "$(kubectl get pods -n "$NS" -l "serving.knative.dev/service=$KSVC" \
-  --field-selector=status.phase=Running --no-headers 2>/dev/null | awk 'NR==1{print $1}')")
-WALL=$(( t1 - t0 ))
-echo "E7_RESULT refs=$REFS wallMs=$WALL totalExecMs=${CONVERGE_MS:-0} consistent=$([ "$CONSISTENT" = ok ] && echo yes || echo no)"
-{
-  echo ""
-  echo "### E7 run"
-  echo "- refs (distinct, concurrent): $REFS"
-  echo "- mixed-ref consistency: $CONSISTENT"
-  echo "- wall ms: $WALL ; total sandbox exec ms (converge+tools): ${CONVERGE_MS:-0}"
-  echo "- observations: $OBS"
-} >> EXPERIMENTS.md
-rm -rf "$d"
-
-[ "$FAIL" = 0 ] || exit 1
-```
-
-- [ ] **Step 2: Lint**
-
-Run: `shellcheck -x deploy/knative/e7-converge-contention.sh > /tmp/sh/shellcheck-e7.log 2>&1; echo "EXIT:$?"`
-Expected: EXIT:0 (or only benign warnings).
-
-- [ ] **Step 3: Gate no-op check**
-
-Run: `bash deploy/knative/e7-converge-contention.sh; echo "EXIT:$?"`
-Expected: `SKIP (set E7_LIVE=1)` and EXIT:0.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add deploy/knative/e7-converge-contention.sh
-git commit -s -m "feat: Add E7 converge-contention driver (mixed-ref correctness + profile)
-
-Fires E7_REFS leaves converging distinct refs on one pinned sandbox; hard-gates
-that each worktree observed only its own ref (the live mixed-ref validation
-deferred from P2 Task 7) and reports the converge contention profile. Gated by
-E7_LIVE=1; records to EXPERIMENTS.md.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 8: Fix `setup-kind.sh` to deploy the pool (issue #54)
-
-Fresh Kind bring-up must deploy `sandbox-pool.yaml` (which carries the pool label and `git`), not the single `sandbox.yaml`, so `KAGENTI_SANDBOX_POOL_SELECTOR` resolves and P3's Kind experiments have a pool.
-
-**Files:**
-- Modify: `deploy/knative/setup-kind.sh` (the sandbox-deploy block, ~lines 108–122)
-
-**Interfaces:**
-- Consumes: `deploy/knative/sandbox-pool.yaml` (3 CRs `sandbox-0..2`, common pool label).
-
-- [ ] **Step 1: Replace the single-sandbox apply + wait**
-
-Replace the block that currently reads:
-
-```bash
-# 6. Deploy durable Sandbox CR
-echo "--- Deploying Sandbox CR ---"
-kubectl apply -f "$SCRIPT_DIR/sandbox.yaml"
-# Wait for the Sandbox controller to publish .status.selector, then wait for the pod
-SEL=""
-for _ in $(seq 1 60); do
-  SEL=$(kubectl -n default get sandbox sandbox-0 -o jsonpath='{.status.selector}' 2>/dev/null || true)
-  [ -n "$SEL" ] && break
-  sleep 2
-done
-[ -n "$SEL" ] && kubectl -n default wait --for=condition=Ready pod -l "$SEL" --timeout=180s || {
-  echo "sandbox pod not ready (selector='$SEL')"
-  kubectl -n default get sandbox sandbox-0 -o yaml | head -40
-  exit 1
-}
-```
-
-with the pool-aware version:
-
-```bash
-# 6. Deploy the durable Sandbox POOL (issue #54: pool, not a single sandbox — the harness
-#    resolves KAGENTI_SANDBOX_POOL_SELECTOR against all pool pods).
-echo "--- Deploying Sandbox pool ---"
-kubectl apply -f "$SCRIPT_DIR/sandbox-pool.yaml"
-# Wait for every pool pod (sandbox-0..N-1) to go Ready via the common pool label.
-POOL_SELECTOR="sh.kagenti.io/sandbox-pool=default"
-for _ in $(seq 1 90); do
-  ready=$(kubectl -n default get pods -l "$POOL_SELECTOR" \
-    --field-selector=status.phase=Running --no-headers 2>/dev/null | wc -l | tr -d ' ')
-  want=$(grep -c '^kind: Sandbox' "$SCRIPT_DIR/sandbox-pool.yaml")
-  [ "$ready" -ge "$want" ] && break
-  sleep 2
-done
-kubectl -n default wait --for=condition=Ready pod -l "$POOL_SELECTOR" --timeout=180s || {
-  echo "sandbox pool not all Ready (label='$POOL_SELECTOR')"
-  kubectl -n default get pods -l "$POOL_SELECTOR" -o wide | head -40
-  exit 1
-}
-```
-
-- [ ] **Step 2: Lint**
-
-Run: `shellcheck -x deploy/knative/setup-kind.sh > /tmp/sh/shellcheck-setup.log 2>&1; echo "EXIT:$?"`
-Expected: EXIT:0 (or only pre-existing warnings unrelated to this block).
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add deploy/knative/setup-kind.sh
-git commit -s -m "fix: setup-kind deploys the sandbox pool, not a single sandbox (#54)
-
-A fresh Kind bring-up applied sandbox.yaml (single CR, no pool label, no git),
-incoherent with KAGENTI_SANDBOX_POOL_SELECTOR. Apply sandbox-pool.yaml and wait
-for all N pool pods via the common label. Prerequisite for P3's Kind experiments.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 9: Docs — EXPERIMENTS.md section + RESULTS.md pointer
-
-Scaffolds where P3 numbers land and how to run the drivers.
-
-**Files:**
-- Modify: `deploy/knative/EXPERIMENTS.md`, `experiments/RESULTS.md`
-
-- [ ] **Step 1: Append the P3 section to `deploy/knative/EXPERIMENTS.md`**
-
-```markdown
-
-# P3 — Sandbox Sharing-Ratio Results
-
-Authoritative home for the P3 experiment numbers (cluster experiments record here, matching
-E1/E3/E4). See the design: `docs/specs/2026-07-03-p3-sandbox-sharing-ratio-experiments-design.md`.
-
-**How to run (develop on Kind, authoritative on OCP):**
-
-```bash
-# Kind sh-knative (3-pod pool up, gitd deployed via kustomize):
-E6_LIVE=1 bash deploy/knative/e6-saturation.sh
-E7_LIVE=1 bash deploy/knative/e7-converge-contention.sh
-
-# OCP 4.20 (authoritative): export KSVC_URL=<route>, KUBECONFIG=<ocp>, then the same.
-```
-
-## E6 — saturation curve (→ CAP + derived N)
-
-Pins one sandbox, sweeps concurrent leaves (`E6_LADDER`), reports the knee (recommended
-`KAGENTI_SANDBOX_CAP`) and the C=1 duty cycle (→ derived N ≈ 1/duty). Hard gate: sanity
-floor `knee >= E6_MIN_CONCURRENCY`. Feed-back: pool never exceeds the derived CAP. Runs
-append their `E6_RESULT` block below.
-
-## E7 — converge contention + mixed-ref correctness
-
-Fires `E7_REFS` leaves converging distinct refs on one pod. Hard gate: every leaf's worktree
-observed only its own ref (the live mixed-ref validation deferred from P2 Task 7). Reports the
-converge contention profile. Runs append their `E7_RESULT` block below.
-```
-
-- [ ] **Step 2: Add a P3 pointer to `experiments/RESULTS.md`**
-
-Append (do not rewrite the file — `report.ts:buildResultsMarkdown` regenerates the M6 sections, so keep P3 as static prose it will not clobber):
-
-```markdown
-
-## P3 — sandbox sharing ratio (E6/E7)
-
-Structural analysis is unit-tested in `experiments/test/e6-saturation-structural.test.ts` and
-`experiments/test/e7-converge-contention-structural.test.ts` (knee/duty-cycle/floor and
-mixed-ref/never-over-cap). **Authoritative cluster numbers live in
-`deploy/knative/EXPERIMENTS.md`** (the E6/E7 drivers append there, matching E1/E3/E4).
-```
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add deploy/knative/EXPERIMENTS.md experiments/RESULTS.md
-git commit -s -m "docs: Scaffold P3 sharing-ratio results (EXPERIMENTS.md + RESULTS.md pointer)
-
-Authoritative P3 numbers land in EXPERIMENTS.md (cluster-experiment convention);
-RESULTS.md points there and to the structural unit tests.
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
----
-
-## Task 10: Gated live verification (Kind → OCP)
-
-Not a CI task — this runs the drivers on real clusters and records the numbers. Verifies the whole plan end-to-end.
-
-**Files:** none (produces appended results in `EXPERIMENTS.md`, committed at the end).
-
-- [ ] **Step 1: Build + deploy on Kind `sh-knative`**
-
-Rebuild the harness image with the Task 1 change and redeploy (force a new ksvc revision — mutable `:local` tag needs a config bump, P2 lesson). Redirect build output:
-
-Run: `bash deploy/knative/setup-kind.sh > /tmp/sh/setup-kind.log 2>&1; echo "EXIT:$?"` (or the repo's image-rebuild path), then confirm the pool + gitd:
-`kubectl get pods -l sh.kagenti.io/sandbox-pool=default -n default --no-headers | wc -l` (expect 3) and `kubectl rollout status deploy/gitd -n default`.
-Analyze the log via a subagent if non-zero; do not read it inline.
-
-- [ ] **Step 2: Run E6 + E7 on Kind (gated)**
-
-```bash
-mkdir -p /tmp/sh
-E6_LIVE=1 bash deploy/knative/e6-saturation.sh > /tmp/sh/e6-kind.log 2>&1; echo "E6:$?"
-E7_LIVE=1 bash deploy/knative/e7-converge-contention.sh > /tmp/sh/e7-kind.log 2>&1; echo "E7:$?"
-```
-Expected: `E6:0` and `E7:0`. Dispatch a subagent to extract the `E6_RESULT`/`E7_RESULT` lines and any `FAIL:` from the logs (do not read the full logs inline). Kind numbers are shape/relative only (D5).
-
-- [ ] **Step 3: Run authoritative E6 + E7 on OCP 4.20**
-
-```bash
-export KUBECONFIG=/Users/paolo/Projects/ocp/auth/kubeconfig
-export KSVC_URL=$(oc get ksvc serverless-harness -n default -o jsonpath='{.status.url}')
-# Ensure gitd + pool deployed on OCP (kubectl apply -k deploy/knative/overlays/ocp), then:
-E6_LIVE=1 bash deploy/knative/e6-saturation.sh > /tmp/sh/e6-ocp.log 2>&1; echo "E6:$?"
-E7_LIVE=1 bash deploy/knative/e7-converge-contention.sh > /tmp/sh/e7-ocp.log 2>&1; echo "E7:$?"
-```
-Expected: `E6:0`, `E7:0`; recovering the recommended CAP + derived N. If `/turn`/`/runs` errors with "Connection error", re-provision `llm-credentials` with an api-key only (P0′ lesson). Analyze via subagent.
-
-- [ ] **Step 4: Record + commit the authoritative numbers**
-
-The drivers already appended `E6_RESULT`/`E7_RESULT` blocks to `EXPERIMENTS.md`. Trim to the authoritative OCP run, add one summary line (recommended `KAGENTI_SANDBOX_CAP` + derived N), then:
-
-```bash
-git add deploy/knative/EXPERIMENTS.md
-git commit -s -m "docs: Record P3 E6/E7 results (CAP + derived N) from live OCP 4.20
-
-Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>"
-```
-
-- [ ] **Step 5: Push the branch and open the PR**
-
-```bash
-git push -u origin docs/p3-sandbox-sharing-experiments
-gh pr create --title "P3: Sandbox sharing-ratio experiments (E6/E7 + git-daemon substrate)" \
-  --body "$(cat <<'EOF'
-Implements P3 (#48) of the two-tier epic (#49): the sharing-ratio experiments on runc.
-
-- Env-gated exec-timing hook (off by default) for duty-cycle measurement.
-- E6 saturation curve → recommended KAGENTI_SANDBOX_CAP + derived N; E7 converge
-  contention + the live mixed-ref validation deferred from P2 Task 7.
-- Hermetic in-cluster git-daemon load substrate.
-- setup-kind deploys the pool (#54).
-- Structural analysis unit-tested; authoritative numbers in EXPERIMENTS.md.
-
-Kata/VM isolation + intra-pod hardening remain P4 (#57).
-
-Assisted-By: Claude Code
-EOF
-)"
-```
-
----
-
-## Self-Review
-
-**1. Spec coverage** (spec `2026-07-03-p3-sandbox-sharing-ratio-experiments-design.md`):
-
-| Spec item | Task |
-|-----------|------|
-| §4 concurrency knee → CAP | Task 2 (`detectKnee`) + Task 6 |
-| §4 duty cycle → derived N | Task 1 (timing) + Task 2 (`dutyCycle`/`derivedRatio`) + Task 6 |
-| §4 converge wait / contention | Task 3 + Task 7 |
-| §4 sandbox CPU/mem per level | Task 6 (reported per rung; CPU via exec-timing sum — see deviation) |
-| §5.1 E6 saturation curve | Task 2 + Task 6 |
-| §5.2 E7 contention + mixed-ref correctness (P2 Task 7) | Task 3 + Task 7 |
-| §5.3 feed-back check at derived CAP | Task 6 (final phase) |
-| §6 in-cluster git-daemon substrate | Task 4 |
-| §6 file:// rejected | honored (git:// only) |
-| §7 vitest structural + gated live drivers | Tasks 2/3 (structural) + Tasks 6/7 (live, `E6_LIVE`/`E7_LIVE`) |
-| §7 lib.sh helper reuse + new helpers | Task 5 |
-| §7 results → EXPERIMENTS.md / RESULTS.md | Task 9 (see deviation) |
-| §7 live-run lessons (min-scale, `:local` revision, `-k`, api-key-only) | Task 10 |
-| §11 fold in #54 | Task 8 |
-| §11 #55/#56 left separate | honored (not touched) |
-| §8 P4 handoff, §11 non-goals | out of scope by design (P4 #57) |
-
-**2. Placeholder scan:** No `TBD`/`TODO`/"add error handling"/"similar to Task N". Every code step shows complete code. (One in-repo `TODO(M3)` comment in `exec.ts:47` is pre-existing and untouched.)
-
-**3. Type consistency:** `LadderPoint` (Task 2) used by `detectKnee` (Task 2) and produced by Task 6's `POINTS` JSON with matching keys `c/throughput/p95Ms`. `LeafObservation` (Task 3, keys `runId/expectedRef/observedMarker`) produced by Task 7's `OBS` JSON with the same keys. `dispatch_converge` (Task 5) sends `LeafEnvelope` keys verified against `harness/src/run-leaf.ts:49` (`sessionId`, `item.{item_id,file,pattern}`, `repoUrl`, `ref`, `model`). Lease key `sh:sandbox:<pod>:leases` and `RedisLeaseStore.{acquire,load,release}` match `harness/src/sandbox-lease.ts`.
-
-**Deviations flagged for the user (resolve at review):**
-- **§4 CPU/mem "per level":** the plan reports sandbox-busy time via the exec-timing sum rather than a separate metrics-server CPU/mem sample per rung (metrics-server is ~15s-coarse vs sub-second execs, so it would be noisy). If a true CPU/mem-per-rung table is wanted, add a `kubectl top pod` sampler rung-by-rung — small addition to Task 6.
-- **§7 results in RESULTS.md:** to avoid clobbering the M6 `RESULTS.md` (its `report.ts:buildResultsMarkdown` rewrites the whole file), P3's authoritative numbers live in `EXPERIMENTS.md` (matching the E1/E3/E4 cluster-experiment convention) and `RESULTS.md` gets a pointer. If you want P3 tables physically in `RESULTS.md`, that needs a clobber-safe section-merge util (extra small task).