#47 (SLICE-2, review): per-block document proposals + word-precise accept

Document-edit flow SLICE-2 (specs/coauthoring-document-edit-flow.md §7.2,
INV-39/40/41 — P1 "too much to review"). A whole-document rewrite now proposes
ONE F4 proposal per CHANGED BLOCK (the unit a human reviews), but accepting a
block reconciles attribution at WORD granularity (the unit F3 records). Block =
decision unit; word = attribution unit. Supersedes INV-37's per-word cut for
document edits; selection edits unchanged.

- trackChangesModel.ts: new pure diffToBlockHunks(current, rewritten) — block-key
  alignment (reusing diffArrays/diffBlocks keying): an isolated changed block →
  one block-aligned hunk → the rewritten block raw (a code/mermaid fence is one
  atomic whole-fence hunk, INV-23); insert/delete runs → one gap-span hunk over
  the inter-anchor region (separators included) so reconstruction stays exact; a
  zero-width gap-span is anchored (INV-41). Also split diffToHunks into the raw,
  un-anchored wordEditHunks + the anchoring wrapper (the anchoring could grow an
  insertion to overlap an adjacent hunk, corrupting a batch apply — a latent bug
  that only surfaced once hunks are applied as a batch).
- trackChangesPreview.ts: runEditAndPropose document branch uses diffToBlockHunks
  and tags each proposal granularity:"block".
- model.ts / proposalModel.ts: additive optional Proposal.granularity
  ("block"|"single"; absent ⇒ single, back-compat — no migration).
- proposalController.ts: accept of a block proposal runs an intra-block word
  sub-diff (wordEditHunks, disjoint) and applies one applyAgentEdit per changed
  run, descending offset — only the words Claude changed land Claude-attributed;
  unchanged spans keep prior authorship (INV-40).
- Tests: diffToBlockHunks unit (reconstruction + fence atomic + add/remove);
  f12Review host E2E (M blocks→M proposals, unchanged→none, fence atomic, INV-40
  attribution, INV-41 insertion accept); updated the f11 document-path E2E to
  per-block (INV-39 supersedes INV-37); MANUAL-SMOKE-F12 §2.

Seam note: pendingEdits.matchEvent resolves one registration per change event, so
INV-40's per-run attribution is sequential applyAgentEdit calls (N undo steps),
not one multi-replace WorkspaceEdit — see transcript Deferred decisions.

214 unit + 69/5 host E2E green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

test/e2e/suite/f11Toolbar.test.ts

@@ -67,8 +67,10 @@ suite("F11 preview toolbar (host E2E — message → seam wiring, no LLM)", () =
     assert.match(entry!.when ?? "", /editorLangId == markdown/, "guarded on markdown");
   });
 
-  // SLICE-3: Edit Document → a whole-document rewrite diffed into N F4 proposals.
-  test("runEditAndPropose(document) with a stubbed multi-hunk rewrite → N proposals matching the hunks (PUC-4, INV-37)", async () => {
+  // #47 (was INV-37): Edit Document now cuts at BLOCK granularity — two word
+  // changes in ONE paragraph are ONE block proposal (INV-39 supersedes INV-37's
+  // per-word cut). Full block coverage lives in f12Review.test.ts.
+  test("runEditAndPropose(document) — two word edits in one paragraph → ONE block proposal (PUC-4, INV-39)", async () => {
     const { doc, key } = await freshDoc(
       "docs/f11doc.md",
       "# F11 doc\n\nThe quick brown fox jumps over the lazy dog.\n",
@@ -87,15 +89,16 @@ suite("F11 preview toolbar (host E2E — message → seam wiring, no LLM)", () =
 
     const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "swap brown→RED and dog→CAT");
     await settle();
-    assert.strictEqual(ids.length, 2, "two changed words → two independent proposals");
+    assert.strictEqual(ids.length, 1, "two changed words in one block → ONE block proposal (INV-39)");
 
     const views = api.proposalController.listProposals(doc);
-    assert.ok(
-      ids.every((id) => views.some((v) => v.id === id)),
-      "every returned proposal id is a live pending proposal",
+    const view = views.find((v) => v.id === ids[0]);
+    assert.ok(view, "the returned proposal id is a live pending proposal");
+    assert.strictEqual(
+      view!.replacement,
+      "The quick RED fox jumps over the lazy CAT.",
+      "the block proposal carries the whole rewritten paragraph",
     );
-    const replacements = views.map((v) => v.replacement);
-    assert.ok(replacements.includes("RED") && replacements.includes("CAT"), "proposals carry the per-hunk replacements");
     // INV-10: proposing never mutates the document.
     assert.ok(doc.getText().includes("brown fox") && doc.getText().includes("lazy dog"), "document unchanged by propose");
     void key;

test/e2e/suite/f12Review.test.ts

@@ -0,0 +1,134 @@
+import * as assert from "assert";
+import * as fs from "fs";
+import * as path from "path";
+import * as vscode from "vscode";
+import type { CowritingApi } from "../../../src/extension";
+
+const WS = process.env.E2E_WORKSPACE!;
+const settle = () => new Promise((r) => setTimeout(r, 400));
+
+async function getApi(): Promise<CowritingApi> {
+  const ext = vscode.extensions.getExtension("benstull.vscode-cowriting-plugin")!;
+  const api = (await ext.activate()) as CowritingApi;
+  assert.ok(api?.trackChangesPreviewController && api?.proposalController, "exports controllers");
+  return api;
+}
+
+async function freshDoc(rel: string, body: string): Promise<vscode.TextDocument> {
+  const abs = path.join(WS, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, body, "utf8");
+  const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(abs));
+  await vscode.window.showTextDocument(doc);
+  await settle();
+  return doc;
+}
+
+// #47 SLICE-2 (review, P1): a document rewrite proposes ONE F4 proposal per
+// CHANGED BLOCK (INV-39 supersedes INV-37's per-word cut), but accepting a block
+// reconciles attribution at WORD granularity (INV-40 — block = decision unit,
+// word = attribution unit). Host E2E, no LLM (the edit turn is stubbed).
+suite("F12 SLICE-2 — block-granularity document proposals (#47, INV-39/40/41)", () => {
+  // PUC-4: M changed blocks → M proposals; unchanged blocks → none.
+  test("edits across two paragraphs → two proposals; the untouched paragraph yields none (INV-39)", async () => {
+    const doc = await freshDoc(
+      "docs/f12-multi.md",
+      "# Doc\n\nFirst paragraph alpha.\n\nSecond paragraph beta.\n\nThird paragraph gamma.\n",
+    );
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    ctl.setEditTurnForTest(async () => ({
+      replacement: "# Doc\n\nFirst paragraph ALPHA.\n\nSecond paragraph beta.\n\nThird paragraph GAMMA.\n",
+      model: "sonnet",
+      sessionId: "e2e-f12-multi",
+    }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "uppercase the first/last nouns");
+    await settle();
+    assert.strictEqual(ids.length, 2, "two changed blocks → two proposals; the unchanged middle block → none");
+
+    // each proposal's anchor spans a whole block, and the replacement is that block's rewrite
+    const views = api.proposalController.listProposals(doc);
+    const replacements = views.map((v) => v.replacement).sort();
+    assert.deepStrictEqual(replacements, ["First paragraph ALPHA.", "Third paragraph GAMMA."]);
+  });
+
+  // PUC-4 + INV-23: a changed code fence is ONE atomic whole-fence proposal.
+  test("a changed code fence → one atomic proposal over the whole fence (INV-23)", async () => {
+    const doc = await freshDoc(
+      "docs/f12-fence.md",
+      "# Code\n\n```js\nconst a = 1;\nconst b = 2;\n```\n",
+    );
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    ctl.setEditTurnForTest(async () => ({
+      replacement: "# Code\n\n```js\nconst a = 10;\nconst b = 2;\n```\n",
+      model: "sonnet",
+      sessionId: "e2e-f12-fence",
+    }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "bump a to 10");
+    await settle();
+    assert.strictEqual(ids.length, 1, "a changed fence is one atomic proposal");
+    const view = api.proposalController.listProposals(doc).find((v) => v.id === ids[0])!;
+    assert.strictEqual(view.replacement, "```js\nconst a = 10;\nconst b = 2;\n```", "whole-fence replacement");
+  });
+
+  // PUC-5 / INV-40: accepting a block attributes ONLY the words Claude changed —
+  // unchanged words in the block are NOT swept into Claude's authorship.
+  test("accepting a block proposal attributes only the changed words to Claude (INV-40)", async () => {
+    const doc = await freshDoc("docs/f12-attr.md", "# T\n\nThe quick brown fox jumps lazily.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    const key = api.proposalController.keyFor(doc);
+
+    ctl.setEditTurnForTest(async () => ({
+      replacement: "# T\n\nThe quick RED fox jumps SLOWLY.\n",
+      model: "sonnet",
+      sessionId: "e2e-f12-attr",
+    }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "change two words");
+    await settle();
+    assert.strictEqual(ids.length, 1, "one changed paragraph → one block proposal");
+
+    const ok = await api.proposalController.acceptById(key, ids[0]);
+    assert.ok(ok, "the block proposal accepts");
+    await settle();
+
+    assert.strictEqual(doc.getText(), "# T\n\nThe quick RED fox jumps SLOWLY.\n", "the whole block landed");
+
+    const agentTexts = api.attributionController
+      .getSpans(key)
+      .filter((s) => s.authorKind === "agent")
+      .map((s) => doc.getText().slice(s.range.start, s.range.end).trim())
+      .filter((t) => t.length > 0);
+    // Only the two words Claude actually changed are Claude-attributed.
+    const joined = agentTexts.join(" ");
+    assert.ok(joined.includes("RED"), "the changed word RED is Claude-attributed");
+    assert.ok(joined.includes("SLOWLY"), "the changed word SLOWLY is Claude-attributed");
+    assert.ok(!/\bquick\b/.test(joined), "the unchanged word 'quick' is NOT swept into Claude's authorship");
+    assert.ok(!/\bfox\b/.test(joined), "the unchanged word 'fox' is NOT swept into Claude's authorship");
+  });
+
+  // PUC-4 / INV-41: a block-insertion rewrite produces acceptable proposals and
+  // accepting them all reconstructs the intended document (no born-orphaned hunk).
+  test("a rewrite that inserts a paragraph → acceptable proposals; accept-all reaches the rewrite (INV-41)", async () => {
+    const original = "# Ins\n\nAlpha block.\n\nBeta block.\n";
+    const rewrite = "# Ins\n\nAlpha block.\n\nBrand new middle block.\n\nBeta block.\n";
+    const doc = await freshDoc("docs/f12-insert.md", original);
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    const key = api.proposalController.keyFor(doc);
+
+    ctl.setEditTurnForTest(async () => ({ replacement: rewrite, model: "sonnet", sessionId: "e2e-f12-insert" }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "insert a paragraph");
+    await settle();
+    assert.ok(ids.length >= 1, "the insertion produced at least one proposal");
+
+    for (const id of ids) {
+      const ok = await api.proposalController.acceptById(key, id);
+      assert.ok(ok, `proposal ${id} is acceptable (not born-orphaned, INV-41)`);
+      await settle();
+    }
+    assert.strictEqual(doc.getText(), rewrite, "accepting all proposals reconstructs the intended rewrite");
+    assert.strictEqual(api.proposalController.listProposals(doc).length, 0, "no proposals left pending");
+  });
+});