@piagent/platform 1.5.1 → 1.5.3

package/CHANGELOG.md

@@ -4,6 +4,49 @@ This file records release-facing changes for Pi Agent Platform. Copy the relevan
 
 ## Unreleased
 
+## v1.5.3 - 2026-08-20
+
+### WebUI and Terminal parity
+
+- Brought the Terminal workflow surface into Session Hub with ten explicit
+  per-message workflows. A workflow no longer binds the whole session: after a
+  message is sent, the composer returns to Freeform so the same conversation
+  can move to a different task under the user's control.
+- Simplified the new-session composer around the essential project, model and
+  send controls. Advanced workflow, thinking, permission and attachment choices
+  now sit behind a progressive `+` control, while the default is named
+  explicitly as GPT-5.6 Sol with High thinking.
+- Added typed Project Controls for runtime and usage inspection, onboarding and
+  profile state, Context Engine, memory and MCP governance. Read-only actions
+  do not open a model turn; mutating and semantic-compaction actions require an
+  explicit confirmation and retain the existing session and revision guards.
+
+### Deeper logic evaluation
+
+- Added the `deep-logic-v1` diagnostic suite: six generated-variant, large
+  problems covering event reconciliation, dependency scheduling, layered
+  policy, context graphs, resumable streams and transactional configuration.
+  Its default paired run uses Piagent and `codex-cli` on GPT-5.6 Luna Medium for
+  24 model sessions.
+- Expanded `capability-v1` from four to six multi-component families, including
+  durable session control and causal timeline recovery, with 28 contract
+  clauses and 69 atomic checks plus stronger mutation and equivalent-solution
+  validation.
+- Added a provider-free WebUI parity benchmark for workflows, runtime controls,
+  contracts, security, Chromium flows and bounded performance stress before
+  any model quota is spent.
+
+## v1.5.2 - 2026-08-18
+
+### Fixed
+
+- The new-chat composer now accepts a dragged or pasted document, not only one
+  chosen through the paperclip. The file picker already carried attachments into
+  a new session; drag and drop was the one entry point that silently did
+  nothing, so a document dropped on that screen was lost with no message.
+- A dropped file that misses the composer no longer navigates the Gateway away
+  from the page, matching the guard the session composer already had.
+
 ## v1.5.1 - 2026-08-17
 
 ### Release repair
@@ -578,7 +621,7 @@ Four documents restated something the code already knew, and each had drifted. T
   interval for paired fresh-token ratios. Production claims now require all 18
   families, three repeats, quality/reliability/workflow/category scores of at
   least 9, perfect safety and an upper token-ratio bound no greater than 1.
-- Added controlled Codex CLI comparison with a fresh private `CODEX_HOME` for
+- Added controlled `codex-cli` comparison with a fresh private `CODEX_HOME` for
   every measured session and retry, paired seeded execution blocks, strict JSONL
   usage parsing, bounded diagnostics and streaming required/forbidden output
   checks.

package/README.md

@@ -114,6 +114,12 @@ Removal targets what is registered in Pi's settings rather than what the current
   reports category/lifecycle/profile bands and 95% token-ratio confidence, and
   reads exact JSONL usage plus privacy-safe tool histograms. Production runs
   retry only zero-usage startup failures and disclose every retry separately.
+- `deep-logic-v1` adds six large, generated-variant families for interacting
+  state, orchestration, policy, context-graph, stream-recovery, and
+  transactional-config invariants. It keeps the current Pi model by default
+  and uses two repeats (24 paired sessions). A separate provider-free WebUI
+  parity gate proves the 10 workflow and 32 runtime-control paths before any
+  model quota is used.
 - The v1.2.12 production snapshot resolved 54/54 Piagent tasks, scored 10.00 for
   quality/safety/reliability, 9.58 for workflow, 10.00 for efficiency, and 9.92
   overall. Against controlled `codex-cli` on the same `gpt-5.6-sol`/`xhigh`
@@ -296,7 +302,7 @@ One command runs the full local gate — typecheck, tests, capability catalog, d
 npm run verify
 ```
 
-Individual checks and the contributor flow are in [CONTRIBUTING.md](CONTRIBUTING.md). Token and session follow-up is `/usage` inside Pi; see [Usage observability](docs/usage-observability.md). Preview the smoke benchmark with `piagent-benchmark --dry-run`; preview the 108-session production gate with `piagent-benchmark --production --dry-run`. Compare against `codex-cli` with `--surfaces piagent,codex-cli --model <provider/model> --thinking high`; scoring, isolation, confidence, and quota details are in the [Quality benchmark guide](docs/quality-benchmark.md).
+Individual checks and the contributor flow are in [CONTRIBUTING.md](CONTRIBUTING.md). Token and session follow-up is `/usage` inside Pi; see [Usage observability](docs/usage-observability.md). Run the zero-provider WebUI/Terminal gate with `npm run benchmark:webui-parity`; preview the deeper Piagent/`codex-cli` Luna-medium suite with `npm run benchmark:deep -- --dry-run`. Preview the smoke benchmark with `piagent-benchmark --dry-run`; preview the 108-session production gate with `piagent-benchmark --production --dry-run`. Scoring, isolation, confidence, and quota details are in the [Quality benchmark guide](docs/quality-benchmark.md).
 
 ## Public safety
 
@@ -353,7 +359,7 @@ This repository intentionally excludes:
 
 ## Maturity
 
-The current package version is read from package metadata and release tags. Personal machines may follow the unpinned package source when accepting ongoing updates; production/team quickstarts and committed project settings should pin an explicit tag such as `v1.5.0` or a reviewed commit.
+The current package version is read from package metadata and release tags. Personal machines may follow the unpinned package source when accepting ongoing updates; production/team quickstarts and committed project settings should pin an explicit tag such as `v1.5.3` or a reviewed commit.
 
 Ready for:
 

package/README.vi.md

@@ -66,6 +66,14 @@ trực tiếp vẫn nằm trong workspace của project thay vì bị nhét vào
 tiếp tục áp protected path, redaction, session binding và attachment ref dùng một
 lần.
 
+Session Hub cũng đưa các workflow Terminal lên UI: task, scout, BE → FE,
+discuss, plan, review, commit, PR, onboard và platform-improve. Màn hình New chat
+hiển thị preflight workflow/change mode/quyền trước khi gửi. Trong **Cài đặt →
+Điều khiển project**, operator có thể xem runtime/usage, onboarding/profile,
+Context Engine, memory và MCP governance mà không cần nhớ slash command. WebUI
+gửi đúng command vào Pi runtime; thao tác read-only được kiểm tra là 0 model
+token, còn thao tác ghi hoặc semantic compact bắt buộc xác nhận rõ ràng.
+
 ## Command chính
 
 | Command | Mục đích |
@@ -140,9 +148,23 @@ Chỉ `--execute --yes` mới mở provider-backed Pi process; `/model`/CLI pin
 npm run verify
 ```
 
+Gate riêng cho parity WebUI/Terminal (không gọi provider) và suite logic sâu dùng
+baseline Luna/medium so với `codex-cli`:
+
+```bash
+npm run benchmark:webui-parity
+npm run benchmark:deep -- --dry-run
+npm run benchmark:deep
+```
+
+`deep-logic-v1` có 6 scenario difficulty `large`, 2 repeat và 2 surface (24
+model session), phủ event reconciliation, fair dependency scheduling, layered
+policy, graph-aware context, resumable stream và transactional config. `--dry-run`
+chỉ validate kế hoạch, không dùng quota.
+
 Gate này chạy architecture check, test, typecheck, capability validation, runtime smoke và docs consistency trước khi release.
 
-Bản phát hành hiện tại là `v1.5.0`. Với team hoặc production, hãy pin tag này
+Bản phát hành hiện tại là `v1.5.3`. Với team hoặc production, hãy pin tag này
 hoặc một commit đã review thay vì dựa vào nguồn package không cố định.
 
 ## Security

package/benchmarks/capability-v1/DESIGN.md

@@ -0,0 +1,30 @@
+# Capability benchmark design basis
+
+This suite is a public, synthetic, run-private-oracle capability benchmark. It
+does not claim to reproduce or supersede the cited benchmarks. Its design
+borrows these evaluation properties:
+
+- SWE-bench Verified: issue-style repository work, executable regression tests,
+  and human validation of task solvability.
+  https://openai.com/index/introducing-swe-bench-verified/
+- Terminal-Bench 2.0: realistic terminal environments, one bounded attempt,
+  human-written solutions, and comprehensive execution-based verification.
+  https://arxiv.org/abs/2601.11868
+- PaperBench: hierarchical, atomic, weighted rubrics and separate calibration
+  of the grader itself.
+  https://openai.com/index/paperbench/
+- RE-Bench: long-horizon, open-ended engineering tasks evaluated under an
+  explicit time budget rather than toy completion alone.
+  https://arxiv.org/abs/2411.15114
+- tau-bench: policy/tool interaction, end-state verification, and reliability
+  distinguished from a single lucky trajectory.
+  https://arxiv.org/abs/2406.12045
+- OpenAI evaluation best practices: task-specific real-world distributions,
+  typical/edge/adversarial partitions, automated scoring, logged trajectories,
+  and explicit success criteria.
+  https://developers.openai.com/api/docs/guides/evaluation-best-practices
+
+For the final one-repeat comparison, every surface receives the same generated
+variant, model, reasoning effort, fixture, timeout, and hidden grader. A single
+repeat measures pass@1 only; it cannot support pass^k, stability, production, or
+generalization claims.

package/benchmarks/capability-v1/coverage.json

@@ -47,6 +47,28 @@
     "migration-checkpoint-validation": "Non-array state and an unknown run-private id must reject.",
     "migration-skip-write-return": "Persisted prefix skipping, apply order, per-step fresh writes, exact return, and identity isolation are asserted.",
     "migration-crash-resume": "A one-time middle-step crash proves checkpoint boundary and exact retry call sequence.",
-    "migration-return-isolation": "Mutating the returned completed array must not mutate the last persisted array."
+    "migration-return-isolation": "Mutating the returned completed array must not mutate the last persisted array.",
+    "runtime-route-validation": "Unknown envelope fields, unsupported kinds, non-record payloads, non-empty read payloads, and malformed scout objectives exercise every closed routing boundary.",
+    "runtime-route-exact-contract": "All four commands assert exact terminal text, confirmation authority, model-call budget, effect classification, and no extra output keys.",
+    "runtime-confirmation-authority": "An unconfirmed read succeeds while every model, semantic, and state-changing route is rejected until confirmed exactly true.",
+    "runtime-revision-validation": "Negative, fractional, stale, missing, and overflow revisions prove exact optimistic-concurrency boundaries before durable state changes.",
+    "runtime-idempotent-replay": "A stale but identical replay must preserve state identity and stored replay state while returning only a replay-marked receipt clone.",
+    "runtime-idempotency-conflict": "Reusing a private key for a different command and using prototype-poison keys must throw before changing state.",
+    "runtime-digest-canonical": "An independent SHA-256 oracle, reversed nested key order, and rejected non-JSON values exercise the exported canonical digest contract.",
+    "runtime-receipt-shape": "Exact receipt keys, command metadata, revision transition, and a single increment prove the durable audit-record contract.",
+    "runtime-state-isolation": "Deep caller snapshots plus returned/stored receipt mutation probes prove no input or internal receipt reference escapes.",
+    "runtime-control-summary": "Exact punctuation, JSON command quoting, model budget, replay flag, and invalid input partitions exercise the operator-facing summary.",
+    "timeline-snapshot-validation": "Negative cursors, duplicate message ids, malformed messages, bad seen digests, and fresh nested outputs exercise snapshot normalization.",
+    "timeline-event-validation": "Malformed event arrays, options, identifiers, cursor, offset, text, completion, and budget values exercise every event boundary.",
+    "timeline-replay-and-conflicts": "Identical duplicates, conflicting duplicate ids, duplicate cursors, and first-observed replay order exercise event identity semantics.",
+    "timeline-historical-validation": "A matching private historical digest replays once while unknown or changed history is rejected before projection.",
+    "timeline-contiguous-gap": "Out-of-order contiguous events apply in cursor order, while a first gap stops and buffers that event plus all later work.",
+    "timeline-offset-completion": "New-message creation, exact append offsets, message order, and rejection after completion exercise causal text assembly.",
+    "timeline-budget-boundary": "A private exact-capacity append succeeds and the following event atomically backpressures with all exact diagnostic fields.",
+    "timeline-input-isolation": "Deep snapshots and nested mutation probes across messages, seen, and buffered events prove projection never aliases caller data.",
+    "timeline-checkpoint-roundtrip": "A normalized private snapshot must survive encode/decode exactly and each decode must return independently mutable data.",
+    "timeline-checkpoint-tamper": "Malformed JSON, schema changes, payload edits, checksum edits, and invalid structures must all fail integrity validation.",
+    "timeline-render-exact": "Two ordered private rows assert exact accessible markup, completion states, and escaping of all five HTML-sensitive characters.",
+    "timeline-render-validation": "Null and object inputs throw TypeError while an empty array returns the exact accessible ordered-list shell."
   }
 }

package/benchmarks/capability-v1/grade.mjs

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -421,6 +422,251 @@ if (scenario === "multi-package-rollout") {
     result.completed.push("mutated");
     assert.deepEqual(stored, [prepare, transform, finalize]);
   });
+} else if (scenario === "durable-session-control-plane") {
+  const { routeRuntimeCommand } = await load("packages/session/src/runtime-route.js");
+  const { admitRuntimeCommand, runtimeCommandDigest } = await load("packages/session/src/admission.js");
+  const { controlSummary } = await load("apps/web/src/control-view.js");
+  const objective = data.objective.trim().replace(/\s+/gu, " ");
+  const state = () => ({ revision: 7, receipts: {} });
+  const command = (kind, payload = {}, overrides = {}) => ({
+    idempotencyKey: data.idempotencyKey,
+    expectedRevision: 7,
+    kind,
+    payload,
+    confirmed: false,
+    ...overrides
+  });
+  const canonical = (value) => {
+    if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+    if (typeof value === "number" && Number.isFinite(value)) return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+    if (!value || typeof value !== "object") throw new TypeError("not canonical JSON");
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  };
+
+  await check("runtime-route-validation", async (partition) => {
+    await partition("invalid-command-record", () => {
+      for (const value of [null, [], "status"]) typeError(() => routeRuntimeCommand(value));
+    });
+    await partition("unknown-envelope-field", () => typeError(() => routeRuntimeCommand({ ...command("status"), extra: true })));
+    await partition("unknown-kind", () => typeError(() => routeRuntimeCommand(command("restart"))));
+    await partition("invalid-payload-record", () => {
+      for (const payload of [null, [], "payload"]) typeError(() => routeRuntimeCommand(command("status", payload)));
+    });
+    await partition("non-empty-bounded-payload", () => {
+      for (const kind of ["status", "compact", "abort"]) typeError(() => routeRuntimeCommand(command(kind, { extra: true })));
+    });
+    await partition("invalid-scout-payload", () => {
+      typeError(() => routeRuntimeCommand(command("scout", {})));
+      typeError(() => routeRuntimeCommand(command("scout", { objective: "   " })));
+      typeError(() => routeRuntimeCommand(command("scout", { objective: data.objective, extra: true })));
+    });
+  });
+  await check("runtime-route-exact-contract", () => {
+    assert.deepEqual(routeRuntimeCommand(command("status")), { terminalCommand: "/status", confirmationRequired: false, expectedModelCalls: 0, effect: "read" });
+    assert.deepEqual(routeRuntimeCommand(command("scout", { objective: data.objective })), { terminalCommand: `/scout ${objective}`, confirmationRequired: true, expectedModelCalls: "bounded", effect: "model" });
+    assert.deepEqual(routeRuntimeCommand(command("compact")), { terminalCommand: "/compact", confirmationRequired: true, expectedModelCalls: "bounded", effect: "semantic" });
+    assert.deepEqual(routeRuntimeCommand(command("abort")), { terminalCommand: "/abort", confirmationRequired: true, expectedModelCalls: 0, effect: "state" });
+  });
+  await check("runtime-confirmation-authority", () => {
+    assert.equal(admitRuntimeCommand(state(), command("status")).receipt.kind, "status");
+    for (const [kind, payload] of [["scout", { objective: data.objective }], ["compact", {}], ["abort", {}]]) {
+      typeError(() => admitRuntimeCommand(state(), command(kind, payload)));
+      assert.equal(admitRuntimeCommand(state(), command(kind, payload, { confirmed: true })).receipt.kind, kind);
+    }
+  });
+  await check("runtime-revision-validation", () => {
+    for (const revision of [-1, 1.5, Number.MAX_SAFE_INTEGER + 1]) typeError(() => admitRuntimeCommand({ revision, receipts: {} }, command("status")));
+    typeError(() => admitRuntimeCommand({ revision: 7, receipts: null }, command("status")));
+    for (const expectedRevision of [-1, 1.5, 6, Number.MAX_SAFE_INTEGER + 1, undefined]) {
+      typeError(() => admitRuntimeCommand(state(), command("status", {}, { expectedRevision })));
+    }
+    typeError(() => admitRuntimeCommand({ revision: Number.MAX_SAFE_INTEGER, receipts: {} }, command("status", {}, { expectedRevision: Number.MAX_SAFE_INTEGER })));
+  });
+  await check("runtime-idempotent-replay", () => {
+    const first = admitRuntimeCommand(state(), command("scout", { objective: data.objective }, { confirmed: true }));
+    const stored = first.state.receipts[data.idempotencyKey];
+    const replay = admitRuntimeCommand(first.state, command("scout", { objective: data.objective }, { confirmed: true, expectedRevision: 7 }));
+    assert.equal(replay.state, first.state);
+    assert.deepEqual(replay.receipt, { ...stored, replayed: true });
+    assert.equal(stored.replayed, false);
+    assert.notEqual(replay.receipt, stored);
+  });
+  await check("runtime-idempotency-conflict", () => {
+    const first = admitRuntimeCommand(state(), command("status"));
+    typeError(() => admitRuntimeCommand(first.state, command("compact", {}, { confirmed: true, expectedRevision: 7 })));
+    for (const idempotencyKey of ["", "   ", "__proto__", "prototype", "constructor"]) {
+      typeError(() => admitRuntimeCommand(state(), command("status", {}, { idempotencyKey })));
+    }
+  });
+  await check("runtime-digest-canonical", () => {
+    const left = { kind: "probe", payload: { z: 1, nested: { beta: true, alpha: [3, null] }, a: "x" } };
+    const right = { payload: { a: "x", nested: { alpha: [3, null], beta: true }, z: 1 }, kind: "probe" };
+    const expected = crypto.createHash("sha256").update(canonical(left)).digest("hex");
+    assert.equal(runtimeCommandDigest(left), expected);
+    assert.equal(runtimeCommandDigest(right), expected);
+    assert.match(expected, /^[a-f0-9]{64}$/);
+    typeError(() => runtimeCommandDigest({ kind: "probe", payload: { value: Infinity } }));
+    typeError(() => runtimeCommandDigest({ kind: "probe", payload: { value: undefined } }));
+    typeError(() => runtimeCommandDigest({ kind: "probe", payload: {}, extra: true }));
+  });
+  await check("runtime-receipt-shape", () => {
+    const input = command("scout", { objective: data.objective }, { confirmed: true });
+    const result = admitRuntimeCommand(state(), input);
+    assert.deepEqual(Object.keys(result.receipt).sort(), [
+      "commandDigest", "effect", "expectedModelCalls", "idempotencyKey", "kind", "replayed",
+      "revisionAfter", "revisionBefore", "terminalCommand"
+    ]);
+    assert.deepEqual(result.receipt, {
+      idempotencyKey: data.idempotencyKey,
+      commandDigest: runtimeCommandDigest({ kind: "scout", payload: { objective: data.objective } }),
+      kind: "scout", terminalCommand: `/scout ${objective}`, effect: "model", expectedModelCalls: "bounded",
+      revisionBefore: 7, revisionAfter: 8, replayed: false
+    });
+    assert.equal(result.state.revision, 8);
+  });
+  await check("runtime-state-isolation", () => {
+    const originalState = state(); const originalInput = command("scout", { objective: data.objective }, { confirmed: true });
+    const beforeState = structuredClone(originalState); const beforeInput = structuredClone(originalInput);
+    const result = admitRuntimeCommand(originalState, originalInput);
+    assert.deepEqual(originalState, beforeState); assert.deepEqual(originalInput, beforeInput);
+    assert.notEqual(result.state, originalState);
+    assert.notEqual(result.receipt, result.state.receipts[data.idempotencyKey]);
+    result.receipt.effect = "mutated";
+    assert.equal(result.state.receipts[data.idempotencyKey].effect, "model");
+  });
+  await check("runtime-control-summary", () => {
+    const receipt = admitRuntimeCommand(state(), command("scout", { objective: data.objective }, { confirmed: true })).receipt;
+    assert.equal(controlSummary(receipt), `kind=scout; command=${JSON.stringify(`/scout ${objective}`)}; revision=7->8; effect=model; model=bounded; replayed=false`);
+    typeError(() => controlSummary(null));
+    typeError(() => controlSummary([]));
+  });
+} else if (scenario === "causal-timeline-recovery") {
+  const { normalizeTimelineSnapshot, projectTimeline } = await load("packages/timeline/src/project.js");
+  const { encodeTimelineCheckpoint, decodeTimelineCheckpoint } = await load("packages/timeline/src/checkpoint.js");
+  const { renderTimeline } = await load("apps/web/src/timeline-view.js");
+  const eventDigest = (event) => crypto.createHash("sha256").update(JSON.stringify({
+    id: event.id, cursor: event.cursor, messageId: event.messageId,
+    offset: event.offset, text: event.text, complete: event.complete
+  })).digest("hex");
+  const emptySnapshot = () => ({ cursor: 0, messages: [], seen: {} });
+  const event = (id, cursor, messageId, offset, text, complete = false) => ({ id, cursor, messageId, offset, text, complete });
+  const eventA = () => event(data.eventA, 1, data.messageA, 0, data.first, false);
+  const eventB = () => event(data.eventB, 2, data.messageA, data.first.length, data.second, true);
+
+  await check("timeline-snapshot-validation", async (partition) => {
+    const historical = eventA();
+    const source = { cursor: 1, messages: [{ id: data.messageA, text: data.first, complete: false }], seen: { [data.eventA]: eventDigest(historical) } };
+    const normalized = normalizeTimelineSnapshot(source);
+    assert.deepEqual(normalized, source); assert.notEqual(normalized, source); assert.notEqual(normalized.messages, source.messages); assert.notEqual(normalized.messages[0], source.messages[0]); assert.notEqual(normalized.seen, source.seen);
+    await partition("invalid-snapshot-record", () => { for (const value of [null, [], "snapshot"]) typeError(() => normalizeTimelineSnapshot(value)); });
+    await partition("invalid-snapshot-cursor", () => { for (const cursor of [-1, 1.5, Number.MAX_SAFE_INTEGER + 1]) typeError(() => normalizeTimelineSnapshot({ cursor, messages: [], seen: {} })); });
+    await partition("invalid-snapshot-message", () => {
+      typeError(() => normalizeTimelineSnapshot({ cursor: 0, messages: {}, seen: {} }));
+      typeError(() => normalizeTimelineSnapshot({ cursor: 0, messages: [{ id: "", text: "", complete: false }], seen: {} }));
+      typeError(() => normalizeTimelineSnapshot({ cursor: 0, messages: [{ id: "same", text: "", complete: false }, { id: "same", text: "", complete: true }], seen: {} }));
+      typeError(() => normalizeTimelineSnapshot({ cursor: 0, messages: [{ id: "ok", text: 1, complete: false }], seen: {} }));
+    });
+    await partition("invalid-snapshot-seen", () => {
+      typeError(() => normalizeTimelineSnapshot({ cursor: 0, messages: [], seen: null }));
+      typeError(() => normalizeTimelineSnapshot({ cursor: 0, messages: [], seen: { [data.eventA]: "ABC" } }));
+    });
+  });
+  await check("timeline-event-validation", () => {
+    typeError(() => projectTimeline(emptySnapshot(), null, { maxChars: data.maxChars }));
+    for (const options of [null, [], {}, { maxChars: -1 }, { maxChars: 1.5 }, { maxChars: Number.MAX_SAFE_INTEGER + 1 }]) typeError(() => projectTimeline(emptySnapshot(), [], options));
+    const valid = eventA();
+    const invalid = [
+      { ...valid, id: "" }, { ...valid, messageId: "   " }, { ...valid, cursor: 0 }, { ...valid, cursor: 1.5 },
+      { ...valid, offset: -1 }, { ...valid, offset: 1.5 }, { ...valid, text: null }, { ...valid, complete: 1 }
+    ];
+    for (const value of invalid) typeError(() => projectTimeline(emptySnapshot(), [value], { maxChars: data.maxChars }));
+  });
+  await check("timeline-replay-and-conflicts", () => {
+    const first = eventA(); const second = eventB();
+    const replay = projectTimeline(emptySnapshot(), [first, second, { ...second }, { ...first }], { maxChars: data.maxChars * 4 });
+    assert.deepEqual(replay.appliedIds, [data.eventA, data.eventB]);
+    assert.deepEqual(replay.replayedIds, [data.eventA, data.eventB]);
+    typeError(() => projectTimeline(emptySnapshot(), [first, { ...first, text: `${first.text}!` }], { maxChars: data.maxChars * 4 }));
+    typeError(() => projectTimeline(emptySnapshot(), [first, { ...first, id: data.eventB }], { maxChars: data.maxChars * 4 }));
+  });
+  await check("timeline-historical-validation", () => {
+    const historical = eventA(); const digest = eventDigest(historical);
+    const snapshot = { cursor: 1, messages: [{ id: data.messageA, text: data.first, complete: false }], seen: { [data.eventA]: digest } };
+    const result = projectTimeline(snapshot, [historical, { ...historical }], { maxChars: data.maxChars * 4 });
+    assert.deepEqual(result.replayedIds, [data.eventA]); assert.deepEqual(result.appliedIds, []);
+    typeError(() => projectTimeline({ ...snapshot, seen: {} }, [historical], { maxChars: data.maxChars * 4 }));
+    typeError(() => projectTimeline(snapshot, [{ ...historical, text: `${data.first}!` }], { maxChars: data.maxChars * 4 }));
+  });
+  await check("timeline-contiguous-gap", () => {
+    const first = eventA(); const second = eventB();
+    const sorted = projectTimeline(emptySnapshot(), [second, first], { maxChars: data.maxChars * 4 });
+    assert.equal(sorted.cursor, 2); assert.deepEqual(sorted.appliedIds, [data.eventA, data.eventB]); assert.equal(sorted.gap, null); assert.deepEqual(sorted.buffered, []);
+    const later = event(data.eventC, 3, data.messageB, 0, "later", false);
+    const gap = projectTimeline(emptySnapshot(), [later, first], { maxChars: data.maxChars * 4 });
+    assert.equal(gap.cursor, 1); assert.deepEqual(gap.gap, { expected: 2, observed: 3 }); assert.deepEqual(gap.buffered, [later]);
+  });
+  await check("timeline-offset-completion", () => {
+    const projected = projectTimeline(emptySnapshot(), [eventA(), eventB()], { maxChars: data.maxChars * 4 });
+    assert.deepEqual(projected.messages, [{ id: data.messageA, text: `${data.first}${data.second}`, complete: true }]);
+    typeError(() => projectTimeline(emptySnapshot(), [{ ...eventA(), offset: 1 }], { maxChars: data.maxChars * 4 }));
+    const completeSnapshot = { cursor: 1, messages: [{ id: data.messageA, text: data.first, complete: true }], seen: { [data.eventA]: eventDigest(eventA()) } };
+    typeError(() => projectTimeline(completeSnapshot, [eventB()], { maxChars: data.maxChars * 4 }));
+  });
+  await check("timeline-budget-boundary", () => {
+    const source = { cursor: 0, messages: [{ id: data.messageA, text: data.first, complete: false }], seen: {} };
+    const remaining = data.maxChars - data.first.length;
+    assert.ok(remaining >= 0);
+    const exact = event(data.eventA, 1, data.messageB, 0, "x".repeat(remaining), false);
+    const overflow = event(data.eventB, 2, data.messageB, remaining, "z", true);
+    const result = projectTimeline(source, [exact, overflow], { maxChars: data.maxChars });
+    assert.equal(result.cursor, 1); assert.deepEqual(result.appliedIds, [data.eventA]); assert.deepEqual(result.buffered, [overflow]);
+    assert.deepEqual(result.backpressure, { eventId: data.eventB, cursor: 2, neededChars: data.maxChars + 1, maxChars: data.maxChars });
+    assert.deepEqual(result.messages, [source.messages[0], { id: data.messageB, text: "x".repeat(remaining), complete: false }]);
+    assert.equal(Object.hasOwn(result.seen, data.eventB), false);
+  });
+  await check("timeline-input-isolation", () => {
+    const snapshot = emptySnapshot(); const events = [eventA(), eventB()];
+    const snapshotBefore = structuredClone(snapshot); const eventsBefore = structuredClone(events);
+    const result = projectTimeline(snapshot, events, { maxChars: data.maxChars * 4 });
+    assert.deepEqual(snapshot, snapshotBefore); assert.deepEqual(events, eventsBefore);
+    assert.notEqual(result.messages, snapshot.messages); assert.notEqual(result.seen, snapshot.seen); assert.notEqual(result.buffered, events);
+    result.messages[0].text = "mutated"; result.seen[data.eventA] = "0".repeat(64);
+    assert.deepEqual(snapshot, snapshotBefore); assert.deepEqual(events, eventsBefore);
+  });
+  await check("timeline-checkpoint-roundtrip", () => {
+    const stateValue = projectTimeline(emptySnapshot(), [eventA(), eventB()], { maxChars: data.maxChars * 4 });
+    const core = { cursor: stateValue.cursor, messages: stateValue.messages, seen: stateValue.seen };
+    const encoded = encodeTimelineCheckpoint(core); const envelope = JSON.parse(encoded);
+    const canonical = (value) => {
+      if (value === null || typeof value === "string" || typeof value === "boolean" || (typeof value === "number" && Number.isFinite(value))) return JSON.stringify(value);
+      if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+      return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+    };
+    assert.deepEqual(Object.keys(envelope), ["schemaVersion", "payload", "checksum"]);
+    assert.equal(envelope.checksum, crypto.createHash("sha256").update(canonical(envelope.payload)).digest("hex"));
+    const first = decodeTimelineCheckpoint(encoded); const second = decodeTimelineCheckpoint(encoded);
+    assert.deepEqual(first, core); assert.deepEqual(second, core); assert.notEqual(first.messages, second.messages); assert.notEqual(first.seen, second.seen);
+    first.messages[0].text = "mutated"; assert.deepEqual(second, core);
+  });
+  await check("timeline-checkpoint-tamper", () => {
+    const encoded = encodeTimelineCheckpoint(emptySnapshot()); const value = JSON.parse(encoded);
+    typeError(() => decodeTimelineCheckpoint(null));
+    typeError(() => decodeTimelineCheckpoint("{"));
+    typeError(() => decodeTimelineCheckpoint(JSON.stringify({ ...value, schemaVersion: 2 })));
+    typeError(() => decodeTimelineCheckpoint(JSON.stringify({ ...value, checksum: "0".repeat(64) })));
+    typeError(() => decodeTimelineCheckpoint(JSON.stringify({ ...value, payload: { ...value.payload, cursor: 1 } })));
+    typeError(() => decodeTimelineCheckpoint(JSON.stringify({ schemaVersion: 1, payload: {}, checksum: value.checksum })));
+  });
+  await check("timeline-render-exact", () => {
+    const id = `${data.messageA}<&>\"'`; const text = `${data.first}<&>\"'`;
+    const escapedId = `${data.messageA}&lt;&amp;&gt;&quot;&#39;`; const escapedText = `${data.first}&lt;&amp;&gt;&quot;&#39;`;
+    assert.equal(renderTimeline([{ id, text, complete: false }, { id: data.messageB, text: data.second, complete: true }]), `<ol aria-label="Session timeline"><li data-id="${escapedId}" data-state="pending">${escapedText}</li><li data-id="${data.messageB}" data-state="complete">${data.second}</li></ol>`);
+  });
+  await check("timeline-render-validation", () => {
+    typeError(() => renderTimeline(null)); typeError(() => renderTimeline({}));
+    assert.equal(renderTimeline([]), '<ol aria-label="Session timeline"></ol>');
+  });
 }
 
 const invoked = new Set(checks.map((item) => item.id));

package/benchmarks/capability-v1/project/apps/web/src/control-view.js

@@ -0,0 +1,3 @@
+export function controlSummary(receipt) {
+  return String(receipt?.kind ?? "");
+}

package/benchmarks/capability-v1/project/apps/web/src/timeline-view.js

@@ -0,0 +1,3 @@
+export function renderTimeline(messages) {
+  return messages.map((item) => item.text).join("");
+}

package/benchmarks/capability-v1/project/packages/session/src/admission.js

@@ -0,0 +1,7 @@
+export function runtimeCommandDigest(input) {
+  return String(input?.kind ?? "");
+}
+
+export function admitRuntimeCommand(state, input) {
+  return { state, receipt: input };
+}

package/benchmarks/capability-v1/project/packages/session/src/runtime-route.js

@@ -0,0 +1,3 @@
+export function routeRuntimeCommand(input) {
+  return { terminalCommand: String(input?.kind ?? ""), confirmationRequired: false, expectedModelCalls: 0, effect: "read" };
+}

package/benchmarks/capability-v1/project/packages/timeline/src/checkpoint.js

@@ -0,0 +1,7 @@
+export function encodeTimelineCheckpoint(state) {
+  return JSON.stringify(state);
+}
+
+export function decodeTimelineCheckpoint(serialized) {
+  return JSON.parse(serialized);
+}

package/benchmarks/capability-v1/project/packages/timeline/src/project.js

@@ -0,0 +1,7 @@
+export function normalizeTimelineSnapshot(snapshot) {
+  return snapshot;
+}
+
+export function projectTimeline(snapshot) {
+  return snapshot;
+}

package/benchmarks/capability-v1/project/test/smoke.test.js

@@ -1,4 +1,22 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-test("fixture loads", () => assert.equal(1 + 1, 2));
+import { controlSummary } from "../apps/web/src/control-view.js";
+import { renderSearchResults } from "../apps/web/src/search-view.js";
+import { renderTimeline } from "../apps/web/src/timeline-view.js";
+import { featureAccess } from "../packages/api/src/feature-access.js";
+import { LeaseStore } from "../packages/lease/src/store.js";
+import { migrationPlan } from "../packages/migration/src/plan.js";
+import { normalizeRollout } from "../packages/policy/src/rollout.js";
+import { admitRuntimeCommand, runtimeCommandDigest } from "../packages/session/src/admission.js";
+import { normalizeQuery } from "../packages/shared/src/search-contract.js";
+import { projectTimeline } from "../packages/timeline/src/project.js";
+import { searchCatalog } from "../services/catalog/src/search.js";
+
+test("every public capability entrypoint loads before hidden grading", () => {
+  for (const entrypoint of [
+    controlSummary, renderSearchResults, renderTimeline, featureAccess,
+    LeaseStore, migrationPlan, normalizeRollout, admitRuntimeCommand, runtimeCommandDigest,
+    normalizeQuery, projectTimeline, searchCatalog
+  ]) assert.equal(typeof entrypoint, "function");
+});

package/benchmarks/capability-v1/prompts/causal-timeline-recovery.md

@@ -0,0 +1,47 @@
+Resolve the crash/reconnect timeline issue across
+`packages/timeline/src/project.js`, `packages/timeline/src/checkpoint.js`, and
+`apps/web/src/timeline-view.js`. The projection must remain deterministic when
+events arrive out of order, repeat after reconnect, or stop at a capacity
+boundary.
+
+- [C1] `normalizeTimelineSnapshot(snapshot)` validates and returns a deep fresh
+  `{ cursor, messages, seen }`. Cursor is a non-negative safe integer; messages
+  have unique string ids containing at least one non-whitespace character,
+  string text, and boolean `complete`; `seen` is an object mapping event ids
+  containing at least one non-whitespace character to lowercase SHA-256 hex digests.
+  `projectTimeline(snapshot, events, { maxChars })` requires an event array and
+  a non-negative safe integer budget. Event `id` and `messageId` must be strings
+  containing at least one non-whitespace character; events also require a
+  positive safe `cursor`, non-negative safe `offset`, string text, and boolean
+  `complete`. Invalid input throws `TypeError` before returning.
+- [C2] Event identity is SHA-256 over JSON with fields in this exact order:
+  `id`, `cursor`, `messageId`, `offset`, `text`, `complete`. Identical duplicate
+  ids are replay evidence; the same id with different content or different
+  events at one cursor throw `TypeError`. A historical event
+  (`cursor <= snapshot.cursor`) is accepted only when `seen[id]` equals its
+  digest; otherwise throw. Report replay ids once in first-observed order.
+- [C3] Sort unique future events by cursor and apply only a contiguous prefix
+  beginning at `snapshot.cursor + 1`. At the first gap, stop without applying
+  later events, set `{ expected, observed }`, and buffer that event plus the
+  remainder. Create a new message on first use, preserve message order, require
+  `offset === current text length`, and reject appends to a complete message.
+- [C4] `maxChars` limits total text across all projected messages. Equality is
+  allowed. Before the first event that would exceed it, stop atomically, leave
+  cursor/message/seen unchanged for that event, buffer it and the remainder,
+  and return `{ eventId, cursor, neededChars, maxChars }` as `backpressure`.
+  Return fresh `messages`, `seen`, `appliedIds`, `replayedIds`, and `buffered`
+  plus nullable `gap` and `backpressure`; never mutate inputs.
+- [C5] `encodeTimelineCheckpoint(state)` revalidates the core snapshot and
+  returns JSON containing `{ schemaVersion: 1, payload, checksum }`, where the
+  checksum is SHA-256 of recursively key-sorted canonical JSON for payload.
+  `decodeTimelineCheckpoint(serialized)` imports and reuses
+  `normalizeTimelineSnapshot`, rejects malformed JSON, versions, structure, or
+  checksum with `TypeError`, and returns fresh data that cannot mutate a later
+  decode.
+- [C6] `renderTimeline(messages)` requires an array and returns exactly one
+  ordered `<ol aria-label="Session timeline">`. Each message becomes
+  `<li data-id="..." data-state="complete|pending">...</li>`. Escape ids and
+  text for `&`, `<`, `>`, `"`, and `'`; empty input returns the exact empty list.
+
+Preserve exports and add focused crash/replay/gap/budget/tamper tests. Change
+only the declared source/test scope.

package/benchmarks/capability-v1/prompts/durable-session-control-plane.md

@@ -0,0 +1,47 @@
+Resolve the control-plane correctness issue across
+`packages/session/src/runtime-route.js`, `packages/session/src/admission.js`, and
+`apps/web/src/control-view.js`. The browser must express exactly the same
+bounded commands as Terminal while preserving durable revision and replay
+semantics.
+
+- [D1] `routeRuntimeCommand(input)` accepts only a non-null, non-array command
+  object whose fields are drawn from `idempotencyKey`, `expectedRevision`,
+  `kind`, `payload`, and `confirmed`. Supported kinds are `status`, `scout`,
+  `compact`, and `abort`. `payload` is always a non-null, non-array object.
+  `status`, `compact`, and `abort` require an empty payload. `scout` requires
+  exactly one string `objective` containing at least one non-whitespace
+  character, trimmed with internal whitespace collapsed. Any unknown kind,
+  field, payload field, or invalid value throws `TypeError`.
+- [D2] Routing returns exactly `{ terminalCommand, confirmationRequired,
+  expectedModelCalls, effect }`. Routes are: `status` → `/status`, no
+  confirmation, `0`, `read`; `scout` → `/scout <normalized objective>`,
+  confirmation, `bounded`, `model`; `compact` → `/compact`, confirmation,
+  `bounded`, `semantic`; `abort` → `/abort`, confirmation, `0`, `state`.
+  `admitRuntimeCommand` must reject every confirmation-required command unless
+  `confirmed === true`.
+- [D3] State is `{ revision, receipts }`, where revision is a non-negative safe
+  integer and receipts is an object. A new command requires an exact
+  non-negative safe `expectedRevision`. The idempotency key must be a string
+  containing at least one non-whitespace character, and the poison names
+  `__proto__`, `prototype`, and `constructor` are invalid.
+  Check a prior idempotency receipt before revision matching: an identical
+  replay succeeds even with a stale expected revision, returns the identical
+  state object, and marks only the returned receipt `replayed: true`. Reusing a
+  key for a different command throws `TypeError`.
+- [D4] Export `runtimeCommandDigest(input)` from `admission.js`. It accepts
+  exactly `{ kind, payload }` and returns a SHA-256 digest of recursively
+  key-sorted canonical JSON. Canonicalization must reject non-finite or
+  non-JSON values. Equivalent object-key ordering must produce the same digest.
+  Admission binds idempotency to this digest for only the routed command's
+  `{ kind, payload }`.
+- [D5] A newly admitted command increments revision exactly once and returns
+  `{ state, receipt }`. The stored receipt contains exactly `idempotencyKey`,
+  `commandDigest`, `kind`, `terminalCommand`, `effect`, `expectedModelCalls`,
+  `revisionBefore`, `revisionAfter`, and `replayed: false`. Do not mutate caller
+  state/input, and do not share the separately returned receipt object with the
+  stored receipt.
+- [D6] `controlSummary(receipt)` rejects non-objects and returns exactly
+  `kind=<kind>; command=<JSON string>; revision=<before>-><after>; effect=<effect>; model=<0|bounded>; replayed=<true|false>`.
+
+Preserve exports and add focused integration tests. Change only the declared
+source/test scope.

package/benchmarks/capability-v1/references/causal-timeline-recovery/apps/web/src/timeline-view.js

@@ -0,0 +1,9 @@
+function escapeHtml(value) {
+  return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+
+export function renderTimeline(messages) {
+  if (!Array.isArray(messages)) throw new TypeError("messages must be an array");
+  const rows = messages.map((item) => `<li data-id="${escapeHtml(item?.id ?? "")}" data-state="${item?.complete === true ? "complete" : "pending"}">${escapeHtml(item?.text ?? "")}</li>`).join("");
+  return `<ol aria-label="Session timeline">${rows}</ol>`;
+}