#40 (WIP, UNVERIFIED): restore exact author attribution on undo/redo

Follow-up to #38. #38 made undo/redo re-inserted text neutral (no false human coloring); #40 restores its EXACT prior attribution so Claude's restored text is blue again, the human's green. Mechanism — text-keyed attribution snapshots: per-doc Map<documentText, spans>, snapshotted after every forward edit + at load; on undo/redo, after the #38 geometry reconcile, if a snapshot's text equals the current buffer the spans are restored exactly (offsets valid — identical text). Robust to VS Code undo coalescing (only the resulting-text-matching event restores); far-back/evicted states fall back to #38 neutral. History bounded (ATTR_HISTORY_MAX, oldest evicted). NOT MERGED / NOT VERIFIED END-TO-END: 222 unit + typecheck green, but the #40 host E2E (and the pre-existing #38 undoMarks E2E) depend on executeCommand("undo"), which is broken in this test environment — the untouched #38 test fails identically on clean main (the known undoMarks flake, now deterministic). Clearing .vscode-test/user-data (the usual remedy) is permission-blocked here. The operator should verify in a working E2E environment before merging. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
claim vscode-cowriting-plugin session 0048 (placeholder) + sessions.json entry
2026-06-13 08:56:43 -07:00 · 2026-06-13 08:45:48 -07:00 · 2026-06-13 08:43:50 -07:00 · 2026-06-13 15:42:04 +00:00 · 2026-06-13 08:41:31 -07:00 · 2026-06-13 08:34:03 -07:00
31 changed files with 2388 additions and 63 deletions
@@ -245,7 +245,10 @@ A clean, **zero-annotation editor** on the left; the rendered preview on the
 right as the **single interactive review surface**. The editor carries no
 attribution tint, no in-editor proposal threads, and no diff — all review lives
 in the preview, toggled by the **Annotations** switch in its header (on by
-default). `Ctrl+Alt+R` opens **"Open Review Preview"**.
+default). Open it via `Ctrl+Alt+R`, the editor title-bar button, or
+**right-click a markdown file in the Explorer / its editor tab →
+"Open Cowriting Review Panel"** (#41) — the right-click acts on the clicked
+document, opening it first if needed.

 In the on-state the preview shows **green = human / blue = Claude /
 strikethrough = deleted**, and surfaces each of Claude's pending F4 proposals as
@@ -0,0 +1,96 @@
+# Manual smoke — F12 document-edit flow
+
+Covers the document-edit-flow cluster (`specs/coauthoring-document-edit-flow.md`,
+#42 · #47 · #46). This file is filled in slice by slice.
+
+## SLICE-1 — #42 (reach): selection-aware Ask-Claude from body + tab (INV-38)
+
+Run the extension (F5) on a markdown document under the sandbox workspace.
+
+1. **Body, with selection (PUC-2).** Select a paragraph, right-click the editor
+   **body**. Expect **Ask Claude to Edit Selection** in the menu (and **not**
+   "Edit Document"). Pick it → instruct → submit; a single proposal lands over
+   the selection (existing F11 behavior, unchanged).
+2. **Body, no selection (PUC-1).** Clear the selection (click once), right-click
+   the editor **body**. Expect **Ask Claude to Edit Document** (and **not** "Edit
+   Selection"). Pick it → instruct → submit; the whole-document rewrite surfaces
+   as F4 proposal(s) in the preview.
+3. **Tab, with selection (PUC-3).** With a selection active, right-click the
+   editor **tab**. Expect **Ask Claude to Edit Selection**, acting on that tab's
+   document.
+4. **Tab, no selection (PUC-3).** With no selection, right-click the editor
+   **tab**. Expect **Ask Claude to Edit Document**, acting on **that tab's**
+   document — even if a *different* editor is the active one. Open two markdown
+   tabs A and B, make A active, right-click B's tab → Edit Document → the
+   proposals land on **B**, not A.
+5. **Markdown-gated.** Open a non-markdown file (e.g. `.txt`). Right-click body or
+   tab: neither **Ask Claude to Edit Selection** nor **Edit Document** appears.
+6. **Single edit path.** Both entries route through the same `runEditAndPropose`
+   path — there is no second edit code path (INV-38). Nothing is written to the
+   document or sidecar by merely invoking the menu (INV-10/20/35) until you accept.
+
+### Pass criteria
+
+The body and tab menus show exactly one Ask-Claude edit entry, matching the live
+selection state (selection → Edit Selection; none → Edit Document); the tab
+gesture targets the clicked tab's document, not the active editor; both are absent
+on non-markdown docs; no console errors.
+
+## SLICE-2 — #47 (review): per-block proposals + word-precise attribution (INV-39/40/41)
+
+On a markdown doc with several paragraphs, **Ask Claude to Edit Document** with a
+light copy-edit instruction (e.g. "tighten the prose, fix typos").
+
+1. **One proposal per changed block (INV-39).** Claude's pass surfaces as **one
+   ✓/✗ block per changed paragraph/header/bullet**, not a flurry of word-level
+   blocks. A paragraph with several word edits is a **single** proposal; the
+   word-level `<ins>`/`<del>` still shows *inside* it. Untouched paragraphs show no
+   proposal.
+2. **Changed fence is atomic (INV-23).** If Claude edits a code/mermaid fence, it
+   is **one** whole-fence proposal.
+3. **Accept attributes only the changed words (INV-40).** Accept a block proposal,
+   then toggle the preview to **Authorship**/colors (or re-open in the on-state):
+   only the words Claude actually changed are Claude-colored; the unchanged words
+   in that block keep their prior author. The block is the decision unit; the word
+   is the attribution unit.
+4. **Inserted block accepts cleanly (INV-41).** If Claude adds a new paragraph,
+   its proposal **accepts** (it is anchored to an adjacent block, never a
+   born-orphaned/zero-width proposal).
+5. **Undo.** Accepting a block is currently **N undo steps** (one per changed run
+   inside the block) — `Ctrl+Z` repeatedly restores it. (Spec deferred note:
+   single-undo-step grouping is a possible follow-up.)
+6. **Selection edits unchanged.** Edit *Selection* still produces exactly one
+   proposal over the selection (no block fan-out).
+
+### Pass criteria
+
+A document edit yields one in-context proposal per changed block (fences atomic);
+accepting a block lands the whole block but Claude-attributes only the words it
+changed; inserted blocks accept; selection edits are unaffected; no console errors.
+
+## SLICE-3 — #46 (accept): Accept all (INV-42)
+
+On a markdown doc, **Ask Claude to Edit Document** with a pass that changes
+**several** blocks, so the preview shows **≥ 2** pending proposals.
+
+1. **Button appears at ≥2 (PUC-6).** The preview toolbar shows **✓✓ Accept all**
+   only when there are **2 or more** pending proposals (and the doc is authorable,
+   annotations on). With 0–1 pending it is hidden.
+2. **One gesture applies all.** Click **Accept all**: every pending proposal lands
+   (Claude-attributed per INV-40), the ✓/✗ blocks clear, and a status message
+   reports how many were accepted. No confirmation dialog.
+3. **Undo restores.** `Ctrl+Z` walks back the applied edits (consistent with
+   single accept; a block accept is itself N steps — see SLICE-2).
+4. **Orphan-skip + report.** If one proposal's target text was changed by hand
+   first (so it can't anchor), Accept all applies the rest and the report says
+   `… , N skipped (target text changed — undo or reject)`; the orphaned proposal
+   stays pending, its text untouched (never force-applied).
+5. **Command path.** With no preview panel open, the command palette **Cowriting:
+   Accept All Claude Proposals** (markdown-gated) applies all proposals on the
+   active doc with the same report.
+
+### Pass criteria
+
+Accept all is offered only at ≥2 pending; one click applies every resolvable
+proposal and reports the tally; orphans are skipped (not mangled) and remain
+pending; the palette command works on the active doc; no console errors.
@@ -30,6 +30,7 @@ const legend = document.getElementById("cw-legend")!;
 const annotationsEl = document.getElementById("cw-annotations") as HTMLInputElement | null;
 const pinEl = document.getElementById("cw-pin") as HTMLButtonElement | null;
 const askEl = document.getElementById("cw-ask") as HTMLButtonElement | null;
+const acceptAllEl = document.getElementById("cw-acceptall") as HTMLButtonElement | null;

 // F10: the annotations on/off toggle.
 annotationsEl?.addEventListener("change", () => {
@@ -88,6 +89,11 @@ askEl?.addEventListener("click", () => {
  }
 });

+// #46 (INV-42): Accept all — batch-accept every pending proposal (intent only).
+acceptAllEl?.addEventListener("click", () => {
+  vscodeApi.postMessage({ type: "acceptAll" });
+});
+
 // F10: delegated ✓/✗ accept/reject of pending proposals (routed back to the F4 seam).
 body.addEventListener("click", (e) => {
  const btn = (e.target as HTMLElement)?.closest<HTMLElement>(".cw-actions button");
@@ -132,6 +138,9 @@ window.addEventListener("message", (event: MessageEvent<RenderMessage>) => {
  if (askEl) askEl.disabled = !authorable;
  const on = msg.mode === "on";
  if (annotationsEl) annotationsEl.checked = on;
+  // #46: Accept all shows only with ≥2 pending proposals, on an authorable doc,
+  // in the annotated (on) state — a single proposal is just a ✓ in place.
+  if (acceptAllEl) acceptAllEl.hidden = !on || !authorable || (msg.summary?.proposals ?? 0) < 2;
  // Off-state is a clean preview: hide the review chrome.
  header.hidden = !on;
  summary.hidden = !on;
@@ -76,13 +76,18 @@
      },
      {
        "command": "cowriting.showTrackChangesPreview",
-        "title": "Cowriting: Open Review Preview",
+        "title": "Open Cowriting Review Panel",
        "category": "Cowriting"
      },
      {
        "command": "cowriting.editDocument",
        "title": "Ask Claude to Edit Document",
        "category": "Cowriting"
+      },
+      {
+        "command": "cowriting.acceptAllProposals",
+        "title": "Accept All Claude Proposals",
+        "category": "Cowriting"
      }
    ],
    "menus": {
@@ -110,6 +115,10 @@
        {
          "command": "cowriting.editDocument",
          "when": "editorLangId == markdown"
+        },
+        {
+          "command": "cowriting.acceptAllProposals",
+          "when": "editorLangId == markdown"
        }
      ],
      "editor/title": [
@@ -119,10 +128,39 @@
          "group": "navigation@9"
        }
      ],
+      "editor/title/context": [
+        {
+          "command": "cowriting.editSelection",
+          "when": "editorHasSelection && resourceLangId == markdown",
+          "group": "1_cowriting@1"
+        },
+        {
+          "command": "cowriting.editDocument",
+          "when": "!editorHasSelection && resourceLangId == markdown",
+          "group": "1_cowriting@1"
+        },
+        {
+          "command": "cowriting.showTrackChangesPreview",
+          "when": "resourceLangId == markdown",
+          "group": "1_cowriting@3"
+        }
+      ],
+      "explorer/context": [
+        {
+          "command": "cowriting.showTrackChangesPreview",
+          "when": "resourceLangId == markdown",
+          "group": "navigation@9"
+        }
+      ],
      "editor/context": [
        {
          "command": "cowriting.editSelection",
-          "when": "editorHasSelection && (resourceScheme == file || resourceScheme == untitled)",
+          "when": "editorHasSelection && editorLangId == markdown && (resourceScheme == file || resourceScheme == untitled)",
+          "group": "1_cowriting@1"
+        },
+        {
+          "command": "cowriting.editDocument",
+          "when": "!editorHasSelection && editorLangId == markdown && (resourceScheme == file || resourceScheme == untitled)",
          "group": "1_cowriting@1"
        },
        {
@@ -0,0 +1,88 @@
+# Session 0038.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-12T15-55 (PST)
+> End: 2026-06-12T16-06 (PST)
+> Type: planning-and-executing
+> Posture: autonomous (yolo)
+> Status: **FINALIZED**
+
+## Pre-state
+
+`main` clean and pushed (HEAD `21df670`, behind origin by 1 — fast-forwarded to
+`de53305` the session-claim commit). No in-flight sessions. Open backlog: #42
+(feature, Ask Claude to Edit Document), #41 (story, right-click → Open Review
+Panel); both filed in capture session 0035 as F11 follow-ups.
+
+## Launch prompt
+
+`/goal next` → stored goal "plan-and-execute #42 (Ask Claude to Edit Document),
+then #41" (from session 0037 finalize).
+
+## Plan
+
+**Gate decision (§4.3 R3):** #42 is `type/feature` with no Solution Design — an
+ineligible anchor for plan-and-execute. Operator chose: **plan-and-execute #41
+now (eligible story); brainstorm #42's design next.** So this session does #41
+only; #42's design becomes the next goal.
+
+**#41 — Open Cowriting Review Panel from the markdown file/tab right-click menu**
+(story, P2):
+- `explorer/context` menu item for `.md` → `cowriting.showTrackChangesPreview`.
+- `editor/title/context` menu item for markdown tabs → same command.
+- Command accepts the right-clicked resource URI (open clicked doc, not just
+  active editor).
+- Menu label reads "Open Cowriting Review Panel" (least-churn option).
+- E2E coverage: menu contributed + opens preview.
+
+### Outcome
+
+**#41 SHIPPED** to main (PR #45, merged + branch deleted; issue auto-closed).
+- `explorer/context` + `editor/title/context` menus (markdown-gated) →
+  `cowriting.showTrackChangesPreview`; command retitled "Open Cowriting Review
+  Panel"; command resolves the *clicked* doc (opens it if not already open),
+  no-arg path unchanged.
+- 208 unit + 7 new E2E (`reviewPanelMenu.test.ts`); full host E2E suite green
+  (66 passing across both workspaces); typecheck clean.
+
+**#42 NOT done this session** — `type/feature` with no Solution Design is an
+ineligible plan-and-execute anchor (§4.3 R3). Operator chose: brainstorm #42's
+design next. → **Next /goal:** brainstorm #42 (Ask Claude to Edit Document)
+Solution Design, then plan-and-execute #42.
+
+## Deferred decisions
+
+- #42 gate (R3): asked the operator rather than auto-overriding; they chose
+  "#41 now, brainstorm #42 next." Not low-confidence — recorded for the
+  finalize report.
+- Pre-existing F11-independent `undoMarks` E2E flake noted in session 0037 still
+  uncaptured as a follow-up issue (out of scope for #41).
+
+## Session arc
+
+1. Claimed session 0038 (peek → no in-flight → atomic push). Fast-forwarded
+   `main`. Fetched #42 + #41 from the Gitea API.
+2. Ran the §4.3 issue-type gate: #42 (feature, no design) ineligible for
+   plan-and-execute; #41 (story) eligible. Surfaced the fork; operator chose
+   "#41 now, brainstorm #42 next."
+3. Implemented #41: read `trackChangesPreview.ts` (the `showTrackChangesPreview`
+   command already took an optional `uri` but only searched *open* docs) +
+   `package.json` menus. Fixed the command to open the clicked doc; added
+   `explorer/context` + `editor/title/context`; retitled the command; updated
+   README.
+4. Wrote `reviewPanelMenu.test.ts` (7 E2E). Typecheck + 208 unit + full host
+   E2E green.
+5. Branch → commit → push → PR #45 → merged (branch deleted); #41 auto-closed.
+6. Finalized: memory updated, transcript published.
+
+## Next-session prompt
+
+```
+/goal brainstorm #42 (Ask Claude to Edit Document) Solution Design, then plan-and-execute #42
+```
+
+**Next /goal:** brainstorm #42 (Ask Claude to Edit Document) Solution Design,
+then plan-and-execute #42. Design forks to settle: whole-doc instruction
+gathering; one large proposal vs several; large-document token-limit behavior.
+`cowriting.editDocument` + `runEditAndPropose(doc, {kind:"document"})` already
+exist (F11 prep) — #42 is mostly menu/tab wiring + those decisions on top.
@@ -0,0 +1,74 @@
+# Session 0039.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-12T16-07 (PST)
+> End: 2026-06-12T17-02 (PST)
+> Type: capture (tracked-lite)
+> Posture: careful (capture default)
+> Status: **FINALIZED**
+
+## Launch prompt
+
+`/wgl-capture We need a way to accept all of Claude's edits`
+
+## Pre-state
+
+Opened immediately after finalizing session 0038. `main` clean + pushed.
+Backlog open: #42 (feature, Ask Claude to Edit Document). No existing
+accept-all draft in the content repo.
+
+## What was captured
+
+**One ask → one issue filed.**
+
+**#46** — `type/feature`, `priority/P2` —
+"Accept all of Claude's pending proposals on the current document in one gesture."
+https://git.benstull.org/benstull/vscode-cowriting-plugin/issues/46
+
+Confirmed gap from the code: accept is **per-proposal only** today
+(`cowriting.acceptProposal` → `ProposalController.acceptById`; F10/F11 preview ✓
+per `cw-proposal` block). No bulk accept. Felt most after F11 "Edit Document"
+(#42), where one whole-document rewrite fans out into N per-hunk proposals.
+
+## Decisions (capture forks)
+
+- **Scope of "all" = all pending proposals on the current document** (operator
+  choice) — not per-turn, not cross-document. Safe apply-order; orphaned /
+  unresolved proposals **skipped + reported**, never force-applied.
+- **Type = `type/feature`** (operator choice). The load-bearing fork is
+  apply-order + re-anchoring: each accept mutates the buffer and re-resolves the
+  remaining proposals' anchors, so bulk-accept needs a correct order /
+  re-resolve-between strategy. Design step also settles confirmation y/n, button
+  placement (preview header vs F11 toolbar), and applied-vs-skipped surfacing.
+- Non-goals recorded: no reject-all, no cross-document/workspace accept-all, no
+  per-turn scope, no new accept seam (reuse F4 `acceptById` in a loop; webview
+  posts an `acceptAll` intent — sealed-webview INV-21/35).
+
+## Session arc
+
+1. Claimed tracked-lite session 0039 (`--type capture`); fast-forwarded `main`.
+2. Resolved the content repo (`vscode-cowriting-plugin-content`); cloned + listed
+   existing drafts (no accept-all duplicate).
+3. Inspected the code's accept surface → confirmed per-proposal-only, no bulk.
+4. Reflected the ask; asked two scope/sizing questions → current-doc + feature.
+5. Drafted `issues/accept-all-proposals.md` (full §5 feature template).
+6. Operator approved → ensured labels → filed **#46**.
+7. Finalized: memory updated, transcript published. Draft left uncommitted in the
+   content-repo working tree (INV-8 — Author to publish/discard).
+
+## Deferred decisions
+
+- Capture scripts 401 with the default token service; needed
+  `WGL_CAPTURE_TOKEN_SERVICE=wgl-gitea-issues-readwrite-token-git.benstull.org`
+  (host-specific). Worth a plugin-feedback follow-up if it recurs.
+
+## Next-session prompt
+
+Unchanged from 0038 — the next coding goal stands:
+
+```
+/goal brainstorm #42 (Ask Claude to Edit Document) Solution Design, then plan-and-execute #42
+```
+
+#46 (accept-all) is now in the backlog alongside #42; either could be the next
+brainstorming target.
@@ -0,0 +1,81 @@
+# Session 0040.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-12T17-03 (PST)
+> End: 2026-06-12T17-21 (PST)
+> Type: capture (tracked-lite)
+> Posture: careful (capture default)
+> Status: **FINALIZED**
+
+## Launch prompt
+
+`/wgl-capture When Claude suggests changes, a single change should be for a
+paragraph (or header, or bulletpoint), not individual words. It's too much to
+review`
+
+## Pre-state
+
+Third session of the run (after 0038 ship + 0039 capture). `main` clean +
+pushed. Backlog: #42 (Edit Document), #46 (accept-all, filed 0039).
+
+## What was captured
+
+**One ask → one issue filed.**
+
+**#47** — `type/feature`, `priority/P1` —
+"Block-granularity proposals: one change per paragraph/header/bullet, not per word."
+https://git.benstull.org/benstull/vscode-cowriting-plugin/issues/47
+
+Confirmed from code: F11 **Ask Claude to Edit Document** mints proposals at **word
+granularity** — `diffToHunks` (src/trackChangesModel.ts) uses `diffWordsWithSpace`
+and flushes a hunk on every unchanged token, so each changed word is its own ✓/✗
+proposal (INV-37 "per-hunk"). A light copy-edit pass explodes into dozens of tiny
+proposals → "too much to review."
+
+## Decisions (capture forks)
+
+- **Scope = document edits only** (operator choice) — the `diffToHunks` fan-out.
+  Selection edits are already a single proposal, so untouched.
+- **Type = `type/feature`** (operator choice). Supersedes F11 **INV-37 per-hunk →
+  per-block**. Real forks recorded for the design step: block taxonomy (list items
+  vs whole lists, tables, blockquotes, nesting); anchoring inserted blocks (a
+  block-level analogue of today's word-oriented `anchorInsertion`); and the
+  **attribution tradeoff** — accepting a block attributes the *whole* block to
+  Claude, including unchanged words.
+- Reuse the existing block splitter (`diffBlocks`; code/mermaid fences atomic,
+  INV-23). Intra-block `<ins>`/`<del>` **rendering is unchanged** — only the
+  decision *unit* becomes the block. `priority/P1` (directly removes the stated
+  pain).
+
+## Session arc
+
+1. Claimed tracked-lite session 0040 (`--type capture`); fast-forwarded `main`.
+2. Inspected `diffToHunks` → confirmed word-level granularity is the cause.
+3. Reflected the ask; asked scope + sizing → document-edits + feature.
+4. Drafted `issues/block-granularity-proposals.md` (full §5 feature template).
+5. Operator approved → filed **#47** (labels already ensured this run).
+6. Finalized: memory updated, transcript published. Draft left uncommitted in the
+   content-repo working tree (INV-8).
+
+## Deferred decisions
+
+_None._
+
+## Backlog observation
+
+#42 (Ask Claude to Edit Document), #46 (accept-all), and #47 (block granularity)
+form one **edit-flow cluster** around the Ask-Claude / document-edit loop. They
+interact (block granularity changes how many proposals exist; accept-all changes
+how they're taken; #42 is the entry point that produces them) and are best
+**brainstormed / sequenced together** rather than designed in isolation.
+
+## Next-session prompt
+
+The standing coding goal is unchanged; consider folding the cluster in:
+
+```
+/goal brainstorm the Ask-Claude document-edit cluster (#42 Edit Document, #47 block-granularity proposals, #46 accept-all) and sequence/design it, starting with #42
+```
+
+(Or keep the narrower `/goal brainstorm #42 … then plan-and-execute #42` and take
+#47/#46 after.)
@@ -0,0 +1,83 @@
+# Session 0041.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-12T18-17 (PST) · End: 2026-06-13T07-16 (PST)
+> Type: brainstorming
+> Posture: autonomous (yolo)
+> Goal: brainstorm the Ask-Claude document-edit cluster (#42, #47, #46) and
+> sequence/design it, starting with #42
+> Outcome: **GRADUATED** — one combined Solution Design
+> `specs/coauthoring-document-edit-flow.md` (content repo, `status: graduated`,
+> commit `9d016e8`), sequencing #42 → #47 → #46.
+
+## Launch prompt
+
+`/goal brainstorm the Ask-Claude document-edit cluster (#42, #47, #46) and
+sequence/design it, starting with #42`
+
+## Plan
+
+Brainstorming session — produce a Solution Design for the **Ask-Claude
+document-edit flow**, the cluster of #42 (Ask Claude to Edit Document — entry
+points), #47 (block-granularity proposals), #46 (accept-all). Deliverable: one
+combined Solution Design (content repo `specs/`), sequencing the three as a
+delivery plan **#42 (reach) → #47 (review) → #46 (accept)**.
+
+## Arc
+
+1. **Init.** Claimed session 0041 (`--type brainstorming`), clean pushed `main`
+   baseline, seeded the Plan block. Resolved app repos (roadmap = framework repo;
+   content = `vscode-cowriting-plugin-content`; no BDD corpus).
+2. **Read the cluster.** Read the three capture drafts (#42/#47/#46) in the
+   content repo `issues/`. Then ground in code: `package.json` menus/commands,
+   `trackChangesModel.ts` (`splitBlocks`/`diffBlocks`/`diffToHunks`/
+   `anchorInsertion`/`renderReview`), `trackChangesPreview.ts`
+   (`editDocument`/`askClaude`/`runEditAndPropose`), `proposalController.ts`
+   (`acceptById`/`accept`→`applyAgentEdit`/`listProposals`).
+3. **Key reframe.** F11 (session 0037) **already shipped** the document-edit path
+   — `cowriting.editDocument` → `runEditAndPropose({kind:"document"})` →
+   `diffToHunks` (word-level, INV-37). So #42 is mostly DONE (remaining = menu
+   wiring); #47 swaps the document-branch diff to block-level; #46 loops the
+   existing accept seam.
+4. **Found a spec-hygiene gap.** The F11 (#43) Solution Design was never graduated
+   to `specs/` — INV-35/36/37 live only in code comments + the F11 issue draft.
+   Logged as OQ-2 (follow-up), restated the depended-on F11 invariants in the new
+   spec.
+5. **Locked two forks with the operator** (AskUserQuestion):
+   - **D-1** — per-block proposals **preserve unchanged-span attribution** (block =
+     decision unit, word = attribution unit; intra-block `diffToHunks` sub-diff at
+     accept; INV-40). *Not* whole-block→Claude.
+   - **D-2** — ship as **one combined Solution Design**, not three.
+6. **Wrote the spec.** `specs/coauthoring-document-edit-flow.md` — business →
+   product → engineering, new invariants INV-38..42 (INV-39 supersedes INV-37),
+   delivery plan SLICE-1/2/3 = #42/#47/#46, traceability, decisions log. Self-
+   reviewed (no placeholders, consistent, scoped). Did **not** invoke
+   `writing-plans` (wgl-brainstorming override — the artifact is the spec,
+   submitted at finalize; implementation is a downstream session).
+7. **Finalize.** Submitted the spec `--status graduated`; memory updated.
+
+## Deferred decisions
+
+- **D-3 (low-confidence driver call)** — sequenced **#42 → #47 → #46** per the
+  goal's "starting with #42," **despite #47 carrying the P1 value** ("too much to
+  review" is the sharpest pain). The three are code-independent so the order is
+  reversible (§7.1); #47 and #42 could swap with no rework if the operator wants
+  the P1 review fix to land first. Surfaced at closeout; logged as D-3 in the
+  spec §9.
+- D-4 (driver) block taxonomy = exactly `splitBlocks`'s units; D-5 (driver)
+  accept-all needs no confirmation, button shown ≥2 pending. Both in spec §9.
+
+## Loose ends → next session
+
+- **OQ-2** — graduate the F11 (#43) spec to `specs/` for a clean invariant ledger
+  (INV-35/36/37 currently code-only).
+- **OQ-1** — whether selection edits should also preserve-unchanged-span
+  attribution (out of #47 scope).
+- Content-repo local working tree carries pre-existing untracked drafts/specs
+  (prior sessions / the Author's) — not landed by this session.
+
+## Next /goal
+
+```
+/goal plan-and-execute #42 (SLICE-1 of the document-edit flow — Ask-Claude entry-point menu wiring), per specs/coauthoring-document-edit-flow.md
+```
@@ -0,0 +1,62 @@
+# Session 0042.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-12T21-04 (PST) · End: 2026-06-13T07-16 (PST)
+> Type: capture (tracked-lite)
+> Posture: autonomous (yolo)
+> Goal: capture "When I pin the baseline, there should be no annotations in the
+> review panel"
+> Outcome: filed **#48** (`type/story`, `priority/P2`).
+
+## Launch prompt
+
+`/wgl-capture When I pin the baseline, there should be no annotations in the
+review panel`
+
+Opened mid-session, concurrent with the in-flight brainstorming session 0041
+(only that — my own — session in flight; warned + proceeded per autonomous).
+
+## Arc
+
+1. **Claim.** Claimed session 0042 (`--type capture`, tracked-lite). App +
+   content repo already resolved from 0041.
+2. **Ground the behavior.** Read `renderReview`/`colorByAuthor`/`renderReviewOp`
+   in `trackChangesModel.ts`: an **unchanged** block renders as
+   `cw-blk cw-unchanged` with `colorByAuthor` applied (line ~526). So after a Pin
+   baseline (baseline == current → every block unchanged), the change axis is
+   empty but **F3 authorship coloring still paints every block** — and the panel
+   *does* refresh on pin (`onDidChangeBaseline`), so it's not a stale render. The
+   author colors are the "annotations."
+3. **Scope fork (AskUserQuestion).** Operator chose **pin → fully clean panel**
+   (zero-diff state: change marks AND authorship colors gone), **not** the broader
+   "authorship never colors unchanged text." → a single, design-free increment.
+4. **Type.** Would be `type/bug`, but `capture-issues.sh` accepts only
+   epic|feature|story|task (the gap plugin feedback #124 tracks — not re-filed).
+   Filed as the accurate fileable type `type/story`, P2.
+5. **Draft + approval + file.** Authored
+   `issues/pin-baseline-clears-review-annotations.md`; operator **approved**;
+   ensured labels (`--host git.benstull.org`,
+   `WGL_CAPTURE_TOKEN_SERVICE=wgl-gitea-issues-readwrite-token-git.benstull.org`);
+   filed **#48** —
+   https://git.benstull.org/benstull/vscode-cowriting-plugin/issues/48
+
+## Deferred decisions
+
+- **Type compromise (driver, tooling-forced)** — filed as `type/story` though the
+  observation is bug-flavored (surprising behavior on a primary gesture);
+  `capture-issues.sh` can't type `bug`. The bug-typing gap is already tracked as
+  plugin feedback **#124**; not re-filed.
+
+## Loose ends
+
+- Draft `issues/pin-baseline-clears-review-annotations.md` left **uncommitted** in
+  the content repo working tree (the Author's to publish or discard — capture
+  INV-8).
+
+## Next /goal
+
+(Continuation is the 0041 handoff.)
+
+```
+/goal plan-and-execute #42 (SLICE-1 of the document-edit flow — Ask-Claude entry-point menu wiring), per specs/coauthoring-document-edit-flow.md
+```
@@ -0,0 +1,92 @@
+# Session 0043.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-13T07-18 (PST)
+> Type: planning-and-executing
+> End: 2026-06-13T07-38 (PST)
+> Status: **FINALIZED.**
+> Posture: autonomous (yolo)
+
+## Launch prompt
+
+`/goal plan-and-execute #42 (SLICE-1 of the document-edit flow — Ask-Claude
+entry-point menu wiring), per specs/coauthoring-document-edit-flow.md`
+
+## Plan
+
+**SLICE-1 — #42 (reach)** of the document-edit flow Solution Design
+(`specs/coauthoring-document-edit-flow.md`, §7.2). Anchor: Feature #42
+(`type/feature`); design graduated (session 0041) → §4.3 R3 satisfied.
+
+Goal (INV-38): "Ask Claude to Edit" reachable from the editor **body** and the
+editor **tab**, selection-aware (selection → `editSelection`; no selection →
+`editDocument`), both gated to markdown/authorable docs, both routing through the
+single `runEditAndPropose` path. Smallest increment — command already exists.
+
+Tasks:
+1. `package.json` — add `editSelection` + `editDocument` to `editor/context`
+   (selection-aware `when`, markdown+authorable) and `editor/title/context`
+   (selection-aware, `resourceLangId == markdown`); keep titles.
+2. `trackChangesPreview.ts` — `cowriting.editDocument` accepts an optional tab
+   `uri` arg (mirror `showTrackChangesPreview`'s #41 resolution): open/resolve the
+   clicked doc, else fall back to the active editor.
+3. E2E (`test/e2e/suite/`) — menu entries present + selection-aware + markdown-gated;
+   `editDocument(uri)` resolves the tab doc and produces a document-scoped proposal.
+
+No model change, no new persisted artifact. No deploy pipeline (VS Code extension).
+
+## Results
+
+**SLICE-1 (#42, reach) shipped to `main`** — PR
+[#49](https://git.benstull.org/benstull/vscode-cowriting-plugin/pulls/49)
+(merged), issue #42 closed.
+
+- `package.json` — `editSelection` + `editDocument` added to `editor/context`
+  (selection-aware, `editorLangId == markdown` + `file`/`untitled`) and
+  `editor/title/context` (selection-aware, `resourceLangId == markdown`);
+  existing `editor/context` `editSelection` entry markdown-gated to match INV-38.
+- `src/trackChangesPreview.ts` — `cowriting.editDocument` now accepts the clicked
+  tab's resource `Uri` (opens it if needed), falling back to the active editor;
+  mirrors `showTrackChangesPreview`'s #41 resolution.
+- `test/e2e/suite/f12Reach.test.ts` — 4 new host E2E (menu wiring declarative +
+  tab-URI targeting + no-arg fallback).
+- `docs/MANUAL-SMOKE-F12.md` — SLICE-1 reach smoke steps.
+
+Verification: `tsc --noEmit` clean; **208 unit** green; **65/5 host E2E** green
+(main suite up from 61 → 65 with the 4 new tests).
+
+**Next:** SLICE-2 — #47 (review, **P1**): document edits propose per changed
+block (`diffToBlockHunks`, INV-39 supersedes INV-37; word-precise intra-block
+attribution INV-40; block-insertion anchoring INV-41). Then SLICE-3 — #46
+(accept-all, INV-42).
+
+## Session arc
+
+1. **Gate + claim.** Classified the `/goal` as planning-and-executing; claimed
+   session 0043 (peek showed nothing in flight). Baseline: local `main` was 4
+   behind `origin/main` → fast-forwarded clean.
+2. **Anchor gate (§4.3 R3).** #42 is `type/feature`; its design is the graduated
+   combined Solution Design `specs/coauthoring-document-edit-flow.md` (session
+   0041) → R3 satisfied, proceed.
+3. **Read the spec**, scoped SLICE-1 (reach). Explored the code: `package.json`
+   menus, `editDocument`/`editSelection` handlers, the F11 E2E harness (`setEditTurnForTest`).
+4. **TDD.** Wrote `f12Reach.test.ts` first (red), then wired the menus + tab-URI
+   resolution (green).
+5. **Verified** (tsc clean, 208 unit, 65/5 E2E), self-reviewed the diff, shipped
+   via PR #49 (merged), closed #42, updated memory, checkpoint-published the
+   transcript.
+
+## Deferred decisions
+
+_Autonomous-mode low-confidence calls the driver made and would have
+liked operator input on. Appended as the session runs; surfaced at
+finalize. Empty if none._
+
+- **Markdown-gating `editSelection`'s `editor/context` entry** (driver call,
+  low-confidence). Spec §5/INV-38 say both Ask-Claude entries are markdown-gated,
+  but F8 made the `editSelection` *command* work on any authorable doc and its
+  current right-click entry has no `editorLangId == markdown` gate. Followed the
+  spec: gated the **menu** entries to markdown while leaving the command handlers'
+  behavior intact (palette still works on any authorable file). Removes the
+  body right-click Ask-Claude-Edit-Selection on non-markdown files — acceptable
+  since the proposal review surface (F10 preview) is markdown-only.
@@ -0,0 +1,127 @@
+# Session 0044.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-13T07-40 (PST)
+> Type: planning-and-executing
+> End: 2026-06-13T08-04 (PST)
+> Status: **FINALIZED.**
+> Posture: autonomous (yolo)
+
+## Launch prompt
+
+```
+/goal plan-and-execute #47 (SLICE-2 of the document-edit flow — document edits propose per changed block: diffToBlockHunks INV-39 supersedes INV-37, word-precise intra-block attribution INV-40, block-insertion anchoring INV-41), per specs/coauthoring-document-edit-flow.md
+
+```
+
+## Plan
+
+**SLICE-2 — #47 (review, P1)** of the document-edit flow
+(`specs/coauthoring-document-edit-flow.md` §7.2). Anchor: Feature #47
+(`type/feature`); covered by the graduated combined Solution Design → §4.3 R3.
+
+Document rewrites propose **one F4 proposal per changed block** (the unit a human
+reviews), but each accept reconciles attribution at **word** granularity (the unit
+F3 records). INV-39 supersedes INV-37 for document edits; INV-40 word-precise
+intra-block attribution; INV-41 block-insertion anchoring. Selection edits
+unchanged.
+
+Tasks:
+1. `model.ts` — add optional `granularity?: "block" | "single"` to `Proposal`
+   (additive, back-compat: absent ⇒ `"single"`). INV-39/§6.3.
+2. `proposalModel.ts` — `addProposal` opts gains `granularity`, threaded onto the
+   proposal (omitted when absent).
+3. `trackChangesModel.ts` — new pure `diffToBlockHunks(currentText,
+   rewrittenText): EditHunk[]`: split both sides into the existing block units
+   (`splitBlocksWithRanges` for source ranges + `splitBlocks` keys), diff blocks
+   (reuse `diffArrays` keying like `diffBlocks`), emit ONE `EditHunk` per
+   changed/added/removed block — changed → `[block.start,end)`→rewrite; fences
+   atomic (whole-fence hunk); inserted → anchored to adjacent boundary (INV-41,
+   reuse the `anchorInsertion` idea); unchanged → none. Same `EditHunk` shape as
+   `diffToHunks` (which is RETAINED as the intra-block sub-diff engine).
+4. `trackChangesPreview.ts` — `runEditAndPropose` **document branch** uses
+   `diffToBlockHunks` and tags each minted proposal `granularity:"block"`.
+5. `proposalController.ts` — `accept`: when `granularity === "block"`, re-resolve
+   the block text, `diffToHunks(blockText, replacement)` → per-run word sub-diff,
+   apply **one `applyAgentEdit` per changed run, descending offset** so only the
+   runs Claude changed land Claude-attributed; unchanged spans keep prior author
+   (INV-40). Non-block keeps the single `applyAgentEdit`.
+6. Tests: unit (`diffToBlockHunks` + INV-40 controller) + host E2E (#47 cases in
+   §6.8); update the existing f11 document-path E2E (now per-block, supersedes
+   INV-37 word-level expectation); `docs/MANUAL-SMOKE-F12.md` §2.
+
+**Design note (seam constraint):** `pendingEdits.matchEvent` resolves ONE
+registration per change event, so INV-40's per-run attribution is implemented as
+**sequential** `applyAgentEdit` calls (descending offset), not a single
+multi-replace `WorkspaceEdit`. The spec's "one undo-grouped edit" wording is thus
+approximated as N undo steps per block accept — see Deferred decisions.
+
+No new persisted artifact; no deploy pipeline (VS Code extension).
+
+## Results
+
+**SLICE-2 (#47, review, P1) shipped to `main`** — PR
+[#50](https://git.benstull.org/benstull/vscode-cowriting-plugin/pulls/50)
+(merged), issue #47 closed.
+
+- `trackChangesModel.ts` — new pure `diffToBlockHunks` (block-key alignment via
+  `diffArrays`/`diffBlocks` keying; isolated changed block → block-aligned hunk →
+  rewritten raw; fences atomic INV-23; insert/delete → exact gap-span hunk;
+  zero-width gap-span anchored INV-41). Split `diffToHunks` into raw
+  `wordEditHunks` + anchoring wrapper (fixes a latent overlap bug under batch apply).
+- `trackChangesPreview.ts` — document branch uses `diffToBlockHunks`, tags
+  `granularity:"block"`.
+- `model.ts`/`proposalModel.ts` — additive optional `Proposal.granularity`.
+- `proposalController.ts` — `acceptBlock`: intra-block word sub-diff
+  (`wordEditHunks`) → one `applyAgentEdit` per changed run, descending offset
+  (INV-40 word-precise attribution; unchanged spans keep prior author).
+- Tests: `diffToBlockHunks` unit (reconstruction/fence/add-remove); `f12Review`
+  host E2E (M→M, unchanged→none, fence atomic, INV-40, INV-41); updated f11
+  document-path E2E to per-block; `MANUAL-SMOKE-F12.md` §2.
+
+Verification: `tsc --noEmit` clean; **214 unit** green; **69/5 host E2E** green
+(main suite 65 → 69 net with the new F12 review tests).
+
+**Next:** SLICE-3 — #46 (accept-all, INV-42): `acceptAllProposals` (controller,
+descending-order, orphan-skip + report) + `cowriting.acceptAllProposals` command
+ preview toolbar **Accept all** button (`{type:"acceptAll"}` intent, shown ≥2
+pending).
+
+## Session arc
+
+1. **Claim.** Resumed via `/goal next` (after session 0043 shipped #42); claimed
+   session 0044 for #47. Clean `main` baseline.
+2. **Anchor gate.** #47 (`type/feature`) covered by the graduated combined design
+   → §4.3 R3 satisfied.
+3. **Deep code read.** `splitBlocks*`/`diffBlocks`/`diffToHunks`/`EditHunk`,
+   `runEditAndPropose`, `proposalController.accept`/`applyAgentEdit`, and crucially
+   `pendingEdits.matchEvent` (one registration per change event → drove the INV-40
+   sequential-apply decision).
+4. **TDD `diffToBlockHunks`.** First attempt (coarsen word-hunks) failed a
+   reconstruction case — discovered `diffToHunks` can emit OVERLAPPING hunks
+   (anchorInsertion over-absorbs). Switched to block-key alignment with
+   replacement-from-rewritten-raw → green.
+5. **Model + wiring + INV-40 accept.** Added `granularity`; document branch →
+   `diffToBlockHunks`; `acceptBlock` intra-block sub-diff. The overlap bug then
+   resurfaced in `acceptBlock` (batch apply) → split `diffToHunks` into raw
+   `wordEditHunks` (disjoint) + anchoring wrapper; `acceptBlock` uses raw → green.
+6. **Verified + shipped** (214 unit, 69/5 E2E), self-reviewed, PR #50 merged,
+   #47 closed, memory + transcript updated.
+
+## Deferred decisions
+
+_Autonomous-mode low-confidence calls the driver made and would have
+liked operator input on. Appended as the session runs; surfaced at
+finalize. Empty if none._
+
+- **INV-40 undo granularity** (driver call). Spec §6.2/§6.7 say accepting a block
+  proposal should be "one undo-grouped WorkspaceEdit." But the F3 seam's
+  `pendingEdits.matchEvent` matches exactly ONE registration per change event, so a
+  single `WorkspaceEdit` with N independent run-replaces can't carry per-run
+  attribution (the multi-hunk event fails to match any single registration → falls
+  through to human). Implemented INV-40 as **sequential per-run `applyAgentEdit`
+  calls, descending offset** — correct word-precise attribution, reuses the seam
+  with zero attribution-core risk, but a block accept is N undo steps rather than
+  one. Single-undo-step would require extending `matchEvent`/`onDidChange` to
+  consume multiple registrations per event (riskier F3 change) — left as a possible
+  follow-up.
@@ -0,0 +1,98 @@
+# Session 0045.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-13T08-04 (PST)
+> Type: planning-and-executing
+> End: 2026-06-13T08-17 (PST)
+> Status: **FINALIZED.**
+> Posture: autonomous (yolo)
+
+## Launch prompt
+
+```
+/goal plan-and-execute #46 (SLICE-3 of the document-edit flow — accept-all, INV-42), per specs/coauthoring-document-edit-flow.md
+
+```
+
+## Plan
+
+**SLICE-3 — #46 (accept)** of the document-edit flow
+(`specs/coauthoring-document-edit-flow.md` §7.2, INV-42). Final slice — completes
+reach→review→**accept**. Anchor: Feature #46 (`type/feature`); covered by the
+graduated combined design → §4.3 R3.
+
+A single **Accept all** gesture applies every pending proposal on the current
+document through the existing F4 `acceptById` seam (block proposals take the INV-40
+path automatically), in a re-anchor-safe (descending) order, **skipping** orphans
+and **reporting** applied-vs-skipped. Batched application of the existing path — no
+new accept mechanism; the webview posts intent only (INV-35).
+
+Tasks:
+1. `proposalController.ts` — `acceptAllProposals(document): Promise<{applied,
+   skipped}>`: snapshot pending, sort descending by resolved anchor start,
+   `acceptById` each **silently** (no per-item orphan warning), tally
+   applied/skipped (orphans counted skipped). Add a `silent` opt to the accept
+   path so the batch suppresses per-proposal warnings.
+2. `extension.ts` — `cowriting.acceptAllProposals` command (active doc) → reports
+   applied-vs-skipped via a status message.
+3. `trackChangesPreview.ts` — `ToolbarMsg += {type:"acceptAll"}`;
+   `handleWebviewMessage` routes it → `proposals.acceptAllProposals(document)` +
+   report.
+4. `media/preview.ts` + `shellHtml` — an **Accept all** toolbar button shown when
+   `summary.proposals >= 2` (and authorable), posting `{type:"acceptAll"}`.
+5. `package.json` — register the `cowriting.acceptAllProposals` command (palette,
+   markdown-gated).
+6. Tests: host E2E (N pending → all applied + cleared; orphan skipped + reported;
+   button hidden < 2 pending); `MANUAL-SMOKE-F12.md` §3.
+
+No new persisted artifact; no deploy pipeline (VS Code extension).
+
+## Results
+
+**SLICE-3 (#46, accept) shipped to `main`** — PR
+[#51](https://git.benstull.org/benstull/vscode-cowriting-plugin/pulls/51)
+(merged), issue #46 closed. **Completes the document-edit-flow cluster
+(#42 reach + #47 review + #46 accept).**
+
+- `proposalController.ts` — `acceptAllProposals(document)` → `{applied, skipped}`
+  (descending order, orphan-skip); `accept`/`acceptById` `silent` opt for the batch.
+- `trackChangesPreview.ts` — `ToolbarMsg += {type:"acceptAll"}` → public
+  `acceptAll(document)` (batch + report).
+- `extension.ts`/`package.json` — `cowriting.acceptAllProposals` command
+  (active doc, markdown-gated palette).
+- `media/preview.ts` + shell — "✓✓ Accept all" toolbar button (intent; shown
+  ≥2 pending, authorable, on-state).
+- `trackChangesModel.ts` — `diffToBlockHunks` fix: emit one block-aligned hunk
+  per changed block **even when adjacent** (changed blocks are 1:1 anchors;
+  gap-spans only cover add/remove runs) — caught by the accept-all E2E (3 adjacent
+  changed blocks were collapsing to 1 proposal).
+- `f12Accept.test.ts` E2E + `MANUAL-SMOKE-F12.md` §3.
+
+Verification: `tsc --noEmit` clean; **214 unit** green; **73/5 host E2E** green
+(main suite 69 → 73 with the new accept-all tests).
+
+**Next:** the cluster is complete; no in-flight next step. Open backlog includes
+#48 (pin → fully clean review panel, story P2) and the OQ-2 F11 (#43) spec
+graduation (hygiene). A natural hand-back point for operator direction.
+
+## Session arc
+
+1. **Claim.** Continued the rolling `next` goal after 0044 shipped #47; claimed
+   session 0045 for #46. Clean `main`.
+2. **Plan + implement.** Controller `acceptAllProposals` (+ `silent` accept opt);
+   `acceptAll` intent route + public method; command + package.json; "Accept all"
+   toolbar button (≥2-pending gating in the sealed webview).
+3. **E2E caught a real bug.** The accept-all "3 adjacent changed blocks" case
+   returned 1 proposal, not 3 — `diffToBlockHunks` was merging adjacent changed
+   blocks into one gap-span run. Fixed by treating `changed` blocks as 1:1 anchors
+   (each → its own block-aligned hunk; gap-spans only span add/remove runs).
+4. **Verified + shipped** (214 unit, 73/5 E2E), self-reviewed, PR #51 merged,
+   #46 closed → **cluster complete**; memory + transcript updated.
+
+## Deferred decisions
+
+_Autonomous-mode low-confidence calls the driver made and would have
+liked operator input on. Empty if none._
+
+- _No low-confidence calls this session._ (The `diffToBlockHunks` adjacency
+  behavior was a bug caught by the accept-all E2E, not a judgment call.)
@@ -0,0 +1,95 @@
+# Session 0046.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-13T08-19 (PST)
+> Type: planning-and-executing
+> End: 2026-06-13T08-31 (PST)
+> Status: **FINALIZED.**
+> Posture: autonomous (yolo)
+
+## Launch prompt
+
+```
+/goal plan-and-execute #48 (pinning the baseline leaves the review panel fully un-annotated — zero-diff → no F3 authorship colors on unchanged blocks; proposals still show)
+
+```
+
+## Plan
+
+**#48 (story, P2)** — pinning the baseline leaves the review panel fully
+un-annotated. Anchor: leaf `story` → §4.3 R2 (no design gate). Picked
+autonomously as the next backlog item after the document-edit-flow cluster shipped
+(0043/0044/0045).
+
+When `diffBlocks(baseline, current)` yields all-`unchanged` ops (zero diff — the
+state right after a pin), the F10 on-render still author-colors every block
+(`colorByAuthor`), so the panel looks painted instead of clean. Fix: in that
+zero-diff case render clean (no author coloring, no change marks) while keeping
+`data-src` mapping (INV-36) and still injecting pending proposals (proposals are
+actions, not annotations). Narrow edge case of INV-33 — with-changes render
+unchanged; off-state unchanged; broader "authorship never colors unchanged" NOT
+in scope.
+
+Tasks:
+1. `trackChangesModel.ts` `renderReview` — detect `ops.every(unchanged)`; in that
+   case use a plain `render` (skip `colorByAuthor`) for blocks; proposal injection
+   loop unchanged.
+2. Unit: baseline==current + author spans → no `cw-by-claude`/`cw-by-human` (and
+   no `cw-add`/`cw-del`) on the body; with a pending proposal → the `cw-proposal`
+   block still renders.
+3. Host E2E: open preview, diverge + author-color, pin → panel clean (no
+   green/blue); edit again → annotations return.
+4. Content repo: one-line INV-33 clarification (zero-diff → clean on-render) in
+   `specs/coauthoring-interactive-review.md`.
+
+No new persisted artifact; no deploy pipeline (VS Code extension).
+
+## Results
+
+**#48 (story, P2) shipped to `main`** — PR
+[#52](https://git.benstull.org/benstull/vscode-cowriting-plugin/pulls/52)
+(merged), issue #48 closed. Picked autonomously after the document-edit-flow
+cluster (0043/0044/0045).
+
+- `trackChangesModel.ts` — `renderReview` gains a `pinned` `RenderOption`; when
+  pinned + zero-diff, blocks render plain (skip `colorByAuthor`).
+- `trackChangesPreview.ts` — pass `{ pinned: baseline?.reason === "pinned" }`
+  from `refresh` + `renderHtmlFor`.
+- Unit (4 new) + `s48PinClean` host E2E.
+
+**Scoped to the pin specifically** (not all zero-diff): a baseline advanced by a
+**machine-landing** (accept) is also zero-diff but keeps its authorship coloring
+(F10 INV-33) — the F10 authorship E2E caught a pure-zero-diff rule would regress
+accepted-Claude-text coloring, so the clean render is gated on `reason ===
+"pinned"`.
+
+Verification: `tsc --noEmit` clean; **218 unit** green; **74/5 host E2E** green.
+
+## Session arc
+
+1. **Pick + claim.** Stop hook required determining/executing the next milestone
+   autonomously (rolling `next`); chose #48 (leaf story, no design gate) and
+   claimed 0046. Clean `main`.
+2. **Read the issue** (detailed, gave the solution shape) + `renderReview`.
+3. **TDD.** Implemented zero-diff-clean; full suite caught the F10 authorship
+   regression (accept advances baseline → zero-diff → coloring was being cleared);
+   re-scoped to `reason === "pinned"` via a `pinned` RenderOption → all green.
+4. **Shipped** (PR #52), closed #48; spec clarification written but left in the
+   content-repo working tree (see Deferred decisions).
+
+## Deferred decisions
+
+_Autonomous-mode low-confidence calls the driver made and would have
+liked operator input on. Empty if none._
+
+- **INV-33 clarification not pushed to the content repo** (loose end, not a
+  judgment call). Wrote the zero-diff-after-pin clarification into
+  `specs/coauthoring-interactive-review.md`, but the **content repo has
+  pre-existing uncommitted state that isn't this session's**: a modified
+  `coauthoring-diff-view.md` and ~18 untracked capture-session draft files
+  (`issues/*.md`, `specs/coauthoring-document-edit-flow.md`), and local `main` is
+  **6 behind origin**. A clean rebase would require deleting the operator's
+  untracked drafts (irreversible — a STOP gate), so I **soft-reset** my spec
+  commit into the working tree rather than force it. The clarification sits as an
+  uncommitted modification alongside the operator's other content-repo drafts,
+  for the operator to reconcile/push. The #48 **code** shipped normally.
@@ -0,0 +1,86 @@
+# Session 0047.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-13T08-34 (PST)
+> Type: planning-and-executing
+> End: 2026-06-13T08-44 (PST)
+> Status: **FINALIZED.**
+> Posture: autonomous (yolo)
+
+## Launch prompt
+
+```
+/goal plan-and-execute #33 (intra-emphasis sentinel hardening — token-aware fix for the 2 characterized failure modes)
+
+```
+
+## Plan
+
+**#33 (task, P3)** — harden the F9/F10 author-coloring PUA sentinels against
+intra-emphasis markdown. Anchor: leaf `task` → §4.3 R2 (no design gate). Picked
+autonomously (next clean plan-and-executable backlog item; doesn't touch the
+content repo). Approach = the token-aware fix recommended in the issue #33 comment.
+
+Two characterized failure modes (issue #33 comment, session 0032):
+- **CASE1** — a span boundary lands strictly inside a delimiter run (`a**b**c`,
+  boundary between the two `*`): the injected sentinel splits `**` → markdown parse
+  breaks (stray `<em></em>`, raw `**` left).
+- **CASE3** — a span boundary inside an emphasis run (`**bold**`, span covers
+  `**bo`): emphasis renders but the author `<span>` and `<strong>` **misnest**
+  (`<strong>bo</span>ld</strong>`).
+
+Fix (both needed):
+1. `injectSentinels` — **clamp** any sentinel offset that lands strictly inside a
+   markdown delimiter run (`* _ ~ \``) to the run's start, so a sentinel never
+   splits a delimiter (fixes CASE1). Skip now-zero-width spans.
+2. `sentinelsToSpans` — replace the naive split/join with a **token-aware walker**
+   over the rendered HTML: emit `cw-by-*` spans only around TEXT runs, closing the
+   span before any `<tag>` and reopening after, so a span never crosses an element
+   boundary (fixes CASE3 — one span segment per text run). Strip any stray sentinel
+   left inside a tag (no PUA leakage).
+
+Pure/vscode-free/deterministic (INV-33). Non-goals: link/attribute sentinel cases,
+visual language, attribution model.
+
+Tasks: unit tests reproducing CASE1 + CASE3 (+ regression on existing
+colorByAuthor/renderReview cases) → implement clamp + walker → green; spec already
+notes the hardening (§1.7/§9). No deploy pipeline (extension).
+
+## Results
+
+**#33 (task, P3) shipped to `main`** — PR
+[#53](https://git.benstull.org/benstull/vscode-cowriting-plugin/pulls/53)
+(merged), issue #33 closed. Picked autonomously (next clean plan-and-executable
+leaf; doesn't touch the content repo).
+
+- `trackChangesModel.ts` `injectSentinels` — clamp any sentinel offset landing
+  strictly inside a delimiter run (`* _ ~ \``) to the run's start (fixes CASE1
+  parse-break); drop spans that clamp to empty.
+- `trackChangesModel.ts` `sentinelsToSpans` — token-aware walker emitting the
+  `cw-by-*` span only around text runs, split at every `<tag>` boundary (fixes
+  CASE3 misnest); strays stripped (no PUA leak).
+- 4 new unit tests (CASE1/CASE3/CASE2-regression/no-leak), real markdown-it via
+  `renderReview`.
+
+Verification: `tsc --noEmit` clean; **222 unit** green; **74/5 host E2E** green;
+the F10/authorship E2E (`cw-by-claude`/`cw-by-human`) still pass (common case
+byte-identical).
+
+## Session arc
+
+1. Stop hook required autonomously determining/executing the next milestone;
+   chose #33 (leaf task, no content-repo dependency). Claimed 0047, clean `main`.
+2. Read issue #33 + its investigation comment (2 failure modes, recommended
+   token-aware approach) + session 0032 characterization + the sentinel code.
+3. TDD: CASE1/CASE3 reproduced red → implemented clamp + walker → green; full
+   suite + E2E green; self-reviewed (one pure module).
+4. Shipped (PR #53), closed #33.
+
+## Deferred decisions
+
+_Autonomous-mode low-confidence calls the driver made and would have
+liked operator input on. Empty if none._
+
+- _No low-confidence calls this session._ (Approach was the one recommended in the
+  issue #33 comment; the fix is a pure-module robustness change with full test
+  coverage and no regression.)
@@ -1,17 +1,20 @@
-# Session 0038.0 — Transcript
+# Session 0048.0 — Transcript

 > App: vscode-cowriting-plugin
-> Start: 2026-06-12T15-55 (PST)
+> Start: 2026-06-13T08-45 (PST)
 > Type: planning-and-executing
 > Status: **PLACEHOLDER — claimed at session start; finalized at session end.**
 >
-> This file reserves session ID 0038 for vscode-cowriting-plugin. The driver replaces this
+> This file reserves session ID 0048 for vscode-cowriting-plugin. The driver replaces this
 > body with the full transcript and renames the file to its final
-> SESSION-0038.0-TRANSCRIPT-2026-06-12T15-55--<end>.md form at session end.
+> SESSION-0048.0-TRANSCRIPT-2026-06-13T08-45--<end>.md form at session end.

 ## Launch prompt

-_(launch prompt not captured at claim time)_
+```
+/goal plan-and-execute #40 (restore exact author attribution on undo/redo — follow-up to #38)
+
+```

 ## Deferred decisions

@@ -112,5 +112,35 @@
  },
  "0038": {
    "title": ""
+  },
+  "0039": {
+    "title": ""
+  },
+  "0040": {
+    "title": ""
+  },
+  "0041": {
+    "title": ""
+  },
+  "0042": {
+    "title": ""
+  },
+  "0043": {
+    "title": ""
+  },
+  "0044": {
+    "title": ""
+  },
+  "0045": {
+    "title": ""
+  },
+  "0046": {
+    "title": ""
+  },
+  "0047": {
+    "title": ""
+  },
+  "0048": {
+    "title": ""
  }
 }
@@ -44,8 +44,19 @@ interface DocAttribution {
   * orphans on reload).
   */
  hadAttributions: boolean;
+  /**
+   * #40: text-keyed attribution snapshots for exact provenance restoration on
+   * undo/redo. Maps a document-text state → the live spans at that state (offsets
+   * valid for that exact text). Captured after every forward edit + at load;
+   * consulted on undo/redo to restore the matching state's spans. Bounded (oldest
+   * evicted) — a far-back/evicted state falls back to the #38 neutral reconcile.
+   */
+  attrHistory: Map<string, LiveSpan[]>;
 }

+/** #40: cap on the per-doc attribution-snapshot history (oldest evicted). */
+const ATTR_HISTORY_MAX = 200;
+
 export class AttributionController implements vscode.Disposable {
  private readonly disposables: vscode.Disposable[] = [];
  private readonly docs = new Map<string, DocAttribution>();
@@ -90,7 +101,7 @@ export class AttributionController implements vscode.Disposable {
  private state(docPath: string): DocAttribution {
    let s = this.docs.get(docPath);
    if (!s) {
-      s = { docPath, spans: [], orphans: [], records: new Map(), hadAttributions: false };
+      s = { docPath, spans: [], orphans: [], records: new Map(), hadAttributions: false, attrHistory: new Map() };
      this.docs.set(docPath, s);
    }
    return s;
@@ -125,6 +136,9 @@ export class AttributionController implements vscode.Disposable {
      s.spans = coalesce(s.spans);
      if (artifact.attributions.length > 0) s.hadAttributions = true;
    }
+    // #40: seed the snapshot history with the loaded state so undoing back to it
+    // restores its exact attribution.
+    this.snapshotAttribution(s, document.getText());
    this.render(document);
  }

@@ -140,6 +154,17 @@ export class AttributionController implements vscode.Disposable {

  // ---- PUC-1/PUC-3: live tracking ---------------------------------------------------

+  /** #40: snapshot the current spans keyed by the document's current text. */
+  private snapshotAttribution(s: DocAttribution, text: string): void {
+    s.attrHistory.delete(text); // re-insert at the end (recency order)
+    s.attrHistory.set(text, s.spans.map((sp) => ({ ...sp })));
+    while (s.attrHistory.size > ATTR_HISTORY_MAX) {
+      const oldest = s.attrHistory.keys().next().value as string | undefined;
+      if (oldest === undefined) break;
+      s.attrHistory.delete(oldest);
+    }
+  }
+
  private onDidChange(e: vscode.TextDocumentChangeEvent): void {
    if (!this.isTracked(e.document) || e.contentChanges.length === 0) return;
    const docPath = this.keyOf(e.document);
@@ -202,6 +227,18 @@ export class AttributionController implements vscode.Disposable {
        );
      }
    }
+    // #40: exact provenance across history navigation. After a FORWARD edit,
+    // snapshot the new state's spans. On UNDO/REDO, the geometry reconcile above
+    // left re-inserted text neutral (#38); if a snapshot's text equals the current
+    // buffer, restore that state's spans exactly (offsets are valid — identical
+    // text) so Claude's restored text is blue again, the human's green. No match
+    // (far-back/evicted state) keeps the #38 neutral fallback.
+    if (isUndoRedo) {
+      const restored = s.attrHistory.get(e.document.getText());
+      if (restored) s.spans = restored.map((sp) => ({ ...sp }));
+    } else {
+      this.snapshotAttribution(s, e.document.getText());
+    }
    if (s.spans.length > 0) s.hadAttributions = true;
    this.render(e.document);
  }
@@ -107,6 +107,20 @@ export function activate(context: vscode.ExtensionContext): CowritingApi | undef
  );
  context.subscriptions.push(trackChangesPreviewController);

+  // #46 (INV-42): accept every pending proposal on the active doc in one gesture
+  // (also reachable from the preview toolbar's "Accept all" button). Reuses the
+  // batched F4 seam + reports applied-vs-skipped.
+  context.subscriptions.push(
+    vscode.commands.registerCommand("cowriting.acceptAllProposals", async () => {
+      const doc = vscode.window.activeTextEditor?.document;
+      if (!doc || doc.languageId !== "markdown") {
+        void vscode.window.showWarningMessage("Cowriting: open a Markdown document to accept its proposals.");
+        return;
+      }
+      await trackChangesPreviewController.acceptAll(doc);
+    }),
+  );
+
  // --- F6 machine-landing wiring — now for ANY authorable doc ---
  // The seam's single machine-landing signal advances the F6 baseline (INV-18);
  // the seam can now fire on out-of-folder files too, so wire it unconditionally.
@@ -90,6 +90,13 @@ export interface Proposal {
  turnId?: string;
  /** what the human asked for (review context). */
  instruction?: string;
+  /**
+   * F12/#47 (INV-39/40): the review-decision unit this proposal represents.
+   * `"block"` ⇒ the anchor spans a whole document block and accept reconciles
+   * attribution per WORD inside it (INV-40); `"single"` (or absent, for
+   * back-compat with older sidecars) ⇒ a single-range proposal accepted whole.
+   */
+  granularity?: "block" | "single";
 }

 export interface Artifact {
@@ -18,7 +18,7 @@ import { addProposal, removeProposal } from "./proposalModel";
 import type { AttributionController } from "./attributionController";
 import type { VersionGuard } from "./versionGuard";
 import { isAuthorable } from "./workspacePath";
-import type { ProposalView } from "./trackChangesModel";
+import { wordEditHunks, type ProposalView } from "./trackChangesModel";

 /** Test-facing snapshot of what is currently rendered for a document. */
 export interface RenderedProposal {
@@ -122,7 +122,7 @@ export class ProposalController implements vscode.Disposable {
    fp: Fingerprint,
    replacement: string,
    author: Provenance,
-    opts?: { turnId?: string; instruction?: string },
+    opts?: { turnId?: string; instruction?: string; granularity?: "block" | "single" },
  ): Promise<string | undefined> {
    if (!this.isTracked(document)) return undefined;
    if (this.guard.isReadOnly(this.keyOf(document))) return undefined;
@@ -138,9 +138,40 @@ export class ProposalController implements vscode.Disposable {
  // ---- PUC-2/PUC-3: accept / reject (INV-11/INV-12) ----------------------------------

  /** Accept by proposal id (test-facing twin of the thread-menu gesture). */
-  async acceptById(docPath: string, proposalId: string): Promise<boolean> {
+  async acceptById(docPath: string, proposalId: string, opts?: { silent?: boolean }): Promise<boolean> {
    const hit = this.byId(docPath, proposalId);
-    return hit ? this.accept(hit.state, hit.proposal) : false;
+    return hit ? this.accept(hit.state, hit.proposal, opts) : false;
+  }
+
+  /**
+   * #46 (INV-42): accept EVERY pending proposal on a document in one gesture — a
+   * batched application of the existing `acceptById` seam, not a new mechanism.
+   * Block proposals take the INV-40 word-precise path automatically. Applied in
+   * DESCENDING anchor order so an earlier accept never invalidates a later one's
+   * offsets; proposals whose anchor can't resolve are SKIPPED (never force-applied)
+   * and counted. Returns the applied-vs-skipped tally for the caller to report.
+   */
+  async acceptAllProposals(document: vscode.TextDocument): Promise<{ applied: number; skipped: number }> {
+    if (!this.isTracked(document)) return { applied: 0, skipped: 0 };
+    const state = this.ensureState(document);
+    state.artifact = this.store.load(state.docPath) ?? emptyArtifact(state.docPath);
+    const text = document.getText();
+    const items = state.artifact.proposals.map((p) => {
+      const fp = state.artifact.anchors[p.anchorId]?.fingerprint;
+      const resolved = fp ? resolve(text, fp) : "orphaned";
+      return { id: p.id, start: resolved === "orphaned" ? null : resolved.start };
+    });
+    const resolvable = items
+      .filter((i): i is { id: string; start: number } => i.start !== null)
+      .sort((a, b) => b.start - a.start);
+    let applied = 0;
+    let skipped = items.length - resolvable.length; // orphans, skipped up front
+    for (const it of resolvable) {
+      // silent: one batch report stands in for N per-proposal warnings.
+      if (await this.acceptById(state.docPath, it.id, { silent: true })) applied++;
+      else skipped++;
+    }
+    return { applied, skipped };
  }
  /** Reject by proposal id (test-facing twin of the thread-menu gesture). */
  rejectById(docPath: string, proposalId: string): boolean {
@@ -150,7 +181,7 @@ export class ProposalController implements vscode.Disposable {
    return true;
  }

-  private async accept(state: DocState, proposal: Proposal): Promise<boolean> {
+  private async accept(state: DocState, proposal: Proposal, opts?: { silent?: boolean }): Promise<boolean> {
    if (this.guard.isReadOnly(state.docPath)) return false;
    const document = this.openDoc(state);
    if (!document) return false;
@@ -158,22 +189,32 @@ export class ProposalController implements vscode.Disposable {
    const fp = state.artifact.anchors[proposal.anchorId]?.fingerprint;
    const resolved = fp ? resolve(document.getText(), fp) : "orphaned";
    if (resolved === "orphaned") {
-      void vscode.window.showWarningMessage(
-        "Cowriting: this proposal's target text changed or is missing — undo to restore it, or reject to discard (it is never applied by guess).",
-      );
+      // #46: accept-all suppresses per-proposal warnings (one batch report instead).
+      if (!opts?.silent)
+        void vscode.window.showWarningMessage(
+          "Cowriting: this proposal's target text changed or is missing — undo to restore it, or reject to discard (it is never applied by guess).",
+        );
      this.renderAll(document);
      return false;
    }
-    const range = new vscode.Range(document.positionAt(resolved.start), document.positionAt(resolved.end));
-    // No awaits between resolve and the seam call: document.version is current.
-    const ok = await this.attribution.applyAgentEdit(document, range, proposal.replacement, proposal.author, {
-      expectedVersion: document.version,
-      turnId: proposal.turnId,
-    });
+    // #47 (INV-40): a BLOCK proposal applies the whole block but attributes only
+    // the words Claude actually changed; a single proposal applies its whole range.
+    const ok =
+      proposal.granularity === "block"
+        ? await this.acceptBlock(document, resolved, proposal)
+        : await this.attribution.applyAgentEdit(
+            document,
+            new vscode.Range(document.positionAt(resolved.start), document.positionAt(resolved.end)),
+            proposal.replacement,
+            proposal.author,
+            // No awaits between resolve and the seam call: document.version is current.
+            { expectedVersion: document.version, turnId: proposal.turnId },
+          );
    if (!ok) {
-      void vscode.window.showWarningMessage(
-        "Cowriting: the editor rejected the accept — the proposal is still pending.",
-      );
+      if (!opts?.silent)
+        void vscode.window.showWarningMessage(
+          "Cowriting: the editor rejected the accept — the proposal is still pending.",
+        );
      return false;
    }
    this.store.update(state.docPath, (a) => removeProposal(a, proposal.id));
@@ -181,6 +222,41 @@ export class ProposalController implements vscode.Disposable {
    return true;
  }

+  /**
+   * #47 (INV-40): accept a BLOCK proposal — apply Claude's whole block, but
+   * attribute ONLY the runs Claude actually changed. The block is the DECISION
+   * unit; the word is the ATTRIBUTION unit. An intra-block word sub-diff
+   * (`wordEditHunks`, the raw engine INV-37 used, repurposed — un-anchored so the
+   * runs stay disjoint for a batch apply) yields the changed runs; each lands
+   * through the F4 seam (Claude-attributed), applied last-position-first so an
+   * earlier run's offsets stay valid under the later ones. Unchanged spans within
+   * the block are never touched, so their prior authorship stands. (Each run is
+   * one seam edit / one undo step — see the spec's deferred note on undo grouping.)
+   */
+  private async acceptBlock(
+    document: vscode.TextDocument,
+    resolved: OffsetRange,
+    proposal: Proposal,
+  ): Promise<boolean> {
+    const blockText = document.getText(
+      new vscode.Range(document.positionAt(resolved.start), document.positionAt(resolved.end)),
+    );
+    const subHunks = wordEditHunks(blockText, proposal.replacement);
+    if (subHunks.length === 0) return true; // block already equals the proposal — nothing to attribute
+    for (const h of [...subHunks].sort((a, b) => b.start - a.start)) {
+      const range = new vscode.Range(
+        document.positionAt(resolved.start + h.start),
+        document.positionAt(resolved.start + h.end),
+      );
+      const ok = await this.attribution.applyAgentEdit(document, range, h.replacement, proposal.author, {
+        expectedVersion: document.version,
+        turnId: proposal.turnId,
+      });
+      if (!ok) return false;
+    }
+    return true;
+  }
+
  private reject(state: DocState, proposal: Proposal): void {
    if (this.guard.isReadOnly(state.docPath)) return;
    this.store.update(state.docPath, (a) => removeProposal(a, proposal.id));
@@ -12,7 +12,7 @@ export function addProposal(
  fp: Fingerprint,
  replacement: string,
  author: Provenance,
-  opts?: { turnId?: string; instruction?: string },
+  opts?: { turnId?: string; instruction?: string; granularity?: "block" | "single" },
 ): { proposalId: string; anchorId: string } {
  const anchorId = newId("a");
  const proposalId = newId("pr");
@@ -25,6 +25,7 @@ export function addProposal(
    createdAt: new Date().toISOString(),
    ...(opts?.turnId !== undefined ? { turnId: opts.turnId } : {}),
    ...(opts?.instruction !== undefined ? { instruction: opts.instruction } : {}),
+    ...(opts?.granularity !== undefined ? { granularity: opts.granularity } : {}),
  });
  return { proposalId, anchorId };
 }
@@ -223,11 +223,27 @@ export interface EditHunk {
 * never part of another hunk.
 */
 export function diffToHunks(currentText: string, rewrittenText: string): EditHunk[] {
+  return wordEditHunks(currentText, rewrittenText).map((h) =>
+    h.start === h.end ? anchorInsertion(h, currentText) : h,
+  );
+}
+
+/**
+ * The raw word-level diff underlying `diffToHunks`: disjoint, ordered EditHunks
+ * that exactly partition the change (a pure insertion stays ZERO-WIDTH at its
+ * offset — not anchored). `diffToHunks` adds anchoring on top so each hunk's F4
+ * fingerprint resolves; callers that apply hunks directly through the seam
+ * (INV-40's intra-block accept) want THESE raw, non-overlapping hunks instead —
+ * anchoring can grow an insertion to absorb a token an adjacent hunk also edits,
+ * which corrupts a batch apply. Pure, vscode-free, deterministic. Applying these
+ * right→left reconstructs `rewrittenText` exactly.
+ */
+export function wordEditHunks(currentText: string, rewrittenText: string): EditHunk[] {
  const hunks: EditHunk[] = [];
  let offset = 0;
  let open: EditHunk | null = null;
  const flush = () => {
-    if (open) hunks.push(open.start === open.end ? anchorInsertion(open, currentText) : open);
+    if (open) hunks.push(open);
    open = null;
  };
  for (const part of diffWordsWithSpace(currentText, rewrittenText)) {
@@ -272,6 +288,115 @@ function anchorInsertion(hunk: EditHunk, text: string): EditHunk {
  return { start: s, end: p, replacement: text.slice(s, p) + hunk.replacement };
 }

+type BlockAlignKind = "unchanged" | "changed" | "removed" | "added";
+interface BlockAlignOp {
+  kind: BlockAlignKind;
+  ci?: number; // index into the current blocks
+  ni?: number; // index into the rewritten blocks
+}
+
+/**
+ * Align two block sequences by normalized key (jsdiff `diffArrays`), pairing an
+ * adjacent removed-then-added run element-wise into `changed` ops (the surplus
+ * staying `removed` / `added`) — the same pairing `diffBlocks` uses, but yielding
+ * index ops so the caller can read each side's source range. Pure.
+ */
+function alignBlocks(cur: BlockWithRange[], next: BlockWithRange[]): BlockAlignOp[] {
+  const changes = diffArrays(
+    cur.map((b) => b.key),
+    next.map((b) => b.key),
+  );
+  const ops: BlockAlignOp[] = [];
+  let bi = 0; // current index
+  let ci = 0; // rewritten index
+  for (let n = 0; n < changes.length; n++) {
+    const ch = changes[n];
+    const count = ch.count ?? ch.value.length;
+    if (!ch.added && !ch.removed) {
+      for (let k = 0; k < count; k++) ops.push({ kind: "unchanged", ci: bi++, ni: ci++ });
+      continue;
+    }
+    if (ch.removed) {
+      const nx = changes[n + 1];
+      const addCount = nx?.added ? (nx.count ?? nx.value.length) : 0;
+      const paired = Math.min(count, addCount);
+      for (let k = 0; k < paired; k++) ops.push({ kind: "changed", ci: bi++, ni: ci++ });
+      for (let k = paired; k < count; k++) ops.push({ kind: "removed", ci: bi++ });
+      for (let k = paired; k < addCount; k++) ops.push({ kind: "added", ni: ci++ });
+      if (nx?.added) n++;
+      continue;
+    }
+    for (let k = 0; k < count; k++) ops.push({ kind: "added", ni: ci++ });
+  }
+  return ops;
+}
+
+/**
+ * #47 (INV-39, §6.4): diff a whole-document rewrite into ONE EditHunk per CHANGED
+ * BLOCK — the unit a human reviews — rather than per word (which INV-37/`diffToHunks`
+ * did and this supersedes for document edits). Built by aligning both sides into
+ * the existing block units (`splitBlocksWithRanges`) and keying with the same diff
+ * as `diffBlocks`:
+ *  - a CHANGED block (1:1 aligned, even when adjacent to other changed blocks) → a
+ *    block-aligned hunk `[block.start, block.end)` → the rewritten block's raw
+ *    text. A code/mermaid fence is one such whole-block hunk (atomic, INV-23). So
+ *    a copy-edit pass touching N consecutive paragraphs yields N proposals.
+ *  - a run of block INSERTIONS / DELETIONS → one gap-span hunk covering the source
+ *    between the bounding aligned blocks (unchanged OR changed — both are 1:1
+ *    anchors) → the matching rewritten span (separators included), so
+ *    reconstruction stays exact. A zero-width gap-span (insert at a seamless
+ *    boundary) is anchored to an adjacent token (INV-41) so its F4 fingerprint
+ *    resolves and it accepts.
+ *  - unchanged blocks (same key AND same raw) → no hunk.
+ * Pure, vscode-free, deterministic; same `EditHunk` shape as `diffToHunks` (which
+ * is RETAINED as the intra-block sub-diff engine for word-precise accept
+ * attribution — INV-40). Applying all hunks right→left reconstructs `rewrittenText`
+ * exactly.
+ */
+export function diffToBlockHunks(currentText: string, rewrittenText: string): EditHunk[] {
+  const cur = splitBlocksWithRanges(currentText);
+  const next = splitBlocksWithRanges(rewrittenText);
+  const ops = alignBlocks(cur, next);
+  // Same key but different raw (whitespace/case) is still a real content change.
+  for (const op of ops) {
+    if (op.kind === "unchanged" && cur[op.ci!].raw !== next[op.ni!].raw) op.kind = "changed";
+  }
+  // `changed` and `unchanged` are 1:1 anchors (both sides' offsets are known);
+  // `added`/`removed` have no counterpart and must be spanned together.
+  const isAnchor = (op: BlockAlignOp) => op.kind === "unchanged" || op.kind === "changed";
+  const hunks: EditHunk[] = [];
+  let i = 0;
+  while (i < ops.length) {
+    const op = ops[i];
+    if (op.kind === "unchanged") {
+      i++;
+      continue;
+    }
+    if (op.kind === "changed") {
+      const c = cur[op.ci!];
+      hunks.push({ start: c.start, end: c.end, replacement: next[op.ni!].raw });
+      i++;
+      continue;
+    }
+    // A maximal run of added/removed blocks → one gap-span hunk over the source
+    // between the bounding anchors (or the document edges), replaced with the
+    // matching rewritten span, so the separators reconstruct exactly.
+    let j = i;
+    while (j < ops.length && !isAnchor(ops[j])) j++;
+    const prev = i > 0 ? ops[i - 1] : null; // an anchor by construction
+    const after = j < ops.length ? ops[j] : null; // an anchor (or null at EOF)
+    const curStart = prev ? cur[prev.ci!].end : 0;
+    const curEnd = after ? cur[after.ci!].start : currentText.length;
+    const newStart = prev ? next[prev.ni!].end : 0;
+    const newEnd = after ? next[after.ni!].start : rewrittenText.length;
+    const hunk: EditHunk = { start: curStart, end: curEnd, replacement: rewrittenText.slice(newStart, newEnd) };
+    hunks.push(hunk.start === hunk.end ? anchorInsertion(hunk, currentText) : hunk);
+    i = j;
+  }
+  hunks.sort((a, b) => a.start - b.start);
+  return hunks;
+}
+
 const md = new MarkdownIt({ html: true, linkify: false, breaks: false });
 // mermaid fences → <pre class="mermaid">SRC</pre> for client-side rendering; all
 // other fences fall through to markdown-it's default (escaped <pre><code>).
@@ -316,6 +441,14 @@ function wordMergedMarkdown(beforeRaw: string, afterRaw: string): string {
 export interface RenderOptions {
  /** Per-block markdown→HTML renderer (test seam). Defaults to the bundled markdown-it. */
  render?: (src: string) => string;
+  /**
+   * #48: the baseline was just PINNED (`reason === "pinned"`). With zero changes
+   * since that pin, the on-render is fully clean — no authorship coloring — so a
+   * pin reads as "this is my clean starting point". Distinct from a baseline
+   * advanced by a machine-landing (accept), which keeps its authorship coloring
+   * (F10 INV-33). Only consulted by `renderReview`.
+   */
+  pinned?: boolean;
 }

 function defaultRender(src: string): string {
@@ -412,13 +545,33 @@ function authorBadge(authors: Set<AuthorKind>): { cls: string; label: string } |
    : { cls: "cw-by-human", label: "You" };
 }

+// Markdown emphasis / code delimiters whose RUNS must never be split by an
+// injected sentinel — a sentinel between two run chars (e.g. `*|*`) breaks
+// markdown-it's delimiter pairing (#33 CASE1).
+const isDelimChar = (c: string): boolean => c === "*" || c === "_" || c === "~" || c === "`";
+
+/**
+ * #33 (CASE1): a sentinel must not land STRICTLY INSIDE a delimiter run. If `at`
+ * sits between two identical delimiter chars, snap it to the run's start (a
+ * position outside the run) so the run stays intact. Delimiters are invisible once
+ * rendered, so snapping only shifts the colored boundary across markup, never over
+ * visible text.
+ */
+function clampOffDelimiterRun(raw: string, at: number): number {
+  if (at <= 0 || at >= raw.length) return at;
+  if (!(isDelimChar(raw[at]) && raw[at - 1] === raw[at])) return at;
+  let p = at;
+  while (p > 0 && raw[p - 1] === raw[at]) p--;
+  return p;
+}
+
 /** Inject paired sentinels into a prose block's raw text for the spans clipped to it. */
 function injectSentinels(raw: string, blockStart: number, spans: AuthorSpan[]): string {
  const inserts: { at: number; marker: string }[] = [];
  for (const s of spans) {
-    const lo = Math.max(0, s.start - blockStart);
-    const hi = Math.min(raw.length, s.end - blockStart);
-    if (hi <= lo) continue;
+    const lo = clampOffDelimiterRun(raw, Math.max(0, s.start - blockStart));
+    const hi = clampOffDelimiterRun(raw, Math.min(raw.length, s.end - blockStart));
+    if (hi <= lo) continue; // empty (or clamped to empty) span contributes nothing
    inserts.push({ at: lo, marker: SENT[s.author].open });
    inserts.push({ at: hi, marker: SENT[s.author].close });
  }
@@ -431,13 +584,69 @@ function injectSentinels(raw: string, blockStart: number, spans: AuthorSpan[]):
  return out;
 }

-/** Replace the rendered sentinels with author <span> tags. */
+const SENTINEL_OF: Record<string, { author: AuthorKind; open: boolean } | undefined> = {
+  [SENT.claude.open]: { author: "claude", open: true },
+  [SENT.claude.close]: { author: "claude", open: false },
+  [SENT.human.open]: { author: "human", open: true },
+  [SENT.human.close]: { author: "human", open: false },
+};
+const ALL_SENTINELS = new RegExp(
+  `[${SENT.claude.open}${SENT.claude.close}${SENT.human.open}${SENT.human.close}]`,
+  "g",
+);
+
+/**
+ * #33: token-aware replacement of the rendered author sentinels with `cw-by-*`
+ * spans. A naive global string-replace (the old approach) could emit a span that
+ * CROSSES an element boundary — `<span><strong>bo</span>ld</strong>` — when a
+ * boundary fell inside an emphasis run (CASE3). This walks the rendered HTML and
+ * emits the author span only around TEXT runs, CLOSING it before any `<tag>` and
+ * REOPENING it after, so a span is always well-nested within the inline elements
+ * (one `<span>` segment per text run). Tags are copied verbatim (with any stray
+ * sentinel stripped, so no Private-Use-Area char ever leaks). Pure, deterministic.
+ */
 function sentinelsToSpans(html: string): string {
-  return html
-    .split(SENT.claude.open).join('<span class="cw-by-claude">')
-    .split(SENT.claude.close).join("</span>")
-    .split(SENT.human.open).join('<span class="cw-by-human">')
-    .split(SENT.human.close).join("</span>");
+  const out: string[] = [];
+  let current: AuthorKind | null = null; // which author region we're inside
+  let spanOpen = false; // whether a <span> is currently open in `out`
+  const openSpan = () => {
+    if (current && !spanOpen) {
+      out.push(`<span class="cw-by-${current}">`);
+      spanOpen = true;
+    }
+  };
+  const closeSpan = () => {
+    if (spanOpen) {
+      out.push("</span>");
+      spanOpen = false;
+    }
+  };
+  for (let i = 0; i < html.length; i++) {
+    const ch = html[i];
+    const sentinel = SENTINEL_OF[ch];
+    if (sentinel) {
+      if (sentinel.open) current = sentinel.author; // span opens lazily before the next text char
+      else {
+        closeSpan();
+        current = null;
+      }
+      continue;
+    }
+    if (ch === "<") {
+      // An HTML tag: never let an author span straddle it (text `<` is escaped to
+      // &lt;, so a raw `<` is always a real tag). Copy the tag verbatim, sentinel-free.
+      closeSpan();
+      const gt = html.indexOf(">", i);
+      const end = gt === -1 ? html.length - 1 : gt;
+      out.push(html.slice(i, end + 1).replace(ALL_SENTINELS, ""));
+      i = end;
+      continue;
+    }
+    openSpan();
+    out.push(ch);
+  }
+  closeSpan();
+  return out.join("");
 }

 /**
@@ -548,6 +757,14 @@ export function renderReview(
  const render = opts.render ?? defaultRender;
  const ranges = splitBlocksWithRanges(currentText);
  const ops = diffBlocks(baselineText, currentText);
+  // #48: right after a PIN (baseline reason "pinned") with no changes since, the
+  // panel is fully clean: no change marks (already absent) AND no authorship
+  // coloring, so the pin reads as "this is my clean starting point". Skip
+  // colorByAuthor for every block in this case; data-src mapping and any pending
+  // proposals (review actions, not annotations) are kept below. A baseline advanced
+  // by a machine-landing (accept) is ALSO zero-diff but is NOT pinned — it keeps
+  // its authorship coloring (F10 INV-33), so this is gated on the pin specifically.
+  const clean = opts.pinned === true && ops.every((o) => o.kind === "unchanged");

  // Associate each resolved proposal with the current-side block index whose range
  // it anchors into: the largest block with start <= anchorStart (the containing
@@ -578,7 +795,7 @@ export function renderReview(
    const blockIndex = op.kind === "removed" ? -1 : ci;
    const blk = op.kind === "removed" ? undefined : ranges[ci++];
    const colored = (raw: string): string =>
-      blk ? colorByAuthor(raw, blk.start, authorSpans, render) : render(raw);
+      blk && !clean ? colorByAuthor(raw, blk.start, authorSpans, render) : render(raw);
    bodyParts.push(renderReviewOp(op, render, colored, srcAttr(blk)));
    const here = blockIndex >= 0 ? byBlock.get(blockIndex) : undefined;
    if (here) for (const p of here) bodyParts.push(proposalBlockHtml(p, render));
@@ -13,7 +13,7 @@ import * as vscode from "vscode";
 import type { DiffViewController } from "./diffViewController";
 import type { AttributionController } from "./attributionController";
 import type { ProposalController } from "./proposalController";
-import { renderReview, renderPlain, diffBlocks, diffToHunks, type BlockOp } from "./trackChangesModel";
+import { renderReview, renderPlain, diffBlocks, diffToBlockHunks, type BlockOp } from "./trackChangesModel";
 import { buildFingerprint } from "./anchorer";
 import { isAuthorable } from "./workspacePath";
 import type { EditTurnResult } from "./liveTurn";
@@ -37,7 +37,8 @@ type ToolbarMsg =
  | { type: "reject"; proposalId: string }
  | { type: "pinBaseline" }
  | { type: "askClaude"; scope: "document" }
-  | { type: "askClaude"; scope: "selection"; start: number; end: number };
+  | { type: "askClaude"; scope: "selection"; start: number; end: number }
+  | { type: "acceptAll" };

 export class TrackChangesPreviewController implements vscode.Disposable {
  private readonly disposables: vscode.Disposable[] = [];
@@ -71,14 +72,28 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    this.disposables.push(
      // F11 (SLICE-5): the editor/title gateway passes the tab's resource Uri;
      // the palette / keybinding pass nothing → fall back to the active editor.
-      vscode.commands.registerCommand("cowriting.showTrackChangesPreview", (uri?: vscode.Uri) => {
-        const byUri = uri && vscode.workspace.textDocuments.find((d) => d.uri.toString() === uri.toString());
-        this.show(byUri || vscode.window.activeTextEditor?.document);
+      // #41: the explorer/tab right-click also passes the clicked Uri, which may
+      // not be an open document yet — open it so we preview the clicked file, not
+      // whatever happens to be the active editor.
+      vscode.commands.registerCommand("cowriting.showTrackChangesPreview", async (uri?: vscode.Uri) => {
+        if (uri) {
+          const open = vscode.workspace.textDocuments.find((d) => d.uri.toString() === uri.toString());
+          this.show(open ?? (await vscode.workspace.openTextDocument(uri)));
+          return;
+        }
+        this.show(vscode.window.activeTextEditor?.document);
      }),
-      // F11: document-scoped Ask-Claude (also reused by #42's gateway). Edits the
-      // active markdown doc; the rewrite is diffed into per-hunk F4 proposals.
-      vscode.commands.registerCommand("cowriting.editDocument", () => {
-        const doc = vscode.window.activeTextEditor?.document;
+      // F11: document-scoped Ask-Claude (also reused by #42's reach gateways).
+      // Edits a markdown doc; the rewrite is diffed into F4 proposals.
+      // #42 (INV-38): the editor/title/context (tab) entry passes the clicked
+      // tab's resource Uri — target THAT document, opening it if it isn't already
+      // an open buffer (mirrors showTrackChangesPreview's #41 resolution); the
+      // palette / keybinding / editor/context pass nothing → the active editor.
+      vscode.commands.registerCommand("cowriting.editDocument", async (uri?: vscode.Uri) => {
+        const doc = uri
+          ? vscode.workspace.textDocuments.find((d) => d.uri.toString() === uri.toString()) ??
+            (await vscode.workspace.openTextDocument(uri))
+          : vscode.window.activeTextEditor?.document;
        if (!doc || !this.isMarkdown(doc)) {
          void vscode.window.showWarningMessage("Cowriting: open a Markdown document to ask Claude to edit it.");
          return;
@@ -176,9 +191,29 @@ export class TrackChangesPreviewController implements vscode.Disposable {
      const target: EditTarget =
        m.scope === "selection" ? { kind: "range", start: m.start, end: m.end } : { kind: "document" };
      void this.askClaude(document, target);
+    } else if (m?.type === "acceptAll") {
+      // #46 (INV-42): batch-accept every pending proposal on this doc, then report.
+      void this.acceptAll(document);
    }
  }

+  /**
+   * #46 (INV-42): apply every pending proposal on the document through the F4
+   * accept seam (orphan-skip) and report the applied-vs-skipped tally. No
+   * confirmation dialog — VS Code undo restores (parity with single accept).
+   * Public so the `cowriting.acceptAllProposals` command can reach it for the
+   * active doc (not only the webview button).
+   */
+  async acceptAll(document: vscode.TextDocument): Promise<void> {
+    const { applied, skipped } = await this.proposals.acceptAllProposals(document);
+    this.refresh(document);
+    if (applied === 0 && skipped === 0) return;
+    const skipNote = skipped > 0 ? `, ${skipped} skipped (target text changed — undo or reject)` : "";
+    void vscode.window.showInformationMessage(
+      `Cowriting: accepted ${applied} proposal${applied === 1 ? "" : "s"}${skipNote}.`,
+    );
+  }
+
  /**
   * F11 (PUC-3/4): prompt host-side for the instruction (keeps the LLM/secret
   * surface out of the sealed webview, INV-8/35), run the edit turn, and surface
@@ -212,11 +247,12 @@ export class TrackChangesPreviewController implements vscode.Disposable {
  }

  /**
-   * F11 (INV-35/37): run one host edit turn and record the result as F4
+   * F11/F12 (INV-35/39): run one host edit turn and record the result as F4
   * proposal(s) — a SELECTION yields one single-range proposal over the resolved
-   * block-union; a DOCUMENT rewrite is `diffToHunks`'d into one single-range
-   * proposal per changed hunk (reusing the F4 single-range model N times, no new
-   * model). Never mutates the document (INV-10). Returns the created proposal ids.
+   * block-union; a DOCUMENT rewrite is `diffToBlockHunks`'d into one proposal per
+   * changed BLOCK (#47, INV-39 supersedes INV-37's per-word cut), each tagged
+   * `granularity:"block"` so accept reconciles attribution per word (INV-40).
+   * Never mutates the document (INV-10). Returns the created proposal ids.
   */
  async runEditAndPropose(
    document: vscode.TextDocument,
@@ -239,9 +275,17 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    }
    const turn = await this.editTurn(instruction, full);
    const ids: string[] = [];
-    for (const h of diffToHunks(full, turn.replacement)) {
+    // #47 (INV-39, supersedes INV-37): a document rewrite is cut at BLOCK
+    // granularity — one proposal per changed block (the unit a human reviews) —
+    // not per word. Each is tagged `granularity:"block"` so accept reconciles
+    // attribution per word inside the block (INV-40).
+    for (const h of diffToBlockHunks(full, turn.replacement)) {
      const fp = buildFingerprint(full, { start: h.start, end: h.end });
-      const id = await this.proposals.propose(document, fp, h.replacement, provenance(turn), { turnId, instruction });
+      const id = await this.proposals.propose(document, fp, h.replacement, provenance(turn), {
+        turnId,
+        instruction,
+        granularity: "block",
+      });
      if (id) ids.push(id);
    }
    return ids;
@@ -293,7 +337,7 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    void panel.webview.postMessage({
      type: "render",
      mode,
-      html: renderReview(baselineText, current, spans, proposals),
+      html: renderReview(baselineText, current, spans, proposals, { pinned: baseline?.reason === "pinned" }),
      epoch: this.epochLabel(baseline),
      summary,
      authorable,
@@ -369,6 +413,7 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    <label id="cw-toggle"><input type="checkbox" id="cw-annotations" checked /> Annotations</label>
    <button id="cw-pin" type="button" title="Pin the review baseline to now (clears the change-marks)">⌖ Pin baseline</button>
    <button id="cw-ask" type="button" title="Ask Claude to edit (the selection if any, else the whole document)">✦ Ask Claude to Edit Document</button>
+    <button id="cw-acceptall" type="button" hidden title="Accept every pending Claude proposal on this document">✓✓ Accept all</button>
    <span id="cw-epoch">Review</span>
    <span id="cw-summary"></span>
    <span id="cw-legend"></span>
@@ -419,6 +464,7 @@ export class TrackChangesPreviewController implements vscode.Disposable {
      current,
      this.attribution.spansFor(doc),
      this.proposals.listProposals(doc),
+      { pinned: baseline?.reason === "pinned" },
    );
  }
  /** F10: current annotations mode for a panel (default on). */
@@ -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;
@@ -0,0 +1,128 @@
+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<{ doc: vscode.TextDocument; key: string }> {
+  const abs = path.join(WS, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, body, "utf8");
+  const uri = vscode.Uri.file(abs);
+  const doc = await vscode.workspace.openTextDocument(uri);
+  await vscode.window.showTextDocument(doc);
+  await settle();
+  return { doc, key: uri.toString() };
+}
+
+// #46 SLICE-3 (accept): one "Accept all" gesture applies every pending proposal
+// on the current document through the existing F4 accept seam (INV-42) — batched,
+// re-anchor-safe (descending), orphan-skip + report. Host E2E, no LLM.
+suite("F12 SLICE-3 — accept-all (#46, INV-42)", () => {
+  // PUC-6: N pending → all applied, text replaced, proposals cleared.
+  test("acceptAll applies every pending proposal and reconstructs the document", async () => {
+    const original = "# All\n\nFirst para alpha.\n\nSecond para beta.\n\nThird para gamma.\n";
+    const rewrite = "# All\n\nFirst para ALPHA.\n\nSecond para BETA.\n\nThird para GAMMA.\n";
+    const { doc, key } = await freshDoc("docs/f12-all.md", original);
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+
+    ctl.setEditTurnForTest(async () => ({ replacement: rewrite, model: "sonnet", sessionId: "e2e-f12-all" }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "uppercase the nouns");
+    await settle();
+    assert.strictEqual(ids.length, 3, "three changed blocks → three pending proposals");
+
+    // Simulate the toolbar "Accept all" button posting its intent.
+    ctl.receiveMessage(key, { type: "acceptAll" });
+    await settle();
+    await settle();
+
+    assert.strictEqual(doc.getText(), rewrite, "accept-all reconstructs the intended document");
+    assert.strictEqual(api.proposalController.listProposals(doc).length, 0, "all proposals cleared");
+  });
+
+  // PUC-6 / INV-42: an orphaned proposal is skipped (not force-applied) and the
+  // resolvable ones still apply — reported via the {applied, skipped} tally.
+  test("acceptAllProposals skips an orphaned proposal and applies the rest (report)", async () => {
+    const original = "# Mix\n\nKeep alpha here.\n\nKeep gamma here.\n";
+    const rewrite = "# Mix\n\nKeep ALPHA here.\n\nKeep GAMMA here.\n";
+    const { doc } = await freshDoc("docs/f12-orphan.md", original);
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+
+    ctl.setEditTurnForTest(async () => ({ replacement: rewrite, model: "sonnet", sessionId: "e2e-f12-orphan" }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "uppercase");
+    await settle();
+    assert.strictEqual(ids.length, 2, "two pending proposals");
+
+    // Orphan the FIRST block's proposal by mangling its target text in the buffer.
+    const para = "Keep alpha here.";
+    const start = doc.getText().indexOf(para);
+    const edit = new vscode.WorkspaceEdit();
+    edit.replace(
+      doc.uri,
+      new vscode.Range(doc.positionAt(start), doc.positionAt(start + para.length)),
+      "Totally different first paragraph now.",
+    );
+    assert.ok(await vscode.workspace.applyEdit(edit), "mangling edit applied");
+    await settle();
+
+    const { applied, skipped } = await api.proposalController.acceptAllProposals(doc);
+    assert.strictEqual(applied, 1, "the still-resolvable proposal applied");
+    assert.strictEqual(skipped, 1, "the orphaned proposal was skipped, not mangled");
+    assert.ok(doc.getText().includes("Keep GAMMA here."), "the resolvable block landed");
+    assert.ok(
+      doc.getText().includes("Totally different first paragraph now."),
+      "the orphaned block kept the operator's text (never force-applied)",
+    );
+    assert.strictEqual(api.proposalController.listProposals(doc).length, 1, "the orphaned proposal remains pending");
+  });
+
+  // A single pending proposal still applies through the batch path (the button is
+  // hidden < 2 pending in the webview, but the command/seam handle any count).
+  test("acceptAllProposals with one pending proposal applies it", async () => {
+    const { doc } = await freshDoc("docs/f12-one.md", "# One\n\nThe only paragraph here.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+    ctl.setEditTurnForTest(async () => ({
+      replacement: "# One\n\nThe ONLY paragraph here.\n",
+      model: "sonnet",
+      sessionId: "e2e-f12-one",
+    }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "uppercase only");
+    await settle();
+    assert.strictEqual(ids.length, 1, "one pending proposal");
+    const { applied, skipped } = await api.proposalController.acceptAllProposals(doc);
+    assert.strictEqual(applied, 1);
+    assert.strictEqual(skipped, 0);
+    assert.strictEqual(doc.getText(), "# One\n\nThe ONLY paragraph here.\n");
+  });
+
+  // The command is registered + palette-guarded on markdown.
+  test("cowriting.acceptAllProposals is registered and palette-guarded on markdown", async () => {
+    const all = await vscode.commands.getCommands(true);
+    assert.ok(all.includes("cowriting.acceptAllProposals"), "command registered");
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../../../../package.json"), "utf8"));
+    const entry = (pkg.contributes.menus.commandPalette as Array<{ command: string; when?: string }>).find(
+      (m) => m.command === "cowriting.acceptAllProposals",
+    );
+    assert.ok(entry, "has a commandPalette entry");
+    assert.match(entry!.when ?? "", /editorLangId == markdown/, "guarded on markdown");
+  });
+});
@@ -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, "exports preview controller");
+  return api;
+}
+
+async function freshDoc(rel: string, body: string): Promise<{ doc: vscode.TextDocument; key: string }> {
+  const abs = path.join(WS, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, body, "utf8");
+  const uri = vscode.Uri.file(abs);
+  const doc = await vscode.workspace.openTextDocument(uri);
+  return { doc, key: uri.toString() };
+}
+
+function pkg(): any {
+  return JSON.parse(fs.readFileSync(path.join(__dirname, "../../../../package.json"), "utf8"));
+}
+function menu(id: string): Array<{ command: string; when?: string; group?: string }> {
+  return pkg().contributes.menus[id] ?? [];
+}
+
+// SLICE-1 / #42 (reach): "Ask Claude to Edit" reachable from the editor BODY and
+// the editor TAB, selection-aware (selection → editSelection; no selection →
+// editDocument), both markdown/authorable-gated, both routing through the single
+// runEditAndPropose path (INV-38). The menu `when` clauses are declarative, so we
+// assert them directly; the tab-targeting behavior is exercised through the command.
+suite("F12 SLICE-1 — Ask-Claude reach (#42, INV-38)", () => {
+  // PUC-1/2: editor BODY (editor/context) is selection-aware + markdown-gated.
+  test("editor/context offers editSelection (with selection) and editDocument (without), markdown+authorable", () => {
+    const m = menu("editor/context");
+    const sel = m.find((e) => e.command === "cowriting.editSelection");
+    const doc = m.find((e) => e.command === "cowriting.editDocument");
+    assert.ok(sel, "editSelection is in editor/context");
+    assert.ok(doc, "editDocument is in editor/context");
+
+    assert.match(sel!.when ?? "", /editorHasSelection/, "editSelection shows only with a selection");
+    assert.ok(!/!\s*editorHasSelection/.test(sel!.when ?? ""), "editSelection is not gated on NO selection");
+    assert.match(sel!.when ?? "", /editorLangId == markdown/, "editSelection gated on markdown");
+    assert.match(sel!.when ?? "", /resourceScheme == file|resourceScheme == untitled/, "editSelection gated authorable");
+
+    assert.match(doc!.when ?? "", /!\s*editorHasSelection/, "editDocument shows only without a selection");
+    assert.match(doc!.when ?? "", /editorLangId == markdown/, "editDocument gated on markdown");
+    assert.match(doc!.when ?? "", /resourceScheme == file|resourceScheme == untitled/, "editDocument gated authorable");
+  });
+
+  // PUC-3: editor TAB (editor/title/context) carries the same selection-aware pair.
+  test("editor/title/context offers editSelection (with selection) and editDocument (without), markdown-gated", () => {
+    const m = menu("editor/title/context");
+    const sel = m.find((e) => e.command === "cowriting.editSelection");
+    const doc = m.find((e) => e.command === "cowriting.editDocument");
+    assert.ok(sel, "editSelection is in editor/title/context");
+    assert.ok(doc, "editDocument is in editor/title/context");
+
+    assert.match(sel!.when ?? "", /editorHasSelection/, "tab editSelection shows only with a selection");
+    assert.ok(!/!\s*editorHasSelection/.test(sel!.when ?? ""), "tab editSelection is not gated on NO selection");
+    assert.match(sel!.when ?? "", /resourceLangId == markdown/, "tab editSelection gated on markdown");
+
+    assert.match(doc!.when ?? "", /!\s*editorHasSelection/, "tab editDocument shows only without a selection");
+    assert.match(doc!.when ?? "", /resourceLangId == markdown/, "tab editDocument gated on markdown");
+  });
+
+  // PUC-3 behavior: editDocument invoked with a tab URI targets THAT document,
+  // not whatever editor happens to be active (mirrors #41's clicked-doc resolution).
+  test("editDocument(uri) targets the clicked tab's document, not the active editor", async () => {
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+
+    // Doc A is the active editor; Doc B is the "clicked tab" we pass by URI.
+    const a = await freshDoc("docs/f12-active.md", "# Active\n\nThe active editor paragraph.\n");
+    const b = await freshDoc("docs/f12-tab.md", "# Tab\n\nThe tab target paragraph to rewrite.\n");
+    await vscode.window.showTextDocument(a.doc);
+    await settle();
+
+    // Stub the instruction prompt (sealed input box can't run in CI) + the LLM turn.
+    const origInput = vscode.window.showInputBox;
+    (vscode.window as any).showInputBox = async () => "rewrite it";
+    ctl.setEditTurnForTest(async () => ({
+      replacement: "# Tab\n\nThe REWRITTEN tab paragraph.\n",
+      model: "sonnet",
+      sessionId: "e2e-f12-tab",
+    }));
+    try {
+      await vscode.commands.executeCommand("cowriting.editDocument", b.doc.uri);
+      await settle();
+    } finally {
+      (vscode.window as any).showInputBox = origInput;
+    }
+
+    // The proposal(s) landed on the TAB doc (B), and the ACTIVE doc (A) has none.
+    assert.ok(api.proposalController.listProposals(b.doc).length >= 1, "tab doc B received the document-edit proposal(s)");
+    assert.strictEqual(
+      api.proposalController.listProposals(a.doc).length,
+      0,
+      "active doc A was NOT edited — editDocument honored the tab URI",
+    );
+    // INV-10: proposing never mutates the document.
+    assert.ok(b.doc.getText().includes("tab target paragraph"), "tab doc unchanged by propose");
+  });
+
+  // No URI arg (palette / keybinding) → fall back to the active editor.
+  test("editDocument() with no arg targets the active editor", async () => {
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    const a = await freshDoc("docs/f12-noarg.md", "# No arg\n\nThe active doc paragraph here.\n");
+    await vscode.window.showTextDocument(a.doc);
+    await settle();
+
+    const origInput = vscode.window.showInputBox;
+    (vscode.window as any).showInputBox = async () => "rewrite it";
+    ctl.setEditTurnForTest(async () => ({
+      replacement: "# No arg\n\nThe REWRITTEN active doc paragraph.\n",
+      model: "sonnet",
+      sessionId: "e2e-f12-noarg",
+    }));
+    try {
+      await vscode.commands.executeCommand("cowriting.editDocument");
+      await settle();
+    } finally {
+      (vscode.window as any).showInputBox = origInput;
+    }
+    assert.ok(api.proposalController.listProposals(a.doc).length >= 1, "active doc received the proposal(s) on no-arg");
+  });
+});
@@ -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");
+  });
+});
@@ -0,0 +1,116 @@
+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, "exports preview controller");
+  return api;
+}
+
+/** Write a markdown file under WS and return its uri (without opening it). */
+function writeFile(rel: string, body: string): vscode.Uri {
+  const abs = path.join(WS, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, body, "utf8");
+  return vscode.Uri.file(abs);
+}
+
+function pkg(): any {
+  return JSON.parse(fs.readFileSync(path.join(__dirname, "../../../../package.json"), "utf8"));
+}
+
+// #41 (story): "Open Cowriting Review Panel" reachable from the markdown
+// file/tab right-click menu. The review surface (showTrackChangesPreview) is the
+// plugin's central affordance; this adds explorer/context + editor/title/context
+// entry points and makes the command open the *clicked* document — not merely
+// the active editor — so the explorer right-click works even when the file is
+// not already open.
+suite("#41 review-panel right-click entry (host E2E — menu wiring + clicked-doc resolution)", () => {
+  test("command with a Uri previews the CLICKED doc, not the active editor", async () => {
+    // Two markdown docs; A is the active editor, B is the right-clicked target.
+    const aUri = writeFile("docs/menu-active.md", "# Active\n\nThe active editor's document.\n");
+    const bUri = writeFile("docs/menu-clicked.md", "# Clicked\n\nThe right-clicked document.\n");
+    const aDoc = await vscode.workspace.openTextDocument(aUri);
+    await vscode.window.showTextDocument(aDoc);
+    const bDoc = await vscode.workspace.openTextDocument(bUri); // open but NOT active
+    await settle();
+    const api = await getApi();
+
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview", bUri);
+    await settle();
+
+    assert.strictEqual(api.trackChangesPreviewController.isOpen(bUri.toString()), true, "preview opened for the clicked doc");
+    assert.strictEqual(
+      api.trackChangesPreviewController.isOpen(aUri.toString()),
+      false,
+      "the active editor's doc did NOT get a preview",
+    );
+    assert.ok(bDoc, "clicked doc handle held");
+  });
+
+  test("command with a Uri for a not-yet-open file opens it and previews (explorer case)", async () => {
+    // Write a file but do not openTextDocument it — mimics an Explorer right-click.
+    const uri = writeFile("docs/menu-unopened.md", "# Unopened\n\nNever opened before the right-click.\n");
+    const key = uri.toString();
+    const api = await getApi();
+    assert.ok(
+      !vscode.workspace.textDocuments.some((d) => d.uri.toString() === key),
+      "precondition: the file is not an open document",
+    );
+
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview", uri);
+    await settle();
+
+    assert.strictEqual(api.trackChangesPreviewController.isOpen(key), true, "the clicked-but-unopened file got a preview");
+  });
+
+  test("no-arg invocation still falls back to the active editor (palette / keybinding unchanged)", async () => {
+    const uri = writeFile("docs/menu-noarg.md", "# No-arg\n\nActive editor for the no-arg path.\n");
+    const doc = await vscode.workspace.openTextDocument(uri);
+    await vscode.window.showTextDocument(doc);
+    await settle();
+    const api = await getApi();
+
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+
+    assert.strictEqual(api.trackChangesPreviewController.isOpen(uri.toString()), true, "no-arg previews the active editor");
+  });
+
+  test("explorer/context contributes the review-panel item for markdown only", () => {
+    const items = (pkg().contributes.menus["explorer/context"] ?? []) as Array<{ command: string; when?: string }>;
+    const entry = items.find((m) => m.command === "cowriting.showTrackChangesPreview");
+    assert.ok(entry, "explorer/context has a showTrackChangesPreview entry");
+    assert.match(entry!.when ?? "", /resourceLangId == markdown/, "gated on markdown resources");
+  });
+
+  test("editor/title/context (tab right-click) contributes the review-panel item for markdown only", () => {
+    const items = (pkg().contributes.menus["editor/title/context"] ?? []) as Array<{ command: string; when?: string }>;
+    const entry = items.find((m) => m.command === "cowriting.showTrackChangesPreview");
+    assert.ok(entry, "editor/title/context has a showTrackChangesPreview entry");
+    assert.match(entry!.when ?? "", /resourceLangId == markdown/, "gated on markdown tabs");
+  });
+
+  test("the command title reads 'Open Cowriting Review Panel'", () => {
+    const cmd = (pkg().contributes.commands as Array<{ command: string; title: string }>).find(
+      (c) => c.command === "cowriting.showTrackChangesPreview",
+    );
+    assert.ok(cmd, "command is contributed");
+    assert.strictEqual(cmd!.title, "Open Cowriting Review Panel", "menus render this title");
+  });
+
+  test("the ctrl+alt+r keybinding still targets the command (unchanged)", () => {
+    const kb = (pkg().contributes.keybindings as Array<{ command: string; key: string; when?: string }>).find(
+      (k) => k.command === "cowriting.showTrackChangesPreview",
+    );
+    assert.ok(kb, "keybinding still present");
+    assert.strictEqual(kb!.key, "ctrl+alt+r", "key unchanged");
+  });
+});
@@ -0,0 +1,113 @@
+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));
+const AGENT = { kind: "agent" as const, id: "claude", agent: { sdk: "@cline/sdk", model: "sonnet", sessionId: "e2e-s40" } };
+
+async function getApi(): Promise<CowritingApi> {
+  const ext = vscode.extensions.getExtension("benstull.vscode-cowriting-plugin")!;
+  const api = (await ext.activate()) as CowritingApi;
+  assert.ok(api?.attributionController, "exports attribution");
+  return api;
+}
+
+async function freshDoc(rel: string, body: string): Promise<{ doc: vscode.TextDocument; key: string }> {
+  const abs = path.join(WS, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, body, "utf8");
+  const uri = vscode.Uri.file(abs);
+  const doc = await vscode.workspace.openTextDocument(uri);
+  await vscode.window.showTextDocument(doc);
+  await settle();
+  return { doc, key: uri.toString() };
+}
+
+// #40 (follow-up to #38): on undo/redo, restore each re-inserted char's EXACT
+// prior author attribution rather than leaving it neutral (#38). Driven mid-edit
+// (buffer dirty) so the attribution branch runs, not the disk-sync one.
+suite("F3 #40 — undo/redo restores exact author attribution (host E2E, no LLM)", () => {
+  test("undo of a deletion of AGENT text restores its agent span (not neutral, not human)", async () => {
+    const { doc } = await freshDoc("docs/s40agent.md", "Human start. xxxx end.\n");
+    const api = await getApi();
+    const ctl = api.attributionController;
+
+    // Make "xxxx" agent-authored via the seam → an agent span over "ROBOT".
+    const t = "xxxx";
+    const start = doc.getText().indexOf(t);
+    const ok = await ctl.applyAgentEdit(
+      doc,
+      new vscode.Range(doc.positionAt(start), doc.positionAt(start + t.length)),
+      "ROBOT",
+      AGENT,
+      { turnId: "turn-s40" },
+    );
+    assert.strictEqual(ok, true, "seam edit applies");
+    await settle();
+    const key = api.proposalController.keyFor(doc);
+    assert.ok(
+      ctl.getSpans(key).some((s) => s.authorKind === "agent" && doc.getText().slice(s.range.start, s.range.end).includes("ROBOT")),
+      "ROBOT is agent-attributed after the seam edit",
+    );
+
+    // Human deletes "ROBOT" (buffer stays dirty: it already diverged from disk).
+    const rs = doc.getText().indexOf("ROBOT");
+    const del = new vscode.WorkspaceEdit();
+    del.delete(doc.uri, new vscode.Range(doc.positionAt(rs), doc.positionAt(rs + "ROBOT".length)));
+    assert.ok(await vscode.workspace.applyEdit(del), "delete applied");
+    await settle();
+    assert.ok(!doc.getText().includes("ROBOT"), "ROBOT deleted");
+
+    // Undo the deletion → ROBOT re-inserted. #40: its AGENT span is restored.
+    await vscode.window.showTextDocument(doc);
+    await vscode.commands.executeCommand("undo");
+    await settle();
+    assert.ok(doc.getText().includes("ROBOT"), "undo restored ROBOT");
+    assert.ok(doc.isDirty, "buffer still dirty → attribution branch ran");
+
+    const r2 = doc.getText().indexOf("ROBOT");
+    const spans = ctl.getSpans(key);
+    const over = spans.filter((s) => s.range.start < r2 + 5 && s.range.end > r2);
+    assert.ok(over.length > 0, "restored ROBOT carries a span");
+    assert.ok(over.every((s) => s.authorKind === "agent"), `restored ROBOT is agent-attributed, got ${JSON.stringify(over)}`);
+  });
+
+  test("edit → undo → redo round-trips attribution to identical state", async () => {
+    const { doc } = await freshDoc("docs/s40roundtrip.md", "Base alpha. yyyy omega.\n");
+    const api = await getApi();
+    const ctl = api.attributionController;
+    const key = api.proposalController.keyFor(doc);
+
+    const start = doc.getText().indexOf("yyyy");
+    await ctl.applyAgentEdit(
+      doc,
+      new vscode.Range(doc.positionAt(start), doc.positionAt(start + 4)),
+      "BLUEWORD",
+      AGENT,
+      { turnId: "turn-s40b" },
+    );
+    await settle();
+    const norm = (k: string) =>
+      ctl
+        .getSpans(k)
+        .map((s) => ({ a: s.authorKind, t: doc.getText().slice(s.range.start, s.range.end) }))
+        .sort((x, y) => (x.t < y.t ? -1 : 1));
+    const afterAgent = JSON.stringify(norm(key));
+    assert.ok(afterAgent.includes("BLUEWORD") && afterAgent.includes("agent"), "agent span present after the edit");
+
+    // Delete BLUEWORD, then undo (restore) then redo (re-delete) then undo again.
+    const bs = doc.getText().indexOf("BLUEWORD");
+    const del = new vscode.WorkspaceEdit();
+    del.delete(doc.uri, new vscode.Range(doc.positionAt(bs), doc.positionAt(bs + "BLUEWORD".length)));
+    await vscode.workspace.applyEdit(del);
+    await settle();
+    await vscode.window.showTextDocument(doc);
+    await vscode.commands.executeCommand("undo"); // restore BLUEWORD
+    await settle();
+    assert.ok(doc.getText().includes("BLUEWORD"), "undo restored BLUEWORD");
+    assert.strictEqual(JSON.stringify(norm(key)), afterAgent, "attribution after undo matches the pre-deletion state exactly");
+  });
+});
@@ -0,0 +1,63 @@
+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, "exports preview controller");
+  return api;
+}
+
+async function freshDoc(rel: string, body: string): Promise<{ doc: vscode.TextDocument; key: string }> {
+  const abs = path.join(WS, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, body, "utf8");
+  const uri = vscode.Uri.file(abs);
+  const doc = await vscode.workspace.openTextDocument(uri);
+  await vscode.window.showTextDocument(doc);
+  await settle();
+  return { doc, key: uri.toString() };
+}
+
+// #48 host E2E (no LLM): pinning the baseline leaves the review panel fully clean
+// — no authorship coloring on unchanged blocks — while re-divergence brings the
+// annotations back. The author colors are read from the on-state renderReview HTML.
+suite("S48 — pin → fully clean review panel (host E2E, no LLM)", () => {
+  test("pin clears authorship coloring; a later edit brings annotations back", async () => {
+    const { doc, key } = await freshDoc("docs/s48pin.md", "# S48\n\nAn original baseline paragraph.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+
+    // Type a paragraph → a human attribution span + author coloring in the on-state.
+    const edit = new vscode.WorkspaceEdit();
+    edit.insert(doc.uri, doc.positionAt(doc.getText().length), "\n\nA freshly typed human paragraph.\n");
+    assert.ok(await vscode.workspace.applyEdit(edit), "operator edit applied");
+    await settle();
+    assert.match(ctl.renderHtmlFor(key), /cw-by-human/, "typed text is author-colored before the pin");
+
+    // Pin the baseline → zero diff → the panel must be fully clean.
+    ctl.receiveMessage(key, { type: "pinBaseline" });
+    await settle();
+    const pinned = ctl.renderHtmlFor(key);
+    assert.ok(!pinned.includes("cw-by-human"), "no human authorship coloring after pin");
+    assert.ok(!pinned.includes("cw-by-claude"), "no Claude authorship coloring after pin");
+    assert.ok(!pinned.includes("cw-add") && !pinned.includes("cw-del"), "no change marks after pin");
+    assert.match(pinned, /data-src-start/, "blocks still carry data-src offsets (INV-36 mapping kept)");
+    assert.ok(pinned.includes("freshly typed human paragraph"), "the body text is still rendered, just plain");
+
+    // Edit again → there are changes since the pinned baseline → annotations return.
+    const edit2 = new vscode.WorkspaceEdit();
+    edit2.insert(doc.uri, doc.positionAt(doc.getText().length), "\n\nA second typed paragraph diverges again.\n");
+    assert.ok(await vscode.workspace.applyEdit(edit2), "second operator edit applied");
+    await settle();
+    assert.match(ctl.renderHtmlFor(key), /cw-by-human/, "authorship coloring returns once the doc diverges from the pin");
+  });
+});
@@ -1,5 +1,5 @@
 import { describe, it, test, expect } from "vitest";
-import { splitBlocks, splitBlocksWithRanges, diffBlocks, diffToHunks, renderTrackChanges, colorByAuthor, type AuthorSpan } from "../src/trackChangesModel";
+import { splitBlocks, splitBlocksWithRanges, diffBlocks, diffToHunks, diffToBlockHunks, renderTrackChanges, colorByAuthor, type AuthorSpan } from "../src/trackChangesModel";

 describe("splitBlocks", () => {
  it("splits prose paragraphs on blank lines, dropping empties", () => {
@@ -168,6 +168,45 @@ describe("colorByAuthor", () => {
    expect(html).toContain('<span class="cw-by-human">hello</span>');
    expect(html).toContain("world");
  });
+
+  // #33: author-coloring must be sentinel-safe around markdown emphasis. These
+  // exercise the REAL markdown-it renderer (via renderReview on an unchanged doc),
+  // since the failure is in markdown-it's inline parsing / element nesting.
+  // CASE1 — a span boundary strictly inside a delimiter run must not split it.
+  test("#33 CASE1: a span boundary inside ** does not break emphasis parsing", () => {
+    const doc = "a**b**c";
+    const html = renderReview(doc, doc, [{ start: 0, end: 2, author: "human" }], []);
+    expect(html).toContain("<strong>b</strong>"); // emphasis still renders
+    expect(html).not.toContain("**"); // no raw delimiters left
+    expect(html).not.toContain("<em></em>"); // no stray empty emphasis (the parse-break symptom)
+    expect(html).toContain('class="cw-by-human"'); // coloring present
+  });
+  // CASE3 — a span boundary inside an emphasis run must color the text without
+  // misnesting span/element (the span is split at the element boundary).
+  test("#33 CASE3: a span boundary inside **bold** colors the text without misnesting", () => {
+    const doc = "**bold**";
+    const html = renderReview(doc, doc, [{ start: 0, end: 4, author: "human" }], []); // covers "**bo"
+    expect(html).toContain("<strong>");
+    expect(html).toContain('<span class="cw-by-human">bo</span>ld</strong>'); // span INSIDE strong, closed before "ld"
+    expect(html).not.toContain('cw-by-human"><strong>'); // NOT the old misnest (span wrapping the <strong> open)
+  });
+  // CASE2 — a span covering a whole emphasis run stays correct (regression).
+  test("#33 CASE2: a span over the whole **bold** colors it correctly", () => {
+    const doc = "**bold**";
+    const html = renderReview(doc, doc, [{ start: 0, end: 8, author: "human" }], []);
+    expect(html).toContain("<strong>");
+    expect((html.match(/cw-by-human/g) ?? []).length).toBe(1);
+    expect(html).toContain("bold");
+  });
+  test("#33: no Private-Use-Area sentinel chars leak into the rendered output", () => {
+    const doc = "a**b**c and `co de` and _x_";
+    const spans: AuthorSpan[] = [
+      { start: 0, end: 2, author: "human" },
+      { start: 12, end: 16, author: "claude" },
+    ];
+    const html = renderReview(doc, doc, spans, []);
+    expect(html).not.toMatch(/[\uE000-\uF8FF]/); // no leftover BMP Private-Use-Area sentinels
+  });
 });

 import { renderPlain } from "../src/trackChangesModel";
@@ -277,6 +316,54 @@ describe("renderReview", () => {
    expect(uIdx).toBeGreaterThan(html.indexOf("Beta there")); // unanchored still trails the body
    expect(html).toContain("cw-proposal-unanchored");
  });
+  // #48: a PINNED baseline with zero changes leaves the panel fully un-annotated —
+  // no authorship coloring on unchanged blocks — while pending proposals still show.
+  test("renderReview: pinned + zero diff with author spans renders NO authorship coloring", () => {
+    const doc = "Human wrote this.\n\nClaude wrote that.";
+    const spans: AuthorSpan[] = [
+      { start: 0, end: 17, author: "human" },
+      { start: 19, end: doc.length, author: "claude" },
+    ];
+    const html = renderReview(doc, doc, spans, [], { pinned: true });
+    expect(html).not.toContain("cw-by-human");
+    expect(html).not.toContain("cw-by-claude");
+    expect(html).not.toContain("cw-add");
+    expect(html).not.toContain("cw-del");
+    // still a selection→source surface (INV-36): blocks carry data-src offsets.
+    expect(html).toContain("data-src-start");
+    // the body text is still there, just plain.
+    expect(html).toContain("Human wrote this.");
+    expect(html).toContain("Claude wrote that.");
+  });
+  test("renderReview: pinned + zero diff still renders a pending proposal block", () => {
+    const doc = "Human wrote this.\n\nClaude wrote that.";
+    const spans: AuthorSpan[] = [{ start: 0, end: 17, author: "human" }];
+    const proposals: ProposalView[] = [
+      { id: "p1", anchorStart: 0, anchorEnd: 5, replaced: "Human", replacement: "Person" },
+    ];
+    const html = renderReview(doc, doc, spans, proposals, { pinned: true });
+    expect(html).not.toContain("cw-by-human"); // body still clean
+    expect(html).toContain('data-proposal-id="p1"'); // proposal still shows (it is an action)
+    expect(html).toContain("Person");
+  });
+  test("renderReview: zero diff WITHOUT a pin (e.g. machine-landing) keeps authorship coloring (INV-33)", () => {
+    // accepting a Claude edit advances the baseline (zero diff) but is NOT a pin —
+    // the landed author coloring must remain.
+    const doc = "Human wrote this.\n\nClaude wrote that.";
+    const spans: AuthorSpan[] = [{ start: 19, end: doc.length, author: "claude" }];
+    const html = renderReview(doc, doc, spans, []); // no pinned flag
+    expect(html).toContain("cw-by-claude");
+  });
+  test("renderReview: with REAL changes since a pin, author coloring returns", () => {
+    // a genuine added block is still author-colored even when pinned (only the
+    // zero-diff-after-pin state is clean).
+    const baseline = "Hello world";
+    const current = "Hello world\n\nHello world";
+    const spans: AuthorSpan[] = [{ start: 19, end: 24, author: "human" }];
+    const html = renderReview(baseline, current, spans, [], { pinned: true });
+    expect((html.match(/cw-by-human/g) ?? []).length).toBe(1);
+  });
+
  test("renderReview is deterministic with mixed anchored/unanchored proposals", () => {
    const doc = "one two three";
    const proposals: ProposalView[] = [
@@ -402,6 +489,90 @@ describe("F11 diffToHunks (INV-37)", () => {
  });
 });

+// #47 SLICE-2 (INV-39): a whole-document rewrite is diffed into ONE EditHunk per
+// CHANGED BLOCK (the unit a human reviews), superseding INV-37's per-word hunks.
+// Built by coarsening diffToHunks to block boundaries; fences stay atomic
+// (INV-23); inserted/deleted blocks keep their anchored gap hunks (INV-41).
+// Applying all hunks right→left must still reconstruct the rewrite exactly.
+describe("#47 diffToBlockHunks (INV-39/41)", () => {
+  const applyHunks = (current: string, hunks: ReturnType<typeof diffToBlockHunks>): string => {
+    let out = current;
+    for (const h of [...hunks].sort((a, b) => b.start - a.start)) {
+      out = out.slice(0, h.start) + h.replacement + out.slice(h.end);
+    }
+    return out;
+  };
+
+  test("an identical rewrite → zero hunks", () => {
+    expect(diffToBlockHunks("# H\n\nSame body.\n", "# H\n\nSame body.\n")).toEqual([]);
+  });
+
+  test("two word edits in ONE paragraph → ONE block hunk (supersedes INV-37's two)", () => {
+    const current = "# Doc\n\nThe quick brown fox jumps over the lazy dog.\n";
+    const rewrite = "# Doc\n\nThe quick RED fox jumps over the lazy CAT.\n";
+    const hunks = diffToBlockHunks(current, rewrite);
+    expect(hunks).toHaveLength(1);
+    // the hunk spans the whole changed paragraph block
+    const para = "The quick brown fox jumps over the lazy dog.";
+    const start = current.indexOf(para);
+    expect(hunks[0].start).toBe(start);
+    expect(hunks[0].end).toBe(start + para.length);
+    expect(hunks[0].replacement).toBe("The quick RED fox jumps over the lazy CAT.");
+    expect(applyHunks(current, hunks)).toBe(rewrite);
+  });
+
+  test("edits across two paragraphs → two block hunks, one per changed block; unchanged → none", () => {
+    const current = "First para alpha.\n\nSecond para beta.\n\nThird para gamma.\n";
+    const rewrite = "First para ALPHA.\n\nSecond para beta.\n\nThird para GAMMA.\n";
+    const hunks = diffToBlockHunks(current, rewrite);
+    expect(hunks).toHaveLength(2);
+    // each hunk lands on a real block boundary in current
+    const blocks = splitBlocksWithRanges(current);
+    for (const h of hunks) {
+      expect(blocks.some((b) => b.start === h.start && b.end === h.end)).toBe(true);
+    }
+    expect(applyHunks(current, hunks)).toBe(rewrite);
+  });
+
+  test("a changed code fence → ONE atomic whole-fence hunk (INV-23)", () => {
+    const current = "# Code\n\n```js\nconst a = 1;\nconst b = 2;\n```\n";
+    const rewrite = "# Code\n\n```js\nconst a = 10;\nconst b = 2;\n```\n";
+    const hunks = diffToBlockHunks(current, rewrite);
+    expect(hunks).toHaveLength(1);
+    const fence = "```js\nconst a = 1;\nconst b = 2;\n```";
+    const start = current.indexOf(fence);
+    expect(hunks[0].start).toBe(start);
+    expect(hunks[0].end).toBe(start + fence.length);
+    expect(hunks[0].replacement).toBe("```js\nconst a = 10;\nconst b = 2;\n```");
+    expect(applyHunks(current, hunks)).toBe(rewrite);
+  });
+
+  test("every hunk is resolvable (non-zero-width, real source text) and reconstructs", () => {
+    const cases: Array<[string, string]> = [
+      ["# H\n\nThe brown fox sleeps.\n", "# H\n\nThe brown fox QUIETLY sleeps today.\n"], // insert words mid-block
+      ["A para.\n\nB para.\n\nC para.\n", "A para.\n\nC para.\n"], // delete a whole block
+      ["A para.\n\nB para.\n", "A para.\n\nNEW para.\n\nB para.\n"], // insert a whole block
+      ["Only one block here.\n", "A totally different single block.\n"], // wholesale
+      ["Keep me.\n\nDrop this one.\n", "Keep me.\n"], // delete trailing block
+      ["unchanged body\n", "unchanged body\n"], // no-op
+    ];
+    for (const [current, rewrite] of cases) {
+      const hunks = diffToBlockHunks(current, rewrite);
+      for (const h of hunks) {
+        expect(h.end).toBeGreaterThan(h.start); // non-zero-width → F4 fp resolves
+        expect(current.slice(h.start, h.end).length).toBeGreaterThan(0);
+      }
+      expect(applyHunks(current, hunks)).toBe(rewrite);
+    }
+  });
+
+  test("is deterministic — same inputs → identical hunks", () => {
+    const c = "P one.\n\nP two.\n";
+    const r = "P ONE.\n\nP two.\n";
+    expect(diffToBlockHunks(c, r)).toEqual(diffToBlockHunks(c, r));
+  });
+});
+
 // F11 SLICE-2 (INV-36): the pure render layer emits data-src-start/data-src-end
 // (source char offsets from BlockWithRange) on every LIVE-source rendered block,
 // in BOTH modes. The webview's selection→source mapping walks the DOM to the
Author	SHA1	Message	Date
Ben Stull	5645b926a3	#40 (WIP, UNVERIFIED): restore exact author attribution on undo/redo Follow-up to #38. #38 made undo/redo re-inserted text neutral (no false human coloring); #40 restores its EXACT prior attribution so Claude's restored text is blue again, the human's green. Mechanism — text-keyed attribution snapshots: per-doc Map<documentText, spans>, snapshotted after every forward edit + at load; on undo/redo, after the #38 geometry reconcile, if a snapshot's text equals the current buffer the spans are restored exactly (offsets valid — identical text). Robust to VS Code undo coalescing (only the resulting-text-matching event restores); far-back/evicted states fall back to #38 neutral. History bounded (ATTR_HISTORY_MAX, oldest evicted). NOT MERGED / NOT VERIFIED END-TO-END: 222 unit + typecheck green, but the #40 host E2E (and the pre-existing #38 undoMarks E2E) depend on executeCommand("undo"), which is broken in this test environment — the untouched #38 test fails identically on clean main (the known undoMarks flake, now deterministic). Clearing .vscode-test/user-data (the usual remedy) is permission-blocked here. The operator should verify in a working E2E environment before merging. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-13 08:56:43 -07:00
Ben Stull	64c7d7bad2	claim vscode-cowriting-plugin session 0048 (placeholder) + sessions.json entry	2026-06-13 08:45:48 -07:00
Ben Stull	ab00cbefcc	add sessions/0047/SESSION-0047.0-TRANSCRIPT-2026-06-13T08-34--2026-06-13T08-44.md + replace placeholder/variant SESSION-0047.0-TRANSCRIPT-2026-06-13T08-34--INPROGRESS.md	2026-06-13 08:43:50 -07:00
benstull	c67749a53c	Merge pull request '#33 : harden author-coloring PUA sentinels against intra-emphasis markdown' (#53 ) from s33-sentinel-hardening into main	2026-06-13 15:42:04 +00:00
Ben Stull	ba7623f813	#33 : harden author-coloring PUA sentinels against intra-emphasis markdown The F9/F10 author-coloring technique injects paired PUA sentinels into prose source at span offsets, renders, then maps sentinels → cw-by-* spans. Two failure modes when a span boundary met emphasis markup (characterized in session 0032): - CASE1: a boundary strictly inside a delimiter run (abc, between the two ) split ``, breaking markdown-it's delimiter pairing (stray <em></em>, raw ). - CASE3: a boundary inside an emphasis run (bold* span covering *bo) rendered the emphasis but MISNESTED span/element (<strong>bo</span>ld</strong>). Token-aware fix (both, per the issue #33 comment): - injectSentinels: clamp any sentinel offset that lands strictly inside a delimiter run ( _ ~ `) to the run's start, so a sentinel never splits a run (CASE1). Delimiters are invisible once rendered, so this only shifts the colored boundary across markup. Drop spans that clamp to empty. - sentinelsToSpans: replace the naive global split/join with a walker over the rendered HTML that emits the cw-by-* span only around TEXT runs — closing it before any <tag> and reopening after — so a span is always well-nested within inline elements (one span segment per text run, CASE3). Tags are copied verbatim with any stray sentinel stripped (no Private-Use-Area char leaks). Pure, vscode-free, deterministic (INV-33). No regression: existing colorByAuthor / renderReview cases stay green; the common no-emphasis case is byte-identical. 222 unit + 74/5 host E2E green. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-13 08:41:31 -07:00
Ben Stull	9e9fcb8057	claim vscode-cowriting-plugin session 0047 (placeholder) + sessions.json entry	2026-06-13 08:34:03 -07:00
Ben Stull	1381eab11e	add sessions/0046/SESSION-0046.0-TRANSCRIPT-2026-06-13T08-19--2026-06-13T08-31.md + replace placeholder/variant SESSION-0046.0-TRANSCRIPT-2026-06-13T08-19--INPROGRESS.md	2026-06-13 08:32:25 -07:00
benstull	54846da1ea	Merge pull request '#48 : pinning the baseline leaves the review panel fully un-annotated' (#52 ) from s48-pin-clean-panel into main	2026-06-13 15:30:55 +00:00
Ben Stull	fdd743490d	#48 : pinning the baseline leaves the review panel fully un-annotated A pinned baseline with no changes since should read as a clean starting point, but the F10 on-render still author-colored every block (colorByAuthor), painting the whole document green/blue right after a pin. Now, when the baseline reason is "pinned" and there are zero changes since (every diffBlocks op unchanged), the on-render is fully clean — no change marks and no authorship coloring — while the data-src block mapping (INV-36) and any pending proposals (review actions, not annotations) are kept. Scoped to the PIN specifically, not all zero-diff: a baseline advanced by a machine-landing (accept) is also zero-diff but keeps its authorship coloring so accepted Claude text stays blue (F10 INV-33). renderReview takes a `pinned` option; the controller passes baseline.reason === "pinned" from both refresh and the renderHtmlFor test seam. - trackChangesModel.ts: renderReview gains the `pinned` RenderOption; when pinned + zero-diff, blocks render plain (no colorByAuthor). - trackChangesPreview.ts: pass { pinned } through refresh + renderHtmlFor. - unit: pinned+zero-diff → no cw-by-*; pinned+zero-diff still shows proposals; zero-diff WITHOUT pin (machine-landing) keeps coloring (INV-33); real changes after a pin re-color. - s48PinClean host E2E: type → colored; pin → clean; edit → annotations return. 218 unit + 74/5 host E2E green. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-13 08:28:52 -07:00
Ben Stull	4584e06679	claim vscode-cowriting-plugin session 0046 (placeholder) + sessions.json entry	2026-06-13 08:19:43 -07:00
Ben Stull	ef07acfdc1	add sessions/0045/SESSION-0045.0-TRANSCRIPT-2026-06-13T08-04--2026-06-13T08-17.md + replace placeholder/variant SESSION-0045.0-TRANSCRIPT-2026-06-13T08-04--INPROGRESS.md	2026-06-13 08:18:17 -07:00
benstull	83c4a80d8b	Merge pull request '#46 (SLICE-3, accept): Accept all pending proposals in one gesture' (#51 ) from f12-slice3-accept-all into main	2026-06-13 15:16:18 +00:00
Ben Stull	c94b9ccfe7	#46 (SLICE-3, accept): Accept all pending proposals in one gesture Document-edit flow SLICE-3 — completes reach→review→accept (specs/coauthoring-document-edit-flow.md §7.2, INV-42). A single "Accept all" gesture applies every pending proposal on the current document through the existing F4 acceptById seam (block proposals take the INV-40 word-precise path automatically), in descending anchor order so an earlier accept never invalidates a later one, skipping (never force-applying) proposals that can't anchor and reporting applied-vs-skipped. Batched application of the existing accept path — no new mechanism; the webview posts intent only (INV-35). No confirmation dialog (undo restores). - proposalController.ts: acceptAllProposals(document) → {applied, skipped} (descending order, orphan-skip); accept/acceptById gain a silent opt so the batch suppresses N per-proposal orphan warnings in favour of one report. - trackChangesPreview.ts: ToolbarMsg += {type:"acceptAll"}; handleWebviewMessage routes it to a public acceptAll(document) that batches + reports. - extension.ts + package.json: cowriting.acceptAllProposals command (active doc, markdown-gated palette entry) for the non-webview path. - media/preview.ts + shellHtml: "✓✓ Accept all" toolbar button, posting the intent, shown only with ≥2 pending proposals (authorable, on-state). - trackChangesModel.ts: diffToBlockHunks now emits one block-aligned hunk per CHANGED block even when changed blocks are ADJACENT (treats changed blocks as 1:1 anchors alongside unchanged ones; gap-spans only cover add/remove runs between anchors) — fixes adjacent changed blocks collapsing into one proposal. - f12Accept host E2E (apply-all reconstructs; orphan skip + report; single proposal; command registered/gated); MANUAL-SMOKE-F12 §3. 214 unit + 73/5 host E2E green. Completes the document-edit-flow cluster (#42 reach + #47 review + #46 accept). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-13 08:15:55 -07:00
Ben Stull	6fd7555183	claim vscode-cowriting-plugin session 0045 (placeholder) + sessions.json entry	2026-06-13 08:05:04 -07:00
Ben Stull	f7788c5585	add sessions/0044/SESSION-0044.0-TRANSCRIPT-2026-06-13T07-40--2026-06-13T08-04.md + replace placeholder/variant SESSION-0044.0-TRANSCRIPT-2026-06-13T07-40--INPROGRESS.md	2026-06-13 08:04:35 -07:00
Ben Stull	b69d0f7d15	update sessions/0044/SESSION-0044.0-TRANSCRIPT-2026-06-13T07-40--INPROGRESS.md	2026-06-13 08:03:06 -07:00
benstull	dc38b55c57	Merge pull request '#47 (SLICE-2, review): per-block document proposals + word-precise accept' (#50 ) from f12-slice2-block-proposals into main	2026-06-13 15:01:55 +00:00
Ben Stull	2f6008ba2b	#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>	2026-06-13 08:01:16 -07:00
Ben Stull	6e944ab4cc	claim vscode-cowriting-plugin session 0044 (placeholder) + sessions.json entry	2026-06-13 07:40:13 -07:00
Ben Stull	2175efb5e5	add sessions/0043/SESSION-0043.0-TRANSCRIPT-2026-06-13T07-18--2026-06-13T07-38.md + replace placeholder/variant SESSION-0043.0-TRANSCRIPT-2026-06-13T07-18--INPROGRESS.md	2026-06-13 07:39:13 -07:00
Ben Stull	5dc7d19419	update sessions/0043/SESSION-0043.0-TRANSCRIPT-2026-06-13T07-18--INPROGRESS.md	2026-06-13 07:29:04 -07:00
benstull	e804c46ba0	Merge pull request '#42 (SLICE-1, reach): selection-aware Ask-Claude from editor body + tab' (#49 ) from f12-slice1-ask-claude-menus into main	2026-06-13 14:27:09 +00:00
Ben Stull	9c3770d26a	#42 (SLICE-1, reach): selection-aware Ask-Claude from editor body + tab Document-edit flow SLICE-1 (specs/coauthoring-document-edit-flow.md §7.2, INV-38): make "Ask Claude to Edit" reachable from the editor body AND the editor tab, selection-aware — a selection routes to editSelection, no selection to editDocument — both gated to markdown/authorable docs, both flowing through the single runEditAndPropose path (no divergent edit code). - package.json: add editSelection + editDocument to editor/context (selection- aware, markdown + file/untitled) and editor/title/context (selection-aware, resourceLangId == markdown). Markdown-gate the existing editor/context editSelection entry to match (its command handler is unchanged; the palette still reaches any authorable doc — see transcript Deferred decisions). - trackChangesPreview.ts: cowriting.editDocument accepts the clicked tab's resource Uri (editor/title/context), targeting THAT document (opening it if needed) and falling back to the active editor when invoked with no arg — mirroring showTrackChangesPreview's #41 clicked-doc resolution. - E2E (test/e2e/suite/f12Reach.test.ts): menu entries present, selection-aware, markdown-gated; editDocument(uri) targets the tab doc not the active editor; no-arg falls back to the active editor. - docs/MANUAL-SMOKE-F12.md: SLICE-1 reach smoke steps. 208 unit + 65/5 host E2E green. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-13 07:26:14 -07:00
Ben Stull	60a396c09e	claim vscode-cowriting-plugin session 0043 (placeholder) + sessions.json entry	2026-06-13 07:19:03 -07:00
Ben Stull	9ec0862353	add sessions/0042/SESSION-0042.0-TRANSCRIPT-2026-06-12T21-04--2026-06-13T07-16.md + replace placeholder/variant SESSION-0042.0-TRANSCRIPT-2026-06-12T21-04--INPROGRESS.md	2026-06-13 07:17:25 -07:00
Ben Stull	d5ef6dc90f	add sessions/0041/SESSION-0041.0-TRANSCRIPT-2026-06-12T18-17--2026-06-13T07-16.md + replace placeholder/variant SESSION-0041.0-TRANSCRIPT-2026-06-12T18-17--INPROGRESS.md	2026-06-13 07:17:16 -07:00
Ben Stull	261f0de240	claim vscode-cowriting-plugin session 0042 (placeholder) + sessions.json entry	2026-06-12 21:05:02 -07:00
Ben Stull	46f74c8247	claim vscode-cowriting-plugin session 0041 (placeholder) + sessions.json entry	2026-06-12 18:17:58 -07:00
Ben Stull	cc3d778da9	add sessions/0040/SESSION-0040.0-TRANSCRIPT-2026-06-12T17-03--2026-06-12T17-21.md + replace placeholder/variant SESSION-0040.0-TRANSCRIPT-2026-06-12T17-03--INPROGRESS.md	2026-06-12 17:22:23 -07:00
Ben Stull	981640f3d5	claim vscode-cowriting-plugin session 0040 (placeholder) + sessions.json entry	2026-06-12 17:03:31 -07:00
Ben Stull	2978663c14	add sessions/0039/SESSION-0039.0-TRANSCRIPT-2026-06-12T16-07--2026-06-12T17-02.md + replace placeholder/variant SESSION-0039.0-TRANSCRIPT-2026-06-12T16-07--INPROGRESS.md	2026-06-12 17:02:44 -07:00
Ben Stull	5eb13deca3	claim vscode-cowriting-plugin session 0039 (placeholder) + sessions.json entry	2026-06-12 16:07:27 -07:00
Ben Stull	91c55870f2	add sessions/0038/SESSION-0038.0-TRANSCRIPT-2026-06-12T15-55--2026-06-12T16-06.md + replace placeholder/variant SESSION-0038.0-TRANSCRIPT-2026-06-12T15-55--INPROGRESS.md	2026-06-12 16:06:50 -07:00
benstull	eea4145904	Merge pull request 'feat(#41 ): Open Cowriting Review Panel from markdown file/tab right-click' (#45 ) from 41-review-panel-right-click into main	2026-06-12 23:04:48 +00:00
Ben Stull	695b51f903	feat(#41 ): Open Cowriting Review Panel from markdown file/tab right-click The review preview (`cowriting.showTrackChangesPreview`) was only reachable from the command palette and `ctrl+alt+r` — neither where a writer's hand naturally goes. Add the obvious right-click entry points to the plugin's central surface: - `explorer/context` + `editor/title/context` menu items gated on `resourceLangId == markdown`, both invoking `showTrackChangesPreview`. - The command now resolves the clicked document: it opens the passed Uri if it isn't already an open document (the Explorer case), instead of falling back to the active editor. No-arg invocation (palette / keybinding) is unchanged. - Retitle the command to "Open Cowriting Review Panel" so the menus read the operator's wording (palette shows "Cowriting: Open Cowriting Review Panel"). E2E: clicked-doc resolution (open + not-yet-open + no-arg fallback), both menu contributions present + markdown-gated, title, and keybinding unchanged. Closes #41. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-12 16:04:02 -07:00