# Live Turn Progress (#60) Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Surface Claude's live output/progress (activity + token count + streamed text + cancel) during the otherwise-opaque "asking Claude…" status, for both edit entry points.

**Architecture:** A pure reducer (`turnProgress.ts`) folds `@cline/sdk` Agent runtime events into a small `TurnProgressSnapshot`; `runEditTurn` subscribes to the agent and emits snapshots via an `onProgress` callback while accepting an `AbortSignal` for cancellation — staying `vscode`-free. The two call sites relay snapshots through a shared host `liveProgressUi` module: the existing `withProgress` notification shows a live activity line, a dedicated OutputChannel streams the full assistant text, and the notification becomes cancellable. The final result path (proposals) is untouched.

**Tech Stack:** TypeScript (strict, `moduleResolution: Bundler`), VS Code extension API, `@cline/sdk` (ESM, dynamic-import-only, never bundled), Vitest (unit), `@vscode/test-electron` (host E2E), esbuild.

**Spec:** `coauthoring-live-progress.md` (graduated, content repo). Invariants INV-43..47.

---

## File Structure

- **Create `src/turnProgress.ts`** — pure reducer + line formatter. No `vscode`, no SDK runtime import (`AgentRuntimeEvent` type-only). Owns ALL event→state logic (INV-46).
- **Create `test/turnProgress.test.ts`** — unit tests for the reducer + `formatProgressLine`.
- **Modify `src/liveTurn.ts`** — `runEditTurn` gains `RunEditTurnOptions { modelId?, onProgress?, signal? }`; subscribes to the agent, folds events through the reducer, wires `signal`→`agent.abort()`. Result shape unchanged (INV-44). Stays `vscode`-free (INV-43).
- **Create `src/liveProgressUi.ts`** — host module (vscode-only): owns the shared `"Cowriting: Claude"` OutputChannel and a `begin(instruction, progress, token)` helper returning `{ signal, onProgress }` for one `withProgress` run. Reads `cowriting.liveProgress.revealOutput`.
- **Modify `src/extension.ts`** — construct `liveProgressUi` once at activate; the `editSelection` command uses it (cancellable notification + onProgress + signal); pass it into the preview controller; expose it on `CowritingApi` for E2E.
- **Modify `src/trackChangesPreview.ts`** — widen the `EditTurn` seam to accept `opts?`; thread `opts` through `askClaude` → `runEditAndPropose` → `editTurn`; use the injected `liveProgressUi` in `askClaude`.
- **Modify `package.json`** — add `contributes.configuration` with `cowriting.liveProgress.revealOutput` (boolean, default `true`).
- **Modify `test/e2e/suite/f11Toolbar.test.ts`** (or a new `test/e2e/suite/liveProgress.test.ts`) — extend the preview `editTurn` stub to emit synthetic progress and assert (a) identical proposals (INV-44) and (b) cancel→zero proposals (INV-47).

**Build note:** the type-only `import type { AgentRuntimeEvent } from "@cline/sdk"` is erased at compile and `@cline/*` stays external in esbuild — no bundling of the ESM SDK (preserves the POC constraint).

---

## Task 1: Pure progress reducer (`turnProgress.ts`)

**Files:**
- Create: `src/turnProgress.ts`
- Test: `test/turnProgress.test.ts`

- [ ] **Step 1: Write the failing test**

Create `test/turnProgress.test.ts`:

```ts
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");
  });
});
```

- [ ] **Step 2: Run the test to verify it fails**

Run: `npx vitest run test/turnProgress.test.ts`
Expected: FAIL — `Cannot find module "../src/turnProgress"`.

- [ ] **Step 3: Write the reducer**

Create `src/turnProgress.ts`:

```ts
/**
 * 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/sdk";

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);
}
```

- [ ] **Step 4: Run the test to verify it passes**

Run: `npx vitest run test/turnProgress.test.ts`
Expected: PASS (all cases).

- [ ] **Step 5: Typecheck**

Run: `npm run typecheck`
Expected: no errors (confirms the type-only `AgentRuntimeEvent` import resolves under `moduleResolution: Bundler` and the discriminated-union narrowing is sound).

- [ ] **Step 6: Commit**

```bash
git add src/turnProgress.ts test/turnProgress.test.ts
git commit -m "feat(#60): pure turn-progress reducer (INV-46)"
```

---

## Task 2: Extend `runEditTurn` with progress + cancellation

**Files:**
- Modify: `src/liveTurn.ts`
- Test: `test/liveTurn.test.ts` (add a mocked-agent case)

- [ ] **Step 1: Write the failing test**

Append to `test/liveTurn.test.ts` (keep the existing `extractReplacement` block). This mocks `@cline/sdk` via Vitest so `runEditTurn` runs without a real LLM, exercising subscribe + abort wiring:

```ts
import { vi } from "vitest";
import { runEditTurn } from "../src/liveTurn";

// A fake Agent that replays a scripted event list to subscribers, supports abort,
// and resolves agent.run() with a completed result.
function fakeSdk(events: any[], opts?: { abortAware?: boolean }) {
  return {
    Agent: class {
      private listeners: ((e: any) => void)[] = [];
      private aborted = false;
      constructor(_cfg: unknown) {}
      subscribe(fn: (e: any) => void) {
        this.listeners.push(fn);
        return () => {
          this.listeners = this.listeners.filter((l) => l !== fn);
        };
      }
      abort() {
        this.aborted = true;
      }
      async run(_input: string) {
        for (const e of events) for (const l of this.listeners) l(e);
        if (opts?.abortAware && this.aborted) {
          return { status: "aborted", outputText: "", runId: "r1", error: { message: "aborted" } };
        }
        return { status: "completed", outputText: "EDITED", runId: "r1" };
      }
    },
  };
}

describe("runEditTurn progress + cancel", () => {
  it("emits progress snapshots and returns the replacement unchanged (INV-44)", async () => {
    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");
  });

  it("a fired AbortSignal aborts the agent and the turn throws (INV-47)", async () => {
    vi.doMock("@cline/sdk", () => fakeSdk([], { abortAware: true }));
    const ac = new AbortController();
    ac.abort();
    await expect(runEditTurn("do it", "old", { signal: ac.signal })).rejects.toThrow(/aborted/);
    vi.doUnmock("@cline/sdk");
  });
});
```

Note: dynamic `import("@cline/sdk")` inside `runEditTurn` picks up `vi.doMock`. If the existing test file lacks `vi` import, the added `import { vi }` covers it.

- [ ] **Step 2: Run to verify it fails**

Run: `npx vitest run test/liveTurn.test.ts`
Expected: FAIL — `runEditTurn` doesn't accept `onProgress`/`signal` yet (type error) or doesn't subscribe.

- [ ] **Step 3: Implement the extension**

In `src/liveTurn.ts`, add the import and options type, and rewrite the body of `runEditTurn` (keep `SYSTEM_PROMPT`, `extractReplacement`, `EditTurnResult` as-is):

```ts
import type { TurnProgressSnapshot } from "./turnProgress";
import { createTurnProgressState, reduceTurnProgress } from "./turnProgress";

export interface RunEditTurnOptions {
  modelId?: string;
  /** out: called with a reduced progress snapshot as the SDK streams (INV-44 additive). */
  onProgress?: (snapshot: TurnProgressSnapshot) => void;
  /** in: aborting this signal cancels the turn via agent.abort() (INV-47). */
  signal?: AbortSignal;
}

export async function runEditTurn(
  instruction: string,
  selectedText: string,
  opts?: RunEditTurnOptions,
): Promise<EditTurnResult> {
  const sdk = await import("@cline/sdk");
  const modelId = opts?.modelId ?? "sonnet";
  const agent = new sdk.Agent({ providerId: "claude-code", modelId, systemPrompt: SYSTEM_PROMPT });

  let state = createTurnProgressState();
  const unsubscribe = opts?.onProgress
    ? agent.subscribe((event) => {
        const next = reduceTurnProgress(state, event);
        state = next.state;
        if (next.snapshot) opts.onProgress!(next.snapshot);
      })
    : undefined;
  const onAbort = () => agent.abort();
  opts?.signal?.addEventListener("abort", onAbort);

  try {
    const result = await agent.run(
      `<instruction>\n${instruction}\n</instruction>\n<text>\n${selectedText}\n</text>`,
    );
    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);
  }
}
```

(`agent.subscribe` returns its unsubscribe fn per `@cline/agents` `AgentRuntime.subscribe(listener): () => void`. `agent.abort()` exists on the same class. `AbortSignal`/`addEventListener` are web standards — no `vscode` import is added, preserving INV-43.)

- [ ] **Step 4: Run the test to verify it passes**

Run: `npx vitest run test/liveTurn.test.ts`
Expected: PASS (both new cases + the existing `extractReplacement` cases).

- [ ] **Step 5: Typecheck + full unit run**

Run: `npm run typecheck && npx vitest run`
Expected: typecheck clean; all unit tests pass (was 222 + Task 1 + these).

- [ ] **Step 6: Commit**

```bash
git add src/liveTurn.ts test/liveTurn.test.ts
git commit -m "feat(#60): runEditTurn streams progress + accepts AbortSignal (INV-43/44/47)"
```

---

## Task 3: Host `liveProgressUi` module + setting

**Files:**
- Create: `src/liveProgressUi.ts`
- Modify: `package.json` (add `contributes.configuration`)

- [ ] **Step 1: Add the configuration to `package.json`**

In `package.json`, under the top-level `"contributes"` object, add a `configuration` block (there is no existing one). Insert it as a sibling of the existing `commands`/`menus` keys:

```json
"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."
    }
  }
}
```

- [ ] **Step 2: Write the module**

Create `src/liveProgressUi.ts`:

```ts
/**
 * 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; the 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, returns the
   * onProgress relay + an AbortSignal linked to the notification's cancel token.
   */
  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 = () => {
      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) => {
      progress.report({ message: formatProgressLine(s) });
      if (s.textDelta) {
        this.channel.append(s.textDelta);
        reveal();
      }
    };
    return { onProgress, signal: controller.signal };
  }

  dispose(): void {
    this.channel.dispose();
  }
}
```

- [ ] **Step 3: Typecheck**

Run: `npm run typecheck`
Expected: no errors.

- [ ] **Step 4: Validate package.json**

Run: `node -e "JSON.parse(require('fs').readFileSync('package.json','utf8')); console.log('ok')"`
Expected: `ok` (the configuration block is valid JSON).

- [ ] **Step 5: Commit**

```bash
git add src/liveProgressUi.ts package.json
git commit -m "feat(#60): liveProgressUi host relay + revealOutput setting (INV-45)"
```

---

## Task 4: Wire the `editSelection` call site

**Files:**
- Modify: `src/extension.ts` (construct LiveProgressUi at activate; use it in the `editSelection` command; add to `CowritingApi`)

- [ ] **Step 1: Construct `LiveProgressUi` once and pass it into the preview controller**

Near the top of `activate(...)`, after the existing POC `output` channel is created, add:

```ts
const liveProgressUi = new LiveProgressUi();
context.subscriptions.push(liveProgressUi);
```

Add the import at the top of `src/extension.ts`:

```ts
import { LiveProgressUi } from "./liveProgressUi";
```

Then thread it into the preview controller construction (Task 5 widens that constructor):

```ts
const trackChangesPreviewController = new TrackChangesPreviewController(
  diffViewController,
  context.extensionUri,
  attributionController,
  proposalController,
  liveProgressUi,
);
```

- [ ] **Step 2: Rewrite the `editSelection` `withProgress` block**

Replace the `editSelection` command's `withProgress(...)` call (currently `src/extension.ts:232-268`) so it is cancellable and relays progress. The turn body is otherwise unchanged:

```ts
try {
  await vscode.window.withProgress(
    {
      location: vscode.ProgressLocation.Notification,
      title: "Cowriting: asking Claude…",
      cancellable: true,
    },
    async (progress, token) => {
      const { runEditTurn } = await import("./liveTurn");
      const ui = liveProgressUi.begin(instruction, progress, token);
      const turn = await runEditTurn(instruction, selectedText, {
        onProgress: ui.onProgress,
        signal: ui.signal,
      });
      if (turn.replacement === "") {
        void vscode.window.showWarningMessage(
          "Cowriting: Claude returned an empty replacement — nothing was proposed.",
        );
        return;
      }
      if (turn.replacement === selectedText) {
        void vscode.window.showInformationMessage("Cowriting: Claude proposed no change to the selection.");
        return;
      }
      const id = await proposalController.propose(
        document,
        fp,
        turn.replacement,
        { kind: "agent", id: "claude", agent: { sdk: "@cline/sdk", model: turn.model, sessionId: turn.sessionId } },
        { turnId, instruction },
      );
      if (id) {
        void vscode.window.showInformationMessage(
          "Cowriting: Claude proposed an edit — review the diff at the highlighted range (✓ accept / ✗ reject).",
        );
      }
    },
  );
} catch (err) {
  if (token_was_cancelled(err)) return; // replaced below
  const message = err instanceof Error ? err.message : String(err);
  void vscode.window.showErrorMessage(`Cowriting: Claude edit failed — ${message}`);
}
```

Because `token` is scoped inside the `withProgress` callback, surface cancellation by catching it there instead of the outer `catch`. Final form of the `catch` and cancel handling: wrap the `runEditTurn` call in a try/catch **inside** the callback that reflects cancel, and let other errors propagate to the outer `catch`:

```ts
// inside the withProgress async (progress, token) callback, around runEditTurn:
let turn;
try {
  turn = await runEditTurn(instruction, selectedText, { onProgress: ui.onProgress, signal: ui.signal });
} catch (err) {
  if (token.isCancellationRequested) {
    void vscode.window.showInformationMessage("Cowriting: Claude edit cancelled.");
    return;
  }
  throw err;
}
```

(Keep the single outer `try/catch` for the non-cancel error path exactly as it is today.)

- [ ] **Step 3: Add `liveProgressUi` to `CowritingApi` and the return**

In the `CowritingApi` interface (`src/extension.ts:18`) add:

```ts
liveProgressUi: LiveProgressUi;
```

And in the `return { ... }` block (`src/extension.ts:287`) add `liveProgressUi,`.

- [ ] **Step 4: Typecheck**

Run: `npm run typecheck`
Expected: no errors (Task 5 must land for the widened constructor to typecheck — if doing tasks strictly in order, expect one error here about the 5th constructor arg; that resolves in Task 5. To keep this task self-contained, do Task 5 Step 1 (constructor signature) before re-running. Otherwise proceed to Task 5 and typecheck there.)

- [ ] **Step 5: Build**

Run: `npm run build`
Expected: esbuild succeeds; `@cline/*` stays external.

- [ ] **Step 6: Commit**

```bash
git add src/extension.ts
git commit -m "feat(#60): editSelection shows live progress + cancel"
```

---

## Task 5: Thread progress through the preview path

**Files:**
- Modify: `src/trackChangesPreview.ts` (widen `EditTurn`; accept `LiveProgressUi`; thread opts through `askClaude` → `runEditAndPropose`)

- [ ] **Step 1: Widen the `EditTurn` seam type and the constructor**

In `src/trackChangesPreview.ts`, change the `EditTurn` type (line 22) to accept optional turn options (back-compat: existing E2E stubs ignore the new arg):

```ts
import type { EditTurnResult, RunEditTurnOptions } from "./liveTurn";
import type { LiveProgressUi } from "./liveProgressUi";

type EditTurn = (instruction: string, text: string, opts?: RunEditTurnOptions) => Promise<EditTurnResult>;
```

Update the default `editTurn` (line 56) to forward opts:

```ts
private editTurn: EditTurn = async (instruction, text, opts) => {
  const { runEditTurn } = await import("./liveTurn");
  return runEditTurn(instruction, text, opts);
};
```

Add `liveProgressUi` as a constructor parameter (after `proposals`):

```ts
constructor(
  private readonly diffView: DiffViewController,
  private readonly extensionUri: vscode.Uri,
  private readonly attribution: AttributionController,
  private readonly proposals: ProposalController,
  private readonly liveProgressUi: LiveProgressUi,
) {
```

- [ ] **Step 2: Make `askClaude` cancellable + progress-relaying**

Rewrite the `withProgress` block in `askClaude` (`src/trackChangesPreview.ts:232-235`) to mirror Task 4:

```ts
try {
  const ids = await vscode.window.withProgress(
    {
      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) {
        if (token.isCancellationRequested) return [] as string[];
        throw err;
      }
    },
  );
  if (ids.length === 0) {
    void vscode.window.showInformationMessage("Cowriting: Claude proposed no changes.");
  } else {
    void vscode.window.showInformationMessage(
      `Cowriting: Claude proposed ${ids.length} edit${ids.length === 1 ? "" : "s"} — review ✓/✗ in the preview.`,
    );
  }
} catch (err) {
  const message = err instanceof Error ? err.message : String(err);
  void vscode.window.showErrorMessage(`Cowriting: Claude edit failed — ${message}`);
}
```

(On cancel the inner catch returns `[]`, which shows the benign "proposed no changes" — no proposal is created, satisfying INV-47. A distinct "cancelled" toast is optional; the editSelection path shows one. Keep parity simple: returning `[]` is the no-proposal outcome.)

- [ ] **Step 3: Thread `opts` through `runEditAndPropose`**

Change the signature (`src/trackChangesPreview.ts:257`) and both `editTurn(...)` calls (lines 270, 276) to pass opts:

```ts
async runEditAndPropose(
  document: vscode.TextDocument,
  target: EditTarget,
  instruction: string,
  opts?: RunEditTurnOptions,
): Promise<string[]> {
  // ...
  // range branch:
  const turn = await this.editTurn(instruction, selected, opts);
  // ...
  // document branch:
  const turn = await this.editTurn(instruction, full, opts);
```

- [ ] **Step 4: Typecheck + full unit run**

Run: `npm run typecheck && npx vitest run`
Expected: typecheck clean (the widened constructor now matches Task 4's call site); all unit tests pass.

- [ ] **Step 5: Build**

Run: `npm run build`
Expected: success.

- [ ] **Step 6: Commit**

```bash
git add src/trackChangesPreview.ts
git commit -m "feat(#60): preview Ask-Claude streams live progress + cancel"
```

---

## Task 6: Host E2E — additive proof + cancel

**Files:**
- Create: `test/e2e/suite/liveProgress.test.ts`

The E2E harness can't read notification subtitles, so it asserts the *contract*: progress is additive (proposals unchanged with progress events) and cancel yields zero proposals. The streamed-UI itself is covered by Task 1 units + the manual smoke.

- [ ] **Step 1: Write the test**

Create `test/e2e/suite/liveProgress.test.ts`, modeled on `f11Toolbar.test.ts` (same `getExtension`→`activate()`→`api.trackChangesPreviewController` pattern, same `setEditTurnForTest`):

```ts
import * as assert from "assert";
import * as vscode from "vscode";
import type { CowritingApi } from "../../../src/extension";

suite("#60 live progress (additive + cancel)", () => {
  async function setup(): Promise<{ api: CowritingApi; doc: vscode.TextDocument }> {
    const ext = vscode.extensions.getExtension("benstull.vscode-cowriting-plugin")!;
    const api = (await ext.activate()) as CowritingApi;
    const doc = await vscode.workspace.openTextDocument({ language: "markdown", content: "# Title\n\nOld paragraph.\n" });
    await vscode.window.showTextDocument(doc);
    await vscode.commands.executeCommand("cowriting.showTrackChangesPreview");
    return { api, doc };
  }

  test("a stub that emits progress still produces the same proposals (INV-44)", async () => {
    const { api, doc } = await setup();
    const ctl = api.trackChangesPreviewController;
    // The stub honors opts.onProgress (emitting synthetic snapshots) but returns
    // the same rewrite — proposals must be unaffected by progress.
    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-live" };
    });
    const ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "rewrite");
    assert.ok(ids.length >= 1, "expected at least one proposal regardless of progress events");
  });

  test("an aborted turn proposes nothing (INV-47)", async () => {
    const { api, doc } = await setup();
    const ctl = api.trackChangesPreviewController;
    // Simulate the SDK honoring the abort signal: throw as runEditTurn would on
    // a non-"completed" (aborted) status.
    ctl.setEditTurnForTest(async (_i, _text, opts) => {
      if (opts?.signal?.aborted) throw new Error("claude-code turn aborted");
      throw new Error("claude-code turn aborted"); // pre-aborted in this test
    });
    const ac = new AbortController();
    ac.abort();
    let ids: string[] = [];
    try {
      ids = await ctl.runEditAndPropose(doc, { kind: "document" }, "rewrite", { signal: ac.signal });
    } catch {
      ids = [];
    }
    assert.strictEqual(ids.length, 0, "aborted turn must create no proposals");
  });
});
```

- [ ] **Step 2: Compile + run the E2E suite**

Run: `npm run pretest:e2e && npm run test:e2e`
Expected: the new suite passes alongside the existing E2E suites. (If the sandboxed `.vscode-test` has the known `executeCommand("undo")` breakage, the #38 undo suite may skip/fail independently — that is pre-existing per session 0048/0049 and unrelated to #60; confirm only the live-progress suite is green and the rest are unchanged from baseline.)

- [ ] **Step 3: Commit**

```bash
git add test/e2e/suite/liveProgress.test.ts
git commit -m "test(#60): host E2E — progress is additive; abort proposes nothing (INV-44/47)"
```

---

## Task 7: Manual smoke + final verification

**Files:** none (verification only)

- [ ] **Step 1: Full unit + typecheck + build**

Run: `npm run typecheck && npx vitest run && npm run build`
Expected: typecheck clean; all unit tests pass; build succeeds.

- [ ] **Step 2: Manual smoke (real LLM)**

Per #60 acceptance (E2E can't assert streamed UI). With Claude Code signed in, run the extension (F5 / Extension Development Host), open a markdown doc, and Ask-Claude a non-trivial edit. Confirm:
- the notification line advances (`thinking…` → `writing… (N chars)` → token count rising; `running <tool>…` if a tool fires);
- the "Cowriting: Claude" OutputChannel reveals (without stealing focus) and streams the text;
- the `✕` cancel aborts cleanly (status resolves, no proposal);
- toggling `cowriting.liveProgress.revealOutput` off suppresses the auto-reveal;
- the final proposals are exactly as before (INV-44).

`scripts/smoke-live-turn.mjs` (`npm run smoke:live`) exercises the turn headlessly if a UI smoke isn't convenient; note it does not render the notification.

- [ ] **Step 3: Record the smoke result in the session transcript** (`## Deferred decisions` or a smoke note), since E2E doesn't cover the live UI.

---

## Self-Review (completed by plan author)

**Spec coverage:**
- §2.1 notification activity line + token count → Task 1 (`formatProgressLine`), Task 4/5 (`progress.report`). ✓
- §2.1 OutputChannel full-text stream + auto-reveal gate → Task 3 (`LiveProgressUi`, setting). ✓
- §2.1 cancellation → "cancelled", no proposal → Task 4 (editSelection), Task 5 (preview), Task 6 (E2E). ✓
- §2.2 reasoning not surfaced → Task 1 (reasoning-delta → thinking, no textDelta). ✓
- §3.2 pure reducer (INV-46) → Task 1. ✓
- §3.3 runEditTurn onProgress + AbortSignal, vscode-free (INV-43/44) → Task 2. ✓
- §3.4 both call sites relay; widened EditTurn seam; stub stays valid → Task 4, Task 5, Task 6. ✓
- §3.5 OutputChannel append + header → Task 3. ✓
- §3.6 setting → Task 3. ✓
- §3.7 INV-43..47 → asserted across Tasks 1/2/6. ✓
- §4 unit (reducer + format) + host E2E (additive + cancel) + manual smoke → Tasks 1, 6, 7. ✓

**Placeholder scan:** none (every code/command step is concrete). The Task 4 Step 2 `token_was_cancelled(err)` pseudo-line is immediately replaced by the concrete inner-try/catch in the same step.

**Type consistency:** `TurnProgressSnapshot`, `RunEditTurnOptions`, `TurnUi`, `LiveProgressUi`, `reduceTurnProgress`, `formatProgressLine`, `createTurnProgressState` used consistently across tasks; `editTurn` widened uniformly; `toolName`/`inputTokens+outputTokens` match the SDK `agent.d.ts`.