#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;