diff --git a/package.json b/package.json
index 534192a..2a4516a 100644
--- a/package.json
+++ b/package.json
@@ -37,7 +37,8 @@
     "batches": "tsx src/cli.ts batches",
     "run": "tsx src/cli.ts run",
     "serve": "tsx src/cli.ts serve",
-    "demo": "tsx src/cli.ts demo --root fixtures/vault --source filesystem:fixture"
+    "demo": "tsx src/cli.ts demo --root fixtures/vault --source filesystem:fixture",
+    "demo:workbench": "tsx scripts/workbench-demo.ts"
   },
   "dependencies": {
     "@atproto/jwk-jose": "0.2.4",
diff --git a/scripts/workbench-demo.ts b/scripts/workbench-demo.ts
new file mode 100644
index 0000000..4790f2c
--- /dev/null
+++ b/scripts/workbench-demo.ts
@@ -0,0 +1,241 @@
+/**
+ * Synthetic workbench demo. NOT a deployment surface.
+ *
+ * Seeds a temporary Jazz store with harmless fixture events, starts the
+ * loopback inspector with a generated Review capability, and starts a second
+ * loopback "demo front" that plays the role of the authenticated proxy: it
+ * answers `/inspector/api/session` with write access, signs workbench and
+ * decision POSTs with the capability under a CSRF check, and proxies every
+ * other `/inspector/*` read to the inspector. There is no authentication at
+ * all, so it binds 127.0.0.1 only and destroys its temporary store on exit.
+ */
+import http, { type IncomingMessage, type ServerResponse } from "node:http";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { randomBytes, timingSafeEqual, createHash } from "node:crypto";
+import { JazzThoughtStore } from "../src/jazz/store.js";
+import {
+  REVIEW_CSRF_HEADER,
+  REVIEW_NONCE_HEADER,
+  REVIEW_SIGNATURE_HEADER,
+  REVIEW_TIMESTAMP_HEADER,
+  signReviewRequest,
+} from "../src/review/web-capability.js";
+import { startInspectorServer } from "../src/web/inspector.js";
+
+process.env.THOUGHTSTREAM_JAZZ_AUTO ??= "1";
+
+const HOST = "127.0.0.1";
+const inspectorPort = Number(process.env.WORKBENCH_DEMO_INSPECTOR_PORT ?? "4317");
+const frontPort = Number(process.env.WORKBENCH_DEMO_PORT ?? "4327");
+const MAX_WRITE_BODY = 98_304;
+
+const root = await fs.mkdtemp(path.join(os.tmpdir(), "thoughtstream-workbench-demo-"));
+const store = await JazzThoughtStore.open({ projectRoot: root, appId: `thoughtstream-workbench-demo-${randomBytes(4).toString("hex")}`, runtimeRevision: "workbench-demo" });
+
+await seed(store);
+
+const reviewCapability = randomBytes(32);
+const csrfToken = randomBytes(24).toString("base64url");
+const inspector = await startInspectorServer(store, {
+  host: HOST,
+  port: inspectorPort,
+  reviewCapability,
+  proposalActor: "operator:demo",
+});
+
+const front = http.createServer((request, response) => {
+  void handle(request, response).catch(() => {
+    if (!response.headersSent) {
+      response.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+    }
+    response.end("demo front error\n");
+  });
+});
+await new Promise<void>((resolve, reject) => {
+  front.once("error", reject);
+  front.listen(frontPort, HOST, () => {
+    front.off("error", reject);
+    resolve();
+  });
+});
+
+process.stdout.write([
+  "",
+  "thought stream workbench demo — SYNTHETIC, NO AUTHENTICATION, LOOPBACK ONLY",
+  `  open:      http://${HOST}:${frontPort}/inspector/`,
+  `  inspector: http://${HOST}:${inspectorPort} (loopback, signed writes only)`,
+  `  store:     ${root} (temporary; removed on exit)`,
+  "  data:      a few synthetic fixture observations, no real sources",
+  "  Ctrl+C to stop.",
+  "",
+].join("\n"));
+
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.once(signal, () => {
+    front.closeAllConnections();
+    inspector.closeAllConnections();
+    front.close(() => {
+      inspector.close(() => {
+        void store.close()
+          .then(() => fs.rm(root, { recursive: true, force: true }))
+          .then(() => process.exit(0), () => process.exit(1));
+      });
+    });
+    setTimeout(() => process.exit(1), 3_000).unref();
+  });
+}
+
+async function handle(request: IncomingMessage, response: ServerResponse): Promise<void> {
+  const url = new URL(request.url ?? "/", `http://${HOST}`);
+  if (url.pathname === "/" || url.pathname === "/inspector") {
+    request.resume();
+    response.writeHead(302, { location: "/inspector/" });
+    response.end();
+    return;
+  }
+  if (!url.pathname.startsWith("/inspector/")) {
+    request.resume();
+    response.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+    response.end("not found\n");
+    return;
+  }
+  if (url.pathname === "/inspector/api/session") {
+    request.resume();
+    response.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    response.end(JSON.stringify({ reviewWriteEnabled: true, courseChatEnabled: false, csrfToken }));
+    return;
+  }
+  const writeRoute = url.search === "" && request.method === "POST" && (
+    /^\/inspector\/api\/(?:reviews|proposals)\/[^/]+\/decisions$/.test(url.pathname)
+    || url.pathname === "/inspector/api/workbench/documents"
+    || /^\/inspector\/api\/workbench\/documents\/[^/]+\/(?:versions|selections|proposals)$/.test(url.pathname)
+    || /^\/inspector\/api\/workbench\/proposals\/[^/]+\/decisions$/.test(url.pathname)
+  );
+  const upstreamPath = `${url.pathname.slice("/inspector".length)}${url.search}`;
+  if (writeRoute) {
+    const presented = request.headers[REVIEW_CSRF_HEADER];
+    if (typeof presented !== "string" || !safeEqual(presented, csrfToken)) {
+      request.resume();
+      response.writeHead(403, { "content-type": "application/json; charset=utf-8" });
+      response.end(JSON.stringify({ error: "Request could not be verified (CSRF)" }));
+      return;
+    }
+    let body: Buffer;
+    try {
+      body = await readJsonBody(request);
+      JSON.parse(body.toString("utf8"));
+    } catch {
+      request.resume();
+      response.writeHead(400, { "content-type": "application/json; charset=utf-8" });
+      response.end(JSON.stringify({ error: "Request is invalid" }));
+      return;
+    }
+    const signature = signReviewRequest(reviewCapability, { method: "POST", path: upstreamPath, body });
+    forward(request, response, upstreamPath, body, {
+      "content-type": "application/json",
+      "content-length": String(body.length),
+      [REVIEW_TIMESTAMP_HEADER]: signature.timestamp,
+      [REVIEW_NONCE_HEADER]: signature.nonce,
+      [REVIEW_SIGNATURE_HEADER]: signature.signature,
+    });
+    return;
+  }
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    request.resume();
+    response.writeHead(405, { "content-type": "application/json; charset=utf-8", allow: "GET, HEAD" });
+    response.end(JSON.stringify({ error: "Method not allowed" }));
+    return;
+  }
+  forward(request, response, upstreamPath);
+}
+
+function forward(request: IncomingMessage, response: ServerResponse, upstreamPath: string, body?: Buffer, extra: Record<string, string> = {}): void {
+  const headers: Record<string, string> = { host: `${HOST}:${inspectorPort}` };
+  for (const name of ["accept", "accept-language", "user-agent"]) {
+    const value = request.headers[name];
+    if (typeof value === "string") headers[name] = value;
+  }
+  Object.assign(headers, extra);
+  const upstream = http.request({ hostname: HOST, port: inspectorPort, path: upstreamPath, method: request.method, headers }, (upstreamResponse) => {
+    const responseHeaders: Record<string, string | string[]> = {};
+    for (const [name, value] of Object.entries(upstreamResponse.headers)) {
+      if (value === undefined || name === "connection" || name === "keep-alive" || name === "transfer-encoding" || name === "set-cookie") continue;
+      responseHeaders[name] = value;
+    }
+    response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders);
+    upstreamResponse.pipe(response);
+  });
+  upstream.on("error", () => {
+    if (!response.headersSent) response.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+    response.end("inspector unavailable\n");
+  });
+  if (body) upstream.end(body);
+  else if (request.method === "GET" || request.method === "HEAD") upstream.end();
+  else request.pipe(upstream);
+}
+
+async function readJsonBody(request: IncomingMessage): Promise<Buffer> {
+  const contentType = (request.headers["content-type"] ?? "").toLowerCase().split(";", 1)[0]?.trim();
+  if (contentType !== "application/json") throw new Error("Expected JSON body");
+  const parts: Buffer[] = [];
+  let bytes = 0;
+  for await (const part of request) {
+    const buffer = Buffer.isBuffer(part) ? part : Buffer.from(part);
+    bytes += buffer.length;
+    if (bytes > MAX_WRITE_BODY) throw new Error("JSON body too large");
+    parts.push(buffer);
+  }
+  if (bytes === 0) throw new Error("JSON body is empty");
+  return Buffer.concat(parts);
+}
+
+function safeEqual(left: string, right: string): boolean {
+  const digest = (value: string) => createHash("sha256").update(value, "utf8").digest();
+  return timingSafeEqual(digest(left), digest(right));
+}
+
+async function seed(target: JazzThoughtStore): Promise<void> {
+  const base = Date.parse("2026-09-18T09:00:00.000Z");
+  const at = (minutes: number) => new Date(base + minutes * 60_000).toISOString();
+  const rssItems = [
+    { id: "fixture-1", title: "Fixture: notes on deterministic runners", summary: "A synthetic article about keeping proposal runners deterministic so tests stay reproducible." },
+    { id: "fixture-2", title: "Fixture: bounded context snapshots", summary: "A synthetic article on recording exact event ids and payload hashes instead of mutable titles." },
+    { id: "fixture-3", title: "Fixture: append-only decisions", summary: "A synthetic article arguing that human decisions should be appended, never edited in place." },
+  ];
+  for (const [index, item] of rssItems.entries()) {
+    await target.appendEvent({
+      type: "stream.thought.source.rss.item",
+      schemaVersion: 1,
+      source: "rss:fixture-demo",
+      sourceKind: "rss",
+      externalId: item.id,
+      idempotencyKey: `rss:${item.id}`,
+      occurredAt: at(index * 7),
+      actor: "rss:fixture-demo",
+      correlationId: "demo-seed",
+      privacy: "public-source",
+      payload: { title: item.title, summary: item.summary, url: `https://example.invalid/${item.id}` },
+    });
+  }
+  const telegramMessages = [
+    "Synthetic note to self: try turning the runner article into a working document.",
+    "Synthetic reminder: the demo store is temporary and contains no real data.",
+  ];
+  for (const [index, text] of telegramMessages.entries()) {
+    await target.appendEvent({
+      type: "stream.thought.source.telegram.message",
+      schemaVersion: 1,
+      source: "telegram:fixture-demo",
+      sourceKind: "telegram",
+      externalId: `message-${index + 1}`,
+      idempotencyKey: `telegram:demo:${index + 1}`,
+      occurredAt: at(30 + index * 5),
+      actor: "telegram:fixture-demo",
+      correlationId: "demo-seed",
+      privacy: "sensitive",
+      payload: { chatId: "demo-chat", messageId: String(index + 1), senderName: "Fixture operator", text },
+    });
+  }
+}
diff --git a/spec/README.md b/spec/README.md
index 03ad174..146d3e0 100644
--- a/spec/README.md
+++ b/spec/README.md
@@ -24,6 +24,7 @@ The core local milestone is implemented and exercised in `test/agent-runtime.tes
 - [`review.md`](review.md): complete review prompts, blinded candidate pairs, judgeability, append-only human decisions, OAuth-only browser writes, and training-data custody.
 - [`incidents.md`](incidents.md): content-dark operational incident projection, private ledger, and independent Telegram alert policy.
 - [`artifacts.md`](artifacts.md): immutable self-rooted content-addressed thought artifacts, artifact-catalog projection, and private inspector rendering.
+- [`documents.md`](documents.md): operator-owned working documents: identity, source links, version identity, head projection, proposal state with stale-base failure, access, judgment lineage, and the deterministic runner seam.
 - [`courses.md`](courses.md): private interactive lessons and the OAuth-only, receipt-backed course-question path.
 - [`tinker.md`](tinker.md): Tinker model and adapter boundary.
 - [`security.md`](security.md): privacy, credentials, authority, and prompt-injection boundaries.
diff --git a/spec/documents.md b/spec/documents.md
new file mode 100644
index 0000000..19beefb
--- /dev/null
+++ b/spec/documents.md
@@ -0,0 +1,112 @@
+# Working documents
+
+## Purpose
+
+A working document is an operator-owned, editable Markdown document created from one Stream observation. It proves one bounded workflow:
+
+`open an event → create a working document linked to it → select exact supporting context → request a proposal from a runner → inspect the diff → accept or reject → retain the version and the judgment`
+
+It is not a general editor, a task system, a collaboration surface, or a new agent runtime. Those remain out of scope and are listed under [Not implemented](#not-implemented).
+
+## Kind
+
+Observed filesystem versions (`filesystem-charter.md`) record what a connector saw on disk. A working document is a separate kind: it is written only through the trusted workbench path and never touches a file on disk. Editing a working document created from a file observation does not modify the observed file.
+
+Working documents reuse the existing `documentVersions` (immutable content) and `documents` (mutable current head) tables rather than adding tables:
+
+| Field | Value |
+| --- | --- |
+| `source` | `workbench:documents` |
+| `contentType` | `text/markdown` |
+| `path` | `documents/<documentId>.md` (a label, not a filesystem path) |
+| version `content` | `---\ntitle: <JSON string>\n---\n<body>` |
+
+The title travels in frontmatter so every version is self-describing without the head projection. Body is at most 64,000 characters; title at most 200.
+
+## Identity
+
+- `documentId = stableKey("working-document", originEventId, createRequestId)`. The origin event is the observation the operator started from. The create request id is a client-generated idempotency key, so a retried create converges on the same document.
+- `versionId = stableKey("version", "workbench:documents", documentId, sha256(content))`, exactly as filesystem versions derive theirs, so `appendDocumentVersion` idempotency holds and identical content is one version.
+- The `documents` row id is `stableKey("document", "workbench:documents", documentId)`. Its `versionId` is the current head. The row is a projection; the version events are the historical authority.
+- Context snapshots are immutable JSON document versions under `source: "context:workbench"` with `snapshotVersionId = stableKey("workbench-context-snapshot", documentId, sha256(canonical { baseVersionId, ids: sorted selected ids }))`.
+- Runner runs are ordinary `AgentRun` rows with `id = stableKey("workbench-run", documentId, requestId)`.
+
+## Events
+
+All workbench events are append-only under `source: "workbench:documents"`, `sourceKind: "system"`, `privacy: "sensitive"`, `schemaVersion: 1`, actor = the configured proposal actor (`operator:local` by default), with zod-validated payloads in `src/workbench/contracts.ts` and registration in the default event registry.
+
+| Type | Lineage | Payload |
+| --- | --- | --- |
+| `stream.thought.workbench.document.created` | root = origin root, parent = origin event | `documentId`, `title`, `originEventId`, `versionId`, `sha256`, `requestId` |
+| `stream.thought.workbench.document.version` | parent = created event (operator edit) or proposal event (accepted proposal) | `documentId`, `versionId`, `baseVersionId \| null`, `sha256`, `sizeBytes`, `reason: created \| operator-edit \| proposal-accepted`, `proposalEventId?`, `decisionEventId?`, `requestId` |
+| `stream.thought.workbench.context.selected` | parent = created event | `documentId`, `selectionId`, `snapshotVersionId`, `selectedEventIds`, `selectedVersionIds`, `requestId` |
+| `stream.thought.workbench.proposal.requested` | parent = selected event | `documentId`, `baseVersionId`, `baseSha256`, `selectionId`, `snapshotVersionId`, `runnerId`, `requestId` |
+| `stream.thought.workbench.proposal.proposed` | parent = requested event | `proposalState: "runner-proposed"`, `proposer { runnerId, runnerRevision, requestId, runId?, contextSnapshotId }`, `target { documentId, baseVersionId, baseSha256 }`, `operation: "replace-document"`, `proposedText`, `proposedTextChars`, `proposedTextSha256`, `reason`, `evidenceEventIds` (at most 16, all admitted by the selection), `publicationEligible: false` |
+| `stream.thought.workbench.proposal.decision` | parent = proposal event | `proposalEventId`, `disposition: accept \| reject`, `submissionId`, `authority: "human"`, `resultVersionId?` (accept only) |
+
+Every event is findable from the origin event's lineage because all of them carry the origin's `rootEventId`.
+
+Idempotency keys are deterministic per request: created `(documentId)`, version `(documentId, reason, requestId)`, selected `(selectionId)`, requested and proposed `(documentId, requestId)`, decision `(proposalEventId)`. One decision identity per proposal is the concurrency boundary, exactly like agent-proposal decisions: the same submission id with identical content replays, a different submission on a decided proposal fails with "already has a human decision", and a reused submission id with different content fails with "submission id conflicts".
+
+## Source links and context snapshots
+
+Selecting context records exact evidence, never mutable titles. The snapshot content is canonical JSON:
+
+```json
+{
+  "documentId": "...",
+  "baseVersionId": "...",
+  "selectedEvents": [{ "eventId": "...", "type": "...", "source": "...", "occurredAt": "...", "payloadHash": "...", "excerpt": "..." }],
+  "selectedVersions": [{ "documentId": "...", "versionId": "...", "sha256": "...", "path": "..." }]
+}
+```
+
+`excerpt` is a bounded plain-text rendering of the payload (at most 2,000 characters), never HTML. Every selected id must exist at selection time. The UI labels this as the evidence the operator selected and states that a runner receives this snapshot plus the current document head and nothing else in this slice; a future model-backed runner that supplies broader context must record that separately rather than widening the selection silently.
+
+## Trusted mutation path
+
+`src/workbench/workflow.ts` is the only writer. It runs behind the inspector's Review capability and serializes mutations per document in process.
+
+- `createWorkingDocument`: origin event must exist; idempotent on request id; a request id reused with different content is a conflict.
+- `saveOperatorEdit`: fails closed with `StaleBaseError` (HTTP 409 with `headVersionId`) when the submitted `baseVersionId` is not the head. Identical content to the head is a no-op. A replayed request id settles the head if the earlier attempt appended the version but not the projection, then returns the current head.
+- `selectContext`: validates every id, writes the snapshot version, then the selected event.
+- `requestProposal`: resolves the runner from the registry, appends the requested event, records a `running` run row, runs the runner, appends the proposed event, then completes the run with `outputEventIds = [proposalEventId]`. Runner failure records a `failed` run with a bounded classified `errorText` and appends no proposal; the error is returned to the action that requested it. A replayed request id returns the existing proposal or the existing failure.
+- `decideProposal`: write order is version row, version event, decision event, head upsert, judgment. Accept requires `head.versionId === target.baseVersionId`; otherwise `StaleBaseError` and nothing is appended. Reject appends the decision and judgment and leaves the document unchanged; rejecting a stale proposal is allowed. Replaying the same submission settles any unfinished head upsert or judgment and applies nothing twice.
+
+## Proposal state
+
+A proposal is `pending` until decided. The projection computes `stale = head.versionId !== target.baseVersionId` and exposes `headVersionId`; a stale undecided proposal is shown as `stale` with Accept disabled and a hint to request a new proposal. Decided proposals are `accepted` or `rejected`. There is no merge, rebase, or overwrite path: a stale proposal either gets rejected or is superseded by a new request.
+
+The diff is computed server side with the `diff` package between the exact base version body and `proposedText` (the identical frontmatter is excluded so the diff shows only body changes) and is rendered in the UI as escaped text lines, never as HTML.
+
+## Judgment lineage
+
+Each decision records one judgment through the existing `recordJudgment` with criterion `workbench-document-proposal@1`, kind `accept` or `reject`, `qualityEligible: false`, `externalExportEligible: false`, `feedbackSourceEventId` = the decision event, `source: judgment:workbench-documents`. The judged run is the runner run whose trigger is the requested event and whose only output is the proposal event, with `contextManifest.contextSnapshot` naming the selection snapshot. The judgment therefore links proposal, base version, result version (through the decision payload), context snapshot, and run. A completed run is not training consent: no workbench judgment is quality- or export-eligible, and nothing here exports documents or judgments.
+
+## Runner seam
+
+`src/workbench/runners.ts` defines `WorkbenchProposalRunner { id, revision, label, inference, propose(request) }` with `request = { documentId, baseVersionId, baseSha256, title, baseText, snapshot, maxProposedChars }` and `result = { proposedText, reason, evidenceEventIds }`. The trusted workflow validates the result (length bound, hash, evidence ids admitted by the selection) before it becomes an event.
+
+The registered runner is `fixture-deterministic@1`: it appends or replaces a `## Sources` section listing each selected event and version and a one-line `Summary:` count, reports `reason: "fixture: append sources section"`, cites the selected event ids, and performs no inference. Identical input yields identical output.
+
+Coordination with the separate fx consumer work: an fx-backed runner implements the same interface, maps the harness result frame's `finalText` to `proposedText` and its run id to `proposer.runId`, and reports its own reason. This repository does not implement that adapter and `src/workbench/` imports nothing from `src/agents/harness/`.
+
+## Access
+
+Reads: `GET /api/workbench/documents`, `GET /api/workbench/documents/:id`, `GET /api/workbench/candidates?documentId=`. Candidates are bounded: the recent root-observation window plus the document's own versions.
+
+Writes: `POST /api/workbench/documents`, `POST /api/workbench/documents/:id/versions`, `POST /api/workbench/documents/:id/selections`, `POST /api/workbench/documents/:id/proposals`, `POST /api/workbench/proposals/:id/decisions`. Each requires the same body-bound Review capability signature as the agent-proposal decision route and returns 405 when no verifier is configured. Bodies are strict zod schemas of at most 98 KB with a client-generated `requestId`/`submissionId`. The authenticated proxy signs these routes only for an allowlisted OAuth session with the session CSRF header; Basic remains read-only. See `web-auth.md`.
+
+Jazz credentials stay server side. Browser clients never write Jazz directly.
+
+## UI
+
+The `Documents` destination lists working documents and opens a detail view with the editor, sources, proposals, and versions. From an observation, `Create working document` appears only when the session has write access. Drafts persist in browser local storage per document until saved. Every write carries a client-generated id held in page state; after a network failure the UI reports the outcome as unknown, reloads the document before any retry, and reuses the same id rather than resending under a new one. See `ui.md`.
+
+## Not implemented
+
+- Real-time or multi-user collaboration, comments, or a permission contract beyond the single owner session. The append-only version chain and per-document serialization leave room for a future collaboration contract without claiming one.
+- Tasks, assignments, or status fields.
+- Model-backed runners. Only the deterministic fixture is registered; the fx adapter is coordinated, not implemented.
+- Document deletion, rename of `documentId`, or import of an observed file version as the initial body beyond the operator typing it.
+- Training export of any workbench judgment or document.
diff --git a/spec/events.md b/spec/events.md
index 0ad8ec0..c998993 100644
--- a/spec/events.md
+++ b/spec/events.md
@@ -134,6 +134,17 @@ A repair request is deterministic append-only evidence over one eligible origina
 
 Proposal events are sensitive, append-only agent requests bound by the trusted parent to one retry-stable context snapshot. They grant no canonicalization, judgment, file, publication, channel, or export authority. A human decision may accept, edit, or reject memory/correction proposals. Public Knowledge diff proposals currently have no decision or materialization path; any future path must consume a separate human decision and may never write or publish directly from the agent proposal. See `proposals.md` and `public-knowledge.md`.
 
+### Working documents
+
+- `stream.thought.workbench.document.created@1`
+- `stream.thought.workbench.document.version@1`
+- `stream.thought.workbench.context.selected@1`
+- `stream.thought.workbench.proposal.requested@1`
+- `stream.thought.workbench.proposal.proposed@1`
+- `stream.thought.workbench.proposal.decision@1`
+
+Workbench events are sensitive, append-only system events under `source: workbench:documents`, rooted at the origin observation's root so a working document is findable from that event's lineage. A version event references one immutable `documentVersions` row; the `documents` row is only the current-head projection. A proposal is inert runner output bound to one exact base version and one exact context snapshot; it grants no publication, file, or training authority. One deterministic decision identity per proposal makes same-submission retries converge and different submissions conflict. Accept appends a new version only when the base is still the head; a stale base fails closed. Decisions project through `recordJudgment` with quality and export eligibility fixed false. See `documents.md`.
+
 ### Focus proposals
 
 - `stream.thought.focus.declaration.proposed`
diff --git a/spec/testing.md b/spec/testing.md
index 4b80cc1..15bf190 100644
--- a/spec/testing.md
+++ b/spec/testing.md
@@ -82,6 +82,9 @@ These are capability gates, not aspirational checks. An API named `transaction`,
 - Review tests freeze exact same-trigger candidate runs; `underdetermined`, `tie`, `malformed`, and `skip` decisions never become preference examples; correction requires a contract-valid replacement; supersession leaves one active export label; and public prompt authority gates v4 input text. Private browser decisions cannot declassify data.
 - Review web tests prove Basic remains read-only; OAuth POST requires CSRF and a fresh one-time proxy signature; replay, stale signatures, unknown routes, oversized bodies, malformed decisions, and direct loopback POSTs fail without appending events.
 - Course web tests prove the repository course has eight ordered lessons and one typed workshop each; question ids are idempotent, stale revisions and divergent reuse fail, Basic remains read-only, OAuth forwarding requires CSRF and a separate fresh body-bound capability, signature replay fails, and the status API reveals an answer only after exact completed tutor lineage.
+- Workbench workflow tests (`test/workbench-workflow.test.ts`) run against temporary Jazz stores and prove: a working document created from an event keeps its origin reference across store reopen; operator edits require the exact head, are idempotent per request id, and fail closed with a stale-base error; context selection records exact event ids, payload hashes, version ids, and hashes in one immutable bounded plain-text snapshot; the fixture runner is deterministic and its diff is computed against the exact base; accepting once yields exactly one new version, one decision, and one non-exportable judgment while a duplicate submission creates nothing extra and a conflicting submission fails; reject leaves the document unchanged; an operator edit followed by accepting the older proposal fails with the stale error and the edit survives; a runner failure records a failed run and no proposal; and a second store client over the same project root sees the accepted head.
+- Workbench inspector tests (`test/workbench-inspector.test.ts`) prove every workbench write returns 405 without a Review verifier, unsigned and wrong-path signatures fail with 403 and no store effect, malformed bodies fail with 400, signed writes apply through the trusted workflow, the GET projections expose head, origin, exact selections, proposals with diff and stale flags, and versions, stale edits and stale accepts return 409 with the current head, decisions replay by submission id, and a consumed signature nonce cannot be replayed.
+- Proxy tests (`test/authenticated-proxy.test.ts`) prove every workbench write route rejects unauthenticated, Basic-only, missing-CSRF, wrong-CSRF, query-bearing, oversized, and non-JSON requests before any upstream contact, forwards one CSRF-checked OAuth write per route with a fresh body-bound Review signature and no browser credentials, and still serves workbench reads to Basic.
 - Inspector HTML tests compile the rendered inline JavaScript, contain the Learn destination and floating composer, and preserve fragment routes for exact lesson ids. Browser acceptance exercises every workshop, narrow and wide layouts, keyboard submission, disabled composer state, and one natural OAuth question through event, tutor run, output, and status readback.
 - Replay uses the exact public run binding but recompiles the private checkpoint through the trusted startup loader; it does not float to another release or trust serialized checkpoint authority.
 - Live Tinker sampling is an opt-in credentialed test and never runs in ordinary CI.
diff --git a/spec/ui.md b/spec/ui.md
index ea36ced..89ed0dd 100644
--- a/spec/ui.md
+++ b/spec/ui.md
@@ -68,6 +68,10 @@ The inspector prewarms and retains both bounded Feed projections in process. An
 
 The bounded Feed projection scans one deterministic window of at most 400 recent source records to select up to 100 root observations, so ordinary child records such as reactions and corrections do not displace unrelated roots. If that hard scan cap cannot recover a complete root window, the response and UI say so instead of falling back to a global scan. It then hydrates at most 500 events in those root lineages, 250 recent runs, and 250 runs directly triggered by the hydrated events. Same-timestamp query limits use the record key as a deterministic second ordering term. When either the recent-run or root-lineage hydration cap is reached, each observation marks processing history incomplete; the UI may show found processors but cannot classify an empty bounded result as “not processed.” The Feed path never enumerates complete run history; complete run evidence remains a System concern.
 
+## Documents
+
+The **Documents** destination lists operator-owned working documents and opens one in the same column: a title field, a body editor, a **Sources** section showing the exact selected evidence with event ids, payload hashes, version ids, and content hashes, a **Proposals** section, and a **Versions** list. From an observation detail, a compact **Create working document** control appears only when the session has write access; otherwise a one-line note says why it is absent. **Save** submits the head version the editor loaded and, on a stale-base conflict, keeps the draft in the browser, explains that the document changed, and offers a reload. **Select context** opens a bounded checkbox list of recent observations plus the document's own versions and records only the checked items. **Request proposal** names the runner and whether it performs inference. Each proposal shows its status, reason, base version, and a unified diff rendered as escaped text lines with `+`/`-` markers, never as HTML; a proposal whose base is no longer the head shows a stale notice with Accept disabled. Errors render at the action that failed. Drafts persist in browser local storage until saved. Every write carries a client-generated request or submission id held in page state; after a network failure the outcome is reported as unknown, the document is reloaded before any retry, and the same id is reused rather than resending under a new one. See [`documents.md`](documents.md).
+
 ## Detail view
 
 - Consumer lifecycle and derived-output details lead with a plain-language **what processed this** block: the declaration display name, actual trigger source, whether it was a rule or model, whether LLM inference occurred, the exact produced summary, any recommendation or proposal that actually exists, derived-record count, and whether external actions were enabled. Technical agent ids and context strategies belong in execution details. Runtime metadata must not be appended to model-authored prose. A reader must not have to traverse raw lifecycle payloads to discover either the semantic result or its provenance.
@@ -88,7 +92,7 @@ The operator CLI may resolve one exact run's durable `contextSnapshot` identity
 
 - Localhost by default.
 - No client-side secrets.
-- No send, publish, arbitrary edit, adapter activation, or generic Jazz controls. The separately specified Review decision form is the only data mutation.
+- No send, publish, arbitrary edit, adapter activation, or generic Jazz controls. The Review decision form, agent-proposal decisions, and the bounded working-document writes in `documents.md` are the only data mutations, and all of them are append-only through the trusted server path.
 - Streaming UI may use server-sent events; persistence never depends on the browser being open.
 
 ## Authenticated external access
diff --git a/spec/web-auth.md b/spec/web-auth.md
index d5865e0..044ba10 100644
--- a/spec/web-auth.md
+++ b/spec/web-auth.md
@@ -46,6 +46,12 @@ Public assets are the four reviewed Markdown pages, one exact validated Around W
 | `/inspector/`, `/inspector/*` except the decision route | GET, HEAD | allowlisted OAuth DID or enabled Basic fallback | loopback inspector |
 | `/inspector/api/reviews/:item/decisions` | POST | allowlisted OAuth browser session, session CSRF, and configured proxy-to-inspector Review capability | one fixed append-only Review decision |
 | `/inspector/api/courses/post-training/questions` | POST | allowlisted OAuth browser session, session CSRF, and configured proxy-to-inspector course-chat capability | one fixed private course question |
+| `/inspector/api/workbench/documents` | GET, HEAD, POST | reads: allowlisted OAuth DID or enabled Basic fallback; POST: allowlisted OAuth browser session, session CSRF, and the Review capability | list working documents; create one working document from one origin event |
+| `/inspector/api/workbench/documents/:id`, `/inspector/api/workbench/candidates` | GET, HEAD | allowlisted OAuth DID or enabled Basic fallback | one working-document projection; bounded selectable context |
+| `/inspector/api/workbench/documents/:id/versions` | POST | allowlisted OAuth browser session, session CSRF, and the Review capability | one operator edit against one exact base version (409 when stale) |
+| `/inspector/api/workbench/documents/:id/selections` | POST | allowlisted OAuth browser session, session CSRF, and the Review capability | one exact context selection and snapshot |
+| `/inspector/api/workbench/documents/:id/proposals` | POST | allowlisted OAuth browser session, session CSRF, and the Review capability | one runner proposal request over the current head |
+| `/inspector/api/workbench/proposals/:id/decisions` | POST | allowlisted OAuth browser session, session CSRF, and the Review capability | one append-only accept/reject decision with judgment (accept fails closed on a stale base) |
 | every other route | none | none | none |
 
 ## Threats and controls
@@ -84,6 +90,8 @@ Logout is a POST with a random token stored only in the server-side browser sess
 
 The same session token protects the exact Review-decision JSON route. The token is returned only from an OAuth-authenticated private session endpoint and is sent in a dedicated request header. Basic authorization never receives it and remains read-only. A successful CSRF check does not reach Jazz directly: the proxy signs the exact method, normalized route, body digest, timestamp, and one-time nonce under a separately injected capability. The inspector verifies that envelope before accepting the fixed Review decision schema. Browser authentication, CSRF, loopback capability, and event validation are distinct gates.
 
+The workbench document routes reuse the Review capability rather than adding a key: they are the same class of bounded, operator-authored append-only writes, and the inspector's workbench handler independently validates every body against strict schemas and the trusted workflow's stale-base and decision-identity checks. Query strings, non-JSON bodies, bodies over 98 KB, Basic credentials, and missing or mismatched CSRF tokens are rejected in the proxy before any upstream contact. Reads of the workbench projections remain ordinary authenticated inspector reads. Edge activation is a separate deployment step: the checked nginx template forwards POST only for the exact Review-decision and course-question locations, so the workbench POST locations must be added there (with the same rate limit and no body/query logging) before browser writes work through the public origin. The loopback proxy and inspector already enforce the full gate without that change.
+
 The course-question route uses the same browser-session CSRF token and a separate course-chat loopback capability. The separate key prevents Review authority from silently expanding into model-triggering authority. The proxy signs the exact bounded question request, and the inspector derives lesson context from repository source before event insertion. Basic remains read-only on both routes.
 
 ### SSRF and hostile OAuth metadata
diff --git a/src/events/registry.ts b/src/events/registry.ts
index 7c171af..1b512e5 100644
--- a/src/events/registry.ts
+++ b/src/events/registry.ts
@@ -69,6 +69,21 @@ import {
   COURSE_QUESTION_SCHEMA_VERSION,
   courseQuestionPayloadSchema,
 } from "../courses/questions.js";
+import {
+  CONTEXT_SELECTED_EVENT_TYPE as WORKBENCH_CONTEXT_SELECTED_EVENT_TYPE,
+  DOCUMENT_CREATED_EVENT_TYPE as WORKBENCH_DOCUMENT_CREATED_EVENT_TYPE,
+  DOCUMENT_VERSION_EVENT_TYPE as WORKBENCH_DOCUMENT_VERSION_EVENT_TYPE,
+  PROPOSAL_DECISION_EVENT_TYPE as WORKBENCH_PROPOSAL_DECISION_EVENT_TYPE,
+  PROPOSAL_PROPOSED_EVENT_TYPE as WORKBENCH_PROPOSAL_PROPOSED_EVENT_TYPE,
+  PROPOSAL_REQUESTED_EVENT_TYPE as WORKBENCH_PROPOSAL_REQUESTED_EVENT_TYPE,
+  WORKBENCH_SCHEMA_VERSION,
+  contextSelectedPayloadSchema as workbenchContextSelectedPayloadSchema,
+  documentCreatedPayloadSchema as workbenchDocumentCreatedPayloadSchema,
+  documentVersionPayloadSchema as workbenchDocumentVersionPayloadSchema,
+  proposalDecisionPayloadSchema as workbenchProposalDecisionPayloadSchema,
+  proposalProposedPayloadSchema as workbenchProposalProposedPayloadSchema,
+  proposalRequestedPayloadSchema as workbenchProposalRequestedPayloadSchema,
+} from "../workbench/contracts.js";
 import type { ThoughtEvent } from "./types.js";
 import {
   X_ACTIVITY_SOURCE_EVENT_TYPE,
@@ -697,6 +712,22 @@ export function createDefaultRegistry(): EventRegistry {
     description: "Signature-verified allowlisted X Activity webhook observation",
     payload: xActivityPayloadSchema,
   });
+  for (const [type, payload, description] of [
+    [WORKBENCH_DOCUMENT_CREATED_EVENT_TYPE, workbenchDocumentCreatedPayloadSchema, "Operator-owned working document created from one origin event"],
+    [WORKBENCH_DOCUMENT_VERSION_EVENT_TYPE, workbenchDocumentVersionPayloadSchema, "Immutable working-document version appended through the trusted workbench path"],
+    [WORKBENCH_CONTEXT_SELECTED_EVENT_TYPE, workbenchContextSelectedPayloadSchema, "Exact operator-selected evidence snapshot for one working document"],
+    [WORKBENCH_PROPOSAL_REQUESTED_EVENT_TYPE, workbenchProposalRequestedPayloadSchema, "Operator request for one runner proposal over one exact base version"],
+    [WORKBENCH_PROPOSAL_PROPOSED_EVENT_TYPE, workbenchProposalProposedPayloadSchema, "Inert runner-proposed replacement for one exact working-document base version"],
+    [WORKBENCH_PROPOSAL_DECISION_EVENT_TYPE, workbenchProposalDecisionPayloadSchema, "Append-only human accept/reject decision over one workbench proposal"],
+  ] as const) {
+    registry.register({
+      type,
+      schemaVersion: WORKBENCH_SCHEMA_VERSION,
+      description,
+      payload: payload as unknown as z.ZodType<JsonObject>,
+      minimumPrivacy: "sensitive",
+    });
+  }
   registry.register({
     type: ARTIFACT_REQUEST_EVENT_TYPE,
     schemaVersion: ARTIFACT_REQUEST_SCHEMA_VERSION,
diff --git a/src/web/authenticated-proxy.ts b/src/web/authenticated-proxy.ts
index 4b10260..d0580ae 100644
--- a/src/web/authenticated-proxy.ts
+++ b/src/web/authenticated-proxy.ts
@@ -317,7 +317,16 @@ async function handleRequest(options: {
     return notFound(options.response);
   }
 
-  const reviewWriteRoute = url.search === "" && /^\/inspector\/api\/(?:reviews|proposals)\/[^/]+\/decisions$/.test(url.pathname);
+  // Review-capability write routes: Review decisions, agent-proposal decisions,
+  // and the bounded workbench document routes. Each is one exact POST path with
+  // no query; the same OAuth session, CSRF header, and body-bound signature apply.
+  const workbenchWriteRoute = url.search === "" && options.request.method === "POST" && (
+    url.pathname === "/inspector/api/workbench/documents"
+    || /^\/inspector\/api\/workbench\/documents\/[^/]+\/(?:versions|selections|proposals)$/.test(url.pathname)
+    || /^\/inspector\/api\/workbench\/proposals\/[^/]+\/decisions$/.test(url.pathname)
+  );
+  const reviewWriteRoute = (url.search === "" && /^\/inspector\/api\/(?:reviews|proposals)\/[^/]+\/decisions$/.test(url.pathname))
+    || workbenchWriteRoute;
   const courseChatWriteRoute = url.search === "" && url.pathname === "/inspector/api/courses/post-training/questions";
   const basicAuthorized = options.expectedAuthorizationDigest !== undefined
     && isAuthorized(options.request.headers.authorization, options.expectedAuthorizationDigest);
diff --git a/src/web/inspector.ts b/src/web/inspector.ts
index 0258d6f..25d6d74 100644
--- a/src/web/inspector.ts
+++ b/src/web/inspector.ts
@@ -49,6 +49,21 @@ import { materializeMemoryDecision } from "../agent-proposals/memory-materialize
 import { recordProposalDecision } from "../agent-proposals/review.js";
 import { z } from "zod";
 import { FONT_DEBUG_ASSET_PATH, FONT_DEBUG_SCRIPT } from "./font-debug.js";
+import {
+  createDocumentRequestSchema,
+  decideProposalRequestSchema,
+  requestProposalRequestSchema,
+  saveEditRequestSchema,
+  selectContextRequestSchema,
+} from "../workbench/contracts.js";
+import type { WorkbenchRunnerRegistry } from "../workbench/runners.js";
+import {
+  StaleBaseError,
+  WorkbenchConflictError,
+  WorkbenchNotFoundError,
+  WorkbenchRunnerError,
+  WorkbenchWorkflow,
+} from "../workbench/workflow.js";
 
 const RUN_TERMINAL_EVENT_TYPES = [
   "stream.thought.agent.run.completed",
@@ -132,6 +147,7 @@ export interface InspectorServerOptions {
   courseChatVerifier?: CourseChatCapabilityVerifier | undefined;
   agentContextRoot?: string | undefined;
   proposalActor?: string | undefined;
+  workbenchRunners?: WorkbenchRunnerRegistry | undefined;
 }
 
 interface InspectorActivityCache {
@@ -188,8 +204,12 @@ export async function startInspectorServer(
     ?? (options.courseChatCapability ? new CourseChatCapabilityVerifier(options.courseChatCapability) : undefined);
   const proposalWritesEnabled = Boolean(reviewVerifier && options.agentContextRoot);
   const activityCache = createInspectorActivityCache(store);
+  const workbench = new WorkbenchWorkflow(store, {
+    actor: options.proposalActor ?? "operator:cameron",
+    ...(options.workbenchRunners ? { runners: options.workbenchRunners } : {}),
+  });
   const server = http.createServer((request, response) => {
-    void handleRequest(store, activityCache, request, response, reviewVerifier, courseChatVerifier, proposalWritesEnabled ? options.agentContextRoot : undefined, options.proposalActor ?? "operator:cameron").catch((error) => {
+    void handleRequest(store, activityCache, request, response, reviewVerifier, courseChatVerifier, proposalWritesEnabled ? options.agentContextRoot : undefined, options.proposalActor ?? "operator:cameron", workbench).catch((error) => {
       sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) });
     });
   });
@@ -212,8 +232,13 @@ async function handleRequest(
   courseChatVerifier?: CourseChatCapabilityVerifier,
   agentContextRoot?: string,
   proposalActor = "operator:cameron",
+  workbench: WorkbenchWorkflow = new WorkbenchWorkflow(store, { actor: proposalActor }),
 ): Promise<void> {
   const url = new URL(request.url ?? "/", "http://127.0.0.1");
+  if (request.method === "POST" && url.pathname.startsWith("/api/workbench/")) {
+    await handleWorkbenchWrite(workbench, request, response, url, reviewVerifier);
+    return;
+  }
   if (request.method === "POST" && url.pathname === "/api/courses/post-training/questions" && url.search === "") {
     if (!courseChatVerifier) {
       request.resume();
@@ -440,6 +465,28 @@ async function handleRequest(
     sendJson(response, 200, await getArtifactCatalog(store));
     return;
   }
+  if (url.pathname === "/api/workbench/documents") {
+    sendJson(response, 200, { items: await workbench.listDocuments(), runners: workbench.listRunners() });
+    return;
+  }
+  if (url.pathname === "/api/workbench/candidates") {
+    const documentId = url.searchParams.get("documentId");
+    if (!documentId || [...url.searchParams.keys()].some((key) => key !== "documentId")) {
+      return sendJson(response, 400, { error: "Candidate lookup requires exactly one documentId" });
+    }
+    const candidates = await workbench.listCandidates(documentId);
+    if (!candidates) return sendJson(response, 404, { error: "Working document not found" });
+    sendJson(response, 200, candidates);
+    return;
+  }
+  const workbenchDocumentMatch = url.pathname.match(/^\/api\/workbench\/documents\/([^/]+)$/);
+  if (workbenchDocumentMatch) {
+    const documentId = decodeURIComponent(workbenchDocumentMatch[1]!);
+    const detail = await workbench.getDocument(documentId);
+    if (!detail) return sendJson(response, 404, { error: "Working document not found" });
+    sendJson(response, 200, detail);
+    return;
+  }
   const sourceMatch = url.pathname.match(/^\/api\/sources\/([^/]+)$/);
   if (sourceMatch) {
     const sourceId = decodeURIComponent(sourceMatch[1]!);
@@ -518,6 +565,95 @@ async function handleRequest(
   sendJson(response, 404, { error: "Not found" });
 }
 
+const WORKBENCH_WRITE_BODY_LIMIT = 98_304;
+
+/**
+ * Trusted workbench mutations. Every route requires the same body-bound Review
+ * capability as the proposal decision route; without a verifier the inspector
+ * stays read-only (405). Request bodies are strict zod schemas and every
+ * mutation carries a client-generated request/submission id so retries after
+ * an uncertain outcome converge instead of duplicating effects.
+ */
+async function handleWorkbenchWrite(
+  workbench: WorkbenchWorkflow,
+  request: IncomingMessage,
+  response: ServerResponse,
+  url: URL,
+  reviewVerifier?: ReviewCapabilityVerifier,
+): Promise<void> {
+  const createMatch = url.pathname === "/api/workbench/documents";
+  const versionMatch = url.pathname.match(/^\/api\/workbench\/documents\/([^/]+)\/versions$/);
+  const selectionMatch = url.pathname.match(/^\/api\/workbench\/documents\/([^/]+)\/selections$/);
+  const proposalMatch = url.pathname.match(/^\/api\/workbench\/documents\/([^/]+)\/proposals$/);
+  const decisionMatch = url.pathname.match(/^\/api\/workbench\/proposals\/([^/]+)\/decisions$/);
+  if (url.search !== "" || (!createMatch && !versionMatch && !selectionMatch && !proposalMatch && !decisionMatch)) {
+    request.resume();
+    sendJson(response, 404, { error: "Not found" });
+    return;
+  }
+  if (!reviewVerifier) {
+    request.resume();
+    sendJson(response, 405, { error: "Workbench is read-only" });
+    return;
+  }
+  let body: Buffer;
+  try {
+    body = await readBody(request, WORKBENCH_WRITE_BODY_LIMIT);
+  } catch {
+    request.resume();
+    sendJson(response, 400, { error: "Workbench request is invalid" });
+    return;
+  }
+  if (!reviewVerifier.verify(request.headers, "POST", url.pathname, body)) {
+    sendJson(response, 403, { error: "Workbench request could not be verified" });
+    return;
+  }
+  try {
+    const parsed: unknown = JSON.parse(body.toString("utf8"));
+    if (createMatch) {
+      const input = createDocumentRequestSchema.parse(parsed);
+      const head = await workbench.createWorkingDocument(input);
+      sendJson(response, 201, { documentId: head.documentId, versionId: head.versionId, sha256: head.sha256 });
+      return;
+    }
+    if (versionMatch) {
+      const input = saveEditRequestSchema.parse(parsed);
+      const head = await workbench.saveOperatorEdit({ documentId: decodeURIComponent(versionMatch[1]!), ...input });
+      sendJson(response, 201, { documentId: head.documentId, versionId: head.versionId, sha256: head.sha256 });
+      return;
+    }
+    if (selectionMatch) {
+      const input = selectContextRequestSchema.parse(parsed);
+      const selection = await workbench.selectContext({ documentId: decodeURIComponent(selectionMatch[1]!), ...input });
+      sendJson(response, 201, { selectionId: selection.selectionId, snapshotVersionId: selection.snapshotVersionId, eventId: selection.eventId });
+      return;
+    }
+    if (proposalMatch) {
+      const input = requestProposalRequestSchema.parse(parsed);
+      const result = await workbench.requestProposal({ documentId: decodeURIComponent(proposalMatch[1]!), ...input });
+      sendJson(response, 201, result);
+      return;
+    }
+    const input = decideProposalRequestSchema.parse(parsed);
+    const result = await workbench.decideProposal({ proposalEventId: decodeURIComponent(decisionMatch![1]!), ...input });
+    sendJson(response, 201, result);
+  } catch (error) {
+    if (error instanceof StaleBaseError) {
+      sendJson(response, 409, { error: "This document changed since you opened it", stale: true, headVersionId: error.headVersionId });
+    } else if (error instanceof WorkbenchNotFoundError) {
+      sendJson(response, 404, { error: error.message });
+    } else if (error instanceof WorkbenchConflictError) {
+      sendJson(response, 409, { error: error.message });
+    } else if (error instanceof WorkbenchRunnerError) {
+      sendJson(response, 502, { error: "The proposal runner failed; no proposal was recorded", runId: error.runId });
+    } else if (error instanceof z.ZodError) {
+      sendJson(response, 400, { error: "Workbench request is invalid" });
+    } else {
+      throw error;
+    }
+  }
+}
+
 async function postTrainingQuestionStatus(store: JazzThoughtStore, eventId: string): Promise<Record<string, unknown>> {
   const event = await store.getEvent(eventId);
   if (!event || event.type !== COURSE_QUESTION_EVENT_TYPE || !parseCourseQuestionEvent(event)) {
@@ -1179,6 +1315,22 @@ export function renderInspectorHtml(): string {
     .suggestion-content { border:1px solid var(--line); border-radius:var(--radius-content); background:var(--surface); padding:15px; margin:8px 0 14px; white-space:pre-wrap; overflow-wrap:anywhere; font:14px/1.6 var(--font-body) }
     .suggestion-compare { display:grid; grid-template-columns:1fr 1fr; gap:10px; margin:8px 0 14px } .suggestion-compare > div { min-width:0 }
     .suggestion-actions { display:grid; gap:10px; padding-top:14px; margin-top:16px } .suggestion-buttons { display:flex; flex-wrap:wrap; gap:8px } .suggestion-buttons button { border:1px solid var(--accent); background:var(--accent-soft); color:var(--text); padding:9px 12px; font:inherit; cursor:pointer } .suggestion-buttons button.reject { border-color:var(--red) }
+    .wb-card { border:1px solid var(--line); border-radius:var(--radius-content); background:var(--surface); padding:14px; margin:8px 0 14px; overflow-wrap:anywhere }
+    .wb-card + .wb-card { margin-top:10px }
+    .wb-head { display:flex; flex-wrap:wrap; align-items:center; gap:6px 8px; margin-bottom:6px } .wb-head strong { color:var(--accent-strong) }
+    .wb-form { display:grid; gap:10px; margin:8px 0 14px }
+    .wb-body { min-height:260px; font:13px/1.55 ui-monospace,SFMono-Regular,Menlo,monospace }
+    .wb-note { color:var(--muted); font-size:12px; margin-top:6px } .wb-warn { color:var(--amber); font-size:12px; margin-top:8px } .wb-error { color:var(--red); font-size:12px }
+    .wb-result { min-height:18px; font-size:12px; color:var(--muted); overflow-wrap:anywhere }
+    .wb-actions { display:flex; flex-wrap:wrap; align-items:center; gap:8px; margin-top:10px } .wb-actions button { min-height:40px; border:1px solid var(--accent); border-radius:var(--radius-control); background:var(--accent-soft); color:var(--text); padding:8px 13px; cursor:pointer } .wb-actions button.reject { border-color:var(--red); background:transparent } .wb-actions button.quiet { border-color:var(--line-strong); background:var(--surface-control) } .wb-actions button:disabled { opacity:.5; cursor:not-allowed }
+    .wb-actions select { width:auto; min-width:160px; min-height:40px; padding:7px 10px }
+    .wb-panel[hidden] { display:none } .wb-panel { margin-top:10px }
+    .wb-check { display:flex; align-items:flex-start; gap:9px; padding:8px 0; color:var(--text) } .wb-check input { width:auto; min-height:0; margin-top:4px; flex:none } .wb-check .meta { display:block }
+    .wb-source { border-left:2px solid var(--accent); padding:6px 0 6px 10px; margin:6px 0; font-size:13px } .wb-source .mono { display:block; margin-top:2px }
+    .wb-list { display:grid; gap:6px } .wb-version { border:1px solid var(--line); border-radius:12px; background:var(--surface); padding:10px 12px; font-size:13px }
+    .wb-version.head { border-color:var(--accent) }
+    .diff { max-height:420px; overflow:auto; font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace } .diff span { display:block; white-space:pre-wrap } .diff .add { color:var(--accent-strong); background:var(--accent-soft) } .diff .del { color:var(--red) } .diff .hunk,.diff .file { color:var(--muted) }
+    .wb-create { margin:16px 0 4px; border:1px solid var(--line); border-radius:var(--radius-content); background:var(--surface); padding:13px 14px } .wb-create .form-row { margin-bottom:8px }
     .spinner { display:inline-block; width:10px; height:10px; margin-right:7px; border:1px solid var(--line); border-top-color:var(--link); border-radius:50%; animation:spin .8s linear infinite; vertical-align:-1px }
     .retry { min-height:40px; margin-top:12px; border:1px solid var(--red); border-radius:var(--radius-control); background:transparent; color:var(--text); padding:8px 13px; cursor:pointer }
     .observation-head h2 { margin-bottom:4px } .observation-card { margin:15px 0; border:0; background:transparent; padding:0; font:15px/1.58 var(--font-body); overflow-wrap:anywhere } .observation-card .bluesky-inlay,.observation-card .x-inlay { border:0; border-radius:0; background:transparent; padding:0 } .observation-card p { margin:0; white-space:pre-wrap } .observation-links { display:flex; flex-wrap:wrap; gap:8px; margin-top:12px } .observation-links a { border:1px solid var(--line); border-radius:var(--radius-control); color:var(--link); padding:7px 10px; text-decoration:none; font:11px/1.4 ui-monospace,SFMono-Regular,Menlo,monospace } .processing-state { display:flex; align-items:center; gap:8px; margin:15px 0 4px; color:var(--muted); font-size:12px } .status-dot { width:7px; height:7px; border-radius:50%; background:var(--line-strong); flex:none } .technical-record { margin-top:26px } .technical-record > summary { padding:3px 0 8px } .technical-section { margin-top:16px } .technical-section h3 { margin-top:0 }
@@ -1283,14 +1435,14 @@ export function renderInspectorHtml(): string {
   </style>
 </head>
 <body>
-<header class="app-header"><h1>Stream</h1><nav class="primary-nav" aria-label="Stream destinations"><button id="events-tab" class="active">Feed</button><button id="learn-tab">Learn</button><button id="review-tab">Review</button><button id="artifacts-tab">Artifacts</button><button id="system-tab">System</button><button id="filter-open" class="filter-nav" hidden>Filter<span id="filter-count" class="filter-count" hidden></span></button></nav><nav id="review-nav" class="context-nav" aria-label="Review views" hidden><button id="suggestions-tab">Suggestions</button><button id="reviews-tab">Comparisons</button></nav><nav id="system-nav" class="context-nav" aria-label="System views" hidden><button id="runs-tab">Runs</button><button id="sources-tab">Sources</button></nav></header>
+<header class="app-header"><h1>Stream</h1><nav class="primary-nav" aria-label="Stream destinations"><button id="events-tab" class="active">Feed</button><button id="learn-tab">Learn</button><button id="review-tab">Review</button><button id="artifacts-tab">Artifacts</button><button id="documents-tab">Documents</button><button id="system-tab">System</button><button id="filter-open" class="filter-nav" hidden>Filter<span id="filter-count" class="filter-count" hidden></span></button></nav><nav id="review-nav" class="context-nav" aria-label="Review views" hidden><button id="suggestions-tab">Suggestions</button><button id="reviews-tab">Comparisons</button></nav><nav id="system-nav" class="context-nav" aria-label="System views" hidden><button id="runs-tab">Runs</button><button id="sources-tab">Sources</button></nav></header>
 <main><section id="list-pane"><h2 id="list-title" class="visually-hidden">Recent activity</h2><div id="active-filters" class="filter-chips" hidden></div><div id="list"><div class="empty"><span class="spinner" aria-hidden="true"></span>Loading recent activity…</div></div></section><section id="course-pane" hidden></section><section id="detail-pane"><button id="detail-back" class="detail-back" aria-label="Back to list">← Back</button><div id="detail"></div></section></main>
 <aside id="course-chat" class="course-chat" hidden><button id="course-chat-toggle" class="course-chat-toggle" aria-expanded="false">Ask about this lesson</button><section id="course-chat-panel" class="course-chat-panel" role="dialog" aria-label="Ask the model factory tutor" hidden><div class="course-chat-head"><div><strong>Ask the tutor</strong><span id="course-chat-context"></span></div><button id="course-chat-close" class="course-chat-close" aria-label="Close course chat">×</button></div><div id="course-chat-log" class="course-chat-log"></div><div class="course-chat-compose"><textarea id="course-chat-input" maxlength="2000" placeholder="Ask about this lesson"></textarea><button id="course-chat-send" class="course-chat-send">Send</button></div></section></aside>
 <dialog id="filters-dialog" class="filter-dialog" aria-labelledby="filter-title"><div class="filter-sheet"><div class="filter-sheet-head"><h2 id="filter-title">Filter feed</h2><button id="filter-close" class="icon-button" aria-label="Close filters">×</button></div><div id="filter-bar" class="filter-bar"></div><div class="filter-sheet-actions"><button id="filter-reset">Reset</button><button id="filter-apply" class="primary">Done</button></div></div></dialog>
 <script src="/assets/font-debug.js" defer></script>
 <script>
-const routeLists={events:'feed',learn:'learn/post-training',suggestions:'review/suggestions',reviews:'review/comparisons',artifacts:'artifacts',runs:'system/runs',sources:'system/sources'};
-const routeDetails={event:{tab:'events',path:'feed/observations'},suggestion:{tab:'suggestions',path:'review/suggestions'},review:{tab:'reviews',path:'review/comparisons'},artifact:{tab:'artifacts',path:'artifacts'},run:{tab:'runs',path:'system/runs'},source:{tab:'sources',path:'system/sources'}};
+const routeLists={events:'feed',learn:'learn/post-training',suggestions:'review/suggestions',reviews:'review/comparisons',artifacts:'artifacts',documents:'documents',runs:'system/runs',sources:'system/sources'};
+const routeDetails={event:{tab:'events',path:'feed/observations'},suggestion:{tab:'suggestions',path:'review/suggestions'},review:{tab:'reviews',path:'review/comparisons'},artifact:{tab:'artifacts',path:'artifacts'},document:{tab:'documents',path:'documents'},run:{tab:'runs',path:'system/runs'},source:{tab:'sources',path:'system/sources'}};
 function parseRoute(hash=location.hash){
   let parts;try{const fragment=hash.startsWith('#/')?hash.slice(2):hash.startsWith('#')?hash.slice(1):hash;parts=fragment.split('/').filter(Boolean).map(value=>decodeURIComponent(value))}catch{return {tab:'events',selected:null}}
   const path=parts.join('/');for(const [tab,listPath] of Object.entries(routeLists))if(path===listPath)return {tab,selected:null,lessonId:null};
@@ -1300,14 +1452,14 @@ function parseRoute(hash=location.hash){
 }
 function routeHash(tab,selected){const path=tab==='learn'&&state?.courseLessonId?routeLists.learn+'/'+encodeURIComponent(state.courseLessonId):selected?routeDetails[selected.kind]?.path+'/'+encodeURIComponent(selected.id):routeLists[tab];return '#/'+(path??routeLists.events)}
 const initialRoute=parseRoute();
-const state={activity:null,system:null,proposals:null,reviews:null,artifacts:null,course:null,session:null,inlays:new Map(),loading:{activity:true,system:true,proposals:true,reviews:true,artifacts:true,course:true,session:true},errors:{},tab:initialRoute.tab,selected:null,courseLessonId:initialRoute.lessonId??null,courseCompleted:readCourseProgress(),courseQuestions:[],coursePendingReceipts:readCourseReceipts(),courseReceiptsResumed:false,courseSubmitting:false,courseChatOpen:false,proposalReceipt:'',eventFilters:{source:'all',activity:'all',processing:'all',query:''},sourceScope:'inputs',activityRefreshInFlight:false,activityRefreshPending:false};
+const state={activity:null,system:null,proposals:null,reviews:null,artifacts:null,documents:null,course:null,session:null,inlays:new Map(),loading:{activity:true,system:true,proposals:true,reviews:true,artifacts:true,documents:true,course:true,session:true},errors:{},workbench:{documentId:null,detail:null,candidates:null,requests:{},selecting:false,checked:{events:new Set(),versions:new Set()}},tab:initialRoute.tab,selected:null,courseLessonId:initialRoute.lessonId??null,courseCompleted:readCourseProgress(),courseQuestions:[],coursePendingReceipts:readCourseReceipts(),courseReceiptsResumed:false,courseSubmitting:false,courseChatOpen:false,proposalReceipt:'',eventFilters:{source:'all',activity:'all',processing:'all',query:''},sourceScope:'inputs',activityRefreshInFlight:false,activityRefreshPending:false};
 function writeRoute(mode='push'){
   const hash=routeHash(state.tab,state.selected);const url=location.pathname+location.search+hash;const existing=history.state?.streamInspector===true?history.state:null;
   if(mode==='replace')history.replaceState(existing??{streamInspector:true,hasInternalParent:false},'',url);
   else if(location.hash!==hash)history.pushState({streamInspector:true,hasInternalParent:true},'',url);
 }
 history.replaceState(history.state?.streamInspector===true?history.state:{streamInspector:true,hasInternalParent:false},'',location.pathname+location.search+routeHash(initialRoute.tab,initialRoute.selected));
-const resources={activity:{path:'api/activity',label:'recent activity'},system:{path:'api/system',label:'system evidence'},proposals:{path:'api/proposals',label:'suggestions'},reviews:{path:'api/reviews',label:'review queue'},artifacts:{path:'api/artifacts',label:'artifacts'},course:{path:'api/courses/post-training',label:'post-training course'},session:{path:'api/session',label:'session'}};
+const resources={activity:{path:'api/activity',label:'recent activity'},system:{path:'api/system',label:'system evidence'},proposals:{path:'api/proposals',label:'suggestions'},reviews:{path:'api/reviews',label:'review queue'},artifacts:{path:'api/artifacts',label:'artifacts'},documents:{path:'api/workbench/documents',label:'working documents'},course:{path:'api/courses/post-training',label:'post-training course'},session:{path:'api/session',label:'session'}};
 const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
 const json=value=>esc(JSON.stringify(value,null,2));
 const bskyActorPathSegment=value=>encodeURIComponent(value).replaceAll('%3A',':');
@@ -1322,33 +1474,33 @@ async function load(){
   await loadResource('session');
   await loadResource(primaryResource);
   if(primaryResource==='activity')await loadActivityEvidence(true);
-  for(const key of ['activity','course','artifacts','proposals','reviews','system'])if(key!==primaryResource)await loadResource(key);
+  for(const key of ['activity','course','artifacts','documents','proposals','reviews','system'])if(key!==primaryResource)await loadResource(key);
   if(primaryResource!=='activity')await loadActivityEvidence(true);
   startLiveUpdates();
 }
-function tabResource(){return state.tab==='events'?'activity':state.tab==='learn'?'course':state.tab==='suggestions'?'proposals':state.tab==='reviews'?'reviews':state.tab==='artifacts'?'artifacts':'system'}
-function primaryTab(){return state.tab==='events'?'events':state.tab==='learn'?'learn':state.tab==='suggestions'||state.tab==='reviews'?'review':state.tab==='artifacts'?'artifacts':'system'}
+function tabResource(){return state.tab==='events'?'activity':state.tab==='learn'?'course':state.tab==='suggestions'?'proposals':state.tab==='reviews'?'reviews':state.tab==='artifacts'?'artifacts':state.tab==='documents'?'documents':'system'}
+function primaryTab(){return state.tab==='events'?'events':state.tab==='learn'?'learn':state.tab==='suggestions'||state.tab==='reviews'?'review':state.tab==='artifacts'?'artifacts':state.tab==='documents'?'documents':'system'}
 function syncNavigation(){
   const primary=primaryTab();
-  for(const id of ['events','learn','review','artifacts','system']){const button=document.querySelector('#'+id+'-tab');const active=id===primary;button.classList.toggle('active',active);if(active)button.setAttribute('aria-current','page');else button.removeAttribute('aria-current')}
+  for(const id of ['events','learn','review','artifacts','documents','system']){const button=document.querySelector('#'+id+'-tab');const active=id===primary;button.classList.toggle('active',active);if(active)button.setAttribute('aria-current','page');else button.removeAttribute('aria-current')}
   const review=document.querySelector('#review-nav');const system=document.querySelector('#system-nav');review.hidden=primary!=='review';system.hidden=primary!=='system';
   for(const id of ['suggestions','reviews','runs','sources']){const button=document.querySelector('#'+id+'-tab');const active=id===state.tab;button.classList.toggle('active',active);button.setAttribute('aria-pressed',String(active))}
 }
-function emptyMessage(){return state.tab==='events'?'No recent activity has been recorded.':state.tab==='runs'?'No agent runs have been recorded.':state.tab==='sources'?'No configured or observed sources are available.':state.tab==='suggestions'?'No suggestions are waiting.':state.tab==='reviews'?'No reviews are waiting.':'No artifacts are available.'}
+function emptyMessage(){return state.tab==='events'?'No recent activity has been recorded.':state.tab==='runs'?'No agent runs have been recorded.':state.tab==='sources'?'No configured or observed sources are available.':state.tab==='suggestions'?'No suggestions are waiting.':state.tab==='reviews'?'No reviews are waiting.':state.tab==='documents'?'No working documents yet. Open an observation and choose Create working document.':'No artifacts are available.'}
 function renderList(){
-  const list=document.querySelector('#list'); const isEvents=state.tab==='events'; const isRuns=state.tab==='runs'; const isSources=state.tab==='sources'; const isSuggestions=state.tab==='suggestions'; const isReviews=state.tab==='reviews'; const isArtifacts=state.tab==='artifacts';
+  const list=document.querySelector('#list'); const isEvents=state.tab==='events'; const isRuns=state.tab==='runs'; const isSources=state.tab==='sources'; const isSuggestions=state.tab==='suggestions'; const isReviews=state.tab==='reviews'; const isArtifacts=state.tab==='artifacts'; const isDocuments=state.tab==='documents';
   syncNavigation();
   const isCourse=state.tab==='learn';const listPane=document.querySelector('#list-pane');const coursePane=document.querySelector('#course-pane');listPane.hidden=isCourse;coursePane.hidden=!isCourse;
   if(isCourse){hideFilterControls();renderCourse();syncCourseChat();return}else syncCourseChat();
-  document.querySelector('#list-title').textContent=isEvents?'Recent activity':isRuns?'Agent runs':isSuggestions?'Suggestions':isReviews?'Comparisons':isArtifacts?'Artifacts':'Sources';
+  document.querySelector('#list-title').textContent=isEvents?'Recent activity':isRuns?'Agent runs':isSuggestions?'Suggestions':isReviews?'Comparisons':isArtifacts?'Artifacts':isDocuments?'Working documents':'Sources';
   const resourceKey=tabResource();const resource=resources[resourceKey];const error=state.errors[resourceKey];
-  const ready=isEvents?state.activity:isRuns||isSources?state.system:isSuggestions?state.proposals:isReviews?state.reviews:state.artifacts;
-  const allValues=!ready?[]:isEvents?state.activity.items:isRuns?state.system.runs:isSuggestions?state.proposals.items:isReviews?state.reviews.items:isArtifacts?state.artifacts.entries:state.system.sources;
+  const ready=isEvents?state.activity:isRuns||isSources?state.system:isSuggestions?state.proposals:isReviews?state.reviews:isDocuments?state.documents:state.artifacts;
+  const allValues=!ready?[]:isEvents?state.activity.items:isRuns?state.system.runs:isSuggestions?state.proposals.items:isReviews?state.reviews.items:isArtifacts?state.artifacts.entries:isDocuments?state.documents.items:state.system.sources;
   const values=isEvents?filterEvents(allValues):isSources?filterSources(allValues):allValues;
   if(isEvents&&ready)renderEventFilters(allValues);else if(isSources&&ready)renderSourceFilter();else hideFilterControls();
   const empty=isEvents&&ready&&values.length===0?eventFilterEmptyMessage():emptyMessage();
   const rootWindowNotice=isEvents&&ready&&state.activity.rootWindowComplete===false?'<div class="processing-window">Some older observations are outside this bounded feed window.</div>':'';
-  const listContent=values.map(value=>isEvents?eventItem(value):isRuns?runItem(value):isSuggestions?suggestionItem(value):isReviews?reviewItem(value):isArtifacts?artifactItem(value):sourceItem(value)).join('')||'<div class="empty">'+esc(empty)+'</div>';
+  const listContent=values.map(value=>isEvents?eventItem(value):isRuns?runItem(value):isSuggestions?suggestionItem(value):isReviews?reviewItem(value):isArtifacts?artifactItem(value):isDocuments?documentItem(value):sourceItem(value)).join('')||'<div class="empty">'+esc(empty)+'</div>';
   list.innerHTML=error?'<div class="empty failed">'+esc(error)+'<div><button class="retry" data-resource="'+esc(resourceKey)+'">Retry</button></div></div>':!ready?'<div class="empty"><span class="spinner" aria-hidden="true"></span>Loading '+esc(resource.label)+'…</div>':rootWindowNotice+listContent;
   list.querySelector('.retry')?.addEventListener('click',event=>loadResource(event.currentTarget.dataset.resource));
   list.querySelectorAll('.item[data-kind]').forEach(item=>{const open=event=>{if(event.target.closest('a,details,input,select,textarea')&&event.target!==item)return;list.querySelectorAll('.item').forEach(value=>value.classList.remove('active'));item.classList.add('active');select(item.dataset.kind,item.dataset.id)};item.addEventListener('click',open);item.addEventListener('keydown',event=>{if((event.key==='Enter'||event.key===' ')&&event.target===item){event.preventDefault();open(event)}})});
@@ -1510,12 +1662,13 @@ function reviewItem(item){const status=item.decision?item.decision.disposition:'
 async function select(kind,id,options={}){
   const route=routeDetails[kind];if(!route)return;state.tab=route.tab;state.selected={kind,id};syncNavigation();document.querySelector('main').classList.add('detail-selected');document.body.classList.add('detail-selected');if(options.history!==false)writeRoute();if(!options.preserveScroll)window.scrollTo({top:0,behavior:'smooth'});
   if(kind==='source'){await showSource(id);return}
+  if(kind==='document'){await showDocument(id);return}
   if(kind==='suggestion'){const detail=document.querySelector('#detail');if(state.errors.proposals){detail.innerHTML='<div class="empty failed">'+esc(state.errors.proposals)+'</div>';return}if(!state.proposals){detail.innerHTML='<div class="empty"><span class="spinner" aria-hidden="true"></span>Loading suggestion…</div>';return}const item=state.proposals.items.find(value=>value.eventId===id);detail.innerHTML=renderSuggestion(item);bindSuggestionForm(item);return}
   if(kind==='review'){const detail=document.querySelector('#detail');if(state.errors.reviews){detail.innerHTML='<div class="empty failed">'+esc(state.errors.reviews)+'</div>';return}if(!state.reviews){detail.innerHTML='<div class="empty"><span class="spinner" aria-hidden="true"></span>Loading review…</div>';return}const item=state.reviews.items.find(value=>value.id===id);detail.innerHTML=renderReview(item);bindReviewForm(item);return}
   if(kind==='artifact'){document.querySelector('#detail').innerHTML='<div class="empty">Loading artifact…</div>';const response=await fetch('api/artifacts/'+encodeURIComponent(id));const data=await response.json();document.querySelector('#detail').innerHTML=renderArtifact(data);return}
   const selection=kind+':'+id;const label=kind==='event'?'observation':'run';const detail=document.querySelector('#detail');
   detail.innerHTML='<div class="empty"><span class="spinner" aria-hidden="true"></span>Loading '+label+'…</div>';
-  try{const data=await fetchJson('api/'+(kind==='event'?'events/':'runs/')+encodeURIComponent(id),label);if(state.selected?.kind+':'+state.selected?.id!==selection)return;detail.innerHTML=kind==='event'?renderEvent(data):renderRun(data);document.querySelectorAll('#detail [data-event-id]').forEach(button=>button.addEventListener('click',()=>select('event',button.dataset.eventId)));hydrateInlays(detail)}catch(error){if(state.selected?.kind+':'+state.selected?.id!==selection)return;detail.innerHTML='<div class="empty failed">'+esc(error instanceof Error?error.message:String(error))+'<div><button class="retry" id="detail-retry">Retry</button></div></div>';document.querySelector('#detail-retry')?.addEventListener('click',()=>select(kind,id))}
+  try{const data=await fetchJson('api/'+(kind==='event'?'events/':'runs/')+encodeURIComponent(id),label);if(state.selected?.kind+':'+state.selected?.id!==selection)return;detail.innerHTML=kind==='event'?renderEvent(data):renderRun(data);document.querySelectorAll('#detail [data-event-id]').forEach(button=>button.addEventListener('click',()=>select('event',button.dataset.eventId)));if(kind==='event')bindWorkbenchCreate(data);hydrateInlays(detail)}catch(error){if(state.selected?.kind+':'+state.selected?.id!==selection)return;detail.innerHTML='<div class="empty failed">'+esc(error instanceof Error?error.message:String(error))+'<div><button class="retry" id="detail-retry">Retry</button></div></div>';document.querySelector('#detail-retry')?.addEventListener('click',()=>select(kind,id))}
 }
 async function showSource(id){const detail=document.querySelector('#detail');detail.innerHTML='<div class="empty"><span class="spinner" aria-hidden="true"></span>Loading source activity…</div>';try{const data=await fetchJson('api/sources/'+encodeURIComponent(id),'source activity');if(state.selected?.kind!=='source'||state.selected.id!==id)return;detail.innerHTML=renderSource(data.source,data.activity.items);detail.querySelectorAll('[data-event-id]').forEach(button=>button.addEventListener('click',()=>select('event',button.dataset.eventId)))}catch(error){detail.innerHTML='<div class="empty failed">'+esc(error instanceof Error?error.message:String(error))+'</div>'}}
 function eventLink(label,event){return event?'<button data-event-id="'+esc(event.id)+'">'+esc(label)+': '+esc(event.type)+' · '+esc(event.id)+'</button>':''}
@@ -1559,7 +1712,89 @@ function renderEvent(data){
   const content='<div class="observation-card">'+renderSourceInlay(e,observation,false)+(links?'<div class="observation-links">'+links+'</div>':'')+'</div>';
   const lineage=(data.root?.id!==e.id?eventLink('root',data.root):'')+(data.parent?eventLink('parent',data.parent):'')+data.children.map(child=>eventLink('child',child)).join('');
   const technical='<details class="technical-record"><summary>Technical details</summary><div class="facts"><span>Event type: <strong>'+esc(e.type)+'</strong></span><span>Source: <strong>'+esc(e.source)+'</strong></span><span>Occurred: <strong>'+esc(e.occurredAt)+'</strong></span><span>Observed: <strong>'+esc(e.observedAt)+'</strong></span></div><div class="technical-section"><h3>Event ID</h3><div class="mono">'+esc(e.id)+'</div></div>'+(lineage?'<div class="technical-section"><h3>Lineage and execution records</h3><div class="lineage">'+lineage+'</div></div>':'')+'<div class="technical-section"><h3>Raw payload</h3><pre>'+json(e.payload)+'</pre></div><div class="technical-section"><h3>Canonical envelope</h3><pre>'+json(e)+'</pre></div></details>';
-  return '<div class="observation-head"><h2>'+esc(observation.title)+'</h2><div class="meta">'+esc(observation.sourceLabel)+' · '+esc(new Date(e.occurredAt).toLocaleString())+' · '+esc(humanPrivacy(e.privacy))+'</div></div>'+content+processing+technical;
+  return '<div class="observation-head"><h2>'+esc(observation.title)+'</h2><div class="meta">'+esc(observation.sourceLabel)+' · '+esc(new Date(e.occurredAt).toLocaleString())+' · '+esc(humanPrivacy(e.privacy))+'</div></div>'+content+renderWorkbenchCreate(e,observation)+processing+technical;
+}
+
+function documentItem(item){return '<button class="item" data-kind="document" data-id="'+esc(item.documentId)+'"><div class="type">Working document'+(item.pendingProposalCount?' <span class="badge">'+esc(item.pendingProposalCount)+' proposal'+(item.pendingProposalCount===1?'':'s')+' waiting</span>':'')+'</div><div class="summary">'+esc(item.title)+'</div><div class="meta">'+esc(item.versionCount)+' version'+(item.versionCount===1?'':'s')+' · '+esc(item.proposalCount)+' proposal'+(item.proposalCount===1?'':'s')+' · updated '+esc(new Date(item.updatedAt).toLocaleString())+'</div></button>'}
+function shortId(value){const text=String(value??'');return text.length>18?text.slice(0,10)+'…'+text.slice(-6):text}
+function workbenchDefaultTitle(observation){const firstLine=(observation.body||'').split(/\\r?\\n/).map(line=>line.trim()).find(Boolean)||'';const label=observation.objectLabel&&!['Observation','Message'].includes(observation.objectLabel)?observation.objectLabel:'';const base=(firstLine||label||observation.title||'observation').slice(0,80);return ('Notes: '+base).slice(0,200)}
+function renderWorkbenchCreate(e,observation){
+  if(!state.session?.reviewWriteEnabled)return '<div class="wb-note">Creating a working document needs the operator session with write access; this session is read-only.</div>';
+  return '<div class="wb-create" id="wb-create"><div class="form-row"><label for="wb-create-title">Working document title</label><input id="wb-create-title" type="text" maxlength="200" value="'+esc(workbenchDefaultTitle(observation))+'"></div><div class="wb-actions"><button id="wb-create-button">Create working document</button><span id="wb-create-result" class="wb-result"></span></div></div>';
+}
+function bindWorkbenchCreate(data){const button=document.querySelector('#wb-create-button');if(!button)return;const e=data.event;const observation=data.presentation?observationPresentation({...e,presentation:data.presentation}):observationPresentation(e);button.addEventListener('click',async()=>{const title=document.querySelector('#wb-create-title').value.trim();const result=document.querySelector('#wb-create-result');if(!title){result.textContent='Enter a title first.';return}button.disabled=true;result.textContent='Creating…';const body='# '+title+'\\n\\nCreated from '+(observation.title||e.type)+' ('+e.type+').\\n\\n'+(observation.body?'> '+observation.body.split(/\\r?\\n/).join('\\n> ')+'\\n':'');try{const created=await workbenchPost('api/workbench/documents',{originEventId:e.id,title,body},'create:'+e.id);await loadResource('documents');select('document',created.documentId)}catch(error){result.textContent=workbenchErrorText(error);button.disabled=false}})}
+function workbenchErrorText(error){return error?.uncertain?'The request was sent but no response arrived. Reload to see whether it applied; a retry reuses the same request id.':error?.message??String(error)}
+async function workbenchPost(path,body,key){
+  const requests=state.workbench.requests;const request=requests[key]??(requests[key]={id:crypto.randomUUID(),status:'idle'});
+  if(request.status==='uncertain'&&state.workbench.documentId){await reloadWorkbenchDocument({quiet:true})}
+  const idField=key.startsWith('decision:')?'submissionId':'requestId';const payload={...body,[idField]:request.id};request.status='sending';
+  let response;try{response=await fetch(path,{method:'POST',headers:{'content-type':'application/json','x-thoughtstream-csrf':state.session?.csrfToken??''},body:JSON.stringify(payload)})}catch{request.status='uncertain';const error=new Error('uncertain');error.uncertain=true;throw error}
+  let data={};try{data=await response.json()}catch{}
+  delete requests[key];
+  if(!response.ok){const error=new Error(data.error??('Request failed (HTTP '+response.status+')'));error.status=response.status;error.data=data;throw error}
+  return data;
+}
+function draftKey(documentId){return 'thoughtstream-workbench-draft:'+documentId}
+function readDraft(documentId){try{const value=JSON.parse(localStorage.getItem(draftKey(documentId))??'null');return value&&typeof value.title==='string'&&typeof value.body==='string'&&typeof value.baseVersionId==='string'?value:null}catch{return null}}
+function writeDraft(documentId,draft){try{localStorage.setItem(draftKey(documentId),JSON.stringify(draft))}catch{}}
+function clearDraft(documentId){try{localStorage.removeItem(draftKey(documentId))}catch{}}
+async function showDocument(id){const detail=document.querySelector('#detail');state.workbench.documentId=id;state.workbench.detail=null;state.workbench.candidates=null;state.workbench.selecting=false;state.workbench.checked={events:new Set(),versions:new Set()};detail.innerHTML='<div class="empty"><span class="spinner" aria-hidden="true"></span>Loading working document…</div>';await reloadWorkbenchDocument()}
+async function reloadWorkbenchDocument(options={}){const id=state.workbench.documentId;const detail=document.querySelector('#detail');try{const data=await fetchJson('api/workbench/documents/'+encodeURIComponent(id),'working document');if(state.selected?.kind!=='document'||state.selected.id!==id)return;state.workbench.detail=data;renderWorkbenchDocument(options)}catch(error){if(options.quiet)return;detail.innerHTML='<div class="empty failed">'+esc(error instanceof Error?error.message:String(error))+'<div><button class="retry" id="wb-retry">Retry</button></div></div>';document.querySelector('#wb-retry')?.addEventListener('click',()=>reloadWorkbenchDocument())}}
+function renderDiff(diff){return '<pre class="diff">'+String(diff??'').split('\\n').filter(line=>!line.startsWith('Index: ')&&!/^=+$/.test(line)).map(line=>{const kind=line.startsWith('+++')||line.startsWith('---')?'file':line.startsWith('@@')?'hunk':line.startsWith('+')?'add':line.startsWith('-')?'del':'ctx';return '<span class="'+kind+'">'+esc(line)+'</span>'}).join('')+'</pre>'}
+function renderWorkbenchProposal(proposal,canWrite){
+  const badge=proposal.status==='accepted'?'accepted':proposal.status==='rejected'?'rejected':proposal.status==='stale'?'stale base':'awaiting decision';
+  const decision=proposal.decision?'<div class="wb-note">Decision '+esc(proposal.decision.disposition)+' · '+esc(new Date(proposal.decision.createdAt).toLocaleString())+(proposal.decision.resultVersionId?' · produced version '+esc(shortId(proposal.decision.resultVersionId)):'')+(proposal.decision.judgmentEventId?' · judgment recorded':' · no judgment recorded')+'</div>':'';
+  const stale=!proposal.decision&&proposal.stale?'<div class="wb-warn">This proposal was made against an older version ('+esc(shortId(proposal.baseVersionId))+'). The document head is now '+esc(shortId(proposal.headVersionId))+'. Accept is disabled; request a new proposal, or reject this one.</div>':'';
+  const controls=!proposal.decision&&canWrite?'<div class="wb-actions"><button data-wb-decide="accept" data-proposal="'+esc(proposal.eventId)+'" '+(proposal.stale?'disabled':'')+'>Accept</button><button class="reject" data-wb-decide="reject" data-proposal="'+esc(proposal.eventId)+'">Reject</button><span class="wb-result" id="wb-decide-result-'+esc(proposal.eventId)+'"></span></div>':!proposal.decision?'<div class="wb-note">Deciding needs the operator session with write access.</div>':'';
+  const evidence=proposal.evidenceEventIds.length?'<div class="wb-note">Cites '+esc(proposal.evidenceEventIds.length)+' selected event'+(proposal.evidenceEventIds.length===1?'':'s')+'</div>':'<div class="wb-note">Cites no selected events</div>';
+  return '<div class="wb-card" data-proposal-card="'+esc(proposal.eventId)+'"><div class="wb-head"><strong>'+esc(proposal.runnerId)+'@'+esc(proposal.runnerRevision)+'</strong><span class="badge">'+esc(badge)+'</span><span class="badge">'+(proposal.inference==='none'?'no LLM inference':proposal.inference==='model'?'model inference':'inference unknown')+'</span></div><div class="work-summary">'+esc(proposal.reason)+'</div><div class="meta">Proposed '+esc(new Date(proposal.createdAt).toLocaleString())+' · base '+esc(shortId(proposal.baseVersionId))+' · '+esc(proposal.proposedTextChars)+' chars · sha '+esc(proposal.proposedTextSha256.slice(0,12))+'</div>'+evidence+stale+decision+'<details open><summary>Diff against base version</summary>'+renderDiff(proposal.diff)+'</details>'+controls+'</div>';
+}
+function renderWorkbenchSelection(selection,latest){
+  const events=selection.selectedEvents.map(event=>'<div class="wb-source">'+esc(event.type)+' · '+esc(new Date(event.occurredAt).toLocaleString())+'<div class="meta">'+esc(event.excerpt.slice(0,160))+'</div><span class="mono">'+esc(event.eventId)+' · payload '+esc(event.payloadHash.slice(0,12))+'</span></div>').join('');
+  const versions=selection.selectedVersions.map(version=>'<div class="wb-source">Document version<span class="mono">'+esc(version.versionId)+' · sha '+esc(version.sha256.slice(0,12))+'</span></div>').join('');
+  const body=(events+versions)||'<div class="wb-note">Empty selection.</div>';
+  return latest?'<div class="wb-card"><div class="wb-head"><strong>Selected evidence</strong><span class="badge">current</span></div><div class="meta">Recorded '+esc(new Date(selection.createdAt).toLocaleString())+' against version '+esc(shortId(selection.baseVersionId))+' · snapshot '+esc(selection.snapshotSha256.slice(0,12))+'</div>'+body+'</div>':'<details><summary>Earlier selection · '+esc(new Date(selection.createdAt).toLocaleString())+'</summary>'+body+'</details>';
+}
+function renderWorkbenchDocument(options={}){
+  const data=state.workbench.detail;const detail=document.querySelector('#detail');if(!data)return;const canWrite=Boolean(state.session?.reviewWriteEnabled);const head=data.head;
+  const draft=readDraft(head.documentId);const editing=options.keepDraft&&document.querySelector('#wb-body')?{title:document.querySelector('#wb-title').value,body:document.querySelector('#wb-body').value}:null;
+  const useDraft=editing??(draft&&(draft.title!==head.title||draft.body!==head.body)?draft:null);
+  const title=useDraft?useDraft.title:head.title;const body=useDraft?useDraft.body:head.body;
+  const draftNote=useDraft&&!editing?'<div class="wb-warn">Unsaved draft restored from this browser'+(draft.baseVersionId!==head.versionId?' (written against an older version; the document has changed since)':'')+'. <button class="filter-chip" id="wb-discard-draft">Discard draft</button></div>':'';
+  const origin=data.origin?'<button class="source-event" data-event-id="'+esc(data.origin.eventId)+'"><div class="source-event-title">'+esc(humanLabel(data.origin.type.split('.').at(-1)))+' · '+esc(sourceLabelFromId(data.origin.source))+'</div><div class="source-event-body">'+esc(data.origin.excerpt)+'</div><div class="meta">'+esc(new Date(data.origin.occurredAt).toLocaleString())+'</div></button>':'<div class="wb-note">Origin event unavailable.</div>';
+  const editor='<div class="wb-form"><div class="form-row"><label for="wb-title">Title</label><input id="wb-title" type="text" maxlength="200" value="'+esc(title)+'" '+(canWrite?'':'readonly')+'></div><div class="form-row"><label for="wb-body">Body</label><textarea id="wb-body" class="wb-body" maxlength="64000" '+(canWrite?'':'readonly')+'>'+esc(body)+'</textarea></div>'+(canWrite?'<div class="wb-actions"><button id="wb-save">Save</button><span id="wb-save-result" class="wb-result"></span></div>':'<div class="wb-note">Editing needs the operator session with write access.</div>')+draftNote+'</div>';
+  const selections=[...data.selections].sort((a,b)=>b.createdAt.localeCompare(a.createdAt));const latest=selections[0];
+  const sources='<div class="wb-note">Exact evidence the operator selected, recorded by event id and payload hash or by version id and content hash. A runner receives this snapshot plus the current document head and nothing else.</div>'+(latest?renderWorkbenchSelection(latest,true):'<div class="wb-note">No context selected yet.</div>')+selections.slice(1).map(selection=>renderWorkbenchSelection(selection,false)).join('')+(canWrite?'<div class="wb-actions"><button id="wb-select-open" class="quiet">'+(state.workbench.selecting?'Close context picker':'Select context')+'</button><span id="wb-select-result" class="wb-result"></span></div><div id="wb-select-panel" class="wb-panel" '+(state.workbench.selecting?'':'hidden')+'></div>':'');
+  const runnerOptions=(data.runners??[]).map(runner=>'<option value="'+esc(runner.id)+'">'+esc(runner.label)+'</option>').join('');
+  const request=canWrite?'<div class="wb-actions"><select id="wb-runner" aria-label="Proposal runner">'+runnerOptions+'</select><button id="wb-request" '+(latest?'':'disabled')+'>Request proposal</button><span id="wb-request-result" class="wb-result">'+(latest?'':'Select context first.')+'</span></div>':'';
+  const proposals=[...data.proposals].sort((a,b)=>b.createdAt.localeCompare(a.createdAt));
+  const proposalList=proposals.length?proposals.map(proposal=>renderWorkbenchProposal(proposal,canWrite)).join(''):'<div class="wb-note">No proposals yet.</div>';
+  const versions='<div class="wb-list">'+[...data.versions].reverse().map(version=>'<div class="wb-version '+(version.versionId===head.versionId?'head':'')+'"><strong>'+esc(humanLabel(version.reason))+'</strong>'+(version.versionId===head.versionId?' <span class="badge">head</span>':'')+'<div class="meta">'+esc(new Date(version.createdAt).toLocaleString())+' · '+esc(version.sizeBytes)+' bytes · sha '+esc(version.sha256.slice(0,12))+'</div><div class="mono">'+esc(version.versionId)+'</div></div>').join('')+'</div>';
+  const technical='<details class="technical-record"><summary>Technical details</summary><div class="human-grid"><div class="human-card wide"><div class="field-label">Document ID</div><div class="mono">'+esc(head.documentId)+'</div></div><div class="human-card wide"><div class="field-label">Head version</div><div class="mono">'+esc(head.versionId)+'</div></div><div class="human-card"><div class="field-label">Head SHA-256</div><div class="mono">'+esc(head.sha256)+'</div></div><div class="human-card"><div class="field-label">Created event</div><div class="mono">'+esc(data.createdEventId)+'</div></div></div></details>';
+  detail.innerHTML='<h2>'+esc(head.title)+'</h2><div class="meta">Working document · head '+esc(shortId(head.versionId))+' · updated '+esc(new Date(head.updatedAt).toLocaleString())+'</div><h3>Created from</h3>'+origin+'<h3>Document</h3>'+editor+'<h3>Sources</h3>'+sources+'<h3>Proposals</h3>'+request+proposalList+'<h3>Versions</h3>'+versions+technical;
+  detail.querySelectorAll('[data-event-id]').forEach(button=>button.addEventListener('click',()=>select('event',button.dataset.eventId)));
+  bindWorkbenchDocument(head,canWrite,latest);
+  if(state.workbench.selecting)renderWorkbenchCandidates();
+}
+function bindWorkbenchDocument(head,canWrite,latest){
+  const titleInput=document.querySelector('#wb-title');const bodyInput=document.querySelector('#wb-body');
+  document.querySelector('#wb-discard-draft')?.addEventListener('click',()=>{clearDraft(head.documentId);renderWorkbenchDocument()});
+  if(!canWrite)return;
+  let draftTimer;const persistDraft=()=>{clearTimeout(draftTimer);draftTimer=setTimeout(()=>{if(titleInput.value===head.title&&bodyInput.value===head.body)clearDraft(head.documentId);else writeDraft(head.documentId,{title:titleInput.value,body:bodyInput.value,baseVersionId:head.versionId,savedAt:Date.now()})},200)};
+  titleInput.addEventListener('input',persistDraft);bodyInput.addEventListener('input',persistDraft);
+  document.querySelector('#wb-save').addEventListener('click',async()=>{const button=document.querySelector('#wb-save');const result=document.querySelector('#wb-save-result');const title=titleInput.value.trim();if(!title){result.textContent='Enter a title first.';return}button.disabled=true;result.textContent='Saving…';result.className='wb-result';try{await workbenchPost('api/workbench/documents/'+encodeURIComponent(head.documentId)+'/versions',{baseVersionId:head.versionId,title,body:bodyInput.value},'save:'+head.documentId);clearDraft(head.documentId);await loadResource('documents');await reloadWorkbenchDocument()}catch(error){button.disabled=false;result.className='wb-result wb-error';if(error.status===409&&error.data?.stale){writeDraft(head.documentId,{title:titleInput.value,body:bodyInput.value,baseVersionId:head.versionId,savedAt:Date.now()});result.innerHTML=esc(error.message)+'. Your draft is kept in this browser. <button class="filter-chip" id="wb-save-reload">Reload document</button>';document.querySelector('#wb-save-reload').addEventListener('click',()=>reloadWorkbenchDocument({keepDraft:true}))}else if(error.uncertain){result.innerHTML=esc(workbenchErrorText(error))+' <button class="filter-chip" id="wb-save-reconcile">Reload document</button>';document.querySelector('#wb-save-reconcile').addEventListener('click',()=>reloadWorkbenchDocument({keepDraft:true}))}else result.textContent=error.message}});
+  document.querySelector('#wb-select-open').addEventListener('click',async()=>{state.workbench.selecting=!state.workbench.selecting;const panel=document.querySelector('#wb-select-panel');panel.hidden=!state.workbench.selecting;document.querySelector('#wb-select-open').textContent=state.workbench.selecting?'Close context picker':'Select context';if(state.workbench.selecting){panel.innerHTML='<div class="empty"><span class="spinner" aria-hidden="true"></span>Loading candidates…</div>';try{state.workbench.candidates=await fetchJson('api/workbench/candidates?documentId='+encodeURIComponent(head.documentId),'context candidates');renderWorkbenchCandidates()}catch(error){panel.innerHTML='<div class="wb-error">'+esc(error.message)+'</div>'}}});
+  document.querySelector('#wb-request')?.addEventListener('click',async()=>{if(!latest)return;const button=document.querySelector('#wb-request');const result=document.querySelector('#wb-request-result');const runnerId=document.querySelector('#wb-runner').value;button.disabled=true;result.className='wb-result';result.textContent='Requesting proposal from '+runnerId+'…';try{await workbenchPost('api/workbench/documents/'+encodeURIComponent(head.documentId)+'/proposals',{selectionId:latest.selectionId,runnerId},'proposal:'+head.documentId+':'+latest.selectionId);await loadResource('documents');await reloadWorkbenchDocument({keepDraft:true})}catch(error){button.disabled=false;result.className='wb-result wb-error';result.textContent=workbenchErrorText(error)}});
+  document.querySelectorAll('[data-wb-decide]').forEach(button=>button.addEventListener('click',async()=>{const proposalId=button.dataset.proposal;const disposition=button.dataset.wbDecide;const card=button.closest('[data-proposal-card]');const result=card.querySelector('.wb-result');card.querySelectorAll('[data-wb-decide]').forEach(value=>value.disabled=true);result.className='wb-result';result.textContent=disposition==='accept'?'Accepting…':'Rejecting…';try{await workbenchPost('api/workbench/proposals/'+encodeURIComponent(proposalId)+'/decisions',{disposition},'decision:'+proposalId);await loadResource('documents');await reloadWorkbenchDocument({keepDraft:true})}catch(error){result.className='wb-result wb-error';if(error.status===409&&error.data?.stale){result.innerHTML=esc(error.message)+'. This proposal is stale; request a new one. <button class="filter-chip" id="wb-decide-reload">Reload document</button>';document.querySelector('#wb-decide-reload').addEventListener('click',()=>reloadWorkbenchDocument({keepDraft:true}))}else result.textContent=workbenchErrorText(error);card.querySelectorAll('[data-wb-decide]').forEach(value=>{value.disabled=value.dataset.wbDecide==='accept'&&error.status===409&&error.data?.stale})}}));
+}
+function renderWorkbenchCandidates(){
+  const panel=document.querySelector('#wb-select-panel');const candidates=state.workbench.candidates;if(!panel||!candidates)return;const checked=state.workbench.checked;
+  const events=candidates.events.map(event=>'<label class="wb-check"><input type="checkbox" data-candidate-event="'+esc(event.eventId)+'" '+(checked.events.has(event.eventId)?'checked':'')+'><span>'+esc(event.title)+(event.origin?' <span class="badge">origin</span>':'')+'<span class="meta">'+esc(sourceLabelFromId(event.source))+' · '+esc(new Date(event.occurredAt).toLocaleString())+'</span><span class="meta">'+esc(event.excerpt)+'</span></span></label>').join('');
+  const versions=candidates.versions.map(version=>'<label class="wb-check"><input type="checkbox" data-candidate-version="'+esc(version.versionId)+'" '+(checked.versions.has(version.versionId)?'checked':'')+'><span>Document version · '+esc(humanLabel(version.reason))+(version.head?' <span class="badge">head</span>':'')+'<span class="meta">'+esc(new Date(version.createdAt).toLocaleString())+' · sha '+esc(version.sha256.slice(0,12))+'</span></span></label>').join('');
+  panel.innerHTML='<div class="wb-card"><div class="wb-head"><strong>Choose the evidence to record</strong></div><div class="wb-note">Only checked items enter the selection. Each is recorded by exact id and hash.'+(candidates.bounded?' This list is bounded to recent observations.':'')+'</div><div class="field-label" style="margin-top:10px">Observations</div>'+(events||'<div class="wb-note">No recent observations.</div>')+'<div class="field-label" style="margin-top:10px">Versions of this document</div>'+(versions||'<div class="wb-note">No versions.</div>')+'<div class="wb-actions"><button id="wb-select-save">Record selection</button><span id="wb-select-save-result" class="wb-result"></span></div></div>';
+  panel.querySelectorAll('[data-candidate-event]').forEach(input=>input.addEventListener('change',()=>{if(input.checked)checked.events.add(input.dataset.candidateEvent);else checked.events.delete(input.dataset.candidateEvent)}));
+  panel.querySelectorAll('[data-candidate-version]').forEach(input=>input.addEventListener('change',()=>{if(input.checked)checked.versions.add(input.dataset.candidateVersion);else checked.versions.delete(input.dataset.candidateVersion)}));
+  panel.querySelector('#wb-select-save').addEventListener('click',async()=>{const button=panel.querySelector('#wb-select-save');const result=panel.querySelector('#wb-select-save-result');const eventIds=[...checked.events];const versionIds=[...checked.versions];if(eventIds.length+versionIds.length===0){result.textContent='Check at least one item.';return}button.disabled=true;result.className='wb-result';result.textContent='Recording…';const documentId=state.workbench.documentId;try{await workbenchPost('api/workbench/documents/'+encodeURIComponent(documentId)+'/selections',{eventIds,versionIds},'select:'+documentId+':'+[...eventIds,...versionIds].sort().join(','));state.workbench.selecting=false;state.workbench.checked={events:new Set(),versions:new Set()};await reloadWorkbenchDocument({keepDraft:true})}catch(error){button.disabled=false;result.className='wb-result wb-error';result.textContent=workbenchErrorText(error)}});
 }
 function renderRun(data){
   if(data.error)return '<div class="failed">'+esc(data.error)+'</div>'; return '<h2>'+esc(agentName(data.run.agentId))+' · '+esc(data.kind)+'</h2><div class="meta">agent '+esc(data.run.agentId)+' · '+esc(data.run.id)+'</div><h3>what it did</h3>'+renderAgentWork(data)+'<details><summary>terminal evidence · '+(data.evidence.consistent?'consistent':'contradiction')+'</summary><pre class="'+(data.evidence.consistent?'':'failed')+'">'+json(data.evidence)+'</pre></details><details><summary>run receipt</summary><pre>'+json(data.run)+'</pre></details><details><summary>trace · '+data.trace.length+'</summary><pre>'+json(data.trace)+'</pre></details>';
@@ -1653,6 +1888,7 @@ document.querySelector('#events-tab').addEventListener('click',()=>switchTab('ev
 document.querySelector('#learn-tab').addEventListener('click',()=>switchTab('learn'));
 document.querySelector('#review-tab').addEventListener('click',()=>switchTab(state.tab==='suggestions'||state.tab==='reviews'?state.tab:'suggestions'));
 document.querySelector('#artifacts-tab').addEventListener('click',()=>switchTab('artifacts'));
+document.querySelector('#documents-tab').addEventListener('click',()=>switchTab('documents'));
 document.querySelector('#system-tab').addEventListener('click',()=>switchTab(state.tab==='runs'||state.tab==='sources'?state.tab:'runs'));
 for(const tab of ['suggestions','reviews','runs','sources'])document.querySelector('#'+tab+'-tab').addEventListener('click',()=>switchTab(tab));
 document.querySelector('#course-chat-toggle').addEventListener('click',()=>setCourseChatOpen(true));
diff --git a/src/workbench/contracts.ts b/src/workbench/contracts.ts
new file mode 100644
index 0000000..065e6d1
--- /dev/null
+++ b/src/workbench/contracts.ts
@@ -0,0 +1,259 @@
+import { z } from "zod";
+import { sha256, type JsonObject } from "../core/json.js";
+
+/**
+ * Working-document workbench contracts.
+ *
+ * A working document is an operator-owned editable document that lives in the
+ * shared `documentVersions`/`documents` tables under its own source namespace.
+ * It is a separate kind from observed filesystem versions: editing it never
+ * touches a file on disk. See `spec/documents.md`.
+ */
+
+export const WORKBENCH_DOCUMENT_SOURCE = "workbench:documents";
+export const WORKBENCH_CONTEXT_SOURCE = "context:workbench";
+export const WORKBENCH_DOCUMENT_CONTENT_TYPE = "text/markdown";
+export const WORKBENCH_SCHEMA_VERSION = 1;
+export const WORKBENCH_RUNTIME = "thoughtstream-workbench-v1";
+
+export const DOCUMENT_CREATED_EVENT_TYPE = "stream.thought.workbench.document.created";
+export const DOCUMENT_VERSION_EVENT_TYPE = "stream.thought.workbench.document.version";
+export const CONTEXT_SELECTED_EVENT_TYPE = "stream.thought.workbench.context.selected";
+export const PROPOSAL_REQUESTED_EVENT_TYPE = "stream.thought.workbench.proposal.requested";
+export const PROPOSAL_PROPOSED_EVENT_TYPE = "stream.thought.workbench.proposal.proposed";
+export const PROPOSAL_DECISION_EVENT_TYPE = "stream.thought.workbench.proposal.decision";
+
+export const WORKBENCH_EVENT_TYPES = [
+  DOCUMENT_CREATED_EVENT_TYPE,
+  DOCUMENT_VERSION_EVENT_TYPE,
+  CONTEXT_SELECTED_EVENT_TYPE,
+  PROPOSAL_REQUESTED_EVENT_TYPE,
+  PROPOSAL_PROPOSED_EVENT_TYPE,
+  PROPOSAL_DECISION_EVENT_TYPE,
+] as const;
+
+export const WORKBENCH_JUDGMENT_CRITERION = "workbench-document-proposal";
+export const WORKBENCH_JUDGMENT_CRITERION_VERSION = 1;
+
+export const MAX_DOCUMENT_TITLE_CHARS = 200;
+export const MAX_DOCUMENT_BODY_CHARS = 64_000;
+export const MAX_PROPOSED_TEXT_CHARS = MAX_DOCUMENT_BODY_CHARS;
+export const MAX_SELECTED_EVENTS = 32;
+export const MAX_SELECTED_VERSIONS = 16;
+export const MAX_EXCERPT_CHARS = 2_000;
+export const MAX_EVIDENCE_IDS = 16;
+
+const idSchema = z.string().min(1).max(500);
+const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+const requestIdSchema = z.string().regex(/^[A-Za-z0-9_-]{8,128}$/);
+const uniqueIds = (max: number) => z.array(idSchema).max(max).superRefine((ids, context) => {
+  if (new Set(ids).size !== ids.length) context.addIssue({ code: "custom", message: "Ids must be unique" });
+});
+
+export const VERSION_REASONS = ["created", "operator-edit", "proposal-accepted"] as const;
+export type VersionReason = typeof VERSION_REASONS[number];
+
+export const documentCreatedPayloadSchema = z.object({
+  documentId: idSchema,
+  title: z.string().min(1).max(MAX_DOCUMENT_TITLE_CHARS),
+  originEventId: idSchema,
+  versionId: idSchema,
+  sha256: sha256Schema,
+  requestId: requestIdSchema,
+}).strict();
+
+export const documentVersionPayloadSchema = z.object({
+  documentId: idSchema,
+  versionId: idSchema,
+  baseVersionId: idSchema.nullable(),
+  sha256: sha256Schema,
+  sizeBytes: z.number().int().nonnegative(),
+  reason: z.enum(VERSION_REASONS),
+  proposalEventId: idSchema.optional(),
+  decisionEventId: idSchema.optional(),
+  requestId: requestIdSchema,
+}).strict().superRefine((value, context) => {
+  if ((value.reason === "proposal-accepted") !== (value.proposalEventId !== undefined && value.decisionEventId !== undefined)) {
+    context.addIssue({ code: "custom", path: ["reason"], message: "Only proposal-accepted versions carry proposal and decision references" });
+  }
+});
+
+export const contextSelectedPayloadSchema = z.object({
+  documentId: idSchema,
+  selectionId: idSchema,
+  snapshotVersionId: idSchema,
+  selectedEventIds: uniqueIds(MAX_SELECTED_EVENTS),
+  selectedVersionIds: uniqueIds(MAX_SELECTED_VERSIONS),
+  requestId: requestIdSchema,
+}).strict();
+
+export const proposalRequestedPayloadSchema = z.object({
+  documentId: idSchema,
+  baseVersionId: idSchema,
+  baseSha256: sha256Schema,
+  selectionId: idSchema,
+  snapshotVersionId: idSchema,
+  runnerId: z.string().min(1).max(200),
+  requestId: requestIdSchema,
+}).strict();
+
+const proposerSchema = z.object({
+  runnerId: z.string().min(1).max(200),
+  runnerRevision: z.string().min(1).max(200),
+  requestId: requestIdSchema,
+  runId: idSchema.optional(),
+  contextSnapshotId: idSchema,
+}).strict();
+
+const proposalTargetSchema = z.object({
+  documentId: idSchema,
+  baseVersionId: idSchema,
+  baseSha256: sha256Schema,
+}).strict();
+
+export const proposalProposedPayloadSchema = z.object({
+  proposalState: z.literal("runner-proposed"),
+  proposer: proposerSchema,
+  target: proposalTargetSchema,
+  operation: z.literal("replace-document"),
+  proposedText: z.string().min(1).max(MAX_PROPOSED_TEXT_CHARS),
+  proposedTextChars: z.number().int().positive().max(MAX_PROPOSED_TEXT_CHARS),
+  proposedTextSha256: sha256Schema,
+  reason: z.string().min(1).max(1_000),
+  evidenceEventIds: uniqueIds(MAX_EVIDENCE_IDS),
+  publicationEligible: z.literal(false),
+}).strict().superRefine((value, context) => {
+  if (value.proposedText.length !== value.proposedTextChars) {
+    context.addIssue({ code: "custom", path: ["proposedTextChars"], message: "Proposal text length does not match" });
+  }
+  if (sha256(value.proposedText) !== value.proposedTextSha256) {
+    context.addIssue({ code: "custom", path: ["proposedTextSha256"], message: "Proposal text hash does not match" });
+  }
+});
+
+export const proposalDecisionPayloadSchema = z.object({
+  proposalEventId: idSchema,
+  disposition: z.enum(["accept", "reject"]),
+  submissionId: requestIdSchema,
+  authority: z.literal("human"),
+  resultVersionId: idSchema.optional(),
+}).strict().superRefine((value, context) => {
+  if ((value.disposition === "accept") !== (value.resultVersionId !== undefined)) {
+    context.addIssue({ code: "custom", path: ["resultVersionId"], message: "Only accepted decisions name a result version" });
+  }
+});
+
+export type DocumentCreatedPayload = z.infer<typeof documentCreatedPayloadSchema>;
+export type DocumentVersionPayload = z.infer<typeof documentVersionPayloadSchema>;
+export type ContextSelectedPayload = z.infer<typeof contextSelectedPayloadSchema>;
+export type ProposalRequestedPayload = z.infer<typeof proposalRequestedPayloadSchema>;
+export type ProposalProposedPayload = z.infer<typeof proposalProposedPayloadSchema>;
+export type WorkbenchProposalDecisionPayload = z.infer<typeof proposalDecisionPayloadSchema>;
+
+/** Browser/API request bodies. Every mutation carries a client-generated request or submission id. */
+export const createDocumentRequestSchema = z.object({
+  originEventId: idSchema,
+  title: z.string().min(1).max(MAX_DOCUMENT_TITLE_CHARS),
+  body: z.string().max(MAX_DOCUMENT_BODY_CHARS),
+  requestId: requestIdSchema,
+}).strict();
+
+export const saveEditRequestSchema = z.object({
+  baseVersionId: idSchema,
+  title: z.string().min(1).max(MAX_DOCUMENT_TITLE_CHARS),
+  body: z.string().max(MAX_DOCUMENT_BODY_CHARS),
+  requestId: requestIdSchema,
+}).strict();
+
+export const selectContextRequestSchema = z.object({
+  eventIds: uniqueIds(MAX_SELECTED_EVENTS),
+  versionIds: uniqueIds(MAX_SELECTED_VERSIONS),
+  requestId: requestIdSchema,
+}).strict();
+
+export const requestProposalRequestSchema = z.object({
+  selectionId: idSchema,
+  runnerId: z.string().min(1).max(200),
+  requestId: requestIdSchema,
+}).strict();
+
+export const decideProposalRequestSchema = z.object({
+  disposition: z.enum(["accept", "reject"]),
+  submissionId: requestIdSchema,
+}).strict();
+
+/** Snapshot content stored as one immutable JSON document version under `context:workbench`. */
+export interface WorkbenchContextSnapshot {
+  documentId: string;
+  baseVersionId: string;
+  selectedEvents: Array<{
+    eventId: string;
+    type: string;
+    source: string;
+    occurredAt: string;
+    payloadHash: string;
+    excerpt: string;
+  }>;
+  selectedVersions: Array<{
+    documentId: string;
+    versionId: string;
+    sha256: string;
+    path: string;
+  }>;
+}
+
+export const workbenchContextSnapshotSchema = z.object({
+  documentId: idSchema,
+  baseVersionId: idSchema,
+  selectedEvents: z.array(z.object({
+    eventId: idSchema,
+    type: z.string().min(1),
+    source: z.string().min(1),
+    occurredAt: z.string(),
+    payloadHash: sha256Schema,
+    excerpt: z.string().max(MAX_EXCERPT_CHARS),
+  }).strict()).max(MAX_SELECTED_EVENTS),
+  selectedVersions: z.array(z.object({
+    documentId: idSchema,
+    versionId: idSchema,
+    sha256: sha256Schema,
+    path: z.string(),
+  }).strict()).max(MAX_SELECTED_VERSIONS),
+}).strict();
+
+/**
+ * A version's content is self-describing: the title travels in frontmatter so
+ * a version can be read without the mutable head projection.
+ */
+export function encodeDocumentContent(title: string, body: string): string {
+  return `---\ntitle: ${JSON.stringify(title)}\n---\n${body}`;
+}
+
+export function decodeDocumentContent(content: string): { title: string; body: string } {
+  const match = content.match(/^---\ntitle: (.*)\n---\n([\s\S]*)$/);
+  if (!match) return { title: "Untitled", body: content };
+  let title: string;
+  try {
+    const parsed: unknown = JSON.parse(match[1]!);
+    title = typeof parsed === "string" && parsed.length > 0 ? parsed : "Untitled";
+  } catch {
+    title = "Untitled";
+  }
+  return { title, body: match[2]! };
+}
+
+/** Bounded plain-text rendering of an event payload for context snapshots. Never HTML. */
+export function plainExcerpt(payload: JsonObject, maxChars = MAX_EXCERPT_CHARS): string {
+  const parts: string[] = [];
+  for (const key of ["subject", "title", "text", "body", "summary", "preview", "path"]) {
+    const value = payload[key];
+    if (typeof value === "string" && value.trim()) parts.push(value.trim());
+  }
+  const record = payload.record;
+  if (record && typeof record === "object" && !Array.isArray(record) && typeof record.text === "string" && record.text.trim()) {
+    parts.push(record.text.trim());
+  }
+  const text = parts.length > 0 ? parts.join("\n") : JSON.stringify(payload);
+  const normalized = text.replace(/\r\n?/g, "\n").replace(/[--]/g, "");
+  return normalized.length > maxChars ? `${normalized.slice(0, maxChars - 1)}…` : normalized;
+}
diff --git a/src/workbench/runners.ts b/src/workbench/runners.ts
new file mode 100644
index 0000000..9e35260
--- /dev/null
+++ b/src/workbench/runners.ts
@@ -0,0 +1,98 @@
+import { MAX_EVIDENCE_IDS, type WorkbenchContextSnapshot } from "./contracts.js";
+
+/**
+ * Workbench proposal runner seam.
+ *
+ * A runner receives the exact head version of one working document plus the
+ * operator's exact context snapshot and returns one full replacement body.
+ * The trusted workflow (`workflow.ts`) owns every durable effect: it appends
+ * the requested event, runs the runner, records the run row, appends the
+ * proposal event, and later applies a human decision. A runner never touches
+ * Jazz, the filesystem, or the network on its own.
+ *
+ * Coordination point with the separate fx consumer work: an fx-backed runner
+ * would implement this same interface, map the harness result frame's
+ * `finalText` to `proposedText`, map its run id to `proposer.runId`, and
+ * report the harness's own reason string. That adapter is not implemented
+ * here and nothing in this module imports from `src/agents/harness/`; the
+ * request/result shapes below are the contract the two sides share.
+ */
+
+export interface WorkbenchProposalRequest {
+  documentId: string;
+  baseVersionId: string;
+  baseSha256: string;
+  title: string;
+  baseText: string;
+  snapshot: WorkbenchContextSnapshot;
+  maxProposedChars: number;
+}
+
+export interface WorkbenchProposalResult {
+  proposedText: string;
+  reason: string;
+  evidenceEventIds: string[];
+}
+
+export interface WorkbenchProposalRunner {
+  id: string;
+  revision: string;
+  /** Plain-language label shown next to the request control. */
+  label: string;
+  /** Whether the runner performs LLM inference. The fixture runner does not. */
+  inference: "none" | "model";
+  propose(request: WorkbenchProposalRequest): Promise<WorkbenchProposalResult>;
+}
+
+export const FIXTURE_RUNNER_ID = "fixture-deterministic";
+export const FIXTURE_RUNNER_REVISION = "1";
+
+const SOURCES_HEADING = "## Sources";
+
+/**
+ * Deterministic fixture runner. It appends (or replaces) a `## Sources`
+ * section listing each selected event and version, plus a one-line
+ * `Summary:` paragraph counting the sources. Identical input yields identical
+ * output; no inference occurs.
+ */
+export const fixtureDeterministicRunner: WorkbenchProposalRunner = {
+  id: FIXTURE_RUNNER_ID,
+  revision: FIXTURE_RUNNER_REVISION,
+  label: "Deterministic fixture (no inference)",
+  inference: "none",
+  async propose(request) {
+    const lines: string[] = [SOURCES_HEADING, ""];
+    for (const event of request.snapshot.selectedEvents) {
+      const excerpt = event.excerpt.replace(/\s+/g, " ").trim().slice(0, 120);
+      lines.push(`- ${event.type} ${event.eventId.slice(0, 16)} — ${excerpt}`);
+    }
+    for (const version of request.snapshot.selectedVersions) {
+      lines.push(`- version ${version.versionId.slice(0, 24)} (${version.sha256.slice(0, 12)})`);
+    }
+    const count = request.snapshot.selectedEvents.length + request.snapshot.selectedVersions.length;
+    lines.push("", `Summary: this document cites ${count} selected source${count === 1 ? "" : "s"}.`);
+    const base = stripSourcesSection(request.baseText).replace(/\s+$/, "");
+    const proposedText = `${base}${base ? "\n\n" : ""}${lines.join("\n")}\n`;
+    if (proposedText.length > request.maxProposedChars) {
+      throw new Error("Fixture runner output exceeds the proposal character bound");
+    }
+    return {
+      proposedText,
+      reason: "fixture: append sources section",
+      evidenceEventIds: request.snapshot.selectedEvents.map((event) => event.eventId).slice(0, MAX_EVIDENCE_IDS),
+    };
+  },
+};
+
+function stripSourcesSection(text: string): string {
+  const index = text.indexOf(`\n${SOURCES_HEADING}`);
+  if (text.startsWith(SOURCES_HEADING)) return "";
+  if (index === -1) return text;
+  return text.slice(0, index);
+}
+
+export type WorkbenchRunnerRegistry = ReadonlyMap<string, WorkbenchProposalRunner>;
+
+export function createDefaultWorkbenchRunnerRegistry(): WorkbenchRunnerRegistry {
+  return new Map([[fixtureDeterministicRunner.id, fixtureDeterministicRunner]]);
+}
diff --git a/src/workbench/workflow.ts b/src/workbench/workflow.ts
new file mode 100644
index 0000000..8f78ff9
--- /dev/null
+++ b/src/workbench/workflow.ts
@@ -0,0 +1,1096 @@
+import { createTwoFilesPatch } from "diff";
+import { canonicalJson, hashJson, parseJsonObject, sha256, type JsonObject } from "../core/json.js";
+import { stableKey } from "../core/ids.js";
+import type { CurrentDocument, DocumentVersion, EventCandidate, ThoughtEvent } from "../events/types.js";
+import { eventIdFor, type JazzThoughtStore } from "../jazz/store.js";
+import { buildRecentRootObservations } from "../projections/activity.js";
+import type { AgentRun } from "../store/types.js";
+import { recordJudgment } from "../training/judgments.js";
+import {
+  CONTEXT_SELECTED_EVENT_TYPE,
+  DOCUMENT_CREATED_EVENT_TYPE,
+  DOCUMENT_VERSION_EVENT_TYPE,
+  MAX_DOCUMENT_BODY_CHARS,
+  MAX_DOCUMENT_TITLE_CHARS,
+  MAX_EVIDENCE_IDS,
+  MAX_PROPOSED_TEXT_CHARS,
+  PROPOSAL_DECISION_EVENT_TYPE,
+  PROPOSAL_PROPOSED_EVENT_TYPE,
+  PROPOSAL_REQUESTED_EVENT_TYPE,
+  WORKBENCH_CONTEXT_SOURCE,
+  WORKBENCH_DOCUMENT_CONTENT_TYPE,
+  WORKBENCH_DOCUMENT_SOURCE,
+  WORKBENCH_JUDGMENT_CRITERION,
+  WORKBENCH_JUDGMENT_CRITERION_VERSION,
+  WORKBENCH_RUNTIME,
+  WORKBENCH_SCHEMA_VERSION,
+  contextSelectedPayloadSchema,
+  decodeDocumentContent,
+  documentCreatedPayloadSchema,
+  documentVersionPayloadSchema,
+  encodeDocumentContent,
+  plainExcerpt,
+  proposalDecisionPayloadSchema,
+  proposalProposedPayloadSchema,
+  proposalRequestedPayloadSchema,
+  workbenchContextSnapshotSchema,
+  type ContextSelectedPayload,
+  type DocumentVersionPayload,
+  type ProposalProposedPayload,
+  type VersionReason,
+  type WorkbenchContextSnapshot,
+} from "./contracts.js";
+import {
+  createDefaultWorkbenchRunnerRegistry,
+  type WorkbenchProposalRequest,
+  type WorkbenchRunnerRegistry,
+} from "./runners.js";
+
+const JUDGMENT_EVENT_TYPE = "stream.thought.judgment.training-example";
+const MAX_DIFF_CHARS = 200_000;
+const MAX_CANDIDATE_EVENTS = 50;
+
+export class StaleBaseError extends Error {
+  constructor(readonly headVersionId: string, message = "The document changed since this base version") {
+    super(message);
+    this.name = "StaleBaseError";
+  }
+}
+
+export class WorkbenchNotFoundError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "WorkbenchNotFoundError";
+  }
+}
+
+export class WorkbenchConflictError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "WorkbenchConflictError";
+  }
+}
+
+export class WorkbenchRunnerError extends Error {
+  constructor(readonly runId: string, message: string) {
+    super(message);
+    this.name = "WorkbenchRunnerError";
+  }
+}
+
+export interface WorkbenchWorkflowOptions {
+  actor?: string | undefined;
+  runners?: WorkbenchRunnerRegistry | undefined;
+}
+
+export interface WorkingDocumentHead {
+  documentId: string;
+  title: string;
+  body: string;
+  versionId: string;
+  sha256: string;
+  sizeBytes: number;
+  updatedAt: string;
+}
+
+export interface WorkbenchVersionSummary {
+  eventId: string;
+  versionId: string;
+  baseVersionId: string | null;
+  sha256: string;
+  sizeBytes: number;
+  reason: VersionReason;
+  proposalEventId?: string;
+  decisionEventId?: string;
+  createdAt: string;
+}
+
+export interface WorkbenchSelectionSummary {
+  eventId: string;
+  selectionId: string;
+  snapshotVersionId: string;
+  snapshotSha256: string;
+  baseVersionId: string;
+  createdAt: string;
+  selectedEvents: WorkbenchContextSnapshot["selectedEvents"];
+  selectedVersions: WorkbenchContextSnapshot["selectedVersions"];
+}
+
+export interface WorkbenchProposalSummary {
+  eventId: string;
+  requestedEventId: string;
+  selectionId: string;
+  snapshotVersionId: string;
+  runId: string | undefined;
+  runStatus: string | undefined;
+  runnerId: string;
+  runnerRevision: string;
+  inference: "none" | "model" | "unknown";
+  reason: string;
+  evidenceEventIds: string[];
+  baseVersionId: string;
+  baseSha256: string;
+  proposedText: string;
+  proposedTextSha256: string;
+  proposedTextChars: number;
+  diff: string;
+  createdAt: string;
+  stale: boolean;
+  headVersionId: string;
+  status: "pending" | "accepted" | "rejected" | "stale";
+  decision?: {
+    eventId: string;
+    disposition: "accept" | "reject";
+    submissionId: string;
+    resultVersionId?: string;
+    judgmentEventId?: string;
+    createdAt: string;
+  };
+}
+
+export interface WorkbenchDocumentDetail {
+  head: WorkingDocumentHead;
+  origin: { eventId: string; type: string; source: string; occurredAt: string; excerpt: string } | undefined;
+  createdEventId: string;
+  versions: WorkbenchVersionSummary[];
+  selections: WorkbenchSelectionSummary[];
+  proposals: WorkbenchProposalSummary[];
+  runners: Array<{ id: string; revision: string; label: string; inference: "none" | "model" }>;
+}
+
+export interface WorkbenchDocumentListItem {
+  documentId: string;
+  title: string;
+  originEventId: string;
+  headVersionId: string;
+  sha256: string;
+  updatedAt: string;
+  versionCount: number;
+  proposalCount: number;
+  pendingProposalCount: number;
+}
+
+export interface WorkbenchCandidates {
+  documentId: string;
+  events: Array<{ eventId: string; type: string; source: string; occurredAt: string; title: string; excerpt: string; origin: boolean }>;
+  versions: Array<{ versionId: string; sha256: string; reason: VersionReason; createdAt: string; head: boolean }>;
+  bounded: boolean;
+}
+
+export function workingDocumentId(originEventId: string, requestId: string): string {
+  return stableKey("working-document", originEventId, requestId);
+}
+
+export function workingDocumentVersionId(documentId: string, contentSha256: string): string {
+  return stableKey("version", WORKBENCH_DOCUMENT_SOURCE, documentId, contentSha256);
+}
+
+export function workbenchSelectionId(documentId: string, requestId: string): string {
+  return stableKey("workbench-selection", documentId, requestId);
+}
+
+export function workbenchRunId(documentId: string, requestId: string): string {
+  return stableKey("workbench-run", documentId, requestId);
+}
+
+function headRowId(documentId: string): string {
+  return stableKey("document", WORKBENCH_DOCUMENT_SOURCE, documentId);
+}
+
+function createdEventKey(documentId: string): string {
+  return stableKey("workbench-document-created", documentId);
+}
+
+function versionEventKey(documentId: string, reason: VersionReason, requestId: string): string {
+  return stableKey("workbench-document-version", documentId, reason, requestId);
+}
+
+function selectedEventKey(selectionId: string): string {
+  return stableKey("workbench-context-selected", selectionId);
+}
+
+function requestedEventKey(documentId: string, requestId: string): string {
+  return stableKey("workbench-proposal-requested", documentId, requestId);
+}
+
+function proposedEventKey(documentId: string, requestId: string): string {
+  return stableKey("workbench-proposal-proposed", documentId, requestId);
+}
+
+function decisionEventKey(proposalEventId: string): string {
+  return stableKey("workbench-proposal-decision", proposalEventId);
+}
+
+const documentQueues = new Map<string, Promise<void>>();
+
+async function withDocumentLock<T>(documentId: string, operation: () => Promise<T>): Promise<T> {
+  const previous = documentQueues.get(documentId) ?? Promise.resolve();
+  let release!: () => void;
+  const current = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const queued = previous.then(() => current);
+  documentQueues.set(documentId, queued);
+  await previous;
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (documentQueues.get(documentId) === queued) documentQueues.delete(documentId);
+  }
+}
+
+/**
+ * Trusted mutation path for working documents. Every method appends
+ * append-only events through the existing store, keeps the `documents` row as
+ * the current-head projection, and never touches a file on disk.
+ */
+export class WorkbenchWorkflow {
+  private readonly actor: string;
+  private readonly runners: WorkbenchRunnerRegistry;
+
+  constructor(private readonly store: JazzThoughtStore, options: WorkbenchWorkflowOptions = {}) {
+    this.actor = options.actor ?? "operator:local";
+    this.runners = options.runners ?? createDefaultWorkbenchRunnerRegistry();
+  }
+
+  listRunners(): WorkbenchDocumentDetail["runners"] {
+    return [...this.runners.values()].map((runner) => ({
+      id: runner.id,
+      revision: runner.revision,
+      label: runner.label,
+      inference: runner.inference,
+    }));
+  }
+
+  async createWorkingDocument(input: {
+    originEventId: string;
+    title: string;
+    body: string;
+    requestId: string;
+  }): Promise<WorkingDocumentHead> {
+    const origin = await this.store.getEvent(input.originEventId);
+    if (!origin) throw new WorkbenchNotFoundError("Origin event was not found");
+    const title = validateTitle(input.title);
+    const body = validateBody(input.body);
+    const documentId = workingDocumentId(origin.id, input.requestId);
+    return withDocumentLock(documentId, async () => {
+      const content = encodeDocumentContent(title, body);
+      const contentSha256 = sha256(content);
+      const versionId = workingDocumentVersionId(documentId, contentSha256);
+      const existing = await this.getHeadRow(documentId);
+      if (existing) {
+        if (existing.sha256 !== contentSha256) {
+          throw new WorkbenchConflictError("Request id was reused with different document content");
+        }
+        return this.headFromRow(existing);
+      }
+      const createdAt = new Date().toISOString();
+      await this.appendVersionRow(documentId, versionId, content, contentSha256, createdAt);
+      const created = await this.store.appendEvent(this.candidate({
+        type: DOCUMENT_CREATED_EVENT_TYPE,
+        idempotencyKey: createdEventKey(documentId),
+        rootEventId: origin.rootEventId,
+        parentEventId: origin.id,
+        correlationId: documentId,
+        occurredAt: createdAt,
+        payload: documentCreatedPayloadSchema.parse({
+          documentId,
+          title,
+          originEventId: origin.id,
+          versionId,
+          sha256: contentSha256,
+          requestId: input.requestId,
+        }),
+      }));
+      await this.store.appendEvent(this.candidate({
+        type: DOCUMENT_VERSION_EVENT_TYPE,
+        idempotencyKey: versionEventKey(documentId, "created", input.requestId),
+        rootEventId: origin.rootEventId,
+        parentEventId: created.event.id,
+        correlationId: documentId,
+        occurredAt: createdAt,
+        payload: versionPayload({
+          documentId,
+          versionId,
+          baseVersionId: null,
+          sha256: contentSha256,
+          sizeBytes: Buffer.byteLength(content),
+          reason: "created",
+          requestId: input.requestId,
+        }),
+      }));
+      const head = await this.upsertHead(documentId, versionId, contentSha256, Buffer.byteLength(content), createdAt);
+      return this.headFromRow(head);
+    });
+  }
+
+  async saveOperatorEdit(input: {
+    documentId: string;
+    baseVersionId: string;
+    title: string;
+    body: string;
+    requestId: string;
+  }): Promise<WorkingDocumentHead> {
+    const title = validateTitle(input.title);
+    const body = validateBody(input.body);
+    return withDocumentLock(input.documentId, async () => {
+      const lineage = await this.requireLineage(input.documentId);
+      const replayed = await this.store.getEvent(eventIdFor(
+        WORKBENCH_DOCUMENT_SOURCE,
+        versionEventKey(input.documentId, "operator-edit", input.requestId),
+      ));
+      if (replayed) {
+        // A retry after an uncertain outcome: settle the head if the append
+        // landed but the projection did not, then return the current head.
+        const payload = documentVersionPayloadSchema.parse(replayed.payload);
+        return this.headFromRow(await this.settleHead(input.documentId, payload));
+      }
+      const head = await this.requireHeadRow(input.documentId);
+      if (input.baseVersionId !== head.versionId) throw new StaleBaseError(head.versionId);
+      const content = encodeDocumentContent(title, body);
+      const contentSha256 = sha256(content);
+      const versionId = workingDocumentVersionId(input.documentId, contentSha256);
+      if (versionId === head.versionId) return this.headFromRow(head);
+      const createdAt = new Date().toISOString();
+      await this.appendVersionRow(input.documentId, versionId, content, contentSha256, createdAt);
+      await this.store.appendEvent(this.candidate({
+        type: DOCUMENT_VERSION_EVENT_TYPE,
+        idempotencyKey: versionEventKey(input.documentId, "operator-edit", input.requestId),
+        rootEventId: lineage.created.rootEventId,
+        parentEventId: lineage.created.id,
+        correlationId: input.documentId,
+        occurredAt: createdAt,
+        payload: versionPayload({
+          documentId: input.documentId,
+          versionId,
+          baseVersionId: head.versionId,
+          sha256: contentSha256,
+          sizeBytes: Buffer.byteLength(content),
+          reason: "operator-edit",
+          requestId: input.requestId,
+        }),
+      }));
+      const updated = await this.upsertHead(input.documentId, versionId, contentSha256, Buffer.byteLength(content), createdAt);
+      return this.headFromRow(updated);
+    });
+  }
+
+  async selectContext(input: {
+    documentId: string;
+    eventIds: string[];
+    versionIds: string[];
+    requestId: string;
+  }): Promise<WorkbenchSelectionSummary> {
+    const lineage = await this.requireLineage(input.documentId);
+    const head = await this.requireHeadRow(input.documentId);
+    const selectionId = workbenchSelectionId(input.documentId, input.requestId);
+    const existing = await this.store.getEvent(eventIdFor(WORKBENCH_DOCUMENT_SOURCE, selectedEventKey(selectionId)));
+    if (existing) return this.selectionSummary(existing);
+    const eventIds = [...new Set(input.eventIds)];
+    const versionIds = [...new Set(input.versionIds)];
+    const events = await this.store.getEvents(eventIds);
+    const eventsById = new Map(events.map((event) => [event.id, event]));
+    for (const id of eventIds) if (!eventsById.has(id)) throw new WorkbenchNotFoundError(`Selected event was not found: ${id}`);
+    const versions: DocumentVersion[] = [];
+    for (const id of versionIds) {
+      const version = await this.store.getDocumentVersion(id);
+      if (!version) throw new WorkbenchNotFoundError(`Selected version was not found: ${id}`);
+      versions.push(version);
+    }
+    const snapshot: WorkbenchContextSnapshot = {
+      documentId: input.documentId,
+      baseVersionId: head.versionId,
+      selectedEvents: eventIds.map((id) => {
+        const event = eventsById.get(id)!;
+        return {
+          eventId: event.id,
+          type: event.type,
+          source: event.source,
+          occurredAt: event.occurredAt,
+          payloadHash: event.payloadHash,
+          excerpt: plainExcerpt(event.payload),
+        };
+      }),
+      selectedVersions: versions.map((version) => ({
+        documentId: version.documentId,
+        versionId: version.id,
+        sha256: version.sha256,
+        path: version.path,
+      })),
+    };
+    const content = canonicalJson(workbenchContextSnapshotSchema.parse(snapshot) as unknown as JsonObject);
+    // Deterministic over the exact base version and the sorted selected ids;
+    // the id list is hashed so the identity stays bounded for any selection size.
+    const sortedIds = [...eventIds, ...versionIds].sort();
+    const snapshotVersionId = stableKey(
+      "workbench-context-snapshot",
+      input.documentId,
+      sha256(canonicalJson({ baseVersionId: head.versionId, ids: sortedIds })),
+    );
+    const createdAt = new Date().toISOString();
+    await this.store.appendDocumentVersion({
+      id: snapshotVersionId,
+      source: WORKBENCH_CONTEXT_SOURCE,
+      documentId: snapshotVersionId,
+      path: `workbench-context/${encodeURIComponent(input.documentId)}/${encodeURIComponent(selectionId)}.json`,
+      contentType: "application/json",
+      sha256: sha256(content),
+      content,
+      sizeBytes: Buffer.byteLength(content),
+      mtimeMs: Date.parse(createdAt),
+      createdAt,
+    });
+    const stored = await this.store.getDocumentVersion(snapshotVersionId);
+    if (!stored) throw new Error("Context snapshot insertion left no durable evidence");
+    if (stored.sha256 !== sha256(content)) throw new WorkbenchConflictError("Context snapshot identity collides with different content");
+    const selected = await this.store.appendEvent(this.candidate({
+      type: CONTEXT_SELECTED_EVENT_TYPE,
+      idempotencyKey: selectedEventKey(selectionId),
+      rootEventId: lineage.created.rootEventId,
+      parentEventId: lineage.created.id,
+      correlationId: input.documentId,
+      occurredAt: createdAt,
+      payload: contextSelectedPayloadSchema.parse({
+        documentId: input.documentId,
+        selectionId,
+        snapshotVersionId,
+        selectedEventIds: eventIds,
+        selectedVersionIds: versionIds,
+        requestId: input.requestId,
+      }) as unknown as JsonObject,
+    }));
+    return this.selectionSummary(selected.event);
+  }
+
+  async requestProposal(input: {
+    documentId: string;
+    selectionId: string;
+    runnerId: string;
+    requestId: string;
+  }): Promise<{ proposalEventId: string; requestedEventId: string; runId: string }> {
+    const runner = this.runners.get(input.runnerId);
+    if (!runner) throw new WorkbenchNotFoundError(`Unknown proposal runner: ${input.runnerId}`);
+    return withDocumentLock(input.documentId, async () => {
+      const lineage = await this.requireLineage(input.documentId);
+      const runId = workbenchRunId(input.documentId, input.requestId);
+      const requestedEventId = eventIdFor(WORKBENCH_DOCUMENT_SOURCE, requestedEventKey(input.documentId, input.requestId));
+      const proposalEventId = eventIdFor(WORKBENCH_DOCUMENT_SOURCE, proposedEventKey(input.documentId, input.requestId));
+      const replayed = await this.store.getEvent(proposalEventId);
+      if (replayed) return { proposalEventId, requestedEventId, runId };
+      const priorRun = await this.store.getRun(runId);
+      if (priorRun?.status === "failed") {
+        throw new WorkbenchRunnerError(runId, priorRun.errorText || "The proposal runner failed");
+      }
+      const selected = await this.store.getEvent(eventIdFor(WORKBENCH_DOCUMENT_SOURCE, selectedEventKey(input.selectionId)));
+      if (!selected || selected.type !== CONTEXT_SELECTED_EVENT_TYPE) throw new WorkbenchNotFoundError("Context selection was not found");
+      const selection = contextSelectedPayloadSchema.parse(selected.payload);
+      if (selection.documentId !== input.documentId) throw new WorkbenchNotFoundError("Context selection belongs to another document");
+      const snapshotVersion = await this.store.getDocumentVersion(selection.snapshotVersionId);
+      if (!snapshotVersion) throw new WorkbenchNotFoundError("Context snapshot was not found");
+      const snapshot = workbenchContextSnapshotSchema.parse(parseJsonObject(snapshotVersion.content)) as WorkbenchContextSnapshot;
+      const head = await this.requireHeadRow(input.documentId);
+      const headVersion = await this.requireVersion(head.versionId);
+      const decoded = decodeDocumentContent(headVersion.content);
+      const createdAt = new Date().toISOString();
+      const requested = await this.store.appendEvent(this.candidate({
+        type: PROPOSAL_REQUESTED_EVENT_TYPE,
+        idempotencyKey: requestedEventKey(input.documentId, input.requestId),
+        rootEventId: lineage.created.rootEventId,
+        parentEventId: selected.id,
+        correlationId: input.documentId,
+        occurredAt: createdAt,
+        payload: proposalRequestedPayloadSchema.parse({
+          documentId: input.documentId,
+          baseVersionId: head.versionId,
+          baseSha256: head.sha256,
+          selectionId: input.selectionId,
+          snapshotVersionId: selection.snapshotVersionId,
+          runnerId: runner.id,
+          requestId: input.requestId,
+        }),
+      }));
+      const request: WorkbenchProposalRequest = {
+        documentId: input.documentId,
+        baseVersionId: head.versionId,
+        baseSha256: head.sha256,
+        title: decoded.title,
+        baseText: decoded.body,
+        snapshot,
+        maxProposedChars: MAX_PROPOSED_TEXT_CHARS,
+      };
+      const run: AgentRun = {
+        id: runId,
+        executionKey: runId,
+        triggerEventId: requested.event.id,
+        agentId: runner.id,
+        agentVersion: 1,
+        status: "running",
+        inputEventIds: [requested.event.id, ...selection.selectedEventIds],
+        outputEventIds: [],
+        attempt: 1,
+        provider: "fixture",
+        model: "deterministic-workbench@1",
+        privacy: "sensitive",
+        promptHash: hashJson(request as unknown as JsonObject),
+        contextManifest: {
+          contextStrategy: "workbench-selection",
+          inference: runner.inference,
+          documentId: input.documentId,
+          baseVersionId: head.versionId,
+          baseSha256: head.sha256,
+          selectionId: input.selectionId,
+          runnerId: runner.id,
+          runnerRevision: runner.revision,
+          tools: [],
+          proposals: [],
+          externalActions: false,
+          privacy: "sensitive",
+          contextSnapshot: {
+            id: selection.snapshotVersionId,
+            storage: "jazz-document-version",
+            sha256: snapshotVersion.sha256,
+          },
+        },
+        createdAt,
+        startedAt: createdAt,
+        updatedAt: createdAt,
+      };
+      await this.store.upsertRun(run);
+      let payload: ProposalProposedPayload;
+      try {
+        const result = await runner.propose(request);
+        const admitted = new Set(selection.selectedEventIds);
+        const evidenceEventIds = [...new Set(result.evidenceEventIds)].slice(0, MAX_EVIDENCE_IDS);
+        for (const id of evidenceEventIds) {
+          if (!admitted.has(id)) throw new Error("Runner cited an event outside the selected context");
+        }
+        payload = proposalProposedPayloadSchema.parse({
+          proposalState: "runner-proposed",
+          proposer: {
+            runnerId: runner.id,
+            runnerRevision: runner.revision,
+            requestId: input.requestId,
+            runId,
+            contextSnapshotId: selection.snapshotVersionId,
+          },
+          target: { documentId: input.documentId, baseVersionId: head.versionId, baseSha256: head.sha256 },
+          operation: "replace-document",
+          proposedText: result.proposedText,
+          proposedTextChars: result.proposedText.length,
+          proposedTextSha256: sha256(result.proposedText),
+          reason: result.reason,
+          evidenceEventIds,
+          publicationEligible: false,
+        });
+      } catch (error) {
+        const completedAt = new Date().toISOString();
+        await this.store.upsertRun({
+          ...run,
+          status: "failed",
+          errorText: classifyRunnerFailure(error),
+          completedAt,
+          updatedAt: completedAt,
+        });
+        throw new WorkbenchRunnerError(runId, classifyRunnerFailure(error));
+      }
+      const proposed = await this.store.appendEvent(this.candidate({
+        type: PROPOSAL_PROPOSED_EVENT_TYPE,
+        idempotencyKey: proposedEventKey(input.documentId, input.requestId),
+        rootEventId: lineage.created.rootEventId,
+        parentEventId: requested.event.id,
+        correlationId: input.documentId,
+        occurredAt: createdAt,
+        payload: payload as unknown as JsonObject,
+      }));
+      const completedAt = new Date().toISOString();
+      await this.store.upsertRun({
+        ...run,
+        status: "completed",
+        outputEventIds: [proposed.event.id],
+        result: {
+          summary: payload.reason,
+          proposedTextSha256: payload.proposedTextSha256,
+          proposedTextChars: payload.proposedTextChars,
+          evidenceCount: payload.evidenceEventIds.length,
+        },
+        completedAt,
+        updatedAt: completedAt,
+      });
+      return { proposalEventId: proposed.event.id, requestedEventId: requested.event.id, runId };
+    });
+  }
+
+  async decideProposal(input: {
+    proposalEventId: string;
+    disposition: "accept" | "reject";
+    submissionId: string;
+  }): Promise<{ decisionEventId: string; disposition: "accept" | "reject"; resultVersionId?: string; judgmentEventId?: string; replayed: boolean }> {
+    const proposal = await this.store.getEvent(input.proposalEventId);
+    if (!proposal || proposal.type !== PROPOSAL_PROPOSED_EVENT_TYPE) throw new WorkbenchNotFoundError("Proposal was not found");
+    const proposalPayload = proposalProposedPayloadSchema.parse(proposal.payload);
+    const documentId = proposalPayload.target.documentId;
+    return withDocumentLock(documentId, async () => {
+      const base = await this.requireVersion(proposalPayload.target.baseVersionId);
+      if (base.sha256 !== proposalPayload.target.baseSha256) throw new WorkbenchConflictError("Proposal base version evidence is inconsistent");
+      const baseTitle = decodeDocumentContent(base.content).title;
+      const resultContent = encodeDocumentContent(baseTitle, proposalPayload.proposedText);
+      const resultSha256 = sha256(resultContent);
+      const resultVersionId = workingDocumentVersionId(documentId, resultSha256);
+      const decisionEventId = eventIdFor(WORKBENCH_DOCUMENT_SOURCE, decisionEventKey(proposal.id));
+      const payload = proposalDecisionPayloadSchema.parse({
+        proposalEventId: proposal.id,
+        disposition: input.disposition,
+        submissionId: input.submissionId,
+        authority: "human",
+        ...(input.disposition === "accept" ? { resultVersionId } : {}),
+      });
+      const decisions = (await this.store.listChildEvents(proposal.id)).filter((event) => event.type === PROPOSAL_DECISION_EVENT_TYPE);
+      const sameSubmission = decisions.find((decision) => decision.payload.submissionId === input.submissionId);
+      if (sameSubmission) {
+        if (canonicalJson(sameSubmission.payload) !== canonicalJson(payload as unknown as JsonObject)) {
+          throw new WorkbenchConflictError("Proposal decision submission id conflicts with existing content");
+        }
+        // Replay: finish any settlement the earlier attempt did not reach; apply nothing twice.
+        if (payload.disposition === "accept") {
+          const versionEvent = await this.store.getEvent(eventIdFor(
+            WORKBENCH_DOCUMENT_SOURCE,
+            versionEventKey(documentId, "proposal-accepted", input.submissionId),
+          ));
+          if (versionEvent) await this.settleHead(documentId, documentVersionPayloadSchema.parse(versionEvent.payload));
+        }
+        const judgment = await this.recordDecisionJudgment(proposalPayload, sameSubmission, payload.disposition);
+        return {
+          decisionEventId: sameSubmission.id,
+          disposition: payload.disposition,
+          ...(payload.resultVersionId ? { resultVersionId: payload.resultVersionId } : {}),
+          ...(judgment ? { judgmentEventId: judgment.id } : {}),
+          replayed: true,
+        };
+      }
+      if (decisions.length > 0) throw new WorkbenchConflictError("Proposal already has a human decision");
+      const head = await this.requireHeadRow(documentId);
+      const occurredAt = new Date().toISOString();
+      if (payload.disposition === "accept") {
+        if (head.versionId !== proposalPayload.target.baseVersionId) throw new StaleBaseError(head.versionId);
+        // Write order for crash safety: version row, version event, decision event, head upsert, judgment.
+        await this.appendVersionRow(documentId, resultVersionId, resultContent, resultSha256, occurredAt);
+        await this.store.appendEvent(this.candidate({
+          type: DOCUMENT_VERSION_EVENT_TYPE,
+          idempotencyKey: versionEventKey(documentId, "proposal-accepted", input.submissionId),
+          rootEventId: proposal.rootEventId,
+          parentEventId: proposal.id,
+          correlationId: documentId,
+          occurredAt,
+          payload: versionPayload({
+            documentId,
+            versionId: resultVersionId,
+            baseVersionId: proposalPayload.target.baseVersionId,
+            sha256: resultSha256,
+            sizeBytes: Buffer.byteLength(resultContent),
+            reason: "proposal-accepted",
+            proposalEventId: proposal.id,
+            decisionEventId,
+            requestId: input.submissionId,
+          }),
+        }));
+      }
+      const decision = await this.store.appendEvent(this.candidate({
+        type: PROPOSAL_DECISION_EVENT_TYPE,
+        idempotencyKey: decisionEventKey(proposal.id),
+        rootEventId: proposal.rootEventId,
+        parentEventId: proposal.id,
+        correlationId: documentId,
+        occurredAt,
+        payload: payload as unknown as JsonObject,
+      }));
+      if (decision.event.id !== decisionEventId) throw new Error("Decision event identity diverged from its deterministic id");
+      if (payload.disposition === "accept") {
+        await this.upsertHead(documentId, resultVersionId, resultSha256, Buffer.byteLength(resultContent), occurredAt);
+      }
+      const judgment = await this.recordDecisionJudgment(proposalPayload, decision.event, payload.disposition);
+      return {
+        decisionEventId: decision.event.id,
+        disposition: payload.disposition,
+        ...(payload.resultVersionId ? { resultVersionId: payload.resultVersionId } : {}),
+        ...(judgment ? { judgmentEventId: judgment.id } : {}),
+        replayed: false,
+      };
+    });
+  }
+
+  async listDocuments(): Promise<WorkbenchDocumentListItem[]> {
+    const heads = (await this.store.listCurrentDocuments(WORKBENCH_DOCUMENT_SOURCE)).filter((row) => !row.deleted);
+    if (heads.length === 0) return [];
+    const events = await this.workbenchEvents();
+    const items: WorkbenchDocumentListItem[] = [];
+    for (const row of heads) {
+      const documentId = row.documentId;
+      const created = events.find((event) => event.type === DOCUMENT_CREATED_EVENT_TYPE && event.payload.documentId === documentId);
+      if (!created) continue;
+      const version = await this.store.getDocumentVersion(row.versionId);
+      const title = version ? decodeDocumentContent(version.content).title : String(created.payload.title);
+      const proposals = events.filter((event) => event.type === PROPOSAL_PROPOSED_EVENT_TYPE && proposalDocumentId(event) === documentId);
+      const decided = new Set(events
+        .filter((event) => event.type === PROPOSAL_DECISION_EVENT_TYPE)
+        .map((event) => String(event.payload.proposalEventId)));
+      items.push({
+        documentId,
+        title,
+        originEventId: String(created.payload.originEventId),
+        headVersionId: row.versionId,
+        sha256: row.sha256,
+        updatedAt: row.updatedAt,
+        versionCount: events.filter((event) => event.type === DOCUMENT_VERSION_EVENT_TYPE && event.payload.documentId === documentId).length,
+        proposalCount: proposals.length,
+        pendingProposalCount: proposals.filter((event) => !decided.has(event.id)).length,
+      });
+    }
+    return items.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) || left.documentId.localeCompare(right.documentId));
+  }
+
+  async getDocument(documentId: string): Promise<WorkbenchDocumentDetail | undefined> {
+    const row = await this.getHeadRow(documentId);
+    if (!row || row.deleted) return undefined;
+    const events = (await this.workbenchEvents()).filter((event) => eventDocumentId(event) === documentId);
+    const created = events.find((event) => event.type === DOCUMENT_CREATED_EVENT_TYPE);
+    if (!created) return undefined;
+    const head = this.headFromRow(row);
+    const headVersion = await this.store.getDocumentVersion(row.versionId);
+    if (headVersion) {
+      const decoded = decodeDocumentContent(headVersion.content);
+      head.title = decoded.title;
+      head.body = decoded.body;
+    }
+    const origin = await this.store.getEvent(String(created.payload.originEventId));
+    const versions = events
+      .filter((event) => event.type === DOCUMENT_VERSION_EVENT_TYPE)
+      .map((event) => {
+        const payload = documentVersionPayloadSchema.parse(event.payload);
+        return {
+          eventId: event.id,
+          versionId: payload.versionId,
+          baseVersionId: payload.baseVersionId,
+          sha256: payload.sha256,
+          sizeBytes: payload.sizeBytes,
+          reason: payload.reason,
+          ...(payload.proposalEventId ? { proposalEventId: payload.proposalEventId } : {}),
+          ...(payload.decisionEventId ? { decisionEventId: payload.decisionEventId } : {}),
+          createdAt: event.observedAt,
+        } satisfies WorkbenchVersionSummary;
+      });
+    const selections: WorkbenchSelectionSummary[] = [];
+    for (const event of events.filter((candidate) => candidate.type === CONTEXT_SELECTED_EVENT_TYPE)) {
+      selections.push(await this.selectionSummary(event));
+    }
+    const decisions = events.filter((event) => event.type === PROPOSAL_DECISION_EVENT_TYPE);
+    const proposals: WorkbenchProposalSummary[] = [];
+    for (const event of events.filter((candidate) => candidate.type === PROPOSAL_PROPOSED_EVENT_TYPE)) {
+      const payload = proposalProposedPayloadSchema.parse(event.payload);
+      const requested = events.find((candidate) => candidate.id === event.parentEventId && candidate.type === PROPOSAL_REQUESTED_EVENT_TYPE);
+      const requestedPayload = requested ? proposalRequestedPayloadSchema.parse(requested.payload) : undefined;
+      const decision = decisions.find((candidate) => candidate.payload.proposalEventId === event.id);
+      const decisionPayload = decision ? proposalDecisionPayloadSchema.parse(decision.payload) : undefined;
+      const judgment = decision
+        ? (await this.store.listChildEvents(decision.id)).find((candidate) => candidate.type === JUDGMENT_EVENT_TYPE)
+        : undefined;
+      const run = payload.proposer.runId ? await this.store.getRun(payload.proposer.runId) : undefined;
+      const base = await this.store.getDocumentVersion(payload.target.baseVersionId);
+      const baseBody = base ? decodeDocumentContent(base.content).body : "";
+      const stale = row.versionId !== payload.target.baseVersionId;
+      const status: WorkbenchProposalSummary["status"] = decisionPayload
+        ? decisionPayload.disposition === "accept" ? "accepted" : "rejected"
+        : stale ? "stale" : "pending";
+      const inference = run?.contextManifest.inference === "none" || run?.contextManifest.inference === "model"
+        ? run.contextManifest.inference
+        : "unknown";
+      proposals.push({
+        eventId: event.id,
+        requestedEventId: requested?.id ?? "",
+        selectionId: requestedPayload?.selectionId ?? "",
+        snapshotVersionId: payload.proposer.contextSnapshotId,
+        runId: payload.proposer.runId,
+        runStatus: run?.status,
+        runnerId: payload.proposer.runnerId,
+        runnerRevision: payload.proposer.runnerRevision,
+        inference,
+        reason: payload.reason,
+        evidenceEventIds: payload.evidenceEventIds,
+        baseVersionId: payload.target.baseVersionId,
+        baseSha256: payload.target.baseSha256,
+        proposedText: payload.proposedText,
+        proposedTextSha256: payload.proposedTextSha256,
+        proposedTextChars: payload.proposedTextChars,
+        diff: boundedUnifiedDiff(documentId, payload.target.baseVersionId, event.id, baseBody, payload.proposedText),
+        createdAt: event.observedAt,
+        stale,
+        headVersionId: row.versionId,
+        status,
+        ...(decision && decisionPayload ? {
+          decision: {
+            eventId: decision.id,
+            disposition: decisionPayload.disposition,
+            submissionId: decisionPayload.submissionId,
+            ...(decisionPayload.resultVersionId ? { resultVersionId: decisionPayload.resultVersionId } : {}),
+            ...(judgment ? { judgmentEventId: judgment.id } : {}),
+            createdAt: decision.observedAt,
+          },
+        } : {}),
+      });
+    }
+    return {
+      head,
+      origin: origin ? {
+        eventId: origin.id,
+        type: origin.type,
+        source: origin.source,
+        occurredAt: origin.occurredAt,
+        excerpt: plainExcerpt(origin.payload, 240),
+      } : undefined,
+      createdEventId: created.id,
+      versions,
+      selections,
+      proposals,
+      runners: this.listRunners(),
+    };
+  }
+
+  /** Bounded selectable context: recent root observations plus this document's own versions. */
+  async listCandidates(documentId: string): Promise<WorkbenchCandidates | undefined> {
+    const row = await this.getHeadRow(documentId);
+    if (!row || row.deleted) return undefined;
+    const events = (await this.workbenchEvents()).filter((event) => eventDocumentId(event) === documentId);
+    const created = events.find((event) => event.type === DOCUMENT_CREATED_EVENT_TYPE);
+    if (!created) return undefined;
+    const originEventId = String(created.payload.originEventId);
+    const observations = await buildRecentRootObservations(this.store, MAX_CANDIDATE_EVENTS);
+    const candidates: WorkbenchCandidates["events"] = observations.items.map((item) => ({
+      eventId: item.id,
+      type: item.type,
+      source: item.source,
+      occurredAt: item.occurredAt,
+      title: item.presentation?.title ?? item.summary,
+      excerpt: (item.presentation?.body || item.presentation?.objectLabel || item.summary).slice(0, 200),
+      origin: item.id === originEventId,
+    }));
+    if (!candidates.some((candidate) => candidate.origin)) {
+      const origin = await this.store.getEvent(originEventId);
+      if (origin) {
+        candidates.unshift({
+          eventId: origin.id,
+          type: origin.type,
+          source: origin.source,
+          occurredAt: origin.occurredAt,
+          title: origin.type.split(".").at(-1) ?? origin.type,
+          excerpt: plainExcerpt(origin.payload, 200),
+          origin: true,
+        });
+      }
+    }
+    const versions = events
+      .filter((event) => event.type === DOCUMENT_VERSION_EVENT_TYPE)
+      .map((event) => {
+        const payload = documentVersionPayloadSchema.parse(event.payload);
+        return {
+          versionId: payload.versionId,
+          sha256: payload.sha256,
+          reason: payload.reason,
+          createdAt: event.observedAt,
+          head: payload.versionId === row.versionId,
+        };
+      });
+    return { documentId, events: candidates, versions, bounded: observations.rootWindowComplete === false || observations.items.length >= MAX_CANDIDATE_EVENTS };
+  }
+
+  private async recordDecisionJudgment(
+    proposal: ProposalProposedPayload,
+    decision: ThoughtEvent,
+    disposition: "accept" | "reject",
+  ): Promise<ThoughtEvent | undefined> {
+    if (!proposal.proposer.runId) return undefined;
+    return recordJudgment(this.store, {
+      runId: proposal.proposer.runId,
+      kind: disposition,
+      criterion: WORKBENCH_JUDGMENT_CRITERION,
+      criterionVersion: WORKBENCH_JUDGMENT_CRITERION_VERSION,
+      qualityEligible: false,
+      externalExportEligible: false,
+      notes: disposition === "accept"
+        ? "Operator accepted a workbench document proposal"
+        : "Operator rejected a workbench document proposal",
+      actor: this.actor,
+      source: "judgment:workbench-documents",
+      feedbackSourceEventId: decision.id,
+    });
+  }
+
+  private async selectionSummary(event: ThoughtEvent): Promise<WorkbenchSelectionSummary> {
+    const payload = contextSelectedPayloadSchema.parse(event.payload) as ContextSelectedPayload;
+    const snapshotVersion = await this.store.getDocumentVersion(payload.snapshotVersionId);
+    const snapshot = snapshotVersion
+      ? workbenchContextSnapshotSchema.parse(parseJsonObject(snapshotVersion.content)) as WorkbenchContextSnapshot
+      : undefined;
+    return {
+      eventId: event.id,
+      selectionId: payload.selectionId,
+      snapshotVersionId: payload.snapshotVersionId,
+      snapshotSha256: snapshotVersion?.sha256 ?? "",
+      baseVersionId: snapshot?.baseVersionId ?? "",
+      createdAt: event.observedAt,
+      selectedEvents: snapshot?.selectedEvents ?? [],
+      selectedVersions: snapshot?.selectedVersions ?? [],
+    };
+  }
+
+  private async workbenchEvents(): Promise<ThoughtEvent[]> {
+    return this.store.listEvents({ source: WORKBENCH_DOCUMENT_SOURCE });
+  }
+
+  private async requireLineage(documentId: string): Promise<{ created: ThoughtEvent }> {
+    const created = await this.store.getEvent(eventIdFor(WORKBENCH_DOCUMENT_SOURCE, createdEventKey(documentId)));
+    if (!created || created.type !== DOCUMENT_CREATED_EVENT_TYPE) throw new WorkbenchNotFoundError("Working document was not found");
+    return { created };
+  }
+
+  private async getHeadRow(documentId: string): Promise<CurrentDocument | undefined> {
+    const id = headRowId(documentId);
+    return (await this.store.listCurrentDocuments(WORKBENCH_DOCUMENT_SOURCE)).find((row) => row.id === id);
+  }
+
+  private async requireHeadRow(documentId: string): Promise<CurrentDocument> {
+    const row = await this.getHeadRow(documentId);
+    if (!row || row.deleted) throw new WorkbenchNotFoundError("Working document was not found");
+    return row;
+  }
+
+  private async requireVersion(versionId: string): Promise<DocumentVersion> {
+    const version = await this.store.getDocumentVersion(versionId);
+    if (!version) throw new WorkbenchNotFoundError(`Document version was not found: ${versionId}`);
+    return version;
+  }
+
+  private headFromRow(row: CurrentDocument): WorkingDocumentHead {
+    return {
+      documentId: row.documentId,
+      title: "",
+      body: "",
+      versionId: row.versionId,
+      sha256: row.sha256,
+      sizeBytes: row.sizeBytes,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  private async appendVersionRow(documentId: string, versionId: string, content: string, contentSha256: string, createdAt: string): Promise<void> {
+    await this.store.appendDocumentVersion({
+      id: versionId,
+      source: WORKBENCH_DOCUMENT_SOURCE,
+      documentId,
+      path: `documents/${encodeURIComponent(documentId)}.md`,
+      contentType: WORKBENCH_DOCUMENT_CONTENT_TYPE,
+      sha256: contentSha256,
+      content,
+      sizeBytes: Buffer.byteLength(content),
+      mtimeMs: Date.parse(createdAt),
+      createdAt,
+    });
+    const stored = await this.store.getDocumentVersion(versionId);
+    if (!stored || stored.sha256 !== contentSha256) throw new WorkbenchConflictError("Version identity collides with different content");
+  }
+
+  private async upsertHead(documentId: string, versionId: string, contentSha256: string, sizeBytes: number, updatedAt: string): Promise<CurrentDocument> {
+    const row: CurrentDocument = {
+      id: headRowId(documentId),
+      source: WORKBENCH_DOCUMENT_SOURCE,
+      documentId,
+      path: `documents/${encodeURIComponent(documentId)}.md`,
+      versionId,
+      sha256: contentSha256,
+      contentType: WORKBENCH_DOCUMENT_CONTENT_TYPE,
+      sizeBytes,
+      mtimeMs: Date.parse(updatedAt),
+      deleted: false,
+      updatedAt,
+    };
+    await this.store.upsertCurrentDocument(row);
+    return row;
+  }
+
+  /** Advance the head only when it still points at the version the event was based on. */
+  private async settleHead(documentId: string, payload: DocumentVersionPayload): Promise<CurrentDocument> {
+    const head = await this.requireHeadRow(documentId);
+    if (head.versionId === payload.baseVersionId && head.versionId !== payload.versionId) {
+      return this.upsertHead(documentId, payload.versionId, payload.sha256, payload.sizeBytes, new Date().toISOString());
+    }
+    return head;
+  }
+
+  private candidate(input: {
+    type: string;
+    idempotencyKey: string;
+    rootEventId: string;
+    parentEventId: string;
+    correlationId: string;
+    occurredAt: string;
+    payload: JsonObject;
+  }): EventCandidate {
+    return {
+      type: input.type,
+      schemaVersion: WORKBENCH_SCHEMA_VERSION,
+      source: WORKBENCH_DOCUMENT_SOURCE,
+      sourceKind: "system",
+      externalId: input.idempotencyKey,
+      idempotencyKey: input.idempotencyKey,
+      occurredAt: input.occurredAt,
+      actor: this.actor,
+      rootEventId: input.rootEventId,
+      parentEventId: input.parentEventId,
+      correlationId: input.correlationId,
+      privacy: "sensitive",
+      payload: input.payload,
+      createdByRuntime: WORKBENCH_RUNTIME,
+    };
+  }
+}
+
+function versionPayload(input: DocumentVersionPayload): JsonObject {
+  return documentVersionPayloadSchema.parse(input) as unknown as JsonObject;
+}
+
+function validateTitle(title: string): string {
+  const trimmed = title.replace(/[\r\n]+/g, " ").trim();
+  if (!trimmed) throw new WorkbenchConflictError("Title is required");
+  if (trimmed.length > MAX_DOCUMENT_TITLE_CHARS) throw new WorkbenchConflictError("Title is too long");
+  return trimmed;
+}
+
+function validateBody(body: string): string {
+  const normalized = body.replace(/\r\n?/g, "\n");
+  if (normalized.length > MAX_DOCUMENT_BODY_CHARS) throw new WorkbenchConflictError("Document body is too long");
+  return normalized;
+}
+
+function classifyRunnerFailure(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return `runner-failed: ${message.slice(0, 500)}`;
+}
+
+function proposalDocumentId(event: ThoughtEvent): string | undefined {
+  const target = event.payload.target;
+  return target && typeof target === "object" && !Array.isArray(target) && typeof target.documentId === "string"
+    ? target.documentId
+    : undefined;
+}
+
+function eventDocumentId(event: ThoughtEvent): string | undefined {
+  if (event.type === PROPOSAL_PROPOSED_EVENT_TYPE) return proposalDocumentId(event);
+  if (event.type === PROPOSAL_DECISION_EVENT_TYPE) return event.correlationId;
+  return typeof event.payload.documentId === "string" ? event.payload.documentId : undefined;
+}
+
+export function boundedUnifiedDiff(documentId: string, baseVersionId: string, proposalEventId: string, base: string, proposed: string): string {
+  const name = `documents/${encodeURIComponent(documentId)}.md`;
+  const patch = createTwoFilesPatch(name, name, base, proposed, `base ${baseVersionId}`, `proposal ${proposalEventId}`, { context: 3 });
+  if (patch.length <= MAX_DIFF_CHARS) return patch;
+  return `${patch.slice(0, MAX_DIFF_CHARS)}\n... diff truncated at ${MAX_DIFF_CHARS} characters ...\n`;
+}
diff --git a/test/authenticated-proxy.test.ts b/test/authenticated-proxy.test.ts
index e5886c1..45938a2 100644
--- a/test/authenticated-proxy.test.ts
+++ b/test/authenticated-proxy.test.ts
@@ -539,6 +539,107 @@ describe("authenticated inspector proxy", () => {
       .verify(forwarded.headers, "POST", forwarded.path!, forwarded.body)).toBe(true);
   });
 
+  test("guards every workbench write route like the Review decision route and keeps workbench reads readable", async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "thoughtstream-workbench-proxy-"));
+    roots.push(root);
+    const fixture = proxyOAuthFixture(root);
+    const reviewCapability = Buffer.alloc(32, 37);
+    const upstreamRequests: Array<{ method: string | undefined; path: string | undefined; headers: http.IncomingHttpHeaders; body: Buffer }> = [];
+    const upstream = http.createServer(async (request, response) => {
+      const parts: Buffer[] = [];
+      for await (const part of request) parts.push(Buffer.isBuffer(part) ? part : Buffer.from(part));
+      upstreamRequests.push({ method: request.method, path: request.url, headers: request.headers, body: Buffer.concat(parts) });
+      response.writeHead(request.method === "POST" ? 201 : 200, { "content-type": "application/json" });
+      response.end(request.method === "POST" ? '{"documentId":"fixture"}' : '{"items":[]}');
+    });
+    servers.push(upstream);
+    const upstreamPort = await listen(upstream);
+    const proxy = await startAuthenticatedInspectorProxy({
+      port: 0,
+      upstreamPort,
+      username: "cameron",
+      password: "correct-horse-battery-staple-private",
+      oauth: fixture.oauth,
+      basicFallbackEnabled: true,
+      reviewCapability,
+    });
+    servers.push(proxy);
+    const base = baseUrl(proxy);
+    const basicAuthorization = basic("cameron", "correct-horse-battery-staple-private");
+    const writeRoutes = [
+      "/inspector/api/workbench/documents",
+      "/inspector/api/workbench/documents/doc%3A1/versions",
+      "/inspector/api/workbench/documents/doc%3A1/selections",
+      "/inspector/api/workbench/documents/doc%3A1/proposals",
+      "/inspector/api/workbench/proposals/evt_1/decisions",
+    ];
+    const body = JSON.stringify({ originEventId: "evt_origin", title: "Notes", body: "# Notes", requestId: "req-proxy-00001" });
+
+    // Unauthenticated: rejected before any upstream contact, without disclosing the route.
+    for (const route of writeRoutes) {
+      const anonymous = await fetch(`${base}${route}`, { method: "POST", headers: { "content-type": "application/json" }, body });
+      expect(anonymous.status, route).toBe(401);
+    }
+    // Wrong owner class: Basic remains read-only on every workbench write.
+    for (const route of writeRoutes) {
+      const basicWrite = await fetch(`${base}${route}`, { method: "POST", headers: { authorization: basicAuthorization, "content-type": "application/json" }, body });
+      expect(basicWrite.status, route).toBe(403);
+    }
+    expect(upstreamRequests).toHaveLength(0);
+    // Basic still reads the workbench projections through the ordinary GET path.
+    const basicRead = await fetch(`${base}/inspector/api/workbench/documents`, { headers: { authorization: basicAuthorization } });
+    expect(basicRead.status).toBe(200);
+    expect(upstreamRequests).toHaveLength(1);
+    expect(upstreamRequests[0]).toMatchObject({ method: "GET", path: "/api/workbench/documents" });
+    upstreamRequests.length = 0;
+
+    const login = await fetch(`${base}/oauth/login`, { method: "POST", redirect: "manual" });
+    const applicationState = cookieFromHeader(login.headers.get("set-cookie")!, "__Host-thoughtstream_oauth");
+    const callback = await fetch(`${base}/oauth/callback?state=sdk-protocol-state-1234567890abcdef&code=fixture`, {
+      headers: { cookie: `__Host-thoughtstream_oauth=${applicationState}` },
+      redirect: "manual",
+    });
+    const sessionId = cookieFromHeader(callback.headers.get("set-cookie")!, "__Host-thoughtstream_session");
+    const cookie = `__Host-thoughtstream_session=${sessionId}`;
+    const session = await fetch(`${base}/inspector/api/session`, { headers: { cookie } });
+    const sessionBody = await session.json() as { reviewWriteEnabled: boolean; csrfToken: string };
+    expect(sessionBody.reviewWriteEnabled).toBe(true);
+
+    // Cross-origin shape: an owner cookie without the session CSRF header never reaches the inspector.
+    for (const route of writeRoutes) {
+      const missingCsrf = await fetch(`${base}${route}`, { method: "POST", headers: { cookie, "content-type": "application/json" }, body });
+      expect(missingCsrf.status, route).toBe(403);
+      const wrongCsrf = await fetch(`${base}${route}`, { method: "POST", headers: { cookie, "content-type": "application/json", [REVIEW_CSRF_HEADER]: "not-the-token" }, body });
+      expect(wrongCsrf.status, route).toBe(403);
+    }
+    expect(upstreamRequests).toHaveLength(0);
+    // Query strings, oversized bodies, and non-JSON bodies are rejected locally.
+    const withQuery = await fetch(`${base}/inspector/api/workbench/documents?x=1`, { method: "POST", headers: { cookie, "content-type": "application/json", [REVIEW_CSRF_HEADER]: sessionBody.csrfToken }, body });
+    expect(withQuery.status).toBe(405);
+    const oversized = await fetch(`${base}/inspector/api/workbench/documents`, { method: "POST", headers: { cookie, "content-type": "application/json", [REVIEW_CSRF_HEADER]: sessionBody.csrfToken }, body: JSON.stringify({ body: "x".repeat(100_000) }) });
+    expect(oversized.status).toBe(400);
+    const notJson = await fetch(`${base}/inspector/api/workbench/documents`, { method: "POST", headers: { cookie, "content-type": "text/plain", [REVIEW_CSRF_HEADER]: sessionBody.csrfToken }, body });
+    expect(notJson.status).toBe(400);
+    expect(upstreamRequests).toHaveLength(0);
+
+    // A CSRF-checked owner write is forwarded once with a fresh body-bound signature and no browser credentials.
+    for (const route of writeRoutes) {
+      const written = await fetch(`${base}${route}`, { method: "POST", headers: { cookie, "content-type": "application/json", [REVIEW_CSRF_HEADER]: sessionBody.csrfToken }, body });
+      expect(written.status, route).toBe(201);
+    }
+    expect(upstreamRequests).toHaveLength(writeRoutes.length);
+    const verifier = new ReviewCapabilityVerifier(reviewCapability);
+    for (const [index, forwarded] of upstreamRequests.entries()) {
+      expect(forwarded.method).toBe("POST");
+      expect(forwarded.path).toBe(writeRoutes[index]!.slice("/inspector".length));
+      expect(forwarded.body.toString("utf8")).toBe(body);
+      expect(forwarded.headers.authorization).toBeUndefined();
+      expect(forwarded.headers.cookie).toBeUndefined();
+      expect(forwarded.headers[REVIEW_CSRF_HEADER]).toBeUndefined();
+      expect(verifier.verify(forwarded.headers, "POST", forwarded.path!, forwarded.body)).toBe(true);
+    }
+  });
+
   test("carries an OAuth course question through the signed proxy into one canonical event", async () => {
     const root = await fs.mkdtemp(path.join(os.tmpdir(), "thoughtstream-course-chat-chain-"));
     roots.push(root);
diff --git a/test/inspector.test.ts b/test/inspector.test.ts
index eac461a..328929f 100644
--- a/test/inspector.test.ts
+++ b/test/inspector.test.ts
@@ -125,7 +125,7 @@ describe("thought stream inspector", () => {
     expect(pageHtml).not.toContain("grid-template-columns:repeat(6,minmax(0,1fr))");
     expect(pageHtml).toContain("const primaryResource=tabResource();");
     expect(pageHtml).toContain("await loadResource(primaryResource)");
-    expect(pageHtml).toContain("for(const key of ['activity','course','artifacts','proposals','reviews','system'])");
+    expect(pageHtml).toContain("for(const key of ['activity','course','artifacts','documents','proposals','reviews','system'])");
     expect(pageHtml).toContain("tabResource()===key||(key==='system'&&state.tab==='events')");
     expect(pageHtml).toContain("activity:{path:'api/activity',label:'recent activity'}");
     expect(pageHtml).toContain("system:{path:'api/system',label:'system evidence'}");
@@ -172,7 +172,9 @@ describe("thought stream inspector", () => {
     expect(pageHtml).toContain("main.detail-selected #list-pane");
     expect(pageHtml).toContain("body.detail-selected .primary-nav,body.detail-selected .context-nav { display:none }");
     expect(pageHtml).toContain("document.body.classList.add('detail-selected')");
-    expect(pageHtml).toContain("const routeLists={events:'feed',learn:'learn/post-training',suggestions:'review/suggestions',reviews:'review/comparisons',artifacts:'artifacts',runs:'system/runs',sources:'system/sources'}");
+    expect(pageHtml).toContain("const routeLists={events:'feed',learn:'learn/post-training',suggestions:'review/suggestions',reviews:'review/comparisons',artifacts:'artifacts',documents:'documents',runs:'system/runs',sources:'system/sources'}");
+    expect(pageHtml).toContain('<button id="documents-tab">Documents</button>');
+    expect(pageHtml).toContain("document:{tab:'documents',path:'documents'}");
     expect(pageHtml).toContain("event:{tab:'events',path:'feed/observations'}");
     expect(pageHtml).toContain('id="course-chat-toggle"');
     expect(pageHtml).toContain("Ask about this lesson");
diff --git a/test/workbench-inspector.test.ts b/test/workbench-inspector.test.ts
new file mode 100644
index 0000000..1b5d984
--- /dev/null
+++ b/test/workbench-inspector.test.ts
@@ -0,0 +1,201 @@
+import fs from "node:fs/promises";
+import { afterEach, describe, expect, test } from "vitest";
+import type { JazzThoughtStore } from "../src/jazz/store.js";
+import type { ThoughtEvent } from "../src/events/types.js";
+import {
+  REVIEW_NONCE_HEADER,
+  REVIEW_SIGNATURE_HEADER,
+  REVIEW_TIMESTAMP_HEADER,
+  signReviewRequest,
+} from "../src/review/web-capability.js";
+import { startInspectorServer } from "../src/web/inspector.js";
+import { PROPOSAL_PROPOSED_EVENT_TYPE, WORKBENCH_DOCUMENT_SOURCE } from "../src/workbench/contracts.js";
+import { FIXTURE_RUNNER_ID } from "../src/workbench/runners.js";
+import { temporaryProject, testStore } from "./helpers.js";
+
+const stores: JazzThoughtStore[] = [];
+const roots: string[] = [];
+const servers: import("node:http").Server[] = [];
+
+afterEach(async () => {
+  await Promise.all(servers.splice(0).map((server) => new Promise<void>((resolve) => {
+    server.closeAllConnections();
+    server.close(() => resolve());
+  })));
+  await Promise.all(stores.splice(0).map((store) => store.close()));
+  await Promise.all(roots.splice(0).map((root) => fs.rm(root, { recursive: true, force: true })));
+});
+
+async function fixture(options: { reviewCapability?: Buffer } = {}): Promise<{ store: JazzThoughtStore; base: string; origin: ThoughtEvent }> {
+  const root = await temporaryProject("thoughtstream-workbench-inspector-");
+  roots.push(root);
+  const store = await testStore(root);
+  stores.push(store);
+  const origin = (await store.appendEvent({
+    type: "stream.thought.source.rss.item",
+    schemaVersion: 1,
+    source: "rss:fixture",
+    sourceKind: "rss",
+    externalId: "item-1",
+    idempotencyKey: "rss:item-1",
+    occurredAt: "2026-07-14T00:00:00.000Z",
+    actor: "rss:fixture",
+    correlationId: "poll-1",
+    privacy: "public-source",
+    payload: { title: "Fixture item", summary: "Synthetic <script>alert(1)</script> summary" },
+  })).event;
+  const server = await startInspectorServer(store, {
+    port: 0,
+    proposalActor: "operator:test",
+    ...(options.reviewCapability ? { reviewCapability: options.reviewCapability } : {}),
+  });
+  servers.push(server);
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("Missing inspector address");
+  return { store, base: `http://127.0.0.1:${address.port}`, origin };
+}
+
+function signedHeaders(key: Buffer, pathName: string, body: Buffer): Record<string, string> {
+  const signed = signReviewRequest(key, { method: "POST", path: pathName, body });
+  return {
+    "content-type": "application/json",
+    [REVIEW_TIMESTAMP_HEADER]: signed.timestamp,
+    [REVIEW_NONCE_HEADER]: signed.nonce,
+    [REVIEW_SIGNATURE_HEADER]: signed.signature,
+  };
+}
+
+async function signedPost(base: string, key: Buffer, pathName: string, payload: unknown): Promise<{ status: number; body: Record<string, unknown> }> {
+  const body = Buffer.from(JSON.stringify(payload), "utf8");
+  const response = await fetch(`${base}${pathName}`, { method: "POST", headers: signedHeaders(key, pathName, body), body });
+  return { status: response.status, body: (await response.json()) as Record<string, unknown> };
+}
+
+describe("workbench inspector routes", () => {
+  test("returns 405 for every workbench write when no Review verifier is configured", async () => {
+    const { base, origin } = await fixture();
+    for (const pathName of [
+      "/api/workbench/documents",
+      "/api/workbench/documents/doc/versions",
+      "/api/workbench/documents/doc/selections",
+      "/api/workbench/documents/doc/proposals",
+      "/api/workbench/proposals/evt/decisions",
+    ]) {
+      const response = await fetch(`${base}${pathName}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ originEventId: origin.id, title: "x", body: "y", requestId: "req-00000001" }),
+      });
+      expect(response.status, pathName).toBe(405);
+    }
+    const unknown = await fetch(`${base}/api/workbench/unknown`, { method: "POST", body: "{}" });
+    expect(unknown.status).toBe(404);
+    const list = await fetch(`${base}/api/workbench/documents`);
+    expect(list.status).toBe(200);
+    expect(await list.json()).toMatchObject({ items: [], runners: [{ id: FIXTURE_RUNNER_ID, inference: "none" }] });
+    const missing = await fetch(`${base}/api/workbench/documents/missing`);
+    expect(missing.status).toBe(404);
+    const candidates = await fetch(`${base}/api/workbench/candidates?documentId=missing`);
+    expect(candidates.status).toBe(404);
+    const badCandidates = await fetch(`${base}/api/workbench/candidates`);
+    expect(badCandidates.status).toBe(400);
+  });
+
+  test("rejects unsigned writes and applies signed writes through the trusted workflow", async () => {
+    const key = Buffer.alloc(32, 31);
+    const { store, base, origin } = await fixture({ reviewCapability: key });
+    const createBody = Buffer.from(JSON.stringify({ originEventId: origin.id, title: "Notes", body: "# Notes\n", requestId: "req-create-0001" }), "utf8");
+    const unsigned = await fetch(`${base}/api/workbench/documents`, { method: "POST", headers: { "content-type": "application/json" }, body: createBody });
+    expect(unsigned.status).toBe(403);
+    expect(await store.listCurrentDocuments(WORKBENCH_DOCUMENT_SOURCE)).toEqual([]);
+    const wrongPath = await fetch(`${base}/api/workbench/documents`, {
+      method: "POST",
+      headers: signedHeaders(key, "/api/workbench/documents/other/versions", createBody),
+      body: createBody,
+    });
+    expect(wrongPath.status).toBe(403);
+    const malformed = await signedPost(base, key, "/api/workbench/documents", { originEventId: origin.id, title: "", body: "x", requestId: "short" });
+    expect(malformed.status).toBe(400);
+    const missingOrigin = await signedPost(base, key, "/api/workbench/documents", { originEventId: "evt_missing", title: "x", body: "y", requestId: "req-create-0009" });
+    expect(missingOrigin.status).toBe(404);
+
+    const created = await signedPost(base, key, "/api/workbench/documents", { originEventId: origin.id, title: "Notes", body: "# Notes\n", requestId: "req-create-0001" });
+    expect(created.status).toBe(201);
+    const documentId = String(created.body.documentId);
+    const headVersionId = String(created.body.versionId);
+    const documentPath = `/api/workbench/documents/${encodeURIComponent(documentId)}`;
+
+    const list = (await (await fetch(`${base}/api/workbench/documents`)).json()) as { items: Array<Record<string, unknown>> };
+    expect(list.items).toHaveLength(1);
+    expect(list.items[0]).toMatchObject({ documentId, title: "Notes", originEventId: origin.id, headVersionId });
+
+    const candidates = (await (await fetch(`${base}/api/workbench/candidates?documentId=${encodeURIComponent(documentId)}`)).json()) as Record<string, unknown>;
+    expect((candidates.events as Array<Record<string, unknown>>).some((event) => event.eventId === origin.id && event.origin === true)).toBe(true);
+    expect(candidates.versions).toEqual([expect.objectContaining({ versionId: headVersionId, head: true })]);
+
+    const selection = await signedPost(base, key, `${documentPath}/selections`, { eventIds: [origin.id], versionIds: [headVersionId], requestId: "req-select-0001" });
+    expect(selection.status).toBe(201);
+    const selectionId = String(selection.body.selectionId);
+
+    const proposal = await signedPost(base, key, `${documentPath}/proposals`, { selectionId, runnerId: FIXTURE_RUNNER_ID, requestId: "req-prop-00001" });
+    expect(proposal.status).toBe(201);
+    const proposalEventId = String(proposal.body.proposalEventId);
+    const unknownRunner = await signedPost(base, key, `${documentPath}/proposals`, { selectionId, runnerId: "missing", requestId: "req-prop-00002" });
+    expect(unknownRunner.status).toBe(404);
+
+    const detail = (await (await fetch(`${base}${documentPath}`)).json()) as Record<string, any>;
+    expect(detail.head).toMatchObject({ documentId, title: "Notes", body: "# Notes\n", versionId: headVersionId });
+    expect(detail.origin).toMatchObject({ eventId: origin.id });
+    expect(detail.selections).toHaveLength(1);
+    expect(detail.selections[0].selectedEvents[0]).toMatchObject({ eventId: origin.id, payloadHash: origin.payloadHash });
+    expect(detail.selections[0].selectedEvents[0].excerpt).toContain("<script>alert(1)</script>");
+    expect(detail.proposals).toHaveLength(1);
+    expect(detail.proposals[0]).toMatchObject({ eventId: proposalEventId, status: "pending", stale: false, inference: "none" });
+    expect(detail.proposals[0].diff).toContain("+## Sources");
+
+    const edit = await signedPost(base, key, `${documentPath}/versions`, { baseVersionId: headVersionId, title: "Notes", body: "# Notes\n\nOperator edit.\n", requestId: "req-edit-00001" });
+    expect(edit.status).toBe(201);
+    const editedVersionId = String(edit.body.versionId);
+    const staleEdit = await signedPost(base, key, `${documentPath}/versions`, { baseVersionId: headVersionId, title: "Notes", body: "# Other\n", requestId: "req-edit-00002" });
+    expect(staleEdit.status).toBe(409);
+    expect(staleEdit.body).toMatchObject({ stale: true, headVersionId: editedVersionId });
+
+    const staleAccept = await signedPost(base, key, `/api/workbench/proposals/${encodeURIComponent(proposalEventId)}/decisions`, { disposition: "accept", submissionId: "sub-accept-0001" });
+    expect(staleAccept.status).toBe(409);
+    expect(staleAccept.body).toMatchObject({ stale: true, headVersionId: editedVersionId });
+    const afterStale = (await (await fetch(`${base}${documentPath}`)).json()) as Record<string, any>;
+    expect(afterStale.head.versionId).toBe(editedVersionId);
+    expect(afterStale.head.body).toBe("# Notes\n\nOperator edit.\n");
+    expect(afterStale.proposals[0]).toMatchObject({ status: "stale", stale: true });
+
+    const rejected = await signedPost(base, key, `/api/workbench/proposals/${encodeURIComponent(proposalEventId)}/decisions`, { disposition: "reject", submissionId: "sub-reject-0001" });
+    expect(rejected.status).toBe(201);
+    expect(rejected.body).toMatchObject({ disposition: "reject", replayed: false });
+    const replay = await signedPost(base, key, `/api/workbench/proposals/${encodeURIComponent(proposalEventId)}/decisions`, { disposition: "reject", submissionId: "sub-reject-0001" });
+    expect(replay.status).toBe(201);
+    expect(replay.body).toMatchObject({ decisionEventId: rejected.body.decisionEventId, replayed: true });
+    const conflict = await signedPost(base, key, `/api/workbench/proposals/${encodeURIComponent(proposalEventId)}/decisions`, { disposition: "accept", submissionId: "sub-accept-0002" });
+    expect(conflict.status).toBe(409);
+
+    const selection2 = await signedPost(base, key, `${documentPath}/selections`, { eventIds: [origin.id], versionIds: [], requestId: "req-select-0002" });
+    const proposal2 = await signedPost(base, key, `${documentPath}/proposals`, { selectionId: String(selection2.body.selectionId), runnerId: FIXTURE_RUNNER_ID, requestId: "req-prop-00003" });
+    expect(proposal2.status).toBe(201);
+    const accepted = await signedPost(base, key, `/api/workbench/proposals/${encodeURIComponent(String(proposal2.body.proposalEventId))}/decisions`, { disposition: "accept", submissionId: "sub-accept-0003" });
+    expect(accepted.status).toBe(201);
+    expect(accepted.body).toMatchObject({ disposition: "accept", replayed: false });
+    expect(accepted.body.judgmentEventId).toBeDefined();
+    const final = (await (await fetch(`${base}${documentPath}`)).json()) as Record<string, any>;
+    expect(final.head.versionId).toBe(accepted.body.resultVersionId);
+    expect(final.head.body).toContain("## Sources");
+    expect(final.versions.map((version: { reason: string }) => version.reason)).toEqual(["created", "operator-edit", "proposal-accepted"]);
+    expect((await store.listEvents({ types: [PROPOSAL_PROPOSED_EVENT_TYPE] }))).toHaveLength(2);
+
+    // Signature replay is refused: the nonce was consumed.
+    const body = Buffer.from(JSON.stringify({ disposition: "accept", submissionId: "sub-accept-0003" }), "utf8");
+    const headers = signedHeaders(key, `/api/workbench/proposals/${encodeURIComponent(String(proposal2.body.proposalEventId))}/decisions`, body);
+    const first = await fetch(`${base}/api/workbench/proposals/${encodeURIComponent(String(proposal2.body.proposalEventId))}/decisions`, { method: "POST", headers, body });
+    expect(first.status).toBe(201);
+    const second = await fetch(`${base}/api/workbench/proposals/${encodeURIComponent(String(proposal2.body.proposalEventId))}/decisions`, { method: "POST", headers, body });
+    expect(second.status).toBe(403);
+  });
+});
diff --git a/test/workbench-workflow.test.ts b/test/workbench-workflow.test.ts
new file mode 100644
index 0000000..0f7b4fb
--- /dev/null
+++ b/test/workbench-workflow.test.ts
@@ -0,0 +1,358 @@
+import fs from "node:fs/promises";
+import { afterEach, describe, expect, test } from "vitest";
+import { sha256 } from "../src/core/json.js";
+import type { ThoughtEvent } from "../src/events/types.js";
+import {
+  CONTEXT_SELECTED_EVENT_TYPE,
+  DOCUMENT_CREATED_EVENT_TYPE,
+  DOCUMENT_VERSION_EVENT_TYPE,
+  PROPOSAL_DECISION_EVENT_TYPE,
+  PROPOSAL_PROPOSED_EVENT_TYPE,
+  PROPOSAL_REQUESTED_EVENT_TYPE,
+  WORKBENCH_CONTEXT_SOURCE,
+  WORKBENCH_DOCUMENT_SOURCE,
+  decodeDocumentContent,
+  encodeDocumentContent,
+  plainExcerpt,
+} from "../src/workbench/contracts.js";
+import { FIXTURE_RUNNER_ID, fixtureDeterministicRunner } from "../src/workbench/runners.js";
+import {
+  StaleBaseError,
+  WorkbenchConflictError,
+  WorkbenchRunnerError,
+  WorkbenchWorkflow,
+  workingDocumentId,
+} from "../src/workbench/workflow.js";
+import { JazzThoughtStore } from "../src/jazz/store.js";
+import { temporaryProject, testStore } from "./helpers.js";
+
+const stores: JazzThoughtStore[] = [];
+const roots: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(stores.splice(0).map((store) => store.close()));
+  await Promise.all(roots.splice(0).map((root) => fs.rm(root, { recursive: true, force: true })));
+});
+
+async function openStore(appId?: string): Promise<{ root: string; store: JazzThoughtStore }> {
+  const projectRoot = await temporaryProject("thoughtstream-workbench-");
+  roots.push(projectRoot);
+  const store = appId
+    ? await JazzThoughtStore.open({ projectRoot, appId, runtimeRevision: "test" })
+    : await testStore(projectRoot);
+  stores.push(store);
+  return { root: projectRoot, store };
+}
+
+async function seedOrigin(store: JazzThoughtStore, suffix = "1"): Promise<ThoughtEvent> {
+  return (await store.appendEvent({
+    type: "stream.thought.source.rss.item",
+    schemaVersion: 1,
+    source: "rss:fixture",
+    sourceKind: "rss",
+    externalId: `item-${suffix}`,
+    idempotencyKey: `rss:item-${suffix}`,
+    occurredAt: `2026-07-14T00:0${suffix}:00.000Z`,
+    actor: "rss:fixture",
+    correlationId: "poll-1",
+    privacy: "public-source",
+    payload: { title: `Fixture item ${suffix}`, summary: `Synthetic summary ${suffix} with <b>markup</b>` },
+  })).event;
+}
+
+async function eventsOfType(store: JazzThoughtStore, type: string): Promise<ThoughtEvent[]> {
+  return store.listEvents({ types: [type], source: WORKBENCH_DOCUMENT_SOURCE });
+}
+
+async function judgments(store: JazzThoughtStore): Promise<ThoughtEvent[]> {
+  return store.listEvents({ types: ["stream.thought.judgment.training-example"] });
+}
+
+describe("workbench document workflow", () => {
+  test("frontmatter encoding is self-describing and reversible", () => {
+    const content = encodeDocumentContent('A "quoted" title', "# Body\n\ntext");
+    expect(content.startsWith("---\ntitle: ")).toBe(true);
+    expect(decodeDocumentContent(content)).toEqual({ title: 'A "quoted" title', body: "# Body\n\ntext" });
+    expect(decodeDocumentContent("no frontmatter")).toEqual({ title: "Untitled", body: "no frontmatter" });
+    expect(plainExcerpt({ title: "T", text: "x".repeat(5_000) }).length).toBe(2_000);
+    expect(plainExcerpt({ nested: { deep: true } })).toBe('{"nested":{"deep":true}}');
+  });
+
+  test("creates a working document whose origin reference survives store reopen", async () => {
+    const { root, store } = await openStore();
+    const origin = await seedOrigin(store);
+    const workflow = new WorkbenchWorkflow(store, { actor: "operator:test" });
+    const head = await workflow.createWorkingDocument({
+      originEventId: origin.id,
+      title: "Notes on fixture item",
+      body: "# Notes\n\nFirst draft.\n",
+      requestId: "req-create-0001",
+    });
+    expect(head.documentId).toBe(workingDocumentId(origin.id, "req-create-0001"));
+    const replay = await workflow.createWorkingDocument({
+      originEventId: origin.id,
+      title: "Notes on fixture item",
+      body: "# Notes\n\nFirst draft.\n",
+      requestId: "req-create-0001",
+    });
+    expect(replay.versionId).toBe(head.versionId);
+    await expect(workflow.createWorkingDocument({
+      originEventId: origin.id,
+      title: "Different",
+      body: "content",
+      requestId: "req-create-0001",
+    })).rejects.toBeInstanceOf(WorkbenchConflictError);
+    await expect(workflow.createWorkingDocument({
+      originEventId: "evt_missing",
+      title: "x",
+      body: "y",
+      requestId: "req-create-0002",
+    })).rejects.toThrow("Origin event was not found");
+
+    const created = await eventsOfType(store, DOCUMENT_CREATED_EVENT_TYPE);
+    expect(created).toHaveLength(1);
+    expect(created[0]!.rootEventId).toBe(origin.rootEventId);
+    expect(created[0]!.parentEventId).toBe(origin.id);
+    expect(created[0]!.privacy).toBe("sensitive");
+    expect(await eventsOfType(store, DOCUMENT_VERSION_EVENT_TYPE)).toHaveLength(1);
+
+    await store.close();
+    stores.splice(stores.indexOf(store), 1);
+    const reopened = await testStore(root);
+    stores.push(reopened);
+    const detail = await new WorkbenchWorkflow(reopened).getDocument(head.documentId);
+    expect(detail?.origin?.eventId).toBe(origin.id);
+    expect(detail?.head.title).toBe("Notes on fixture item");
+    expect(detail?.head.body).toBe("# Notes\n\nFirst draft.\n");
+    expect(detail?.head.versionId).toBe(head.versionId);
+    const version = await reopened.getDocumentVersion(head.versionId);
+    expect(version?.source).toBe(WORKBENCH_DOCUMENT_SOURCE);
+    expect(version?.path).toBe(`documents/${encodeURIComponent(head.documentId)}.md`);
+    expect(version?.contentType).toBe("text/markdown");
+    const list = await new WorkbenchWorkflow(reopened).listDocuments();
+    expect(list).toHaveLength(1);
+    expect(list[0]).toMatchObject({ documentId: head.documentId, originEventId: origin.id, versionCount: 1, proposalCount: 0 });
+  });
+
+  test("operator edits require the exact head and are idempotent per request", async () => {
+    const { store } = await openStore();
+    const origin = await seedOrigin(store);
+    const workflow = new WorkbenchWorkflow(store);
+    const head = await workflow.createWorkingDocument({ originEventId: origin.id, title: "T", body: "one\n", requestId: "req-create-0001" });
+    const edited = await workflow.saveOperatorEdit({ documentId: head.documentId, baseVersionId: head.versionId, title: "T2", body: "two\n", requestId: "req-edit-00001" });
+    expect(edited.versionId).not.toBe(head.versionId);
+    const stale = workflow.saveOperatorEdit({ documentId: head.documentId, baseVersionId: head.versionId, title: "T3", body: "three\n", requestId: "req-edit-00002" });
+    await expect(stale).rejects.toBeInstanceOf(StaleBaseError);
+    await expect(stale).rejects.toMatchObject({ headVersionId: edited.versionId });
+    const replay = await workflow.saveOperatorEdit({ documentId: head.documentId, baseVersionId: head.versionId, title: "T2", body: "two\n", requestId: "req-edit-00001" });
+    expect(replay.versionId).toBe(edited.versionId);
+    const noop = await workflow.saveOperatorEdit({ documentId: head.documentId, baseVersionId: edited.versionId, title: "T2", body: "two\n", requestId: "req-edit-00003" });
+    expect(noop.versionId).toBe(edited.versionId);
+    expect(await eventsOfType(store, DOCUMENT_VERSION_EVENT_TYPE)).toHaveLength(2);
+    const detail = await workflow.getDocument(head.documentId);
+    expect(detail?.head.title).toBe("T2");
+    expect(detail?.versions.map((version) => version.reason)).toEqual(["created", "operator-edit"]);
+  });
+
+  test("selects exact context and stores a bounded plain-text snapshot", async () => {
+    const { store } = await openStore();
+    const origin = await seedOrigin(store, "1");
+    const other = await seedOrigin(store, "2");
+    const workflow = new WorkbenchWorkflow(store);
+    const head = await workflow.createWorkingDocument({ originEventId: origin.id, title: "T", body: "body\n", requestId: "req-create-0001" });
+    await expect(workflow.selectContext({ documentId: head.documentId, eventIds: ["evt_missing"], versionIds: [], requestId: "req-select-001" }))
+      .rejects.toThrow("Selected event was not found");
+    const selection = await workflow.selectContext({
+      documentId: head.documentId,
+      eventIds: [other.id, origin.id],
+      versionIds: [head.versionId],
+      requestId: "req-select-002",
+    });
+    expect(selection.baseVersionId).toBe(head.versionId);
+    expect(selection.selectedEvents.map((event) => event.eventId)).toEqual([other.id, origin.id]);
+    expect(selection.selectedEvents[0]).toMatchObject({ type: other.type, source: other.source, payloadHash: other.payloadHash });
+    expect(selection.selectedEvents[0]!.excerpt).toContain("Synthetic summary 2 with <b>markup</b>");
+    expect(selection.selectedVersions).toEqual([{ documentId: head.documentId, versionId: head.versionId, sha256: head.sha256, path: `documents/${encodeURIComponent(head.documentId)}.md` }]);
+    const snapshot = await store.getDocumentVersion(selection.snapshotVersionId);
+    expect(snapshot?.source).toBe(WORKBENCH_CONTEXT_SOURCE);
+    expect(snapshot?.contentType).toBe("application/json");
+    expect(snapshot?.sha256).toBe(sha256(snapshot!.content));
+    expect(JSON.parse(snapshot!.content)).toMatchObject({ documentId: head.documentId, baseVersionId: head.versionId });
+    const replay = await workflow.selectContext({ documentId: head.documentId, eventIds: [other.id, origin.id], versionIds: [head.versionId], requestId: "req-select-002" });
+    expect(replay.eventId).toBe(selection.eventId);
+    expect(await eventsOfType(store, CONTEXT_SELECTED_EVENT_TYPE)).toHaveLength(1);
+    const candidates = await workflow.listCandidates(head.documentId);
+    expect(candidates?.events.some((event) => event.eventId === origin.id && event.origin)).toBe(true);
+    expect(candidates?.events.some((event) => event.eventId === other.id)).toBe(true);
+    expect(candidates?.versions).toEqual([{ versionId: head.versionId, sha256: head.sha256, reason: "created", createdAt: expect.any(String), head: true }]);
+  });
+
+  test("deterministic fixture proposal, diff, accept once, duplicate submission, judgment lineage", async () => {
+    const appId = "thoughtstream-workbench-attach-test";
+    const { root, store } = await openStore(appId);
+    const origin = await seedOrigin(store);
+    const workflow = new WorkbenchWorkflow(store, { actor: "operator:test" });
+    const head = await workflow.createWorkingDocument({ originEventId: origin.id, title: "Doc", body: "# Doc\n\nIntro.\n", requestId: "req-create-0001" });
+    const selection = await workflow.selectContext({ documentId: head.documentId, eventIds: [origin.id], versionIds: [head.versionId], requestId: "req-select-001" });
+    await expect(workflow.requestProposal({ documentId: head.documentId, selectionId: selection.selectionId, runnerId: "missing", requestId: "req-prop-00001" }))
+      .rejects.toThrow("Unknown proposal runner");
+    const first = await workflow.requestProposal({ documentId: head.documentId, selectionId: selection.selectionId, runnerId: FIXTURE_RUNNER_ID, requestId: "req-prop-00001" });
+    const replay = await workflow.requestProposal({ documentId: head.documentId, selectionId: selection.selectionId, runnerId: FIXTURE_RUNNER_ID, requestId: "req-prop-00001" });
+    expect(replay.proposalEventId).toBe(first.proposalEventId);
+    expect(await eventsOfType(store, PROPOSAL_REQUESTED_EVENT_TYPE)).toHaveLength(1);
+    expect(await eventsOfType(store, PROPOSAL_PROPOSED_EVENT_TYPE)).toHaveLength(1);
+    const proposal = (await store.getEvent(first.proposalEventId))!;
+    expect(proposal.parentEventId).toBe(first.requestedEventId);
+    expect(proposal.privacy).toBe("sensitive");
+    expect(proposal.payload).toMatchObject({
+      proposalState: "runner-proposed",
+      operation: "replace-document",
+      publicationEligible: false,
+      reason: "fixture: append sources section",
+      evidenceEventIds: [origin.id],
+      target: { documentId: head.documentId, baseVersionId: head.versionId, baseSha256: head.sha256 },
+    });
+    const run = (await store.getRun(first.runId))!;
+    expect(run.status).toBe("completed");
+    expect(run.triggerEventId).toBe(first.requestedEventId);
+    expect(run.outputEventIds).toEqual([first.proposalEventId]);
+    expect(run.provider).toBe("fixture");
+    expect(run.contextManifest.contextSnapshot).toMatchObject({ id: selection.snapshotVersionId, storage: "jazz-document-version" });
+
+    const direct = await fixtureDeterministicRunner.propose({
+      documentId: head.documentId,
+      baseVersionId: head.versionId,
+      baseSha256: head.sha256,
+      title: "Doc",
+      baseText: "# Doc\n\nIntro.\n",
+      snapshot: { documentId: head.documentId, baseVersionId: head.versionId, selectedEvents: selection.selectedEvents, selectedVersions: selection.selectedVersions },
+      maxProposedChars: 64_000,
+    });
+    expect(direct.proposedText).toBe(proposal.payload.proposedText);
+    expect(direct.proposedText).toContain("## Sources");
+    expect(direct.proposedText).toContain("Summary: this document cites 2 selected sources.");
+
+    const detailBefore = (await workflow.getDocument(head.documentId))!;
+    expect(detailBefore.proposals).toHaveLength(1);
+    expect(detailBefore.proposals[0]).toMatchObject({ status: "pending", stale: false, headVersionId: head.versionId, inference: "none" });
+    expect(detailBefore.proposals[0]!.diff).toContain("+## Sources");
+    expect(detailBefore.proposals[0]!.diff).toContain(`base ${head.versionId}`);
+
+    const accepted = await workflow.decideProposal({ proposalEventId: first.proposalEventId, disposition: "accept", submissionId: "sub-accept-0001" });
+    expect(accepted.replayed).toBe(false);
+    expect(accepted.resultVersionId).toBeDefined();
+    expect(accepted.judgmentEventId).toBeDefined();
+    const duplicate = await workflow.decideProposal({ proposalEventId: first.proposalEventId, disposition: "accept", submissionId: "sub-accept-0001" });
+    expect(duplicate).toMatchObject({ decisionEventId: accepted.decisionEventId, resultVersionId: accepted.resultVersionId, judgmentEventId: accepted.judgmentEventId, replayed: true });
+    await expect(workflow.decideProposal({ proposalEventId: first.proposalEventId, disposition: "reject", submissionId: "sub-accept-0001" }))
+      .rejects.toThrow("submission id conflicts");
+    await expect(workflow.decideProposal({ proposalEventId: first.proposalEventId, disposition: "reject", submissionId: "sub-reject-0002" }))
+      .rejects.toThrow("already has a human decision");
+
+    expect(await eventsOfType(store, DOCUMENT_VERSION_EVENT_TYPE)).toHaveLength(2);
+    expect(await eventsOfType(store, PROPOSAL_DECISION_EVENT_TYPE)).toHaveLength(1);
+    const allJudgments = await judgments(store);
+    expect(allJudgments).toHaveLength(1);
+    expect(allJudgments[0]!.payload).toMatchObject({
+      runId: first.runId,
+      outputEventId: first.proposalEventId,
+      kind: "accept",
+      criterion: "workbench-document-proposal",
+      qualityEligible: false,
+      externalExportEligible: false,
+      feedbackSourceEventId: accepted.decisionEventId,
+    });
+    expect(allJudgments[0]!.parentEventId).toBe(accepted.decisionEventId);
+    expect(allJudgments[0]!.rootEventId).toBe(origin.rootEventId);
+
+    const detail = (await workflow.getDocument(head.documentId))!;
+    expect(detail.head.versionId).toBe(accepted.resultVersionId);
+    expect(detail.head.title).toBe("Doc");
+    expect(detail.head.body).toBe(direct.proposedText);
+    expect(detail.proposals[0]).toMatchObject({ status: "accepted", decision: { disposition: "accept", resultVersionId: accepted.resultVersionId, judgmentEventId: accepted.judgmentEventId } });
+    expect(detail.versions.at(-1)).toMatchObject({ reason: "proposal-accepted", proposalEventId: first.proposalEventId, decisionEventId: accepted.decisionEventId, baseVersionId: head.versionId });
+
+    // A second independent client over the same project root sees the accepted head.
+    const second = await JazzThoughtStore.open({ projectRoot: root, appId, runtimeRevision: "test" });
+    stores.push(second);
+    const seen = await new WorkbenchWorkflow(second).getDocument(head.documentId);
+    expect(seen?.head.versionId).toBe(accepted.resultVersionId);
+    expect(seen?.head.body).toBe(direct.proposedText);
+    expect((await second.listCurrentDocuments(WORKBENCH_DOCUMENT_SOURCE))[0]?.versionId).toBe(accepted.resultVersionId);
+  });
+
+  test("reject records a decision and judgment and leaves the document unchanged", async () => {
+    const { store } = await openStore();
+    const origin = await seedOrigin(store);
+    const workflow = new WorkbenchWorkflow(store);
+    const head = await workflow.createWorkingDocument({ originEventId: origin.id, title: "Doc", body: "body\n", requestId: "req-create-0001" });
+    const selection = await workflow.selectContext({ documentId: head.documentId, eventIds: [origin.id], versionIds: [], requestId: "req-select-001" });
+    const proposal = await workflow.requestProposal({ documentId: head.documentId, selectionId: selection.selectionId, runnerId: FIXTURE_RUNNER_ID, requestId: "req-prop-00001" });
+    const rejected = await workflow.decideProposal({ proposalEventId: proposal.proposalEventId, disposition: "reject", submissionId: "sub-reject-0001" });
+    expect(rejected.resultVersionId).toBeUndefined();
+    expect(rejected.judgmentEventId).toBeDefined();
+    const detail = (await workflow.getDocument(head.documentId))!;
+    expect(detail.head.versionId).toBe(head.versionId);
+    expect(detail.head.body).toBe("body\n");
+    expect(detail.versions).toHaveLength(1);
+    expect(detail.proposals[0]).toMatchObject({ status: "rejected", decision: { disposition: "reject" } });
+    expect((await judgments(store))[0]!.payload).toMatchObject({ kind: "reject", qualityEligible: false, externalExportEligible: false });
+    const replay = await workflow.decideProposal({ proposalEventId: proposal.proposalEventId, disposition: "reject", submissionId: "sub-reject-0001" });
+    expect(replay).toMatchObject({ decisionEventId: rejected.decisionEventId, replayed: true });
+    expect(await eventsOfType(store, PROPOSAL_DECISION_EVENT_TYPE)).toHaveLength(1);
+    expect(await judgments(store)).toHaveLength(1);
+  });
+
+  test("an operator edit makes an older proposal stale; accept fails closed and the edit survives", async () => {
+    const { store } = await openStore();
+    const origin = await seedOrigin(store);
+    const workflow = new WorkbenchWorkflow(store);
+    const head = await workflow.createWorkingDocument({ originEventId: origin.id, title: "Doc", body: "body\n", requestId: "req-create-0001" });
+    const selection = await workflow.selectContext({ documentId: head.documentId, eventIds: [origin.id], versionIds: [], requestId: "req-select-001" });
+    const proposal = await workflow.requestProposal({ documentId: head.documentId, selectionId: selection.selectionId, runnerId: FIXTURE_RUNNER_ID, requestId: "req-prop-00001" });
+    const edited = await workflow.saveOperatorEdit({ documentId: head.documentId, baseVersionId: head.versionId, title: "Doc", body: "newer operator work\n", requestId: "req-edit-00001" });
+    const stale = workflow.decideProposal({ proposalEventId: proposal.proposalEventId, disposition: "accept", submissionId: "sub-accept-0001" });
+    await expect(stale).rejects.toBeInstanceOf(StaleBaseError);
+    await expect(stale).rejects.toMatchObject({ headVersionId: edited.versionId });
+    const detail = (await workflow.getDocument(head.documentId))!;
+    expect(detail.head.versionId).toBe(edited.versionId);
+    expect(detail.head.body).toBe("newer operator work\n");
+    expect(detail.proposals[0]).toMatchObject({ status: "stale", stale: true, headVersionId: edited.versionId });
+    expect(detail.proposals[0]!.decision).toBeUndefined();
+    expect(await eventsOfType(store, PROPOSAL_DECISION_EVENT_TYPE)).toHaveLength(0);
+    expect(await eventsOfType(store, DOCUMENT_VERSION_EVENT_TYPE)).toHaveLength(2);
+    expect(await judgments(store)).toHaveLength(0);
+    // Rejecting a stale proposal remains allowed.
+    const rejected = await workflow.decideProposal({ proposalEventId: proposal.proposalEventId, disposition: "reject", submissionId: "sub-reject-0001" });
+    expect(rejected.disposition).toBe("reject");
+    expect((await workflow.getDocument(head.documentId))!.head.versionId).toBe(edited.versionId);
+  });
+
+  test("runner failure records a failed run and no proposal", async () => {
+    const { store } = await openStore();
+    const origin = await seedOrigin(store);
+    const failing = new Map([["failing", {
+      id: "failing",
+      revision: "1",
+      label: "Failing fixture",
+      inference: "none" as const,
+      async propose() {
+        throw new Error("synthetic runner failure");
+      },
+    }]]);
+    const workflow = new WorkbenchWorkflow(store, { runners: failing });
+    const head = await workflow.createWorkingDocument({ originEventId: origin.id, title: "Doc", body: "body\n", requestId: "req-create-0001" });
+    const selection = await workflow.selectContext({ documentId: head.documentId, eventIds: [origin.id], versionIds: [], requestId: "req-select-001" });
+    const attempt = workflow.requestProposal({ documentId: head.documentId, selectionId: selection.selectionId, runnerId: "failing", requestId: "req-prop-00001" });
+    await expect(attempt).rejects.toBeInstanceOf(WorkbenchRunnerError);
+    await expect(attempt).rejects.toThrow("synthetic runner failure");
+    expect(await eventsOfType(store, PROPOSAL_REQUESTED_EVENT_TYPE)).toHaveLength(1);
+    expect(await eventsOfType(store, PROPOSAL_PROPOSED_EVENT_TYPE)).toHaveLength(0);
+    const runs = await store.listRuns();
+    expect(runs).toHaveLength(1);
+    expect(runs[0]).toMatchObject({ status: "failed", errorText: "runner-failed: synthetic runner failure" });
+    await expect(workflow.requestProposal({ documentId: head.documentId, selectionId: selection.selectionId, runnerId: "failing", requestId: "req-prop-00001" }))
+      .rejects.toBeInstanceOf(WorkbenchRunnerError);
+    expect(await store.listRuns()).toHaveLength(1);
+  });
+});
diff --git a/tsconfig.json b/tsconfig.json
index 69f9aae..63f4c3e 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -15,5 +15,5 @@
     "types": ["node"],
     "jsx": "react-jsx"
   },
-  "include": ["src/**/*.ts", "src/**/*.tsx", "test/**/*.ts", "scripts/serve-inspector-proxy.ts", "scripts/configure-inspector-co-chat.ts", "scripts/test-co-chat-browser.ts"]
+  "include": ["src/**/*.ts", "src/**/*.tsx", "test/**/*.ts", "scripts/serve-inspector-proxy.ts", "scripts/configure-inspector-co-chat.ts", "scripts/test-co-chat-browser.ts", "scripts/workbench-demo.ts"]
 }