fix(proposals): reload-safe optimisticApply + reconciled toolbar summary (#64 )

Final-review fixes: - CRITICAL: optimisticApply no longer re-captures `original` from an already-applied buffer after a window reload (in-memory `applied` set is empty post-reload). A proposal already carrying `original` is marked applied and skipped, so Reject's revert target survives save+reload (INV-51/54). Adds a reload-safety host-E2E that reproduces the prior-session state. - MINOR: the preview toolbar +N/-N summary now counts against the landed text (current minus pending proposals) via the new pure landedTextOf(), so a pending change is shown once (as a proposal), not double-counted (INV-50). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
feat(webview): Accept/Reject + dropdown, rejectAll, control parity (#64 , INV-53)
2026-06-26 08:21:53 -07:00 · 2026-06-26 08:07:06 -07:00 · 2026-06-26 07:49:04 -07:00 · 2026-06-26 07:46:15 -07:00 · 2026-06-26 07:39:14 -07:00 · 2026-06-26 06:34:47 -07:00
37 changed files with 2081 additions and 166 deletions
@@ -89,6 +89,11 @@ pre.mermaid[data-cw-error] { color: var(--vscode-errorForeground); }
 }
 .cw-accept:hover { background: var(--vscode-testing-iconPassed, #2ea043); color: #fff; }
 .cw-reject:hover { background: var(--vscode-errorForeground, #f14c4c); color: #fff; }
+.cw-btngroup { display: inline-flex; }
+.cw-btngroup .cw-caret { border-left: none; padding: 0.1em 0.25em; }
+.cw-actions .cw-accept { font-weight: 600; }
+.cw-accept:hover, .cw-btngroup:has(.cw-accept) .cw-caret:hover { background: var(--vscode-testing-iconPassed, #2ea043); color: #fff; }
+.cw-reject:hover, .cw-btngroup:has(.cw-reject) .cw-caret:hover { background: var(--vscode-errorForeground, #f14c4c); color: #fff; }

 /* F7.1 (#22) intra-diagram mermaid diff legend. */
 .cw-mermaid-legend { display: flex; gap: 0.6rem; font-size: 0.75em; opacity: 0.85; margin: 0.2rem 0 0.6rem; }
@@ -94,13 +94,14 @@ acceptAllEl?.addEventListener("click", () => {
  vscodeApi.postMessage({ type: "acceptAll" });
 });

-// F10: delegated ✓/✗ accept/reject of pending proposals (routed back to the F4 seam).
+// F12/#64: Accept/Reject (+ caret → accept-all/reject-all) on a proposal block.
 body.addEventListener("click", (e) => {
  const btn = (e.target as HTMLElement)?.closest<HTMLElement>(".cw-actions button");
  if (!btn) return;
-  const block = btn.closest<HTMLElement>(".cw-proposal");
-  const id = block?.dataset.proposalId;
+  const id = btn.closest<HTMLElement>(".cw-proposal")?.dataset.proposalId;
  const action = btn.dataset.action;
+  if (action === "acceptAll") return void vscodeApi.postMessage({ type: "acceptAll" });
+  if (action === "rejectAll") return void vscodeApi.postMessage({ type: "rejectAll" });
  if (id && (action === "accept" || action === "reject")) {
    vscodeApi.postMessage({ type: action, proposalId: id });
  }
@@ -18,6 +18,16 @@
    "onStartupFinished"
  ],
  "contributes": {
+    "configuration": {
+      "title": "Cowriting",
+      "properties": {
+        "cowriting.liveProgress.revealOutput": {
+          "type": "boolean",
+          "default": true,
+          "description": "When Claude is editing, reveal the \"Cowriting: Claude\" output channel (without stealing focus) as soon as Claude starts producing text, so you can read the output as it streams."
+        }
+      }
+    },
    "commands": [
      {
        "command": "cowriting.showClineSdkInfo",
@@ -49,6 +59,21 @@
        "title": "Apply Agent Edit (internal seam)",
        "category": "Cowriting"
      },
+      {
+        "command": "cowriting.edit",
+        "title": "Ask Claude to Edit",
+        "category": "Cowriting"
+      },
+      {
+        "command": "cowriting.askClaude.submit",
+        "title": "Ask Claude to Edit",
+        "category": "Cowriting"
+      },
+      {
+        "command": "cowriting.askClaude.cancel",
+        "title": "Cancel",
+        "category": "Cowriting"
+      },
      {
        "command": "cowriting.editSelection",
        "title": "Ask Claude to Edit Selection",
@@ -88,6 +113,21 @@
        "command": "cowriting.acceptAllProposals",
        "title": "Accept All Claude Proposals",
        "category": "Cowriting"
+      },
+      {
+        "command": "cowriting.rejectAllProposals",
+        "title": "Reject All Claude Proposals",
+        "category": "Cowriting"
+      },
+      {
+        "command": "cowriting.proposalAcceptMenu",
+        "title": "Accept Claude Proposal",
+        "category": "Cowriting"
+      },
+      {
+        "command": "cowriting.proposalRejectMenu",
+        "title": "Reject Claude Proposal",
+        "category": "Cowriting"
      }
    ],
    "menus": {
@@ -108,17 +148,45 @@
          "command": "cowriting.rejectProposal",
          "when": "false"
        },
+        {
+          "command": "cowriting.askClaude.submit",
+          "when": "false"
+        },
+        {
+          "command": "cowriting.askClaude.cancel",
+          "when": "false"
+        },
        {
          "command": "cowriting.pinDiffBaseline",
          "when": "editorLangId == markdown"
        },
        {
-          "command": "cowriting.editDocument",
+          "command": "cowriting.edit",
          "when": "editorLangId == markdown"
        },
+        {
+          "command": "cowriting.editSelection",
+          "when": "false"
+        },
+        {
+          "command": "cowriting.editDocument",
+          "when": "false"
+        },
        {
          "command": "cowriting.acceptAllProposals",
          "when": "editorLangId == markdown"
+        },
+        {
+          "command": "cowriting.rejectAllProposals",
+          "when": "editorLangId == markdown"
+        },
+        {
+          "command": "cowriting.proposalAcceptMenu",
+          "when": "false"
+        },
+        {
+          "command": "cowriting.proposalRejectMenu",
+          "when": "false"
        }
      ],
      "editor/title": [
@@ -130,13 +198,8 @@
      ],
      "editor/title/context": [
        {
-          "command": "cowriting.editSelection",
-          "when": "editorHasSelection && resourceLangId == markdown",
-          "group": "1_cowriting@1"
-        },
-        {
-          "command": "cowriting.editDocument",
-          "when": "!editorHasSelection && resourceLangId == markdown",
+          "command": "cowriting.edit",
+          "when": "resourceLangId == markdown",
          "group": "1_cowriting@1"
        },
        {
@@ -154,13 +217,8 @@
      ],
      "editor/context": [
        {
-          "command": "cowriting.editSelection",
-          "when": "editorHasSelection && editorLangId == markdown && (resourceScheme == file || resourceScheme == untitled)",
-          "group": "1_cowriting@1"
-        },
-        {
-          "command": "cowriting.editDocument",
-          "when": "!editorHasSelection && editorLangId == markdown && (resourceScheme == file || resourceScheme == untitled)",
+          "command": "cowriting.edit",
+          "when": "editorLangId == markdown && (resourceScheme == file || resourceScheme == untitled)",
          "group": "1_cowriting@1"
        },
        {
@@ -174,6 +232,11 @@
          "command": "cowriting.reply",
          "group": "inline",
          "when": "commentController == cowriting.threads"
+        },
+        {
+          "command": "cowriting.askClaude.submit",
+          "group": "inline",
+          "when": "commentController == cowriting.askClaude"
        }
      ],
      "comments/commentThread/title": [
@@ -186,6 +249,11 @@
          "command": "cowriting.reopenThread",
          "group": "inline",
          "when": "commentController == cowriting.threads && commentThread =~ /^resolved$/"
+        },
+        {
+          "command": "cowriting.askClaude.cancel",
+          "group": "inline",
+          "when": "commentController == cowriting.askClaude"
        }
      ]
    },
@@ -193,7 +261,14 @@
      {
        "command": "cowriting.showTrackChangesPreview",
        "key": "ctrl+alt+r",
+        "mac": "cmd+alt+r",
        "when": "editorLangId == markdown"
+      },
+      {
+        "command": "cowriting.edit",
+        "key": "ctrl+alt+e",
+        "mac": "cmd+alt+e",
+        "when": "editorTextFocus && editorLangId == markdown"
      }
    ]
  },
@@ -10,7 +10,15 @@ console.log(`instruction: ${instruction}`);
 console.log(`text:        ${text}`);
 try {
  const t0 = Date.now();
-  const result = await runEditTurn(instruction, text);
+  // #60: exercise the live-progress path against the real SDK — log each reduced
+  // snapshot so the smoke shows streaming/activity/tokens, not just the result.
+  const result = await runEditTurn(instruction, text, {
+    onProgress: (s) => {
+      const bits = [s.phase === "tool" ? `tool:${s.tool}` : s.phase, `${s.chars}c`];
+      if (s.tokens) bits.push(`${s.tokens}tok`);
+      console.log(`  progress: ${bits.join(" ")}`);
+    },
+  });
  console.log(`replacement: ${JSON.stringify(result.replacement)}`);
  console.log(`model:       ${result.model}`);
  console.log(`sessionId:   ${result.sessionId}`);
@@ -0,0 +1,106 @@
+# Session 0056.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-26T04-24 (PST)
+> End: 2026-06-26T04-54 (PST)
+> Type: planning-and-executing
+> Posture: autonomous (yolo)
+> Status: **FINALIZED**
+
+## Launch prompt
+
+`/wgl-planning-and-executing implement #60 (live turn progress) from coauthoring-live-progress.md`
+
+(Continuation of brainstorming session 0055, which graduated the spec; the
+operator said "implement it" → this coding session.)
+
+## Plan
+
+Plan + execute **#60** (P1 feature — live turn progress) from the graduated
+Solution Design `coauthoring-live-progress.md`. Four cuts: (1) pure
+`turnProgress.ts` reducer + tests; (2) `runEditTurn` + `onProgress`/`AbortSignal`;
+(3) `liveProgressUi` + setting + both call sites; (4) host-E2E + smoke.
+Branch `s60-live-progress` → PR → main.
+
+## Pre-state
+
+- Clean `main` at session start (fast-forwarded 13 commits — the sessions/ repo
+  is the code repo itself). Baseline: 222 unit green.
+- #60 has a graduated Solution Design → §4.3 R2(b) satisfied.
+
+## Session arc
+
+1. **Claim + plan.** Claimed 0056 (no in-flight). Wrote the implementation plan
+   with `superpowers:writing-plans` → `docs/superpowers/plans/2026-06-26-live-turn-progress.md`
+   (self-reviewed: full spec coverage, no placeholders). Grounded in the exact SDK
+   types (`AgentToolCallPart.toolName`, `AgentUsage.inputTokens+outputTokens`), the
+   vitest/host-E2E patterns, and the injectable `editTurn` seam. Branch
+   `s60-live-progress`.
+2. **Task 1 — pure reducer.** `src/turnProgress.ts` + `test/turnProgress.test.ts`
+   (13 cases). Fixed the type-only event import: `AgentRuntimeEvent` is exported
+   from **`@cline/shared`**, not `@cline/sdk` (which doesn't re-export it) — caught
+   by typecheck; amended the commit.
+3. **Task 2 — `runEditTurn`.** Added `RunEditTurnOptions {onProgress, signal}`;
+   subscribes to the agent, folds events through the reducer, wires `signal` →
+   `agent.abort()`; `finally` unsubscribes. Mocked-agent unit tests (vitest
+   `doMock` intercepts the dynamic import).
+4. **Task 3 — host relay.** `src/liveProgressUi.ts` (notification line +
+   "Cowriting: Claude" OutputChannel, reveal gated by setting) + `package.json`
+   `contributes.configuration` `cowriting.liveProgress.revealOutput`.
+5. **Tasks 4+5 — both call sites.** `editSelection` (extension.ts) and preview
+   `askClaude`/`runEditAndPropose` (trackChangesPreview.ts) made cancellable,
+   relaying via the shared `liveProgressUi`; widened the `EditTurn` seam to accept
+   `opts?` (back-compat). Added `liveProgressUi` to `CowritingApi`.
+6. **Task 6 — host E2E.** `test/e2e/suite/liveProgress.test.ts`: progress is
+   additive (INV-44), aborted turn proposes nothing (INV-47).
+7. **Task 7 — verify + smoke.** typecheck + 237 unit + build green; enhanced
+   `scripts/smoke-live-turn.mjs` to log progress.
+8. **Subagent review.** Found a **Medium** (a pre-aborted `AbortSignal` was a
+   no-op — `agent.abort()` runs before the SDK's AbortController exists, so the
+   turn ran to completion) + a **Low** (a throwing `onProgress` relay could fail
+   the turn). Fixed both: short-circuit (throw) before `run()` on a pre-aborted
+   signal; wrap the relay in try/catch. Strengthened the unit + E2E to prove it.
+9. **Ship.** Pushed; opened PR #61; operator approved merge despite the
+   concurrency (below). Squash-merged `644885c`; issue #60 auto-closed.
+
+## ⚠️ Concurrency event (mid-session)
+
+Partway through, the shared working tree gained **uncommitted changes this session
+did NOT make** — a `cowriting.edit` / `routeEdit` reach refactor across
+`src/workspacePath.ts`, `test/workspacePath.test.ts`, and the menu/`routeEdit`
+parts of `package.json` + `src/extension.ts`. It broke 3 E2E (`f12Reach` ×2,
+`f11Toolbar` ×1) that still expect the old `editSelection`/`editDocument` command
+surface. Handling: committed **nothing** of it, discarded **nothing**; verified
+#60 green in isolation by stashing it (by path, reversible) — 237 unit + both #60
+E2E pass, only the documented `F10 #38` undo-sandbox flake remains — then popped
+the stash to restore it. Surfaced to the operator, who chose to merge #60 (its 7
+commits are isolated; the PR diff contains none of the foreign WIP).
+
+## Cut state (at finalize)
+
+- **#60 merged** to main (PR #61 squash `644885c`); issue #60 closed.
+- **Plan archived:** `submit-plan.sh` → content repo `plans/2026-06-26-live-turn-progress.md` (`22ec57e`).
+- **Foreign refactor WIP:** still uncommitted in the working tree, untouched —
+  for whoever is doing it to continue/commit (it rebases onto the new main).
+- **Local tree:** left on branch `s60-live-progress` (merged) DELIBERATELY — a
+  `checkout main`/`pull` would have disturbed the foreign uncommitted WIP. Local
+  main not synced; origin/main has #60. Operator should reconcile the local tree
+  + the in-flight refactor.
+- **Memory:** added `session-0056-60-live-progress-shipped.md` + index line.
+
+## Next-session prompt
+
+```
+/wgl-planning-and-executing reconcile the local tree (sync main; land/branch the in-flight cowriting.edit/routeEdit refactor), then pick the next item (open: #59 P1 bug, #57, #58, #32, #35, #40, OQ-2)
+```
+
+## Deferred decisions
+
+- **Left local on `s60-live-progress` (did not sync main):** to avoid disturbing
+  the concurrent uncommitted refactor in the shared tree. Low confidence this is
+  the tidiest end state, but it is the safest for the foreign WIP. Operator to
+  reconcile.
+- **Token field for the activity line:** used `inputTokens + outputTokens` from
+  `AgentUsage` (no `totalTokens` field exists). Cache tokens excluded.
+- **OutputChannel append-not-clear + auto-reveal gating:** per spec §3.5; carried
+  from session 0055's confirmed sub-decisions.
@@ -0,0 +1,22 @@
+# Session 0057.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-26T04-35 (PST)
+> Type: executing-plans
+> Posture: yolo
+> Claude-Session: 3d66a467-8026-472d-9693-52a37939d493
+> Status: **PLACEHOLDER — claimed at session start; finalized at session end.**
+>
+> This file reserves session ID 0057 for vscode-cowriting-plugin. The driver replaces this
+> body with the full transcript and renames the file to its final
+> SESSION-0057.0-TRANSCRIPT-2026-06-26T04-35--<end>.md form at session end.
+
+## Launch prompt
+
+_(launch prompt not captured at claim time)_
+
+## 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._
@@ -0,0 +1,85 @@
+# Session 0058.0 — Transcript
+
+> App: vscode-cowriting-plugin
+> Start: 2026-06-26T05-12 (PST)
+> End: 2026-06-26T05-58 (PST)
+> Type: brainstorming
+> Posture: autonomous (yolo)
+> Status: **FINALIZED**
+
+## Launch prompt
+
+Operator opened by asking what was in the Gitea backlog, then directed a
+brainstorming session for a new feature: *"We should also show the proposed change
+in the Markdown file in the same way. The proposed change in the markdown file
+should be human-editable, show the diff just like it would after the change is
+completed in both the markdown file and the webview as the change is made. The
+diff in both the markdown file and preview webview should be exactly as they will
+be shown if the edit is accepted. Create a new working tree in a directory other
+than main for this work."* — extended mid-session with: *"replace the checkbox
+icon and 'x' icon on the proposed change as 'Accept' and 'Reject'. Each should
+have an arrow next to them for a dropdown that is 'Accept All' or 'Reject All'.
+One should be able to accept, reject, accept all, or reject all from either the
+markdown file or the web preview file."*
+
+## Pre-state
+
+- Branch `main`, clean/pushed baseline (after FF). Latest shipped work: #60 live
+  turn progress (session 0056, PR #61). Session 0057 (a `cowriting.edit`/`routeEdit`
+  refactor) still **in-flight** sharing the checkout.
+- Backlog at session start (8 open): #59 (P1 bug, Apple-Events prompt), #54/#57/#58
+  (P2), #32/#35/#40 (P3), #62 (untriaged).
+
+## Turn-by-turn arc
+
+1. **Backlog query** — listed the 8 open Gitea issues for `benstull/vscode-cowriting-plugin`
+   by priority; flagged #62 as the only untriaged item.
+2. **Session routing** — operator's feature request was feature-shaped *and*
+   reversed a locked invariant (F10/INV-32 "clean editor"), so the session type
+   was ambiguous. Asked; operator chose **brainstorm a spec first**. Routed via
+   `wgl-brainstorming`; claimed session **0058**.
+3. **Isolation** — session 0057 still in-flight on the shared checkout → created an
+   isolated worktree `vscode-cowriting-plugin-s58` on branch
+   `s58-inline-editor-diff` off `origin/main` (§5.4).
+4. **Exploration** — dispatched an Explore agent that mapped five areas: webview
+   render engine (`trackChangesModel.ts`), F4 proposal model + seam, the F10
+   clean-editor decision (zero editor decorations remain), controllers/wiring, and
+   commands/toolbar. Key constraint surfaced: **VS Code text editors cannot host
+   editable phantom text** — anything editable in the editor is buffer content;
+   decorations only style existing text or inject *non-editable* before/after
+   content.
+5. **Four design forks (AskUserQuestion, with ASCII previews):**
+   - Editor model → **optimistic apply + decorations**.
+   - Timing → **on proposal** (not live token-stream into the editor).
+   - Editor affordance → **CodeLens `Accept ▾ / Reject ▾` + QuickPick dropdown**.
+   - (Operator-added) Control parity → Accept/Reject/Accept-all/Reject-all from
+     both surfaces; ✓/✗ superseded.
+6. **Design presented** section-by-section; operator approved with "keep going"
+   (nodded the two flagged sub-decisions: dedicated `EditorProposalController`;
+   allow save of pending text).
+7. **Anchor + spec** — filed Feature **#64** (`type/feature`, `priority/P2`) since
+   no tracker anchor existed; wrote `specs/coauthoring-inline-editor-diff.md`
+   (INV-48..54, reversing INV-10/INV-32). Self-review clean. Operator **approved**.
+
+## Cut state
+
+- Spec **graduated** → content repo `vscode-cowriting-plugin-content` at `80d5d1a`
+  (`specs/coauthoring-inline-editor-diff.md`).
+- Feature **#64** filed + labelled.
+- Worktree `vscode-cowriting-plugin-s58` (branch `s58-inline-editor-diff`) stands
+  ready for the downstream planning-and-executing session; no code committed this
+  session (brainstorming output is the spec only).
+- Memory updated: `f12-inline-editor-diff-spec-graduated.md` + MEMORY.md index.
+
+## Deferred decisions
+
+No autonomous low-confidence calls — every fork was decided live with the operator
+via AskUserQuestion, and the spec was operator-approved before submission. (The
+two design sub-decisions — dedicated controller, allow-save-of-pending — were
+flagged in the presented design and nodded by the operator.)
+
+## Next-session prompt
+
+```
+/goal Plan-and-execute #64 (F12 inline editable proposed-change diff in the Markdown editor) from specs/coauthoring-inline-editor-diff.md, in worktree vscode-cowriting-plugin-s58 (branch s58-inline-editor-diff); follow the spec's 5-slice Delivery Plan
+```
@@ -1,13 +1,13 @@
-# Session 0056.0 — Transcript
+# Session 0059.0 — Transcript

 > App: vscode-cowriting-plugin
-> Start: 2026-06-26T04-24 (PST)
+> Start: 2026-06-26T06-01 (PST)
 > Type: planning-and-executing
 > Status: **PLACEHOLDER — claimed at session start; finalized at session end.**
 >
-> This file reserves session ID 0056 for vscode-cowriting-plugin. The driver replaces this
+> This file reserves session ID 0059 for vscode-cowriting-plugin. The driver replaces this
 > body with the full transcript and renames the file to its final
-> SESSION-0056.0-TRANSCRIPT-2026-06-26T04-24--<end>.md form at session end.
+> SESSION-0059.0-TRANSCRIPT-2026-06-26T06-01--<end>.md form at session end.

 ## Launch prompt

@@ -166,5 +166,14 @@
  },
  "0056": {
    "title": ""
+  },
+  "0057": {
+    "title": ""
+  },
+  "0058": {
+    "title": ""
+  },
+  "0059": {
+    "title": ""
  }
 }
@@ -249,7 +249,7 @@ export class AttributionController implements vscode.Disposable {
    range: vscode.Range,
    newText: string,
    provenance: Provenance,
-    opts?: { expectedVersion?: number; turnId?: string },
+    opts?: { expectedVersion?: number; turnId?: string; landBaseline?: boolean },
  ): Promise<boolean> {
    if (!this.isTracked(document)) return false;
    if (opts?.expectedVersion !== undefined && document.version !== opts.expectedVersion) return false;
@@ -290,15 +290,25 @@ export class AttributionController implements vscode.Disposable {
        "(host minimized differently?) — the edit may be mis-attributed (INV-9).",
      );
    }
-    if (ok) {
-      // F6 (INV-18): a real machine landing — signal the baseline to advance so
-      // this text never shows as a change in the diff view. Fire regardless of
-      // attribution-match bookkeeping above; the landing happened either way.
+    if (ok && opts?.landBaseline !== false) {
+      // F6 (INV-18): a real machine landing — advance the baseline. F12 (INV-48)
+      // suppresses this for optimistic apply: the proposed text is in the buffer
+      // but the change stays PENDING (baseline at pre-proposal) until accept.
      this.applyEmitter.fire({ document });
    }
    return ok;
  }

+  /**
+   * F12/#64 (INV-51): fire the machine-landing signal WITHOUT applying text — used
+   * by finalize-in-place, where the proposed text already landed in the buffer via
+   * optimistic apply (`landBaseline:false`) and accept only needs to advance the
+   * F6 baseline so the now-accepted change stops reading as pending.
+   */
+  signalLanded(document: vscode.TextDocument): void {
+    if (this.isTracked(document)) this.applyEmitter.fire({ document });
+  }
+
  // ---- PUC-4: persistence on save ----------------------------------------------------

  private onDidSave(document: vscode.TextDocument): void {
@@ -0,0 +1,151 @@
+/**
+ * EditorProposalController — F12/#64 editor surface (spec coauthoring-inline-editor-diff
+ * §3.5). Reverses INV-32 for pending proposals: on `onDidChangeProposals` it
+ * (1) optimistically applies any not-yet-applied proposal into the active editor's
+ * buffer (ProposalController.optimisticApply, INV-48), (2) decorates each applied
+ * proposal — insertion tint over the proposed text + a non-editable struck-red hint
+ * for deletions (INV-52, decorationPlan/INV-49), and (3) provides a CodeLens
+ * `Accept ▾ / Reject ▾` above each block whose ▾ opens a QuickPick (this / all).
+ * Owns no proposal STATE — it is a view over ProposalController (which stays the
+ * pure F4 owner). A document with no pending proposals shows nothing (INV-32's
+ * spirit when nothing is pending).
+ */
+import * as vscode from "vscode";
+import type { ProposalController } from "./proposalController";
+import { decorationPlan } from "./trackChangesModel";
+import { isAuthorable } from "./workspacePath";
+
+export class EditorProposalController implements vscode.Disposable, vscode.CodeLensProvider {
+  private readonly disposables: vscode.Disposable[] = [];
+  private readonly insertionDeco = vscode.window.createTextEditorDecorationType({
+    backgroundColor: new vscode.ThemeColor("diffEditor.insertedTextBackground"),
+  });
+  private readonly deletionDeco = vscode.window.createTextEditorDecorationType({
+    // a non-editable struck-red hint injected AFTER the insertion (INV-52)
+    after: { color: new vscode.ThemeColor("gitDecoration.deletedResourceForeground") },
+    textDecoration: "none",
+  });
+  private readonly lensEmitter = new vscode.EventEmitter<void>();
+  readonly onDidChangeCodeLenses = this.lensEmitter.event;
+  /** Pending debounce timers — one per URI — coalesce rapid-fire propose events
+   * (e.g. runEditAndPropose's N sequential propose() calls) into a single
+   * optimistic-apply pass that runs after ALL proposals are created. Without this,
+   * each propose() fires onDidChangeProposals synchronously and the controller's
+   * optimisticApply runs concurrently with the still-in-progress propose loop,
+   * causing "file changed in the meantime" workspace-edit conflicts. */
+  private readonly pendingApply = new Map<string, ReturnType<typeof setTimeout>>();
+
+  constructor(private readonly proposals: ProposalController) {
+    this.disposables.push(
+      this.insertionDeco, this.deletionDeco, this.lensEmitter,
+      vscode.languages.registerCodeLensProvider({ language: "markdown" }, this),
+      this.proposals.onDidChangeProposals(({ uri }) => this.scheduleApply(uri)),
+      vscode.window.onDidChangeActiveTextEditor((ed) => ed && this.renderEditor(ed)),
+      // the four QuickPick-backed menu commands
+      vscode.commands.registerCommand("cowriting.proposalAcceptMenu", (id?: string) => this.menu("accept", id)),
+      vscode.commands.registerCommand("cowriting.proposalRejectMenu", (id?: string) => this.menu("reject", id)),
+    );
+  }
+
+  /** Debounce-schedule an optimistic-apply pass for the given URI. Multiple rapid
+   * onDidChangeProposals events (from a single runEditAndPropose batch) collapse
+   * into one pass that runs after the batch completes. */
+  private scheduleApply(uri: string): void {
+    const prev = this.pendingApply.get(uri);
+    if (prev !== undefined) clearTimeout(prev);
+    this.pendingApply.set(
+      uri,
+      setTimeout(() => {
+        this.pendingApply.delete(uri);
+        void this.onProposalsChanged(uri);
+      }, 0),
+    );
+  }
+
+  /** Apply any not-yet-applied proposals on the doc, then re-decorate + refresh lenses. */
+  private async onProposalsChanged(uri: string): Promise<void> {
+    const doc = vscode.workspace.textDocuments.find((d) => d.uri.toString() === uri);
+    if (!doc || doc.languageId !== "markdown" || !isAuthorable(doc.uri.scheme)) return;
+    const key = this.proposals.keyFor(doc);
+    for (const v of this.proposals.listProposals(doc)) {
+      if (v.anchorStart !== null && !this.proposals.isApplied(key, v.id)) {
+        await this.proposals.optimisticApply(doc, v.id); // fires onDidChangeProposals again; guarded by isApplied
+      }
+    }
+    const ed = vscode.window.visibleTextEditors.find((e) => e.document.uri.toString() === uri);
+    if (ed) this.renderEditor(ed);
+    this.lensEmitter.fire();
+  }
+
+  /** Decorate the editor for every applied proposal on its document (INV-52). */
+  private renderEditor(editor: vscode.TextEditor): void {
+    const doc = editor.document;
+    if (doc.languageId !== "markdown") {
+      editor.setDecorations(this.insertionDeco, []);
+      editor.setDecorations(this.deletionDeco, []);
+      return;
+    }
+    const key = this.proposals.keyFor(doc);
+    const insertions: vscode.Range[] = [];
+    const deletions: vscode.DecorationOptions[] = [];
+    for (const v of this.proposals.listProposals(doc)) {
+      if (v.anchorStart === null || v.original === undefined || !this.proposals.isApplied(key, v.id)) continue;
+      const plan = decorationPlan(v.anchorStart, v.original, v.replacement);
+      for (const ins of plan.insertions) {
+        insertions.push(new vscode.Range(doc.positionAt(ins.start), doc.positionAt(ins.end)));
+      }
+      for (const del of plan.deletions) {
+        deletions.push({
+          range: new vscode.Range(doc.positionAt(del.at), doc.positionAt(del.at)),
+          renderOptions: { after: { contentText: ` ${del.text} `, textDecoration: "line-through" } },
+        });
+      }
+    }
+    editor.setDecorations(this.insertionDeco, insertions);
+    editor.setDecorations(this.deletionDeco, deletions);
+  }
+
+  /** CodeLensProvider: a `Accept ▾` / `Reject ▾` pair above each applied block. */
+  provideCodeLenses(document: vscode.TextDocument): vscode.CodeLens[] {
+    if (document.languageId !== "markdown") return [];
+    const key = this.proposals.keyFor(document);
+    const lenses: vscode.CodeLens[] = [];
+    for (const v of this.proposals.listProposals(document)) {
+      if (v.anchorStart === null || !this.proposals.isApplied(key, v.id)) continue;
+      const pos = document.positionAt(v.anchorStart);
+      const line = new vscode.Range(pos.line, 0, pos.line, 0);
+      lenses.push(
+        new vscode.CodeLens(line, { title: "Accept ▾", command: "cowriting.proposalAcceptMenu", arguments: [v.id] }),
+        new vscode.CodeLens(line, { title: "Reject ▾", command: "cowriting.proposalRejectMenu", arguments: [v.id] }),
+      );
+    }
+    return lenses;
+  }
+
+  /** The dropdown: this-proposal vs all-proposals, then dispatch. */
+  private async menu(kind: "accept" | "reject", id?: string): Promise<void> {
+    const doc = vscode.window.activeTextEditor?.document;
+    if (!doc || !id) return;
+    const key = this.proposals.keyFor(doc);
+    const verb = kind === "accept" ? "Accept" : "Reject";
+    const pick = await vscode.window.showQuickPick(
+      [`${verb} this proposal`, `${verb} ALL proposals`],
+      { placeHolder: `${verb} Claude's proposal` },
+    );
+    if (!pick) return;
+    const all = pick.includes("ALL");
+    if (kind === "accept") {
+      if (all) await this.proposals.acceptAllProposals(doc);
+      else await this.proposals.finalizeInPlace(key, id);
+    } else {
+      if (all) await this.proposals.rejectAll(doc);
+      else await this.proposals.revertInPlace(key, id);
+    }
+  }
+
+  dispose(): void {
+    for (const t of this.pendingApply.values()) clearTimeout(t);
+    this.pendingApply.clear();
+    for (const d of this.disposables) d.dispose();
+  }
+}
@@ -11,7 +11,10 @@ import { GlobalSidecarStore } from "./globalSidecarStore";
 import { SidecarRouter } from "./sidecarRouter";
 import { DiffViewController } from "./diffViewController";
 import { TrackChangesPreviewController } from "./trackChangesPreview";
-import { isAuthorable, selectionRejection } from "./workspacePath";
+import { LiveProgressUi } from "./liveProgressUi";
+import { InlineAskController } from "./inlineAsk";
+import { EditorProposalController } from "./editorProposalController";
+import { isAuthorable, routeEdit, selectionRejection } from "./workspacePath";

 const CHANNEL_NAME = "Cowriting (Cline SDK)";

@@ -23,12 +26,25 @@ export interface CowritingApi {
  diffViewController: DiffViewController;
  trackChangesPreviewController: TrackChangesPreviewController;
  sidecarRouter: SidecarRouter;
+  liveProgressUi: LiveProgressUi;
+  inlineAsk: InlineAskController;
+  editorProposalController: EditorProposalController;
 }

 export function activate(context: vscode.ExtensionContext): CowritingApi | undefined {
  // --- POC command (Feature #2), unchanged ---
  const output = vscode.window.createOutputChannel(CHANNEL_NAME);
  context.subscriptions.push(output);
+
+  // #60: shared live-progress UI (notification activity line + "Cowriting: Claude"
+  // OutputChannel) for both Ask-Claude entry points.
+  const liveProgressUi = new LiveProgressUi();
+  context.subscriptions.push(liveProgressUi);
+
+  // The inline "Ask Claude to Edit" prompt — rendered at the selection/cursor via
+  // the Comments API rather than the top-center QuickInput (see inlineAsk.ts).
+  // Shared by both Ask-Claude entry points (editSelection + the preview's askClaude).
+  const inlineAsk = new InlineAskController(context.subscriptions);
  context.subscriptions.push(
    vscode.commands.registerCommand("cowriting.showClineSdkInfo", async () => {
      try {
@@ -104,9 +120,16 @@ export function activate(context: vscode.ExtensionContext): CowritingApi | undef
    context.extensionUri,
    attributionController,
    proposalController,
+    liveProgressUi,
+    inlineAsk,
  );
  context.subscriptions.push(trackChangesPreviewController);

+  // --- F12 (#64): the editor surface — optimistic-apply proposals into the buffer,
+  // decorate the diff, and provide Accept ▾/Reject ▾ CodeLens (INV-48/49/52/53). ---
+  const editorProposalController = new EditorProposalController(proposalController);
+  context.subscriptions.push(editorProposalController);
+
  // #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.
@@ -121,6 +144,18 @@ export function activate(context: vscode.ExtensionContext): CowritingApi | undef
    }),
  );

+  // #64 (INV-53): reject every pending proposal on the active doc in one gesture.
+  context.subscriptions.push(
+    vscode.commands.registerCommand("cowriting.rejectAllProposals", async () => {
+      const doc = vscode.window.activeTextEditor?.document;
+      if (!doc || doc.languageId !== "markdown") {
+        void vscode.window.showWarningMessage("Cowriting: open a Markdown document to reject its proposals.");
+        return;
+      }
+      await trackChangesPreviewController.rejectAll(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.
@@ -209,17 +244,12 @@ export function activate(context: vscode.ExtensionContext): CowritingApi | undef
        return;
      }
      if (!editor) return; // unreachable once reason is null, but narrows the type
-      const instruction = await vscode.window.showInputBox({
-        prompt: "What should Claude do with the selection?",
-        placeHolder: "e.g. tighten this paragraph",
-      });
-      if (!instruction) return;
-      if (editor.selection.isEmpty) {
-        void vscode.window.showWarningMessage("Cowriting: select some text to send to Claude first.");
-        return;
-      }
      const document = editor.document;
-      const selection = editor.selection;
+      const selection = editor.selection; // non-empty (selectionRejection guaranteed it)
+      // The instruction prompt opens INLINE at the selection (inlineAsk), not the
+      // top-center QuickInput — anchored to the text Claude will edit.
+      const instruction = await inlineAsk.prompt(document.uri, selection);
+      if (!instruction) return;
      const selectedText = document.getText(selection);
      // Capture the anchor BEFORE the turn (spec §6.5 PUC-1): mid-turn edits
      // can't skew it — the proposal renders wherever the target re-resolves.
@@ -230,10 +260,28 @@ export function activate(context: vscode.ExtensionContext): CowritingApi | undef
      const turnId = `turn-${Date.now().toString(36)}`;
      try {
        await vscode.window.withProgress(
-          { location: vscode.ProgressLocation.Notification, title: "Cowriting: asking Claude…" },
-          async () => {
+          {
+            location: vscode.ProgressLocation.Notification,
+            title: "Cowriting: asking Claude…",
+            cancellable: true,
+          },
+          async (progress, token) => {
            const { runEditTurn } = await import("./liveTurn");
-            const turn = await runEditTurn(instruction, selectedText);
+            const ui = liveProgressUi.begin(instruction, progress, token);
+            let turn;
+            try {
+              turn = await runEditTurn(instruction, selectedText, {
+                onProgress: ui.onProgress,
+                signal: ui.signal,
+              });
+            } catch (err) {
+              // #60 (INV-47): a user cancel surfaces as "cancelled", not a failure.
+              if (token.isCancellationRequested) {
+                void vscode.window.showInformationMessage("Cowriting: Claude edit cancelled.");
+                return;
+              }
+              throw err;
+            }
            if (turn.replacement === "") {
              void vscode.window.showWarningMessage(
                "Cowriting: Claude returned an empty replacement — nothing was proposed.",
@@ -273,6 +321,28 @@ export function activate(context: vscode.ExtensionContext): CowritingApi | undef
    }),
  );

+  // The single user-facing "Ask Claude to Edit" gesture (one command, one
+  // keybinding, one menu entry). It routes to the selection flow (editSelection)
+  // or the whole-document flow (editDocument) by selection/context — see
+  // routeEdit. The two underlying commands stay registered for the host E2E
+  // harness and the internal seams, but are hidden from the palette.
+  context.subscriptions.push(
+    vscode.commands.registerCommand("cowriting.edit", async (uri?: vscode.Uri) => {
+      const editor = vscode.window.activeTextEditor;
+      const route = routeEdit({
+        hasUri: !!uri,
+        uriMatchesActiveEditor: !!uri && editor?.document.uri.toString() === uri.toString(),
+        hasActiveEditor: !!editor,
+        selectionEmpty: editor?.selection.isEmpty ?? true,
+      });
+      if (route === "selection") {
+        await vscode.commands.executeCommand("cowriting.editSelection");
+      } else {
+        await vscode.commands.executeCommand("cowriting.editDocument", uri);
+      }
+    }),
+  );
+
  // Render threads + attributions for already-open editors, and on future opens.
  const renderIfOpen = (doc: vscode.TextDocument) => {
    if (isAuthorable(doc.uri.scheme)) {
@@ -292,6 +362,9 @@ export function activate(context: vscode.ExtensionContext): CowritingApi | undef
    diffViewController,
    trackChangesPreviewController,
    sidecarRouter,
+    liveProgressUi,
+    inlineAsk,
+    editorProposalController,
  };
 }

@@ -0,0 +1,71 @@
+import * as vscode from "vscode";
+
+/** Trim the reply text; an empty/whitespace-only instruction is "no instruction". */
+export function normalizeInstruction(text: string | undefined): string | undefined {
+  const t = text?.trim();
+  return t ? t : undefined;
+}
+
+/**
+ * The "Ask Claude to Edit" prompt, rendered INLINE at the selection (or cursor)
+ * instead of the top-center QuickInput. VS Code's native pattern for "ask AI to
+ * edit this" is Inline Chat — an input anchored in the editor at the target. The
+ * stable-API equivalent for a third-party extension is the Comments API: a
+ * transient comment thread whose reply box renders right at the range. (The
+ * coauthoring THREADS feature already uses the Comments API via its own
+ * controller — this is a SEPARATE, dedicated `cowriting.askClaude` controller so
+ * the two never collide.)
+ *
+ * One prompt is live at a time; opening a new one cancels the previous. The
+ * thread carries no comments — it is purely the inline input — and is disposed
+ * as soon as the user submits or cancels.
+ */
+export class InlineAskController {
+  private readonly controller: vscode.CommentController;
+  private pending?: { resolve: (v: string | undefined) => void; thread: vscode.CommentThread };
+
+  constructor(disposables: vscode.Disposable[]) {
+    this.controller = vscode.comments.createCommentController("cowriting.askClaude", "Ask Claude to Edit");
+    // The reply box's prompt + placeholder (Comments API options).
+    this.controller.options = {
+      prompt: "Ask Claude to Edit",
+      placeHolder: "e.g. tighten this paragraph",
+    };
+    disposables.push(
+      this.controller,
+      vscode.commands.registerCommand("cowriting.askClaude.submit", (r: vscode.CommentReply) =>
+        this.finish(normalizeInstruction(r?.text)),
+      ),
+      vscode.commands.registerCommand("cowriting.askClaude.cancel", () => this.finish(undefined)),
+      // The controller itself disposes the live thread on extension teardown.
+      new vscode.Disposable(() => this.finish(undefined)),
+    );
+  }
+
+  /**
+   * Open the inline input anchored at `range` in `uri`'s editor and resolve with
+   * the typed instruction (or `undefined` if cancelled / left empty). Replaces
+   * any prompt already open.
+   */
+  prompt(uri: vscode.Uri, range: vscode.Range): Promise<string | undefined> {
+    // A fresh prompt supersedes any prior one (resolve it as cancelled).
+    this.finish(undefined);
+    return new Promise<string | undefined>((resolve) => {
+      const thread = this.controller.createCommentThread(uri, range, []);
+      thread.label = "Ask Claude to Edit";
+      thread.canReply = true;
+      thread.collapsibleState = vscode.CommentThreadCollapsibleState.Expanded;
+      thread.contextValue = "askClaude";
+      this.pending = { resolve, thread };
+    });
+  }
+
+  /** Resolve the live prompt (if any) and tear its thread down. */
+  private finish(value: string | undefined): void {
+    const p = this.pending;
+    this.pending = undefined;
+    if (!p) return;
+    p.thread.dispose();
+    p.resolve(value);
+  }
+}
@@ -0,0 +1,65 @@
+/**
+ * liveProgressUi.ts — host-side relay of TurnProgress snapshots to VS Code UI
+ * (#60, spec coauthoring-live-progress.md §3.4). The ONLY surfaces are the
+ * existing withProgress notification (an activity line) and a dedicated
+ * OutputChannel streaming the full assistant text — no new network/webview
+ * surface (INV-45). vscode-only; all pure logic lives in turnProgress.ts.
+ */
+import * as vscode from "vscode";
+import { formatProgressLine, type TurnProgressSnapshot } from "./turnProgress";
+
+const CHANNEL_NAME = "Cowriting: Claude";
+
+export interface TurnUi {
+  /** Pass to runEditTurn's opts.onProgress. */
+  onProgress: (snapshot: TurnProgressSnapshot) => void;
+  /** Pass to runEditTurn's opts.signal — fired when the user cancels the notification. */
+  signal: AbortSignal;
+}
+
+export class LiveProgressUi {
+  readonly channel: vscode.OutputChannel;
+
+  constructor() {
+    this.channel = vscode.window.createOutputChannel(CHANNEL_NAME);
+  }
+
+  /**
+   * Begin one turn's UI. Writes the per-turn header to the channel and returns
+   * the onProgress relay + an AbortSignal linked to the notification's cancel
+   * token. The channel APPENDS (it doubles as a debug log of recent turns, spec
+   * §3.5); it auto-reveals (without stealing focus) on the first streamed text,
+   * gated by `cowriting.liveProgress.revealOutput`.
+   */
+  begin(
+    instruction: string,
+    progress: vscode.Progress<{ message?: string }>,
+    token: vscode.CancellationToken,
+  ): TurnUi {
+    const controller = new AbortController();
+    token.onCancellationRequested(() => controller.abort());
+    this.channel.appendLine(`── asking: ${instruction} ──`);
+
+    let revealed = false;
+    const reveal = (): void => {
+      if (revealed) return;
+      revealed = true;
+      const cfg = vscode.workspace.getConfiguration("cowriting");
+      if (cfg.get<boolean>("liveProgress.revealOutput", true)) this.channel.show(true);
+    };
+
+    const onProgress = (s: TurnProgressSnapshot): void => {
+      progress.report({ message: formatProgressLine(s) });
+      if (s.textDelta) {
+        this.channel.append(s.textDelta);
+        reveal();
+      }
+    };
+
+    return { onProgress, signal: controller.signal };
+  }
+
+  dispose(): void {
+    this.channel.dispose();
+  }
+}
@@ -9,6 +9,9 @@
 * never bundled (esbuild keeps it external).
 */

+import type { TurnProgressSnapshot } from "./turnProgress";
+import { createTurnProgressState, reduceTurnProgress } from "./turnProgress";
+
 export interface EditTurnResult {
  replacement: string;
  model: string;
@@ -16,6 +19,19 @@ export interface EditTurnResult {
  sessionId: string;
 }

+/**
+ * Options for runEditTurn. Both new fields are purely additive observability /
+ * control over the existing turn (INV-44): `onProgress` streams reduced progress
+ * snapshots out; `signal` cancels the turn in. Neither touches the result path,
+ * and neither pulls `vscode` into this module (INV-43 — `AbortSignal` is a web
+ * standard, the progress snapshot is a domain type).
+ */
+export interface RunEditTurnOptions {
+  modelId?: string;
+  onProgress?: (snapshot: TurnProgressSnapshot) => void;
+  signal?: AbortSignal;
+}
+
 const SYSTEM_PROMPT = [
  "You are a precise text editor embedded in VS Code.",
  "You will be given a piece of text and an instruction.",
@@ -40,7 +56,7 @@ export function extractReplacement(outputText: string, selectedText: string): st
 export async function runEditTurn(
  instruction: string,
  selectedText: string,
-  opts?: { modelId?: string },
+  opts?: RunEditTurnOptions,
 ): Promise<EditTurnResult> {
  const sdk = await import("@cline/sdk");
  const modelId = opts?.modelId ?? "sonnet";
@@ -49,16 +65,50 @@ export async function runEditTurn(
    modelId,
    systemPrompt: SYSTEM_PROMPT,
  });
-  const result = await agent.run(
-    `<instruction>\n${instruction}\n</instruction>\n<text>\n${selectedText}\n</text>`,
-  );
-  // The SDK's AgentRunResult.status union is "completed" | "aborted" | "failed"
-  // (@cline/shared agent.d.ts) — "completed" is the success status.
-  if (result.status !== "completed") {
-    throw new Error(
-      `claude-code turn ${result.status}: ${result.error?.message ?? "unknown error"} ` +
-        "(is Claude Code installed and signed in?)",
+
+  // Stream reduced progress snapshots out (INV-44 additive) and wire cancellation
+  // in via the AbortSignal (INV-47). agent.subscribe returns its unsubscribe fn.
+  let state = createTurnProgressState();
+  const unsubscribe = opts?.onProgress
+    ? agent.subscribe((event) => {
+        const next = reduceTurnProgress(state, event);
+        state = next.state;
+        // Observability must never affect the result (INV-44): a throwing relay
+        // is swallowed, not allowed to propagate into the SDK and fail the turn.
+        if (next.snapshot) {
+          try {
+            opts.onProgress!(next.snapshot);
+          } catch {
+            /* progress is best-effort */
+          }
+        }
+      })
+    : undefined;
+  const onAbort = () => agent.abort();
+  opts?.signal?.addEventListener("abort", onAbort);
+
+  try {
+    // A signal already aborted before the turn starts can't be honored by
+    // agent.abort() (the SDK's AbortController isn't created until run()), so
+    // short-circuit to the same aborted outcome the call site reflects (INV-47).
+    if (opts?.signal?.aborted) {
+      throw new Error("claude-code turn aborted: cancelled before start");
+    }
+    const result = await agent.run(
+      `<instruction>\n${instruction}\n</instruction>\n<text>\n${selectedText}\n</text>`,
    );
+    // The SDK's AgentRunResult.status union is "completed" | "aborted" | "failed"
+    // (@cline/shared agent.d.ts) — "completed" is the success status. An aborted
+    // turn (user cancel) falls into this throw; the call site reflects "cancelled".
+    if (result.status !== "completed") {
+      throw new Error(
+        `claude-code turn ${result.status}: ${result.error?.message ?? "unknown error"} ` +
+          "(is Claude Code installed and signed in?)",
+      );
+    }
+    return { replacement: extractReplacement(result.outputText, selectedText), model: modelId, sessionId: result.runId };
+  } finally {
+    unsubscribe?.();
+    opts?.signal?.removeEventListener("abort", onAbort);
  }
-  return { replacement: extractReplacement(result.outputText, selectedText), model: modelId, sessionId: result.runId };
 }
@@ -97,6 +97,14 @@ export interface Proposal {
   * back-compat with older sidecars) ⇒ a single-range proposal accepted whole.
   */
  granularity?: "block" | "single";
+  /**
+   * F12/#64 (INV-48): the pre-apply text, captured when a proposal is
+   * optimistically applied to the buffer. `replacement` is now in the buffer and
+   * `fp.text` re-anchors to it, so `original` is the only record of what to revert
+   * to (revert-in-place) and what to show struck in the `<del>` half. Absent on a
+   * proposal created but not yet optimistically applied (or older sidecars).
+   */
+  original?: string;
 }

 export interface Artifact {
@@ -252,6 +260,8 @@ export function serializeArtifact(a: Artifact): string {
            createdAt: p.createdAt,
            ...(p.turnId !== undefined ? { turnId: p.turnId } : {}),
            ...(p.instruction !== undefined ? { instruction: p.instruction } : {}),
+            ...(p.original !== undefined ? { original: p.original } : {}),
+            ...(p.granularity !== undefined ? { granularity: p.granularity } : {}),
          },
          p,
        ),
@@ -13,8 +13,8 @@
 import * as vscode from "vscode";
 import { SidecarRouter, docIdentity } from "./sidecarRouter";
 import { emptyArtifact, type Artifact, type Fingerprint, type Proposal, type Provenance } from "./model";
-import { resolve, shift, type OffsetRange } from "./anchorer";
-import { addProposal, removeProposal } from "./proposalModel";
+import { resolve, shift, buildFingerprint, type OffsetRange } from "./anchorer";
+import { addProposal, removeProposal, setProposalApplied } from "./proposalModel";
 import type { AttributionController } from "./attributionController";
 import type { VersionGuard } from "./versionGuard";
 import { isAuthorable } from "./workspacePath";
@@ -39,6 +39,8 @@ interface DocState {
  live: Map<string, OffsetRange>;
  /** proposal ids whose anchor did not resolve at last render (stale/orphaned). */
  unresolved: Set<string>;
+  /** ids already optimistically applied to the buffer (so the trigger doesn't re-apply). */
+  applied: Set<string>;
 }

 export class ProposalController implements vscode.Disposable {
@@ -89,8 +91,9 @@ export class ProposalController implements vscode.Disposable {
        id: p.id,
        anchorStart: resolved === "orphaned" ? null : resolved.start,
        anchorEnd: resolved === "orphaned" ? null : resolved.end,
-        replaced: fp?.text ?? "",
+        replaced: p.original ?? fp?.text ?? "",
        replacement: p.replacement,
+        original: p.original,
      };
    });
  }
@@ -104,6 +107,7 @@ export class ProposalController implements vscode.Disposable {
        artifact: this.store.load(docPath) ?? emptyArtifact(docPath),
        live: new Map(),
        unresolved: new Set(),
+        applied: new Set(),
      };
      this.docs.set(docPath, state);
    }
@@ -137,8 +141,33 @@ 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). */
+  /** Accept by id — F12: finalize the already-applied text in place (INV-51). */
  async acceptById(docPath: string, proposalId: string, opts?: { silent?: boolean }): Promise<boolean> {
+    if (this.isApplied(docPath, proposalId)) {
+      // INV-11 (applied path): if an external write mangled the optimistically-applied
+      // text so the fingerprint no longer resolves, refuse finalize — same guard as the
+      // legacy accept path.  Direct finalizeInPlace calls (CodeLens Accept gesture where
+      // the user may have edited inside the applied span) bypass this check intentionally.
+      const hit = this.byId(docPath, proposalId);
+      if (hit) {
+        const document = this.openDoc(hit.state);
+        if (document) {
+          const fp = hit.state.artifact.anchors[hit.proposal.anchorId]?.fingerprint;
+          const resolved = fp ? resolve(document.getText(), fp) : "orphaned";
+          if (resolved === "orphaned") {
+            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).",
+              );
+            }
+            return false;
+          }
+        }
+      }
+      return this.finalizeInPlace(docPath, proposalId);
+    }
+    // Fallback: a proposal that was never optimistically applied (e.g. orphaned at
+    // apply time) keeps the legacy seam-apply accept.
    const hit = this.byId(docPath, proposalId);
    return hit ? this.accept(hit.state, hit.proposal, opts) : false;
  }
@@ -181,6 +210,12 @@ export class ProposalController implements vscode.Disposable {
    return true;
  }

+  /** Reject by id — F12: revert the applied text in place (INV-51). */
+  async rejectByIdInPlace(docPath: string, proposalId: string): Promise<boolean> {
+    if (this.isApplied(docPath, proposalId)) return this.revertInPlace(docPath, proposalId);
+    return this.rejectById(docPath, proposalId);
+  }
+
  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);
@@ -257,6 +292,158 @@ export class ProposalController implements vscode.Disposable {
    return true;
  }

+  /** True once this proposal's text is in the buffer (optimistic apply ran). */
+  isApplied(docPath: string, proposalId: string): boolean {
+    return this.docs.get(docPath)?.applied.has(proposalId) ?? false;
+  }
+
+  /**
+   * F12/#64 (INV-48): optimistically apply a pending proposal INTO the buffer so
+   * the editor shows the would-be-accepted result (editable). Reuses the F4
+   * word-precise seam (block → per-word hunks, INV-40; single → whole range) but
+   * with `landBaseline:false` (the change stays pending). Then re-anchors the
+   * proposal to the applied text and stores the original (`setProposalApplied`), so
+   * `resolve()` finds it in the mutated buffer and revert/decorate key off it.
+   * Idempotent: a no-op if already applied.
+   */
+  async optimisticApply(document: vscode.TextDocument, proposalId: string): Promise<boolean> {
+    if (!this.isTracked(document) || this.guard.isReadOnly(this.keyOf(document))) return false;
+    const docPath = this.keyOf(document);
+    const state = this.ensureState(document);
+    if (state.applied.has(proposalId)) return true;
+    state.artifact = this.store.load(docPath) ?? emptyArtifact(docPath);
+    const proposal = state.artifact.proposals.find((p) => p.id === proposalId);
+    const fp = proposal ? state.artifact.anchors[proposal.anchorId]?.fingerprint : undefined;
+    if (!proposal || !fp) return false;
+    // Reload-safety (INV-51/54): a proposal that already carries `original` was
+    // optimistically applied in a PRIOR session — the buffer holds the applied text
+    // and `fp` points at it, but this (fresh) controller's in-memory `applied` set is
+    // empty. Re-applying would recapture `original` from the already-applied buffer
+    // (= the replacement) and CLOBBER the true revert target, breaking Reject. Mark it
+    // applied in memory and stop — `original` is captured exactly once, on first apply.
+    if (proposal.original !== undefined) {
+      state.applied.add(proposalId);
+      this.renderAll(document);
+      return true;
+    }
+    const resolved = resolve(document.getText(), fp);
+    if (resolved === "orphaned") return false;
+    const original = document.getText(
+      new vscode.Range(document.positionAt(resolved.start), document.positionAt(resolved.end)),
+    );
+    const ok =
+      proposal.granularity === "block"
+        ? await this.applyBlockOptimistic(document, resolved, proposal)
+        : await this.attribution.applyAgentEdit(
+            document,
+            new vscode.Range(document.positionAt(resolved.start), document.positionAt(resolved.end)),
+            proposal.replacement,
+            proposal.author,
+            { expectedVersion: document.version, turnId: proposal.turnId, landBaseline: false },
+          );
+    if (!ok) return false;
+    state.applied.add(proposalId);
+    // Re-anchor to the applied text now in the buffer (its start is unchanged; its
+    // end shifts by the net length delta of the replacement).
+    const appliedStart = resolved.start;
+    const appliedEnd = appliedStart + proposal.replacement.length;
+    const appliedFp = buildFingerprint(document.getText(), { start: appliedStart, end: appliedEnd });
+    this.store.update(docPath, (a) => setProposalApplied(a, proposalId, appliedFp, original));
+    this.renderAll(document);
+    return true;
+  }
+
+  /** Block optimistic apply: the INV-40 per-word hunks, but landBaseline:false. */
+  private async applyBlockOptimistic(
+    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;
+    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, landBaseline: false,
+      });
+      if (!ok) return false;
+    }
+    return true;
+  }
+
+  /**
+   * F12/#64 (INV-51): ACCEPT an optimistically-applied proposal — the text is
+   * already in the buffer, so this only advances the F6 baseline (machine-landing,
+   * via `attribution.signalLanded`) and clears the proposal. No re-application.
+   */
+  async finalizeInPlace(docPath: string, proposalId: string): Promise<boolean> {
+    const hit = this.byId(docPath, proposalId);
+    if (!hit) return false;
+    const document = this.openDoc(hit.state);
+    if (!document) return false;
+    this.attribution.signalLanded(document);
+    this.store.update(docPath, (a) => removeProposal(a, proposalId));
+    hit.state.applied.delete(proposalId);
+    this.renderAll(document);
+    return true;
+  }
+
+  /**
+   * F12/#64 (INV-51): REJECT an optimistically-applied proposal — replace its live
+   * applied span with the stored `original`, then clear it. Reverts the whole block
+   * regardless of any in-place edits the human made to the inserted text.
+   */
+  async revertInPlace(docPath: string, proposalId: string): Promise<boolean> {
+    const hit = this.byId(docPath, proposalId);
+    if (!hit) return false;
+    const document = this.openDoc(hit.state);
+    if (!document) return false;
+    const fp = hit.state.artifact.anchors[hit.proposal.anchorId]?.fingerprint;
+    const resolved = fp ? resolve(document.getText(), fp) : "orphaned";
+    if (resolved !== "orphaned" && hit.proposal.original !== undefined) {
+      const we = new vscode.WorkspaceEdit();
+      we.replace(
+        document.uri,
+        new vscode.Range(document.positionAt(resolved.start), document.positionAt(resolved.end)),
+        hit.proposal.original,
+      );
+      if (!(await vscode.workspace.applyEdit(we))) return false;
+    }
+    this.store.update(docPath, (a) => removeProposal(a, proposalId));
+    hit.state.applied.delete(proposalId);
+    this.renderAll(document);
+    return true;
+  }
+
+  /**
+   * F12/#64 (INV-53): reject EVERY pending proposal on a document — revert each in
+   * DESCENDING anchor order (so an earlier revert never shifts a later one's
+   * offsets), symmetric with #46's accept-all. Returns the reverted count.
+   */
+  async rejectAll(document: vscode.TextDocument): Promise<{ reverted: number }> {
+    if (!this.isTracked(document)) return { reverted: 0 };
+    const docPath = this.keyOf(document);
+    const state = this.ensureState(document);
+    state.artifact = this.store.load(docPath) ?? emptyArtifact(docPath);
+    const text = document.getText();
+    const ordered = state.artifact.proposals
+      .map((p) => {
+        const fp = state.artifact.anchors[p.anchorId]?.fingerprint;
+        const r = fp ? resolve(text, fp) : "orphaned";
+        return { id: p.id, start: r === "orphaned" ? -1 : r.start };
+      })
+      .sort((a, b) => b.start - a.start);
+    let reverted = 0;
+    for (const it of ordered) if (await this.revertInPlace(docPath, it.id)) reverted++;
+    return { reverted };
+  }
+
  private reject(state: DocState, proposal: Proposal): void {
    if (this.guard.isReadOnly(state.docPath)) return;
    this.store.update(state.docPath, (a) => removeProposal(a, proposal.id));
@@ -37,6 +37,25 @@ export function removeProposal(artifact: Artifact, proposalId: string): boolean
  return artifact.proposals.length < before;
 }

+/**
+ * F12/#64 (INV-48): record a proposal as optimistically applied — store the
+ * pre-apply `original` (for revert + the struck `<del>`) and re-point its anchor
+ * fingerprint to the now-in-buffer applied text so `resolve()` finds it. Idempotent
+ * shape: a second call simply overwrites with the same values.
+ */
+export function setProposalApplied(
+  artifact: Artifact,
+  proposalId: string,
+  appliedFp: Fingerprint,
+  original: string,
+): boolean {
+  const p = artifact.proposals.find((x) => x.id === proposalId);
+  if (!p) return false;
+  p.original = original;
+  artifact.anchors[p.anchorId] = { fingerprint: appliedFp };
+  return true;
+}
+
 /** Markdown comment body: instruction header + fenced whole-range diff. */
 export function proposalBody(targetText: string, p: Proposal): string {
  const header = p.instruction ? `**Claude proposes** — _${p.instruction}_` : "**Claude proposes**";
@@ -263,6 +263,42 @@ export function wordEditHunks(currentText: string, rewrittenText: string): EditH
  return hunks;
 }

+/** F12/#64 (INV-49/52): the editor render of one optimistically-applied proposal. */
+export interface DecorationPlan {
+  /** buffer ranges of inserted (proposed) text → tinted (INV-52). */
+  insertions: { start: number; end: number }[];
+  /** struck original text shown as a non-editable hint at a buffer offset (INV-52). */
+  deletions: { at: number; text: string }[];
+}
+
+/**
+ * F12/#64 (INV-49): compute the editor decoration plan for a proposal whose applied
+ * text occupies `[anchorStart, anchorStart+replacement.length)` in the buffer. The
+ * SAME word diff the webview uses (`wordEditHunks`) drives it, so both surfaces show
+ * the identical diff. A changed run maps to (a) an insertion range over the run's
+ * applied text and (b) a deletion hint carrying the run's removed original text at
+ * the run start; a pure insertion has no deletion hint; a pure deletion has only a
+ * hint. Pure, vscode-free, deterministic.
+ */
+export function decorationPlan(anchorStart: number, original: string, replacement: string): DecorationPlan {
+  const insertions: { start: number; end: number }[] = [];
+  const deletions: { at: number; text: string }[] = [];
+  // Walk the word diff once, tracking the applied-side offset as we consume parts.
+  let appliedOffset = anchorStart;
+  for (const part of diffWordsWithSpace(original, replacement)) {
+    if (part.added) {
+      insertions.push({ start: appliedOffset, end: appliedOffset + part.value.length });
+      appliedOffset += part.value.length;
+    } else if (part.removed) {
+      deletions.push({ at: appliedOffset, text: part.value });
+      // removed text is NOT in the applied buffer → appliedOffset does not advance
+    } else {
+      appliedOffset += part.value.length;
+    }
+  }
+  return { insertions, deletions };
+}
+
 const isWs = (c: string): boolean => /\s/.test(c);

 /**
@@ -701,6 +737,8 @@ export interface ProposalView {
  replaced: string;
  /** the proposed replacement text. */
  replacement: string;
+  /** F12/#64 (INV-48): the pre-apply original, set after optimistic apply. */
+  original?: string;
 }

 function proposalBlockHtml(p: ProposalView, render: (src: string) => string): string {
@@ -716,8 +754,14 @@ function proposalBlockHtml(p: ProposalView, render: (src: string) => string): st
  const after = `<ins class="cw-add">${safe(p.replacement)}</ins>`;
  const actions =
    `<span class="cw-actions">` +
-    `<button class="cw-accept" data-action="accept">✓</button>` +
-    `<button class="cw-reject" data-action="reject">✗</button>` +
+    `<span class="cw-btngroup">` +
+    `<button class="cw-accept" data-action="accept">Accept</button>` +
+    `<button class="cw-caret" data-action="acceptAll" title="Accept all pending proposals">▾</button>` +
+    `</span>` +
+    `<span class="cw-btngroup">` +
+    `<button class="cw-reject" data-action="reject">Reject</button>` +
+    `<button class="cw-caret" data-action="rejectAll" title="Reject all pending proposals">▾</button>` +
+    `</span>` +
    `</span>`;
  return `<div class="cw-proposal${unanchored}" data-proposal-id="${md.utils.escapeHtml(p.id)}">${actions}${before}${after}</div>`;
 }
@@ -747,6 +791,26 @@ function renderReviewOp(
 * INV-34). Deterministic: proposals in the same block are ordered by anchorStart
 * then id; trailing proposals keep input order.
 */
+/**
+ * F12/#64 (INV-50): `currentText` with every resolved pending proposal's applied
+ * span reverted to its original (`replaced`) — the "landed" text the baseline diff
+ * should run against, so a pending proposal renders ONCE (as a proposal), never also
+ * as a landed change. Reverts high→low so earlier offsets stay valid. Pure. The
+ * preview's summary tally diffs against this too, so the toolbar count matches the
+ * body (a pending change is not double-counted as both a landed add/remove and a
+ * proposal).
+ */
+export function landedTextOf(currentText: string, proposals: ProposalView[]): string {
+  const pendingApplied = proposals
+    .filter((p) => p.anchorStart !== null)
+    .sort((a, b) => b.anchorStart! - a.anchorStart!);
+  let landedText = currentText;
+  for (const p of pendingApplied) {
+    landedText = landedText.slice(0, p.anchorStart!) + p.replaced + landedText.slice(p.anchorEnd!);
+  }
+  return landedText;
+}
+
 export function renderReview(
  baselineText: string,
  currentText: string,
@@ -755,8 +819,18 @@ export function renderReview(
  opts: RenderOptions = {},
 ): string {
  const render = opts.render ?? defaultRender;
-  const ranges = splitBlocksWithRanges(currentText);
-  const ops = diffBlocks(baselineText, currentText);
+
+  // F12/#64 (INV-50): with optimistic apply the proposed text is already in
+  // `currentText`, so a naive baseline→current diff would render each proposed
+  // change BOTH as a landed diff and as its proposal block. Diff against the
+  // "landed" text (current minus pending proposals) so they render once.
+  const pendingApplied = proposals
+    .filter((p) => p.anchorStart !== null)
+    .sort((a, b) => b.anchorStart! - a.anchorStart!);
+  const landedText = landedTextOf(currentText, proposals);
+
+  const ranges = splitBlocksWithRanges(landedText);
+  const ops = diffBlocks(baselineText, landedText);
  // #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
@@ -766,7 +840,28 @@ export function renderReview(
  // 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
+  // Map a currentText offset to its landedText offset (account for reverted spans
+  // that precede it; reverts were applied high→low so the cumulative delta is stable).
+  const toLanded = (curOff: number): number => {
+    let delta = 0;
+    for (const p of [...pendingApplied].sort((a, b) => a.anchorStart! - b.anchorStart!)) {
+      if (p.anchorStart! < curOff) delta += p.replaced.length - (p.anchorEnd! - p.anchorStart!);
+    }
+    return curOff + delta;
+  };
+
+  // F12/#64 (INV-49/50): blocks are split from `landedText`, so `blk.start` is a
+  // landedText offset — but `authorSpans` arrive in `currentText` coordinates. A
+  // colored block sitting AFTER a length-changing pending proposal would otherwise
+  // be mis-colored (the offsets diverge by the revert delta). Map the spans into
+  // landedText coordinates once so authorship coloring stays aligned.
+  const landedSpans: AuthorSpan[] = authorSpans.map((s) => ({
+    ...s,
+    start: toLanded(s.start),
+    end: toLanded(s.end),
+  }));
+
+  // Associate each resolved proposal with the landedText block index whose range
  // it anchors into: the largest block with start <= anchorStart (the containing
  // block, or the nearest preceding block when the anchor sits in a gap). A
  // resolved anchor before all blocks, and every unresolved proposal, trails.
@@ -778,7 +873,7 @@ export function renderReview(
  const byBlock = new Map<number, ProposalView[]>();
  const trailing: ProposalView[] = [];
  for (const p of proposals) {
-    const j = p.anchorStart === null ? -1 : blockOf(p.anchorStart);
+    const j = p.anchorStart === null ? -1 : blockOf(toLanded(p.anchorStart));
    if (j < 0) {
      trailing.push(p);
      continue;
@@ -795,7 +890,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 && !clean ? colorByAuthor(raw, blk.start, authorSpans, render) : render(raw);
+      blk && !clean ? colorByAuthor(raw, blk.start, landedSpans, 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,13 +13,19 @@ import * as vscode from "vscode";
 import type { DiffViewController } from "./diffViewController";
 import type { AttributionController } from "./attributionController";
 import type { ProposalController } from "./proposalController";
-import { renderReview, renderPlain, diffBlocks, diffToBlockHunks, type BlockOp } from "./trackChangesModel";
+import { renderReview, renderPlain, diffBlocks, diffToBlockHunks, landedTextOf, type BlockOp } from "./trackChangesModel";
 import { buildFingerprint } from "./anchorer";
 import { isAuthorable } from "./workspacePath";
-import type { EditTurnResult } from "./liveTurn";
+import type { EditTurnResult, RunEditTurnOptions } from "./liveTurn";
+import type { LiveProgressUi } from "./liveProgressUi";
+import type { InlineAskController } from "./inlineAsk";

-/** F11: a host edit turn (selection/document text + instruction → rewrite). Injectable for tests. */
-type EditTurn = (instruction: string, text: string) => Promise<EditTurnResult>;
+/**
+ * F11: a host edit turn (selection/document text + instruction → rewrite).
+ * Injectable for tests. #60: accepts optional turn options (onProgress/signal);
+ * the arg is optional so existing test stubs that ignore it stay valid.
+ */
+type EditTurn = (instruction: string, text: string, opts?: RunEditTurnOptions) => Promise<EditTurnResult>;
 /** F11: what an Ask-Claude gesture edits — a resolved selection range, or the whole document. */
 type EditTarget = { kind: "range"; start: number; end: number } | { kind: "document" };

@@ -38,7 +44,8 @@ type ToolbarMsg =
  | { type: "pinBaseline" }
  | { type: "askClaude"; scope: "document" }
  | { type: "askClaude"; scope: "selection"; start: number; end: number }
-  | { type: "acceptAll" };
+  | { type: "acceptAll" }
+  | { type: "rejectAll" };

 export class TrackChangesPreviewController implements vscode.Disposable {
  private readonly disposables: vscode.Disposable[] = [];
@@ -53,9 +60,9 @@ export class TrackChangesPreviewController implements vscode.Disposable {
   * F11: the host edit turn (INV-8 — runs host-side, @cline/sdk loaded lazily and
   * never bundled). Injectable so host E2E can stub it (no LLM in CI).
   */
-  private editTurn: EditTurn = async (instruction, text) => {
+  private editTurn: EditTurn = async (instruction, text, opts) => {
    const { runEditTurn } = await import("./liveTurn");
-    return runEditTurn(instruction, text);
+    return runEditTurn(instruction, text, opts);
  };
  /** Monotonic per-session counter minting a stable turnId for each Ask-Claude gesture. */
  private turnSeq = 0;
@@ -68,6 +75,8 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    private readonly extensionUri: vscode.Uri,
    private readonly attribution: AttributionController,
    private readonly proposals: ProposalController,
+    private readonly liveProgressUi: LiveProgressUi,
+    private readonly inlineAsk: InlineAskController,
  ) {
    this.disposables.push(
      // F11 (SLICE-5): the editor/title gateway passes the tab's resource Uri;
@@ -182,8 +191,7 @@ export class TrackChangesPreviewController implements vscode.Disposable {
        .acceptById(this.proposals.keyFor(document), m.proposalId)
        .then(() => this.refresh(document));
    } else if (m?.type === "reject" && m.proposalId) {
-      this.proposals.rejectById(this.proposals.keyFor(document), m.proposalId);
-      this.refresh(document);
+      void this.proposals.rejectByIdInPlace(this.proposals.keyFor(document), m.proposalId).then(() => this.refresh(document));
    } else if (m?.type === "pinBaseline") {
      // F6 baseline store re-render arrives via the onDidChangeBaseline subscription.
      this.diffView.pin(document);
@@ -194,6 +202,8 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    } else if (m?.type === "acceptAll") {
      // #46 (INV-42): batch-accept every pending proposal on this doc, then report.
      void this.acceptAll(document);
+    } else if (m?.type === "rejectAll") {
+      void this.rejectAll(document);
    }
  }

@@ -214,24 +224,66 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    );
  }

+  /** #64 (INV-53): revert every pending proposal on the document; report the count. */
+  async rejectAll(document: vscode.TextDocument): Promise<void> {
+    const { reverted } = await this.proposals.rejectAll(document);
+    this.refresh(document);
+    if (reverted > 0) {
+      void vscode.window.showInformationMessage(
+        `Cowriting: rejected ${reverted} proposal${reverted === 1 ? "" : "s"}.`,
+      );
+    }
+  }
+
+  /**
+   * Where the inline Ask-Claude input anchors: a range edit pins to its selection;
+   * a whole-document edit pins to the editor's cursor line if this document is the
+   * active editor, else to the document start.
+   */
+  private editTargetAnchor(document: vscode.TextDocument, target: EditTarget): vscode.Range {
+    if (target.kind === "range") {
+      return new vscode.Range(document.positionAt(target.start), document.positionAt(target.end));
+    }
+    const active = vscode.window.activeTextEditor;
+    if (active && active.document.uri.toString() === document.uri.toString()) {
+      const line = active.selection.active.line;
+      return new vscode.Range(line, 0, line, 0);
+    }
+    return new vscode.Range(0, 0, 0, 0);
+  }
+
  /**
   * 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
   * the result as F4 proposal(s). UI wrapper around `runEditAndPropose`.
   */
  private async askClaude(document: vscode.TextDocument, target: EditTarget): Promise<void> {
-    const instruction = await vscode.window.showInputBox({
-      prompt:
-        target.kind === "document"
-          ? "What should Claude do with the document?"
-          : "What should Claude do with the selection?",
-      placeHolder: "e.g. tighten the prose",
-    });
+    // The instruction prompt opens INLINE (inlineAsk) at the target: the selected
+    // range for a range edit, or the editor's cursor line / the document start for
+    // a whole-document edit — never the top-center QuickInput.
+    const anchor = this.editTargetAnchor(document, target);
+    const instruction = await this.inlineAsk.prompt(document.uri, anchor);
    if (!instruction) return;
    try {
      const ids = await vscode.window.withProgress(
-        { location: vscode.ProgressLocation.Notification, title: "Cowriting: asking Claude…" },
-        () => this.runEditAndPropose(document, target, instruction),
+        {
+          location: vscode.ProgressLocation.Notification,
+          title: "Cowriting: asking Claude…",
+          cancellable: true,
+        },
+        async (progress, token) => {
+          const ui = this.liveProgressUi.begin(instruction, progress, token);
+          try {
+            return await this.runEditAndPropose(document, target, instruction, {
+              onProgress: ui.onProgress,
+              signal: ui.signal,
+            });
+          } catch (err) {
+            // #60 (INV-47): a user cancel proposes nothing (the benign empty path).
+            if (token.isCancellationRequested) return [] as string[];
+            throw err;
+          }
+        },
      );
      if (ids.length === 0) {
        void vscode.window.showInformationMessage("Cowriting: Claude proposed no changes.");
@@ -258,6 +310,7 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    document: vscode.TextDocument,
    target: EditTarget,
    instruction: string,
+    opts?: RunEditTurnOptions,
  ): Promise<string[]> {
    const full = document.getText();
    // One turnId per gesture — the document case's N hunk-proposals all share it,
@@ -267,13 +320,13 @@ export class TrackChangesPreviewController implements vscode.Disposable {
      ({ kind: "agent" as const, id: "claude", agent: { sdk: "@cline/sdk", model: turn.model, sessionId: turn.sessionId } });
    if (target.kind === "range") {
      const selected = full.slice(target.start, target.end);
-      const turn = await this.editTurn(instruction, selected);
+      const turn = await this.editTurn(instruction, selected, opts);
      if (turn.replacement === "" || turn.replacement === selected) return [];
      const fp = buildFingerprint(full, { start: target.start, end: target.end });
      const id = await this.proposals.propose(document, fp, turn.replacement, provenance(turn), { turnId, instruction });
      return id ? [id] : [];
    }
-    const turn = await this.editTurn(instruction, full);
+    const turn = await this.editTurn(instruction, full, opts);
    const ids: string[] = [];
    // #47 (INV-39, supersedes INV-37): a document rewrite is cut at BLOCK
    // granularity — one proposal per changed block (the unit a human reviews) —
@@ -329,9 +382,13 @@ export class TrackChangesPreviewController implements vscode.Disposable {
    }
    const spans = this.attribution.spansFor(document);
    const proposals = this.proposals.listProposals(document);
+    // F12/#64 (INV-50): count added/removed against the LANDED text (current minus
+    // pending proposals), matching the body — a pending change shows once, as a
+    // proposal, and is not also tallied as a landed add/remove.
+    const landedOps = diffBlocks(baselineText, landedTextOf(current, proposals));
    const summary = {
-      added: ops.filter((o) => o.kind === "added").length,
-      removed: ops.filter((o) => o.kind === "removed").length,
+      added: landedOps.filter((o) => o.kind === "added").length,
+      removed: landedOps.filter((o) => o.kind === "removed").length,
      proposals: proposals.length,
    };
    void panel.webview.postMessage({
@@ -0,0 +1,122 @@
+/**
+ * turnProgress.ts — pure reduction of @cline/sdk Agent runtime events into a
+ * small UI-facing progress snapshot (#60, spec coauthoring-live-progress.md §3.2).
+ *
+ * INV-43: vscode-free. INV-46: a pure function — no vscode, no SDK runtime
+ * dependency (`AgentRuntimeEvent` is imported TYPE-only, so it is erased at
+ * compile and never pulls the ESM SDK into the bundle). All event→state logic
+ * lives here so it is unit-tested in isolation; the UI call sites only format and
+ * relay snapshots.
+ */
+import type { AgentRuntimeEvent } from "@cline/shared";
+
+export type TurnPhase = "thinking" | "writing" | "tool";
+
+export interface TurnProgressSnapshot {
+  phase: TurnPhase;
+  /** present iff phase === "tool" — the running tool's name. */
+  tool?: string;
+  /** accumulated assistant-text length so far. */
+  chars: number;
+  /** running total tokens (input+output); undefined until the first usage event. */
+  tokens?: number;
+  /** the new assistant-text chunk since the last snapshot (for the OutputChannel). */
+  textDelta?: string;
+}
+
+export interface TurnProgressState {
+  phase: TurnPhase;
+  chars: number;
+  tokens?: number;
+  /** stack of tool names currently running (depth-tracked for overlap). */
+  activeTools: string[];
+  /** true once any assistant text has streamed (tool-finish then reverts to writing). */
+  sawText: boolean;
+}
+
+export function createTurnProgressState(): TurnProgressState {
+  return { phase: "thinking", chars: 0, tokens: undefined, activeTools: [], sawText: false };
+}
+
+function restingPhase(state: TurnProgressState): TurnPhase {
+  if (state.activeTools.length) return "tool";
+  return state.sawText ? "writing" : "thinking";
+}
+
+function toSnapshot(state: TurnProgressState, textDelta?: string): TurnProgressSnapshot {
+  return {
+    phase: state.phase,
+    tool: state.phase === "tool" ? state.activeTools[state.activeTools.length - 1] : undefined,
+    chars: state.chars,
+    tokens: state.tokens,
+    textDelta,
+  };
+}
+
+/**
+ * Fold one SDK event into the state, returning the next state and the snapshot to
+ * emit (snapshot undefined for events that don't change the surface).
+ */
+export function reduceTurnProgress(
+  state: TurnProgressState,
+  event: AgentRuntimeEvent,
+): { state: TurnProgressState; snapshot?: TurnProgressSnapshot } {
+  switch (event.type) {
+    case "run-started":
+    case "turn-started": {
+      const next: TurnProgressState = { ...state, phase: restingPhase(state) };
+      return { state: next, snapshot: toSnapshot(next) };
+    }
+    case "assistant-text-delta": {
+      const next: TurnProgressState = {
+        ...state,
+        phase: state.activeTools.length ? "tool" : "writing",
+        chars: event.accumulatedText.length,
+        sawText: true,
+      };
+      return { state: next, snapshot: toSnapshot(next, event.text) };
+    }
+    case "assistant-reasoning-delta": {
+      // Reasoning TEXT is not surfaced (operator fork); collapse to motion only.
+      const next: TurnProgressState = { ...state, phase: state.activeTools.length ? "tool" : "thinking" };
+      return { state: next, snapshot: toSnapshot(next) };
+    }
+    case "tool-started": {
+      const activeTools = [...state.activeTools, event.toolCall.toolName];
+      const next: TurnProgressState = { ...state, phase: "tool", activeTools };
+      return { state: next, snapshot: toSnapshot(next) };
+    }
+    case "tool-updated": {
+      const next: TurnProgressState = { ...state, phase: "tool" };
+      return { state: next, snapshot: toSnapshot(next) };
+    }
+    case "tool-finished": {
+      const name = event.toolCall.toolName;
+      const idx = state.activeTools.lastIndexOf(name);
+      const activeTools = idx >= 0 ? state.activeTools.filter((_, i) => i !== idx) : state.activeTools.slice(0, -1);
+      const next: TurnProgressState = { ...state, activeTools, phase: "thinking" };
+      next.phase = restingPhase(next);
+      return { state: next, snapshot: toSnapshot(next) };
+    }
+    case "usage-updated": {
+      const tokens = event.usage.inputTokens + event.usage.outputTokens || undefined;
+      const next: TurnProgressState = { ...state, tokens };
+      return { state: next, snapshot: toSnapshot(next) };
+    }
+    default:
+      return { state };
+  }
+}
+
+/** Render the notification activity line from a snapshot (pure; spec §2.1). */
+export function formatProgressLine(s: TurnProgressSnapshot): string {
+  let head: string;
+  if (s.phase === "tool") head = `running ${s.tool ?? "tool"}…`;
+  else if (s.phase === "writing") head = `writing… (${s.chars} chars)`;
+  else head = "thinking…";
+  return s.tokens ? `${head} · ${formatTokens(s.tokens)} tokens` : head;
+}
+
+export function formatTokens(n: number): string {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+}
@@ -60,3 +60,29 @@ export function selectionRejection(ctx: SelectionContext): string | null {
  }
  return null;
 }
+
+export interface EditRouteContext {
+  /** Was the command invoked on a specific resource (a tab right-click)? */
+  hasUri: boolean;
+  /** Does that resource match the focused editor's document? */
+  uriMatchesActiveEditor: boolean;
+  /** Is there a focused text editor at all? */
+  hasActiveEditor: boolean;
+  /** Is the focused editor's selection empty (no highlight)? */
+  selectionEmpty: boolean;
+}
+
+/**
+ * Route the single "Ask Claude to Edit" gesture (`cowriting.edit`) to the
+ * selection or whole-document flow. One conceptual command, two destinations:
+ *
+ * - A tab right-click on a document that ISN'T the focused editor has no
+ *   selection to act on → edit the whole document.
+ * - Otherwise a non-empty selection in the focused editor → edit the selection;
+ *   an empty selection (or no editor) → edit the whole document.
+ */
+export function routeEdit(ctx: EditRouteContext): "selection" | "document" {
+  if (ctx.hasUri && !ctx.uriMatchesActiveEditor) return "document";
+  if (ctx.hasActiveEditor && !ctx.selectionEmpty) return "selection";
+  return "document";
+}
@@ -0,0 +1,27 @@
+import { describe, test, expect } from "vitest";
+import { decorationPlan } from "../src/trackChangesModel";
+
+describe("decorationPlan (INV-49)", () => {
+  test("derives insertion ranges + deletion hints from original→replacement", () => {
+    // anchorStart 10; original 'the brown fox' → 'the red fox'
+    const plan = decorationPlan(10, "the brown fox", "the red fox");
+    // one changed run: 'brown ' → 'red ' (word-level); insertion 'red ' tinted,
+    // deletion hint 'brown ' shown at the run start.
+    expect(plan.insertions.length).toBeGreaterThan(0);
+    expect(plan.deletions.length).toBeGreaterThan(0);
+    // insertion offsets are in buffer coords (>= anchorStart) and lie within the applied text
+    for (const ins of plan.insertions) {
+      expect(ins.start).toBeGreaterThanOrEqual(10);
+      expect(ins.end).toBeLessThanOrEqual(10 + "the red fox".length);
+    }
+    // a deletion hint carries the struck original text at a buffer offset
+    expect(plan.deletions[0].text).toContain("brown");
+  });
+
+  test("pure insertion (no deletion) yields an insertion range and no deletion hint", () => {
+    // 'hello' → 'hello world': ' world' is a pure word-level insertion (no removed tokens)
+    const plan = decorationPlan(0, "hello", "hello world");
+    expect(plan.insertions.length).toBe(1);
+    expect(plan.deletions.length).toBe(0);
+  });
+});
@@ -13,11 +13,20 @@ async function main(): Promise<void> {
  const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "cowriting-e2e-"));
  fs.cpSync(fixture, workspace, { recursive: true });

+  // VS Code derives its IPC socket path from --user-data-dir. The default
+  // (`<projectRoot>/.vscode-test/user-data`) plus `/<version>-main.sock` can blow
+  // past macOS's ~103-char UNIX-socket limit (`listen EINVAL`) when the project
+  // lives at a long path (e.g. a git worktree). Pin the user-data dir to a SHORT
+  // root under /tmp so the socket path stays well under the limit. (os.tmpdir() on
+  // macOS is itself a long /var/folders/… path, so we use /tmp directly.)
+  const userDataRoot = process.platform === "win32" ? os.tmpdir() : "/tmp";
+  const userDataDir = fs.mkdtempSync(path.join(userDataRoot, "cwud-"));
+
  try {
    await runTests({
      extensionDevelopmentPath,
      extensionTestsPath,
-      launchArgs: [workspace, "--disable-extensions"],
+      launchArgs: [workspace, "--disable-extensions", "--user-data-dir", userDataDir],
      extensionTestsEnv: { E2E_WORKSPACE: workspace },
    });

@@ -26,10 +35,11 @@ async function main(): Promise<void> {
    await runTests({
      extensionDevelopmentPath,
      extensionTestsPath: path.resolve(__dirname, "./suite-no-workspace/index"),
-      launchArgs: ["--disable-extensions"],
+      launchArgs: ["--disable-extensions", "--user-data-dir", userDataDir],
    });
  } finally {
    fs.rmSync(workspace, { recursive: true, force: true });
+    fs.rmSync(userDataDir, { recursive: true, force: true });
  }
 }

@@ -28,7 +28,10 @@ suite("no-workspace authoring (F8 — real folder-less, #8 lineage)", () => {
      "cowriting.reply",
      "cowriting.resolveThread",
      "cowriting.reopenThread",
+      "cowriting.edit",
      "cowriting.editSelection",
+      "cowriting.askClaude.submit",
+      "cowriting.askClaude.cancel",
      "cowriting.applyAgentEdit",
      "cowriting.proposeAgentEdit",
    ]) {
@@ -109,8 +109,9 @@ suite("F10 interactive review (host E2E — preview is the single review surface
    const pIdx = html.indexOf(`data-proposal-id="${id}"`);
    const t2Idx = html.indexOf("second claude target");
    assert.ok(t2Idx >= 0 && pIdx < t2Idx, "the proposal renders in place, before the following block (#31)");
-    // INV-10: proposing never touches the document.
-    assert.ok(doc.getText().includes(T1), "document unchanged by propose");
+    // F12 (INV-48): EditorProposalController auto-applies the proposal into the buffer;
+    // the replacement text is now in the document, proposal is still pending.
+    assert.ok(doc.getText().includes("A FIRST claude REPLACEMENT sentence."), "F12 optimistic-apply: replacement in buffer");
  });

  test("accept → the proposal lands, clears from the preview, and the baseline advances (PUC-4)", async () => {
@@ -131,17 +132,18 @@ suite("F10 interactive review (host E2E — preview is the single review surface
    assert.ok(!marked, "the just-landed Claude text renders unmarked (baseline advanced)");
  });

-  test("reject → the proposal vanishes and the document is untouched (PUC-5)", async () => {
+  test("reject → the proposal vanishes and the document is reverted (PUC-5)", async () => {
    const { doc, key } = await reopen(DOC_REL);
    const api = await getApi();
    const before = doc.getText();
    const id2 = await propose(doc, key, T2, "A SECOND would-be replacement.", "turn-f10-2");
    await settle();
    assert.ok(api.proposalController.listProposals(doc).some((v) => v.id === id2), "second proposal pending");
-    assert.strictEqual(api.proposalController.rejectById(DOC_REL, id2), true, "reject");
+    // F12: use rejectByIdInPlace to revert the optimistically-applied buffer edit.
+    assert.ok(await api.proposalController.rejectByIdInPlace(DOC_REL, id2), "rejectByIdInPlace reverts + removes");
    await settle();
    assert.ok(!api.proposalController.listProposals(doc).some((v) => v.id === id2), "rejected proposal gone");
-    assert.strictEqual(doc.getText(), before, "document untouched by reject");
+    assert.strictEqual(doc.getText(), before, "document reverted to pre-propose state");
    const html = api.trackChangesPreviewController.renderHtmlFor(key);
    assert.ok(!html.includes(`data-proposal-id="${id2}"`), "no rejected block in the preview");
  });
@@ -99,8 +99,9 @@ suite("F11 preview toolbar (host E2E — message → seam wiring, no LLM)", () =
      "The quick RED fox jumps over the lazy CAT.",
      "the block proposal carries the whole rewritten paragraph",
    );
-    // INV-10: proposing never mutates the document.
-    assert.ok(doc.getText().includes("brown fox") && doc.getText().includes("lazy dog"), "document unchanged by propose");
+    // F12 (INV-48): EditorProposalController optimistically applies the proposed text,
+    // so after settle the buffer has the replacement. The proposal is still pending.
+    assert.ok(doc.getText().includes("RED fox") && doc.getText().includes("lazy CAT"), "F12 optimistic-apply: proposed text in buffer");
    void key;
  });

@@ -129,7 +130,9 @@ suite("F11 preview toolbar (host E2E — message → seam wiring, no LLM)", () =
    assert.ok(view, "the proposal is live");
    assert.strictEqual(view!.replacement, "The REWRITTEN paragraph from Claude.", "carries the turn replacement");
    assert.strictEqual(view!.replaced, target, "replaces exactly the selected range");
-    assert.ok(doc.getText().includes(target), "document unchanged by propose (INV-10)");
+    // F12 (INV-48): the EditorProposalController optimistically applies, so the buffer
+    // now has the replacement. `view.replaced` still records the original target text.
+    assert.ok(doc.getText().includes("The REWRITTEN paragraph from Claude."), "F12 optimistic-apply: proposed text in buffer");
    void key;
  });

@@ -174,16 +177,22 @@ suite("F11 preview toolbar (host E2E — message → seam wiring, no LLM)", () =
    assert.strictEqual(api.proposalController.listProposals(doc).length, 0, "no proposals left pending");
  });

-  // SLICE-3: the document-scoped command exists for #42 reuse, guarded on markdown.
-  test("cowriting.editDocument is a registered command, palette-guarded on markdown", async () => {
+  // SLICE-3: the document-scoped command stays registered for #42 reuse (now behind
+  // the unified `cowriting.edit`). editDocument is hidden from the palette; the
+  // markdown-guarded user-facing palette command is `cowriting.edit`.
+  test("cowriting.editDocument stays registered; cowriting.edit is the markdown-guarded palette command", async () => {
    const all = await vscode.commands.getCommands(true);
    assert.ok(all.includes("cowriting.editDocument"), "editDocument 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.editDocument",
-    );
-    assert.ok(entry, "editDocument has a commandPalette entry");
-    assert.match(entry!.when ?? "", /editorLangId == markdown/, "guarded on markdown");
+    assert.ok(all.includes("cowriting.edit"), "unified edit command registered");
+    const palette = JSON.parse(fs.readFileSync(path.join(__dirname, "../../../../package.json"), "utf8")).contributes
+      .menus.commandPalette as Array<{ command: string; when?: string }>;
+    // editDocument is hidden (routed via cowriting.edit).
+    const docEntry = palette.find((m) => m.command === "cowriting.editDocument");
+    assert.strictEqual(docEntry?.when, "false", "editDocument hidden from the palette");
+    // cowriting.edit is the user-facing, markdown-guarded entry.
+    const editEntry = palette.find((m) => m.command === "cowriting.edit");
+    assert.ok(editEntry, "cowriting.edit has a commandPalette entry");
+    assert.match(editEntry!.when ?? "", /editorLangId == markdown/, "guarded on markdown");
  });

  // SLICE-5: the minimal right-click gateway lives in editor/title (markdown only).
@@ -0,0 +1,251 @@
+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";
+import { addProposal, setProposalApplied } from "../../../src/proposalModel";
+import { buildFingerprint } from "../../../src/anchorer";
+
+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() };
+}
+
+suite("F12 inline diff — seam landBaseline (#64, INV-48)", () => {
+  test("applyAgentEdit with landBaseline:false applies text but does NOT advance the baseline", async () => {
+    const { doc, key } = await freshDoc("docs/f12-land.md", "# T\n\nalpha here.\n");
+    const api = await getApi();
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+    const before = api.diffViewController.getBaseline(key)?.text ?? doc.getText();
+    const start = doc.getText().indexOf("alpha");
+    const ok = await api.attributionController.applyAgentEdit(
+      doc,
+      new vscode.Range(doc.positionAt(start), doc.positionAt(start + "alpha".length)),
+      "ALPHA",
+      { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } },
+      { landBaseline: false },
+    );
+    await settle();
+    assert.ok(ok, "edit applied");
+    assert.ok(doc.getText().includes("ALPHA"), "text in buffer");
+    assert.strictEqual(api.diffViewController.getBaseline(key)?.text ?? doc.getText(), before, "baseline unchanged");
+  });
+});
+
+suite("F12 inline diff — finalize / revert in place (#64, INV-51)", () => {
+  // Optimistic apply lands the text + re-anchors; the buffer becomes the accepted result.
+  test("optimisticApply puts the proposed text in the buffer and re-anchors", async () => {
+    const { doc } = await freshDoc("docs/f12-opt.md", "# T\n\nReplace alpha please.\n");
+    const api = await getApi();
+    const p = api.proposalController;
+    const fp = { text: "Replace alpha please.", before: "", after: "", lineHint: 2 };
+    const id = await p.propose(doc, fp, "Replace ALPHA please.",
+      { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } }, { granularity: "block" });
+    await api.proposalController.optimisticApply(doc, id!);
+    await settle();
+    assert.ok(doc.getText().includes("Replace ALPHA please."), "applied to buffer");
+    // re-anchored: the proposal still resolves against the mutated buffer
+    assert.strictEqual(p.listProposals(doc)[0].anchorStart !== null, true, "re-anchored, resolves");
+    assert.strictEqual(p.listProposals(doc)[0].original, "Replace alpha please.", "original stored");
+  });
+
+  test("finalizeInPlace clears the proposal and keeps the applied text (no double-apply)", async () => {
+    const { doc } = await freshDoc("docs/f12-fin.md", "# T\n\nKeep alpha now.\n");
+    const api = await getApi();
+    const p = api.proposalController;
+    const docPath = p.keyFor(doc);
+    const fp = { text: "Keep alpha now.", before: "", after: "", lineHint: 2 };
+    const id = await p.propose(doc, fp, "Keep ALPHA now.",
+      { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } }, { granularity: "block" });
+    await p.optimisticApply(doc, id!);
+    await settle();
+    const ok = await p.finalizeInPlace(docPath, id!);
+    await settle();
+    assert.ok(ok, "finalized");
+    assert.strictEqual(doc.getText(), "# T\n\nKeep ALPHA now.\n", "applied text retained, no double-apply");
+    assert.strictEqual(p.listProposals(doc).length, 0, "proposal cleared");
+  });
+
+  test("revertInPlace restores the original and clears the proposal", async () => {
+    const { doc } = await freshDoc("docs/f12-rev.md", "# T\n\nUndo alpha here.\n");
+    const api = await getApi();
+    const p = api.proposalController;
+    const docPath = p.keyFor(doc);
+    const fp = { text: "Undo alpha here.", before: "", after: "", lineHint: 2 };
+    const id = await p.propose(doc, fp, "Undo ALPHA here.",
+      { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } }, { granularity: "block" });
+    await p.optimisticApply(doc, id!);
+    await settle();
+    const ok = await p.revertInPlace(docPath, id!);
+    await settle();
+    assert.ok(ok, "reverted");
+    assert.strictEqual(doc.getText(), "# T\n\nUndo alpha here.\n", "original restored");
+    assert.strictEqual(p.listProposals(doc).length, 0, "proposal cleared");
+  });
+
+  test("rejectAll reverts every pending proposal", async () => {
+    const { doc } = await freshDoc("docs/f12-rejall.md", "# T\n\nOne aaa.\n\nTwo bbb.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    const p = api.proposalController;
+    ctl.setEditTurnForTest(async () => ({ replacement: "# T\n\nOne AAA.\n\nTwo BBB.\n", model: "m", sessionId: "s" }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "up");
+    await settle();
+    for (const id of ids) await p.optimisticApply(doc, id);
+    await settle();
+    assert.ok(doc.getText().includes("AAA") && doc.getText().includes("BBB"), "both applied");
+    const { reverted } = await p.rejectAll(doc);
+    await settle();
+    assert.strictEqual(reverted, ids.length, "all reverted");
+    assert.strictEqual(doc.getText(), "# T\n\nOne aaa.\n\nTwo bbb.\n", "document restored");
+    assert.strictEqual(p.listProposals(doc).length, 0, "all cleared");
+  });
+});
+
+suite("F12 inline diff — INV-50 listProposals.replaced", () => {
+  test("listProposals reports the original as `replaced` after optimistic apply", async () => {
+    const { doc } = await freshDoc("docs/f12-replaced.md", "# R\n\nbrown here.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    ctl.setEditTurnForTest(async () => ({ replacement: "# R\n\nred here.\n", model: "m", sessionId: "s" }));
+    await ctl.runEditAndPropose(doc, { kind: "document" }, "x");
+    await settle(); await settle();
+    assert.strictEqual(api.proposalController.listProposals(doc)[0].replaced, "brown here.");
+  });
+});
+
+suite("F12 inline diff — editor surface (#64, INV-48/52)", () => {
+  test("proposing optimistically applies into the editor and the buffer is the accepted result", async () => {
+    const { doc } = await freshDoc("docs/f12-editor.md", "# E\n\nThe brown fox runs.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    ctl.setEditTurnForTest(async () => ({ replacement: "# E\n\nThe red fox runs.\n", model: "m", sessionId: "s" }));
+    await ctl.runEditAndPropose(doc, { kind: "document" }, "recolor the fox");
+    await settle(); await settle();
+    assert.ok(doc.getText().includes("The red fox runs."), "optimistically applied into the buffer");
+    const v = api.proposalController.listProposals(doc)[0];
+    assert.strictEqual(v.original, "The brown fox runs.", "original captured for the deletion hint/revert");
+  });
+
+  test("editing the inserted text then finalizing keeps the human edit", async () => {
+    const { doc } = await freshDoc("docs/f12-edit-keep.md", "# E\n\nalpha word here.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    ctl.setEditTurnForTest(async () => ({ replacement: "# E\n\nALPHA word here.\n", model: "m", sessionId: "s" }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "up");
+    await settle(); await settle();
+    // human tweaks the inserted text
+    const at = doc.getText().indexOf("ALPHA");
+    const we = new vscode.WorkspaceEdit();
+    we.replace(doc.uri, new vscode.Range(doc.positionAt(at), doc.positionAt(at + 5)), "ALPHA!");
+    await vscode.workspace.applyEdit(we);
+    await settle();
+    // keyFor(doc) gives the repo-relative path that finalizeInPlace uses as its key;
+    // the `key` from freshDoc is the URI string, which would not match for in-workspace docs.
+    const docKey = api.proposalController.keyFor(doc);
+    await api.proposalController.finalizeInPlace(docKey, ids[0]);
+    await settle();
+    assert.ok(doc.getText().includes("ALPHA! word here."), "human edit preserved on accept");
+    assert.strictEqual(api.proposalController.listProposals(doc).length, 0, "cleared");
+  });
+});
+
+suite("F12 inline diff — control parity (#64, INV-53)", () => {
+  test("reject from the webview reverts in place; rejectAll clears every proposal", async () => {
+    const { doc, key } = await freshDoc("docs/f12-parity.md", "# P\n\nuno aaa.\n\ndos bbb.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+    ctl.setEditTurnForTest(async () => ({ replacement: "# P\n\nuno AAA.\n\ndos BBB.\n", model: "m", sessionId: "s" }));
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "up");
+    await settle(); await settle();
+    assert.ok(doc.getText().includes("AAA") && doc.getText().includes("BBB"));
+    // reject ONE via the webview intent → that block reverts, the other stays applied
+    ctl.receiveMessage(key, { type: "reject", proposalId: ids[0] });
+    await settle(); await settle();
+    assert.ok(doc.getText().includes("uno aaa.") && doc.getText().includes("BBB"), "one reverted, one applied");
+    // rejectAll via the command → all gone, document restored
+    ctl.receiveMessage(key, { type: "rejectAll" });
+    await settle(); await settle();
+    assert.strictEqual(doc.getText(), "# P\n\nuno aaa.\n\ndos bbb.\n", "document restored");
+    assert.strictEqual(api.proposalController.listProposals(doc).length, 0);
+  });
+
+  test("cowriting.rejectAllProposals is registered + markdown-guarded", async () => {
+    const all = await vscode.commands.getCommands(true);
+    assert.ok(all.includes("cowriting.rejectAllProposals"));
+    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.rejectAllProposals",
+    );
+    assert.ok(entry && /editorLangId == markdown/.test(entry.when ?? ""), "palette-guarded on markdown");
+  });
+});
+
+// Reload-safety: a proposal that was optimistically applied in a PRIOR session
+// persists with `original` set and its fp re-anchored to the applied text. A fresh
+// controller (empty in-memory `applied` set) must NOT re-capture `original` from the
+// already-applied buffer — doing so would clobber the true revert target and break
+// Reject. (Regression for the final-review CRITICAL; INV-51/54.)
+suite("F12 inline diff — reload-safety (#64, INV-51/54)", () => {
+  test("optimisticApply does not clobber a previously-persisted original", async () => {
+    const TRUE_ORIGINAL = "The original sentence here.";
+    const APPLIED = "The APPLIED sentence here.";
+    const { doc } = await freshDoc("docs/f12-reload.md", `# R\n\n${TRUE_ORIGINAL}\n`);
+    const api = await getApi();
+    const p = api.proposalController;
+    const key = p.keyFor(doc);
+
+    // 1) The buffer holds the APPLIED text (as the saved-while-pending file would).
+    const at = doc.getText().indexOf(TRUE_ORIGINAL);
+    const we = new vscode.WorkspaceEdit();
+    we.replace(doc.uri, new vscode.Range(doc.positionAt(at), doc.positionAt(at + TRUE_ORIGINAL.length)), APPLIED);
+    assert.ok(await vscode.workspace.applyEdit(we), "apply the prior-session applied text");
+    await settle();
+
+    // 2) Record the proposal directly in the sidecar exactly as a prior session left
+    //    it: fp anchored to the APPLIED text + `original` = the TRUE original. We do
+    //    NOT call optimisticApply, so this controller's in-memory `applied` stays empty.
+    const appliedAt = doc.getText().indexOf(APPLIED);
+    const appliedFp = buildFingerprint(doc.getText(), { start: appliedAt, end: appliedAt + APPLIED.length });
+    let id = "";
+    api.sidecarRouter.update(key, (a) => {
+      id = addProposal(a, appliedFp, APPLIED, { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } }, { granularity: "block" }).proposalId;
+      setProposalApplied(a, id, appliedFp, TRUE_ORIGINAL);
+    });
+    p.renderAll(doc);
+    await settle();
+
+    // 3) Re-entry as a reload would trigger (EditorProposalController re-applies on
+    //    onDidChangeProposals because `applied` is empty). The guard must preserve original.
+    await p.optimisticApply(doc, id);
+    await settle();
+    const view = p.listProposals(doc).find((v) => v.id === id);
+    assert.ok(view, "proposal still present");
+    assert.strictEqual(view!.original, TRUE_ORIGINAL, "true original preserved, NOT clobbered with the applied text");
+
+    // 4) Reject restores the TRUE original (not the applied text).
+    assert.ok(await p.revertInPlace(key, id), "revert");
+    await settle();
+    assert.ok(doc.getText().includes(TRUE_ORIGINAL), "reject restored the true original");
+    assert.ok(!doc.getText().includes(APPLIED), "applied text removed on reject");
+  });
+});
@@ -31,43 +31,37 @@ function menu(id: string): Array<{ command: string; when?: string; group?: strin
 }

 // 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.
+// the editor TAB. The two split commands (editSelection / editDocument) were
+// unified behind ONE user-facing command `cowriting.edit` that auto-routes by
+// selection at runtime (routeEdit: selection → editSelection, none → editDocument)
+// — so the menus carry a SINGLE selection-agnostic entry, both markdown/authorable
+// -gated. The routing itself is unit-tested (routeEdit) and exercised through the
+// command below; here we assert the declarative menu `when` clauses.
 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", () => {
+  // PUC-1/2: editor BODY (editor/context) offers the single unified entry,
+  // markdown + authorable gated, NOT selection-gated (it routes both cases).
+  test("editor/context offers a single 'Ask Claude to Edit' (cowriting.edit), 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");
+    const edit = m.find((e) => e.command === "cowriting.edit");
+    assert.ok(edit, "cowriting.edit is in editor/context");
+    assert.match(edit!.when ?? "", /editorLangId == markdown/, "gated on markdown");
+    assert.match(edit!.when ?? "", /resourceScheme == file|resourceScheme == untitled/, "gated authorable");
+    assert.ok(!/editorHasSelection/.test(edit!.when ?? ""), "not selection-gated — one entry routes both cases");
+    // The old split pair is gone from the menu (the commands stay registered/hidden).
+    assert.ok(!m.some((e) => e.command === "cowriting.editSelection"), "old editSelection menu entry removed");
+    assert.ok(!m.some((e) => e.command === "cowriting.editDocument"), "old editDocument menu entry removed");
  });

-  // 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", () => {
+  // PUC-3: editor TAB (editor/title/context) carries the same single entry.
+  test("editor/title/context offers a single 'Ask Claude to Edit' (cowriting.edit), 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");
+    const edit = m.find((e) => e.command === "cowriting.edit");
+    assert.ok(edit, "cowriting.edit is in editor/title/context");
+    assert.match(edit!.when ?? "", /resourceLangId == markdown/, "tab entry gated on markdown");
+    assert.ok(
+      !m.some((e) => e.command === "cowriting.editSelection" || e.command === "cowriting.editDocument"),
+      "old split pair removed from the tab menu",
+    );
  });

  // PUC-3 behavior: editDocument invoked with a tab URI targets THAT document,
@@ -83,8 +77,8 @@ suite("F12 SLICE-1 — Ask-Claude reach (#42, INV-38)", () => {
    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";
+    const origPrompt = api.inlineAsk.prompt;
+    (api.inlineAsk as any).prompt = async () => "rewrite it";
    ctl.setEditTurnForTest(async () => ({
      replacement: "# Tab\n\nThe REWRITTEN tab paragraph.\n",
      model: "sonnet",
@@ -94,7 +88,7 @@ suite("F12 SLICE-1 — Ask-Claude reach (#42, INV-38)", () => {
      await vscode.commands.executeCommand("cowriting.editDocument", b.doc.uri);
      await settle();
    } finally {
-      (vscode.window as any).showInputBox = origInput;
+      (api.inlineAsk as any).prompt = origPrompt;
    }

    // The proposal(s) landed on the TAB doc (B), and the ACTIVE doc (A) has none.
@@ -104,8 +98,10 @@ suite("F12 SLICE-1 — Ask-Claude reach (#42, INV-38)", () => {
      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");
+    // F12 (INV-48): EditorProposalController optimistically applies proposals into the
+    // buffer, so the proposed text is now in the tab doc B. Confirm one of the proposal
+    // texts is present (the tab doc was edited, not A).
+    assert.ok(b.doc.getText().includes("REWRITTEN"), "F12 optimistic-apply: proposed text in tab doc B");
  });

  // No URI arg (palette / keybinding) → fall back to the active editor.
@@ -116,8 +112,8 @@ suite("F12 SLICE-1 — Ask-Claude reach (#42, INV-38)", () => {
    await vscode.window.showTextDocument(a.doc);
    await settle();

-    const origInput = vscode.window.showInputBox;
-    (vscode.window as any).showInputBox = async () => "rewrite it";
+    const origPrompt = api.inlineAsk.prompt;
+    (api.inlineAsk as any).prompt = async () => "rewrite it";
    ctl.setEditTurnForTest(async () => ({
      replacement: "# No arg\n\nThe REWRITTEN active doc paragraph.\n",
      model: "sonnet",
@@ -127,7 +123,7 @@ suite("F12 SLICE-1 — Ask-Claude reach (#42, INV-38)", () => {
      await vscode.commands.executeCommand("cowriting.editDocument");
      await settle();
    } finally {
-      (vscode.window as any).showInputBox = origInput;
+      (api.inlineAsk as any).prompt = origPrompt;
    }
    assert.ok(api.proposalController.listProposals(a.doc).length >= 1, "active doc received the proposal(s) on no-arg");
  });
@@ -0,0 +1,86 @@
+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<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;
+}
+
+// #60 host E2E (no LLM): live progress is purely additive observability. The
+// harness can't read notification subtitles, so it asserts the CONTRACT —
+// progress events don't change the proposals (INV-44), and an aborted turn
+// proposes nothing (INV-47). The live notification/OutputChannel UI itself is
+// covered by the turnProgress unit tests + the manual smoke.
+suite("#60 live turn progress (additive + cancel)", () => {
+  test("a stub that emits progress still produces the same proposals (INV-44)", async () => {
+    const doc = await freshDoc("docs/live60-additive.md", "# Title\n\nOld paragraph.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+
+    // The stub honors opts.onProgress (emitting synthetic snapshots) but returns
+    // the same rewrite — proposals must be unaffected by progress events.
+    ctl.setEditTurnForTest(async (_i, _text, opts) => {
+      opts?.onProgress?.({ phase: "writing", chars: 5 });
+      opts?.onProgress?.({ phase: "writing", chars: 13, tokens: 1234, textDelta: "New paragraph." });
+      return { replacement: "# Title\n\nNew paragraph.\n", model: "sonnet", sessionId: "e2e-live60" };
+    });
+
+    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "rewrite the paragraph");
+    await settle();
+    assert.strictEqual(ids.length, 1, "one changed block → one proposal, regardless of progress events");
+    const view = api.proposalController.listProposals(doc).find((v) => v.id === ids[0]);
+    assert.ok(view, "the proposal is live");
+    // F12 (INV-48): the EditorProposalController optimistically applies the proposed
+    // text into the buffer, so after settle the active-editor buffer shows the
+    // replacement. The proposal is still pending (not finalized) until Accept.
+    assert.ok(doc.getText().includes("New paragraph."), "F12 optimistic-apply: proposed text in buffer");
+  });
+
+  test("an aborted turn proposes nothing (INV-47)", async () => {
+    const doc = await freshDoc("docs/live60-cancel.md", "# Title\n\nOld paragraph.\n");
+    const api = await getApi();
+    const ctl = api.trackChangesPreviewController;
+    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
+    await settle();
+
+    // The stub throws ONLY when the aborted signal reached it — so if opts.signal
+    // failed to thread through runEditAndPropose, the stub would instead return a
+    // rewrite and create a proposal, failing this test. That proves propagation.
+    ctl.setEditTurnForTest(async (_i, _text, opts) => {
+      if (opts?.signal?.aborted) throw new Error("claude-code turn aborted");
+      return { replacement: "# Title\n\nSHOULD NOT BE PROPOSED.\n", model: "sonnet", sessionId: "e2e-live60-nope" };
+    });
+
+    const ac = new AbortController();
+    ac.abort();
+    let ids: string[] = [];
+    try {
+      ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "rewrite", { signal: ac.signal });
+    } catch {
+      ids = [];
+    }
+    await settle();
+    assert.strictEqual(ids.length, 0, "aborted turn must create no proposals");
+    assert.strictEqual(api.proposalController.listProposals(doc).length, 0, "no pending proposals after abort");
+  });
+});
@@ -63,13 +63,14 @@ suite("F4 propose/accept (host E2E — programmatic ingress, no LLM)", () => {
  const TARGET = "The propose target sentence lives here.";
  const REPLACEMENT = "PROPOSED-BY-CLAUDE replacement sentence.";

-  test("propose records + renders a pending proposal and does NOT touch the document (INV-10)", async () => {
+  test("propose records a pending proposal; F12 optimistically applies it (INV-48, reverses INV-10)", async () => {
    const doc = await openDoc();
    const api = await getApi();
-    const before = doc.getText();
    await proposeViaCommand(doc, TARGET, REPLACEMENT, "turn-p1");
    await settle();
-    assert.strictEqual(doc.getText(), before, "document text unchanged (INV-10)");
+    // F12 (INV-48): EditorProposalController auto-applies the proposed text into the
+    // buffer, so after settle the buffer has the replacement text (INV-10 is reversed).
+    assert.ok(doc.getText().includes(REPLACEMENT), "F12 optimistic-apply: replacement in buffer after propose");
    const rendered = api.proposalController.getRendered(DOC_REL);
    assert.strictEqual(rendered.length, 1);
    assert.strictEqual(rendered[0].pending, true);
@@ -77,7 +78,8 @@ suite("F4 propose/accept (host E2E — programmatic ingress, no LLM)", () => {
    assert.strictEqual(rendered[0].canReply, false, "proposals are decide-only — no dead reply input (INV-12)");
    const art = readSidecar();
    assert.strictEqual(art.proposals.length, 1, "proposal persisted at propose time");
-    assert.strictEqual(art.anchors[art.proposals[0].anchorId].fingerprint.text, TARGET);
+    // After optimistic apply, the fingerprint re-anchors to the replacement text.
+    assert.strictEqual(art.anchors[art.proposals[0].anchorId].fingerprint.text, REPLACEMENT);
  });

  test("accept applies via the seam: text replaced, Claude-attributed, proposal removed (INV-9/11/13)", async () => {
@@ -97,15 +99,18 @@ suite("F4 propose/accept (host E2E — programmatic ingress, no LLM)", () => {
    assert.strictEqual(readSidecar().proposals.length, 0, "removed from the sidecar");
  });

-  test("reject leaves the document untouched and removes the proposal (PUC-3)", async () => {
+  test("reject reverts the optimistically-applied text and removes the proposal (PUC-3, F12-INV-48)", async () => {
    const doc = await openDoc();
    const api = await getApi();
    const before = doc.getText();
    const id = await proposeViaCommand(doc, "A second target for coexistence checks.", "WOULD-BE replacement.", "turn-p2");
    await settle();
-    assert.strictEqual(api.proposalController.rejectById(DOC_REL, id), true);
+    // F12: optimistic apply has put "WOULD-BE replacement." in the buffer.
+    assert.ok(doc.getText().includes("WOULD-BE replacement."), "F12: optimistically applied");
+    // rejectByIdInPlace reverts the buffer to the original (PUC-3, INV-51).
+    assert.ok(await api.proposalController.rejectByIdInPlace(DOC_REL, id), "rejectByIdInPlace removes + reverts");
    await settle();
-    assert.strictEqual(doc.getText(), before, "document untouched");
+    assert.strictEqual(doc.getText(), before, "document restored to pre-propose state");
    assert.strictEqual(api.proposalController.getRendered(DOC_REL).length, 0);
    assert.strictEqual(readSidecar().proposals.length, 0);
  });
@@ -114,25 +119,35 @@ suite("F4 propose/accept (host E2E — programmatic ingress, no LLM)", () => {
    let doc = await openDoc();
    const api = await getApi();
    const anchor = "A stable closing paragraph.";
-    await proposeViaCommand(doc, anchor, "A PROPOSED closing paragraph.", "turn-p3");
+    const appliedText = "A PROPOSED closing paragraph.";
+    await proposeViaCommand(doc, anchor, appliedText, "turn-p3");
    await settle();
+    // F12: optimistic apply has put the proposed text in the buffer (anchor → appliedText).
+    assert.ok(doc.getText().includes(appliedText), "F12: optimistically applied before reload");
    const uri = vscode.Uri.file(path.join(WS, DOC_REL));
+    // doc.getText() now has appliedText; the reload prepends a line.
    doc = await externalWriteAndReload(uri, "PREPENDED LINE\n\n" + doc.getText());
    await settle();
    api.proposalController.renderAll(doc);
    const rendered = api.proposalController.getRendered(DOC_REL);
    assert.strictEqual(rendered.length, 1, "proposal survived reload");
    assert.strictEqual(rendered[0].pending, true, "still decidable");
-    const moved = doc.getText().indexOf(anchor);
-    assert.strictEqual(rendered[0].range.start, moved, "re-anchored after the move");
+    // After F12 re-anchor, the fingerprint tracks the appliedText, not the original anchor.
+    const moved = doc.getText().indexOf(appliedText);
+    assert.ok(moved >= 0, "applied text present in the reloaded document");
+    assert.strictEqual(rendered[0].range.start, moved, "re-anchored to appliedText after the move");
  });

  test("editing the target text makes the proposal stale: flagged, accept refused, doc untouched (INV-11)", async () => {
    let doc = await openDoc();
    const api = await getApi();
    const id = api.proposalController.getRendered(DOC_REL)[0].id;
-    const mangled = doc.getText().replace("A stable closing paragraph.", "A reworded closing paragraph.");
-    doc = await externalWriteAndReload(vscode.Uri.file(path.join(WS, DOC_REL)), mangled);
+    // After F12 optimistic apply the fingerprint tracks the APPLIED text ("A PROPOSED
+    // closing paragraph."), not the original.  Mangle that text to make the proposal stale.
+    const preMangled = doc.getText();
+    const mangled = preMangled.replace("A PROPOSED closing paragraph.", "A reworded closing paragraph.");
+    const uri = vscode.Uri.file(path.join(WS, DOC_REL));
+    doc = await externalWriteAndReload(uri, mangled);
    await settle();
    api.proposalController.renderAll(doc);
    assert.strictEqual(api.proposalController.getStaleCount(DOC_REL), 1, "flagged stale");
@@ -143,22 +158,30 @@ suite("F4 propose/accept (host E2E — programmatic ingress, no LLM)", () => {
    assert.strictEqual(readSidecar().proposals.length, 1, "proposal still pending (recoverable)");
    // discard the husk so later tests see a clean sidecar
    assert.strictEqual(api.proposalController.rejectById(DOC_REL, id), true);
+    // Restore the file so subsequent tests can find their fixture targets:
+    // replace the optimistically-applied text back to the original fixture text.
+    const restored = preMangled.replace("A PROPOSED closing paragraph.", "A stable closing paragraph.");
+    doc = await externalWriteAndReload(uri, restored);
+    await settle();
  });

  test("multiple pending proposals coexist and are decidable out of order (PUC-5)", async () => {
    const doc = await openDoc();
    const api = await getApi();
-    const id1 = await proposeViaCommand(doc, "A stable opening paragraph.", "An ACCEPTED opening paragraph.", "turn-p4");
-    const id2 = await proposeViaCommand(doc, "PROPOSED-BY-CLAUDE replacement sentence.", "A REPLACED-AGAIN sentence.", "turn-p5");
+    // Clean up any proposals left over from prior tests (F12: proposals persist in state).
+    await api.proposalController.rejectAll(doc);
    await settle();
-    assert.strictEqual(api.proposalController.getRendered(DOC_REL).length, 2);
+    const id1 = await proposeViaCommand(doc, "A stable opening paragraph.", "An ACCEPTED opening paragraph.", "turn-p4");
+    const id2 = await proposeViaCommand(doc, "A stable closing paragraph.", "A REPLACED closing paragraph.", "turn-p5");
+    await settle();
+    assert.strictEqual(api.proposalController.getRendered(DOC_REL).length, 2, "two new proposals");
    // decide the SECOND first, then the first — order independence
    assert.strictEqual(await api.proposalController.acceptById(DOC_REL, id2), true);
    await settle();
    assert.strictEqual(await api.proposalController.acceptById(DOC_REL, id1), true);
    await settle();
    assert.ok(doc.getText().includes("An ACCEPTED opening paragraph."));
-    assert.ok(doc.getText().includes("A REPLACED-AGAIN sentence."));
+    assert.ok(doc.getText().includes("A REPLACED closing paragraph."));
    assert.strictEqual(api.proposalController.getRendered(DOC_REL).length, 0);
  });
 });
@@ -1,5 +1,32 @@
-import { describe, it, expect } from "vitest";
-import { extractReplacement } from "../src/liveTurn";
+import { describe, it, expect, vi } from "vitest";
+import { extractReplacement, runEditTurn } from "../src/liveTurn";
+
+// A fake Agent that replays a scripted event list to subscribers, supports abort,
+// and resolves agent.run() with a completed (or aborted) result.
+const runs = { count: 0 };
+function fakeSdk(events: any[]) {
+  return {
+    Agent: class {
+      private listeners: ((e: any) => void)[] = [];
+      constructor(_cfg: unknown) {}
+      subscribe(fn: (e: any) => void) {
+        this.listeners.push(fn);
+        return () => {
+          this.listeners = this.listeners.filter((l) => l !== fn);
+        };
+      }
+      // The real SDK's abort() is a no-op before run() creates its AbortController,
+      // so this fake does NOT cooperate with a pre-abort — proving runEditTurn's own
+      // short-circuit, not the fake's leniency.
+      abort() {}
+      async run(_input: string) {
+        runs.count += 1;
+        for (const e of events) for (const l of this.listeners) l(e);
+        return { status: "completed", outputText: "EDITED", runId: "r1" };
+      }
+    },
+  };
+}

 describe("extractReplacement", () => {
  it("returns plain text untouched", () => {
@@ -24,3 +51,33 @@ describe("extractReplacement", () => {
    expect(extractReplacement("```\nplain\n```", "plain old text")).toBe("plain");
  });
 });
+
+describe("runEditTurn progress + cancel", () => {
+  it("emits progress snapshots and returns the replacement unchanged (INV-44)", async () => {
+    vi.resetModules();
+    vi.doMock("@cline/sdk", () =>
+      fakeSdk([
+        { type: "assistant-text-delta", text: "ED", accumulatedText: "ED" },
+        { type: "usage-updated", usage: { inputTokens: 10, outputTokens: 5, cacheReadTokens: 0, cacheWriteTokens: 0 } },
+      ]),
+    );
+    const seen: string[] = [];
+    const turn = await runEditTurn("do it", "old", { onProgress: (s) => seen.push(s.phase) });
+    expect(turn.replacement).toBe("EDITED");
+    expect(seen).toContain("writing");
+    vi.doUnmock("@cline/sdk");
+    vi.resetModules();
+  });
+
+  it("a pre-aborted AbortSignal short-circuits before run() and throws (INV-47)", async () => {
+    vi.resetModules();
+    vi.doMock("@cline/sdk", () => fakeSdk([]));
+    runs.count = 0;
+    const ac = new AbortController();
+    ac.abort();
+    await expect(runEditTurn("do it", "old", { signal: ac.signal })).rejects.toThrow(/aborted/);
+    expect(runs.count).toBe(0); // the turn never ran — no proposal could be produced
+    vi.doUnmock("@cline/sdk");
+    vi.resetModules();
+  });
+});
@@ -1,4 +1,5 @@
-import { describe, it, expect } from "vitest";
+import assert from "node:assert";
+import { describe, it, test, expect } from "vitest";
 import {
  SCHEMA_VERSION,
  emptyArtifact,
@@ -179,6 +180,19 @@ describe("unknown-field preservation (F5 SLICE-2, INV-15)", () => {
  });
 });

+test("serializeArtifact round-trips Proposal.original", () => {
+  const a = emptyArtifact("doc.md");
+  a.anchors["a_1"] = { fingerprint: { text: "new", before: "", after: "", lineHint: 0 } };
+  a.proposals.push({
+    id: "pr_1", anchorId: "a_1", replacement: "new",
+    author: { kind: "agent", id: "claude", agent: { sdk: "@cline/sdk", model: "sonnet", sessionId: "s" } },
+    createdAt: "2026-06-26T00:00:00.000Z", original: "old", granularity: "block",
+  });
+  const json = serializeArtifact(a);
+  assert.match(json, /"original": "old"/);
+  assert.match(json, /"granularity": "block"/);
+});
+
 describe("attributions[] (F3 SLICE-1)", () => {
  it("round-trips an attribution record through serialize → parse", () => {
    const a = emptyArtifact("docs/x.md");
@@ -9,7 +9,7 @@ import {
  type Proposal,
 } from "../src/model";
 import { CoauthorStore } from "../src/store";
-import { addProposal, proposalBody, removeProposal } from "../src/proposalModel";
+import { addProposal, proposalBody, removeProposal, setProposalApplied } from "../src/proposalModel";

 const agent = {
  kind: "agent" as const,
@@ -104,4 +104,19 @@ describe("proposalModel helpers (spec §6.4)", () => {
    expect(body).toContain("- old line two");
    expect(body).toContain("+ new only line");
  });
+
+  it("setProposalApplied stores original and re-anchors the fingerprint to the applied text", () => {
+    const a = emptyArtifact("docs/x.md");
+    const { proposalId, anchorId } = addProposal(
+      a,
+      { text: "old", before: "", after: "", lineHint: 0 },
+      "new",
+      { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } },
+      { granularity: "block" },
+    );
+    setProposalApplied(a, proposalId, { text: "new", before: "", after: "", lineHint: 0 }, "old");
+    const p = a.proposals.find((x) => x.id === proposalId)!;
+    expect(p.original).toBe("old");
+    expect(a.anchors[anchorId].fingerprint.text).toBe("new");
+  });
 });
@@ -231,7 +231,7 @@ describe("renderReview", () => {
    const html = renderReview("hello world", "hello", [], []);
    expect(html).toMatch(/<del>|cw-del/);
  });
-  test("renderReview: a pending proposal renders a blue block with data-proposal-id and ✓/✗ actions", () => {
+  test("renderReview: a pending proposal renders a blue block with data-proposal-id and Accept/Reject actions", () => {
    const proposals: ProposalView[] = [{ id: "p1", anchorStart: 0, anchorEnd: 5, replaced: "hello", replacement: "goodbye" }];
    const html = renderReview("hello", "hello", [], proposals);
    expect(html).toContain('class="cw-proposal"');
@@ -375,6 +375,55 @@ describe("renderReview", () => {
    const b = renderReview(doc, doc, [], proposals);
    expect(a).toBe(b);
  });
+
+  test("renderReview renders an applied proposal ONCE, not also as a landed diff (INV-50)", () => {
+    const baseline = "# T\n\nThe brown fox.\n";
+    const current = "# T\n\nThe red fox.\n"; // proposal already optimistically applied
+    const proposals: ProposalView[] = [{
+      id: "pr_1",
+      anchorStart: current.indexOf("The red fox."),
+      anchorEnd: current.indexOf("The red fox.") + "The red fox.".length,
+      replaced: "The brown fox.",      // original
+      replacement: "The red fox.",
+    }];
+    const html = renderReview(baseline, current, [], proposals);
+    // exactly one proposal block
+    expect((html.match(/cw-proposal/g) ?? []).length).toBe(1);
+    // the applied paragraph is NOT also emitted as a word-merged changed block
+    expect(html).not.toContain("<del>brown</del>"); // no double-render of the change as a baseline diff
+  });
+
+  test("renderReview keeps author coloring aligned on a block AFTER a length-changing pending proposal (INV-49/50)", () => {
+    // block 1 has a pending proposal whose applied text is MUCH LONGER than its
+    // original; block 2 carries a Claude authorship span (in currentText coords).
+    const baseline = "one short.\n\ntwo stable here.\n";
+    const current = "one MUCH LONGER REPLACED TEXT.\n\ntwo stable here.\n";
+    const proposals: ProposalView[] = [{
+      id: "pr_1",
+      anchorStart: current.indexOf("one MUCH LONGER REPLACED TEXT."),
+      anchorEnd: current.indexOf("one MUCH LONGER REPLACED TEXT.") + "one MUCH LONGER REPLACED TEXT.".length,
+      replaced: "one short.",
+      replacement: "one MUCH LONGER REPLACED TEXT.",
+      original: "one short.",
+    }];
+    const sStart = current.indexOf("stable");
+    const authorSpans = [{ start: sStart, end: sStart + "stable".length, author: "claude" as const }];
+    const html = renderReview(baseline, current, authorSpans, proposals);
+    // the Claude coloring wraps "stable" exactly — not shifted by the proposal's length delta.
+    expect(html).toMatch(/<span class="cw-by-claude">stable<\/span>/);
+  });
+
+  test("proposalBlockHtml renders Accept/Reject controls with dropdown carets (#64)", () => {
+    const html = renderReview("a\n", "b\n", [], [
+      { id: "pr_1", anchorStart: 0, anchorEnd: 1, replaced: "a", replacement: "b" },
+    ]);
+    expect(html).toMatch(/data-action="accept"/);
+    expect(html).toMatch(/data-action="reject"/);
+    expect(html).toMatch(/data-action="acceptAll"/);
+    expect(html).toMatch(/data-action="rejectAll"/);
+    expect(html).toMatch(/Accept/);
+    expect(html).toMatch(/Reject/);
+  });
 });

 import { renderTrackChanges as rtc2 } from "../src/trackChangesModel";
@@ -0,0 +1,102 @@
+import { describe, it, expect } from "vitest";
+import {
+  createTurnProgressState,
+  reduceTurnProgress,
+  formatProgressLine,
+  formatTokens,
+  type TurnProgressSnapshot,
+} from "../src/turnProgress";
+
+// Minimal event factories — structurally match the @cline/sdk AgentRuntimeEvent
+// members the reducer reads. `as any` because we only supply the fields used.
+const ev = (e: any) => e as any;
+const textDelta = (text: string, accumulatedText: string) =>
+  ev({ type: "assistant-text-delta", text, accumulatedText });
+const toolStarted = (toolName: string) => ev({ type: "tool-started", toolCall: { toolName } });
+const toolFinished = (toolName: string) => ev({ type: "tool-finished", toolCall: { toolName } });
+const usage = (inputTokens: number, outputTokens: number) =>
+  ev({ type: "usage-updated", usage: { inputTokens, outputTokens, cacheReadTokens: 0, cacheWriteTokens: 0 } });
+
+// Drive a sequence of events, returning every emitted snapshot.
+function run(events: any[]): TurnProgressSnapshot[] {
+  let state = createTurnProgressState();
+  const out: TurnProgressSnapshot[] = [];
+  for (const e of events) {
+    const r = reduceTurnProgress(state, e);
+    state = r.state;
+    if (r.snapshot) out.push(r.snapshot);
+  }
+  return out;
+}
+
+describe("reduceTurnProgress", () => {
+  it("starts in thinking", () => {
+    const s = run([ev({ type: "run-started" })]);
+    expect(s.at(-1)!.phase).toBe("thinking");
+    expect(s.at(-1)!.chars).toBe(0);
+    expect(s.at(-1)!.tokens).toBeUndefined();
+  });
+
+  it("text deltas move to writing and accumulate chars + carry the delta", () => {
+    const s = run([textDelta("Hel", "Hel"), textDelta("lo", "Hello")]);
+    expect(s.map((x) => x.phase)).toEqual(["writing", "writing"]);
+    expect(s.at(-1)!.chars).toBe(5);
+    expect(s.map((x) => x.textDelta)).toEqual(["Hel", "lo"]);
+  });
+
+  it("usage sets a running token total (input+output)", () => {
+    const s = run([textDelta("Hi", "Hi"), usage(1000, 234)]);
+    expect(s.at(-1)!.tokens).toBe(1234);
+  });
+
+  it("tool start shows the tool name; tool finish reverts to writing once text was seen", () => {
+    const s = run([textDelta("x", "x"), toolStarted("read_file"), toolFinished("read_file")]);
+    expect(s[1].phase).toBe("tool");
+    expect(s[1].tool).toBe("read_file");
+    expect(s.at(-1)!.phase).toBe("writing");
+  });
+
+  it("tool finish reverts to thinking when no text was seen", () => {
+    const s = run([toolStarted("grep"), toolFinished("grep")]);
+    expect(s.at(-1)!.phase).toBe("thinking");
+  });
+
+  it("overlapping tools resolve in order", () => {
+    const s = run([toolStarted("a"), toolStarted("b"), toolFinished("b"), toolFinished("a")]);
+    expect(s.map((x) => x.phase)).toEqual(["tool", "tool", "tool", "thinking"]);
+    expect(s[1].tool).toBe("b");
+    expect(s[2].tool).toBe("a");
+  });
+
+  it("reasoning deltas stay thinking and surface no text", () => {
+    const s = run([ev({ type: "assistant-reasoning-delta", text: "secret", accumulatedText: "secret" })]);
+    expect(s.at(-1)!.phase).toBe("thinking");
+    expect(s.at(-1)!.textDelta).toBeUndefined();
+  });
+
+  it("ignores lifecycle/finish events (no snapshot)", () => {
+    const s = run([ev({ type: "turn-finished" }), ev({ type: "run-finished" })]);
+    expect(s).toEqual([]);
+  });
+});
+
+describe("formatProgressLine / formatTokens", () => {
+  it("thinking", () => {
+    expect(formatProgressLine({ phase: "thinking", chars: 0 })).toBe("thinking…");
+  });
+  it("writing with chars", () => {
+    expect(formatProgressLine({ phase: "writing", chars: 412 })).toBe("writing… (412 chars)");
+  });
+  it("writing with chars + tokens", () => {
+    expect(formatProgressLine({ phase: "writing", chars: 412, tokens: 1234 })).toBe(
+      "writing… (412 chars) · 1.2k tokens",
+    );
+  });
+  it("tool with name", () => {
+    expect(formatProgressLine({ phase: "tool", tool: "read_file", chars: 0 })).toBe("running read_file…");
+  });
+  it("formats token magnitudes", () => {
+    expect(formatTokens(950)).toBe("950");
+    expect(formatTokens(1234)).toBe("1.2k");
+  });
+});
@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { isAuthorable, isUnderRoot, selectionRejection } from "../src/workspacePath";
+import { isAuthorable, isUnderRoot, routeEdit, selectionRejection } from "../src/workspacePath";

 describe("isUnderRoot", () => {
  const root = "/a/vscode-cowriting-plugin/sandbox";
@@ -58,3 +58,27 @@ describe("selectionRejection — F8 widened (accepts out-of-folder + untitled)",
    expect(msg).not.toMatch(/select some text/i);
  });
 });
+
+describe("routeEdit (single Ask-Claude-to-Edit gesture)", () => {
+  const focused = { hasUri: false, uriMatchesActiveEditor: false, hasActiveEditor: true, selectionEmpty: false };
+
+  it("non-empty selection in the focused editor → selection", () => {
+    expect(routeEdit(focused)).toBe("selection");
+  });
+  it("empty selection in the focused editor → document", () => {
+    expect(routeEdit({ ...focused, selectionEmpty: true })).toBe("document");
+  });
+  it("no active editor → document", () => {
+    expect(routeEdit({ ...focused, hasActiveEditor: false, selectionEmpty: true })).toBe("document");
+  });
+  it("tab right-click on a doc that ISN'T the focused editor → document (no selection to act on)", () => {
+    expect(routeEdit({ hasUri: true, uriMatchesActiveEditor: false, hasActiveEditor: true, selectionEmpty: false })).toBe(
+      "document",
+    );
+  });
+  it("tab right-click on the focused editor with a selection → selection", () => {
+    expect(routeEdit({ hasUri: true, uriMatchesActiveEditor: true, hasActiveEditor: true, selectionEmpty: false })).toBe(
+      "selection",
+    );
+  });
+});
Author	SHA1	Message	Date
BenStullsBets	656089432f	fix(proposals): reload-safe optimisticApply + reconciled toolbar summary (#64 ) Final-review fixes: - CRITICAL: optimisticApply no longer re-captures `original` from an already-applied buffer after a window reload (in-memory `applied` set is empty post-reload). A proposal already carrying `original` is marked applied and skipped, so Reject's revert target survives save+reload (INV-51/54). Adds a reload-safety host-E2E that reproduces the prior-session state. - MINOR: the preview toolbar +N/-N summary now counts against the landed text (current minus pending proposals) via the new pure landedTextOf(), so a pending change is shown once (as a proposal), not double-counted (INV-50). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 08:21:53 -07:00
BenStullsBets	f4594daa6f	feat(webview): Accept/Reject + dropdown, rejectAll, control parity (#64 , INV-53) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-26 08:07:06 -07:00
BenStullsBets	38053239fa	fix(render): map author spans to landedText coords (INV-49/50 coloring alignment) (#64 ) renderReview diffs against landedText (current minus pending proposals), so block offsets are landedText-relative while authorSpans arrive in currentText coords. A colored block after a length-changing pending proposal was mis-colored. Map the spans through toLanded so authorship coloring stays aligned. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 07:49:04 -07:00
BenStullsBets	65293326c8	feat(render): INV-50 render-once — diff against current-minus-pending (#64 ) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-26 07:46:15 -07:00
BenStullsBets	e5992840d2	feat(editor): EditorProposalController — optimistic apply + decorations + CodeLens (#64 ) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-26 07:39:14 -07:00
BenStullsBets	8c6e7822b4	feat(render): pure decorationPlan feeds editor + webview from one diff (#64 , INV-49) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-26 06:34:47 -07:00
BenStullsBets	ddbbb7aec3	feat(proposals): optimisticApply + finalize/revert in place + rejectAll (#64 ) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-26 06:31:28 -07:00
BenStullsBets	930b4ab056	test(e2e): pin --user-data-dir to a short /tmp path (fix macOS socket-length EINVAL) The default .vscode-test/user-data socket path exceeds macOS's ~103-char UNIX socket limit when the repo lives at a long path (e.g. a git worktree), so the host-E2E harness failed to launch (listen EINVAL). Point --user-data-dir at a short /tmp root so the IPC socket stays under the limit. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 06:22:36 -07:00
BenStullsBets	6d54963f15	feat(attribution): landBaseline opt + signalLanded for F12 optimistic apply (#64 ) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-26 06:20:10 -07:00
BenStullsBets	92ff4dd4ac	feat(proposalModel): setProposalApplied re-anchors + stores original (#64 ) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-26 06:17:38 -07:00
BenStullsBets	bea9fd5148	feat(model): add Proposal.original for F12 optimistic-apply revert (#64 )	2026-06-26 06:15:36 -07:00
BenStullsBets	56cc9eb6ad	claim vscode-cowriting-plugin session 0059 (placeholder) + sessions.json entry	2026-06-26 06:01:30 -07:00
BenStullsBets	2069029d73	add sessions/0058/SESSION-0058.0-TRANSCRIPT-2026-06-26T05-12--2026-06-26T05-58.md + replace placeholder/variant SESSION-0058.0-TRANSCRIPT-2026-06-26T05-12--INPROGRESS.md	2026-06-26 05:58:49 -07:00
BenStullsBets	a99430c247	claim vscode-cowriting-plugin session 0058 (placeholder) + sessions.json entry	2026-06-26 05:13:09 -07:00
benstull	9432300e3c	feat(ux): unify "Ask Claude to Edit" + inline prompt at selection; fix keybindings (#62 )	2026-06-26 12:11:43 +00:00
BenStullsBets	a42e5f145d	add sessions/0056/SESSION-0056.0-TRANSCRIPT-2026-06-26T04-24--2026-06-26T04-54.md + replace placeholder/variant SESSION-0056.0-TRANSCRIPT-2026-06-26T04-24--INPROGRESS.md	2026-06-26 04:55:04 -07:00
BenStullsBets	26628c0dbe	claim vscode-cowriting-plugin session 0057 (placeholder) + sessions.json entry	2026-06-26 04:53:46 -07:00
benstull	644885c6ec	#60 : live turn progress (activity line + token count + OutputChannel stream + cancel) (#61 ) Surface Claude live output/progress during the asking-Claude status: notification activity line + token count, a Cowriting: Claude OutputChannel streaming assistant text, and a cancellable turn. Pure turnProgress reducer + runEditTurn onProgress/AbortSignal (vscode-free) + both call sites. INV-43..47. Fixes #60	2026-06-26 11:53:10 +00:00