# vscode-cowriting-plugin

Non-shippable **proof-of-concept** (Feature #2 of Epic #1): a standalone VS Code
extension that drives **[`@cline/sdk`](https://www.npmjs.com/package/@cline/sdk)**
— validating Approach A (own coauthoring extension on the Cline SDK, no fork).

## What it does

Registers one command, **`Cowriting: Show Cline SDK Info`**, which loads
`@cline/sdk` and shows the SDK build version plus the agent's builtin tool
catalog (a pure, key-free SDK call) in a notification and the
"Cowriting (Cline SDK)" output channel.

Features shipped so far: F2 region-anchored threads (Feature #4), F3 live
human/Claude attribution (Feature #6), F4 propose/accept diff flow
(Feature #12), F5 cross-rung sidecar contract (Feature #14), F6 diff-view
toggle (Feature #17), F10 interactive review — **write left / review
right** (Feature #29), and F11 — the **preview toolbar as the primary
interaction surface** (Feature #43).

## Architecture

- CommonJS extension bundled with esbuild (`src/extension.ts` → `out/extension.cjs`).
- `@cline/sdk` is ESM-only (Node ≥22) and uses `createRequire(import.meta.url)`,
  so it is **not** bundled — it is shipped in `node_modules` and loaded at
  runtime via dynamic `import()` from the vscode-free `src/cline.ts`.

## Run it (F5)

1. `npm install`
2. `npm run build`
3. Press **F5** (or Run → "Run Extension") to launch the Extension Development Host.
   It opens the committed **`sandbox/`** playground as its workspace (not the
   repo itself — VS Code won't open one folder in two windows, #8); start with
   `sandbox/playground.md`.
4. In the new window: **Cmd/Ctrl+Shift+P** → **"Cowriting: Show Cline SDK Info"**.

## F2 — Region-anchored threads (Feature #4)

Attach durable, region-anchored discussion threads to any document. Threads
render in the native VS Code **Comments** gutter and persist as git-native
sidecars under `.threads/<doc-path>.json` (plain, diffable JSON — no server).

- **Create:** select text → run **"Cowriting: Add Coauthoring Thread on Selection"**
  (or the Comments gutter "+").
- **Reply / Resolve:** use the native Comments reply box and the thread's
  Resolve/Reopen actions.
- **Survives edits, reload, and external change (`git pull`):** a hybrid anchor
  (durable content fingerprint + live offset tracking) re-resolves the thread.
  If the anchored text can't be confidently re-found, the thread is shown as
  **orphaned** at its last-known line — never silently moved.

Design: `vscode-cowriting-plugin-content/specs/coauthoring-inner-loop.md`. No live
`@cline/sdk` turn and no credentials are involved in F2.

## F3 — Live human/Claude attribution (Feature #6)

As you and Claude coauthor, every span in the buffer carries an author: human
edits render with a subtle left border, Claude-authored spans with a background
tint. Text that predates tracking stays plain — the honest record. Edits that
touch a boundary (split, merge, partial overwrite) are handled char-precisely.

Attribution is persisted git-natively in the same `.threads/` sidecars
(`attributions[]`, sharing the same `anchors` fingerprints as F2 threads). On
reload, fingerprints re-resolve spans against the current document; spans that
can't be confidently re-found are **orphaned** (status-bar count + "Cowriting
Attribution" output channel) rather than silently moved or discarded.

**Commands**

- **`Cowriting: Ask Claude to Edit Selection`** — select text → enter an
  instruction → a live `@cline/sdk` turn runs on the built-in `claude-code`
  provider (rides your local Claude Code Pro/Max login; the extension stores no
  credentials). As of F4 the turn ends in a **proposal** (see below); accepted
  text lands as a Claude-attributed span.
- **`Cowriting: Toggle Attribution`** — show/hide attribution decorations.
- `cowriting.applyAgentEdit` _(palette-hidden)_ — the single machine-edit
  ingress seam. Tests drive this directly so CI requires no LLM.

Design: `vscode-cowriting-plugin-content/specs/coauthoring-attribution.md`.

## F4 — Propose/accept diff flow (Feature #12)

Claude's edits arrive as **pending proposals** — propose-by-default, the
document never changes without your say-so. A proposal renders two ways at
once: an **amber tint** on the target range, and a "Claude proposes" comment
thread showing a fenced `diff` of current → proposed text with two actions:

- **✓ Accept Proposal** — applies the replacement through the `applyAgentEdit`
  seam, so it lands Claude-attributed (F3) — and the proposal disappears.
- **✗ Reject Proposal** — the document is untouched; the proposal disappears.

Pending proposals persist git-natively in the same sidecar (`proposals[]`,
sharing the F2/F3 `anchors` fingerprints), survive reload, and re-anchor as
surrounding text changes. If the **target text itself** changes, the proposal
goes **stale** (status-bar count, accept disabled — never applied by guess);
undo the change and it becomes decidable again. `cowriting.proposeAgentEdit`
_(palette-hidden)_ is the programmatic propose ingress E2E drives — no LLM in
CI.

Design: `vscode-cowriting-plugin-content/specs/coauthoring-propose-accept.md`.
Live smoke: [`docs/MANUAL-SMOKE-F4.md`](docs/MANUAL-SMOKE-F4.md).

## F5 — Cross-rung format + round-trip (Feature #14)

The `.threads/` sidecar is the **published cross-rung contract**: any rung of
the ladder (this editor → Gitea substrate → rfc-app) reads and writes the same
record per the contract; git push/pull is the transport, no re-homing ever.

- **Normative contract (INV-14):**
  `vscode-cowriting-plugin-content/specs/coauthoring-sidecar-contract.md` —
  format changes land there first, then schema, then code.
- **Machine-checkable half:**
  [`schemas/coauthoring-sidecar.schema.json`](schemas/coauthoring-sidecar.schema.json);
  validate any sidecar from any rung with
  `node scripts/validate-sidecar.mjs <file>`. The unit suite validates every
  serialized artifact — contract drift fails CI.
- **Identity crosses rungs:** `Provenance.email` (git's own join key —
  populated from the workspace git config when available) and
  `agent.onBehalfOf` (who the machine acted for).
- **Writers preserve unknown fields (INV-15):** rewriting a sidecar never
  destroys another rung's data — unknown keys survive, after known keys,
  sorted.
- **Newer-major sidecars are read-only (INV-16):** the editor renders what it
  understands, warns once, and writes nothing (the store refuses as a
  backstop).
- **Deterministic merge (INV-17):** `src/mergeArtifacts.ts` — union-by-id,
  documented tie-breaks, every resolved divergence surfaced in `conflicts`.
- **The round-trip is proven, not asserted:**
  [`scripts/crossrung-reply.mjs`](scripts/crossrung-reply.mjs) is a
  self-contained conforming foreign writer (the Gitea-rung stand-in); host E2E
  drives editor-thread → stand-in reply → external-change → the reply renders
  in the thread.

Design: `vscode-cowriting-plugin-content/specs/coauthoring-cross-rung-format.md`.

## F6 — Diff-view toggle (Feature #17, #19)

**`Ctrl+Alt+D`** (the same chord on macOS — not `Cmd`; or **Cowriting: Toggle
Diff View**) flips the focused document into a native `vscode.diff` against a
**coauthoring baseline** — the readonly baseline on the left, your **live,
editable** document on the right (so you keep writing inside the diff; toggling
again closes it). The diff answers "what did *I* change?" in one keystroke
instead of git archaeology.

- **Works on any file (#19):** any document you can edit — a file inside or
  outside the workspace folder, or an **untitled** scratch buffer. Only a
  non-text-editor focus warns. (Untitled buffers diff in-memory; saving makes
  the baseline persist.)
- **Machine-factored baseline (INV-18):** the baseline initializes when a doc
  is first seen and **advances automatically at every machine landing** (every
  successful `applyAgentEdit` seam apply — INV-9). So text Claude landed never
  shows as a change; everything the diff shows is operator-authored by
  construction — no attribution filtering.
- **Pin on demand:** **Cowriting: Pin Diff Baseline to Now** resets the
  baseline to the current buffer for a deliberate "review my next pass" epoch;
  the diff tab title names the epoch (`opened` / `Claude landed` / `pinned`).
- **Pure view, repo-free (INV-19):** the baseline snapshot lives in VS Code
  **global** extension storage, keyed by a hash of the document URI, **never**
  the repo — `.threads/`, the cross-rung contract (INV-14..17), and
  `SCHEMA_VERSION` are untouched. Storage-unavailable degrades to in-memory
  baselines + one warning.
- **No LLM in CI:** host E2E (`test/e2e/suite/diffView.test.ts`) drives the same
  programmatic seam ingress (propose + accept) the F4 suite uses.

Design: `vscode-cowriting-plugin-content/specs/coauthoring-diff-view.md`.
Live smoke: [`docs/MANUAL-SMOKE-F6.md`](docs/MANUAL-SMOKE-F6.md).

## F7 — Rendered track-changes preview (Feature #21)

**`Ctrl+Alt+R`** (or **Cowriting: Open Track-Changes Preview**) opens a
read-only webview **beside** a **Markdown** editor that renders the document and
marks what changed since the F6 baseline — the "track changes" / "suggesting
mode" altitude rather than a raw-text split-diff:

- **Prose** additions are highlighted (`<ins>`), deletions struck (`<del>`),
  refined to the word.
- **Code and mermaid fences** are diffed **whole** (atomic, INV-23): a changed or
  added one renders fully with a small **"changed"** badge; a removed one renders
  struck. Mermaid fences render as **diagrams** (mermaid runs in the webview).
  Intra-diagram node/edge diffing is deferred (#22).
- It **updates live** as you and Claude edit (debounced), and **re-bases** when
  Claude lands an edit (baseline advances, INV-18) or you pin — so accepted text
  drops its marks. It **reuses the F6 baseline** and adds **no** persistence
  (pure read-only, INV-20).
- The webview is **sealed** (INV-21): local bundled assets only, strict CSP with
  a per-load nonce, no network/CDN, no LLM. Mermaid is bundled into the
  **webview** asset only, never the extension-host bundle.
- The render engine (`src/trackChangesModel.ts`) is a **pure, vscode-free**
  function (INV-22), unit-tested with no editor and no webview; host E2E
  (`test/e2e/suite/trackChangesPreview.test.ts`) drives the same programmatic
  propose/accept seam with no LLM.

F7 is **markdown-only**; for any other file (incl. code), use F6's diff toggle
(`Ctrl+Alt+D`). The webview's visual rendering (mermaid, theming) is verified by
the manual smoke, not the sealed-sandbox E2E.

Design: `vscode-cowriting-plugin-content/specs/coauthoring-rendered-preview.md`.
Live smoke: [`docs/MANUAL-SMOKE-F7.md`](docs/MANUAL-SMOKE-F7.md).

## F9 — Authorship view in the preview (Feature ~#27)

The rendered preview (F7) gains a second mode, switched by a `[ Track changes |
Authorship ]` toggle in its header. **Authorship** mode re-renders the current
document with each span colored by its F3 author — Claude (blue) vs you (green),
inline and char-precise — with a legend. Unlike track-changes (which diffs against
the F6 baseline, and so hides Claude's text once the baseline advances past a
landing), authorship reads F3 attribution directly, so Claude's contributions stay
visible. Code/mermaid fences carry a block-level author badge (atomic). Read-only,
sealed webview, no new persistence (INV-26..28).

Design: `docs/superpowers/specs/2026-06-11-authorship-preview-design.md`.
Live smoke: [`docs/MANUAL-SMOKE-F9.md`](docs/MANUAL-SMOKE-F9.md).

## F8 — Out-of-workspace authoring (Feature #25)

"Ask Claude to Edit Selection" (and F2 threads / F3 attribution / F4
propose-accept) now work on **any** document the editor shows — saved in the
workspace folder, saved outside it, or untitled — matching the already-universal
F6 diff and F7 preview. Authoring is no longer gated to in-workspace files, and
the commands are live even with **no folder open**.

Persistence is **hybrid** (one `SidecarStore` abstraction, routed per-document):

- an **in-workspace** file keeps its committable `.threads/<repo-rel>.json`
  sidecar, **byte-for-byte unchanged** (INV-2) — the only home the F5 cross-rung
  contract ever sees;
- an **out-of-workspace** file or **untitled** buffer stores its coauthoring
  artifact in VS Code **global storage** keyed by `sha256(uri)` (the same home
  and key F6's baseline uses, INV-19/24); untitled buffers are **in-memory
  only** (lost on reload/save).

A global-storage artifact is **not a committed file**, so it is **never
cross-rung-shareable** (INV-25), and renaming/moving the file **orphans** its
artifact (the key is the URI hash) — both stated as design contract, not
discovered later. Routing leaves the in-workspace path untouched, so rollback is
a plain PR revert with zero data migration.

Design: `vscode-cowriting-plugin-content/specs/coauthoring-out-of-workspace.md`.
Live smoke: [`docs/MANUAL-SMOKE-F8.md`](docs/MANUAL-SMOKE-F8.md).

## F10 — Interactive review: write left / review right (Feature #29)

A clean, **zero-annotation editor** on the left; the rendered preview on the
right as the **single interactive review surface**. The editor carries no
attribution tint, no in-editor proposal threads, and no diff — all review lives
in the preview, toggled by the **Annotations** switch in its header (on by
default). Open it via `Ctrl+Alt+R`, the editor title-bar button, or
**right-click a markdown file in the Explorer / its editor tab →
"Open Cowriting Review Panel"** (#41) — the right-click acts on the clicked
document, opening it first if needed.

In the on-state the preview shows **green = human / blue = Claude /
strikethrough = deleted**, and surfaces each of Claude's pending F4 proposals as
a blue `cw-proposal` block with **✓ / ✗** buttons: **✓** accepts (the
replacement lands Claude-attributed via the seam and the baseline advances past
it), **✗** rejects (the block vanishes, the document untouched). With no preview
open, a status-bar indicator shows the pending-proposal count and opens the
review when clicked. Toggle **Annotations** off for clean rendered markdown.
Read-only, sealed webview, no new persistence (INV-32..34).

F6's two-pane diff and F9's authorship view are **retained only as data layers**
(the baseline the preview diffs against; the F3 attribution that colors it) —
they are no longer separate user surfaces.

Design: `vscode-cowriting-plugin-content/specs/coauthoring-interactive-review.md`.
Live smoke: [`docs/MANUAL-SMOKE-F10.md`](docs/MANUAL-SMOKE-F10.md).

## F11 — Preview toolbar as the primary interaction surface (Feature #43)

The review preview's **header toolbar** becomes the cockpit for the inner loop.
Beside the existing **Annotations** switch it gains two controls:

- **⌖ Pin baseline** — pins the previewed document's review baseline to now and
  clears the change-marks (homes the previously-orphaned `pinDiffBaseline`
  command, which is reachable from the palette again too).
- **✦ Ask Claude…** — one **adaptive** button. Its label flips on the preview's
  selection: **Edit Selection** when text is selected in the rendered preview,
  **Edit Document** otherwise. Clicking it opens a host input box for the
  instruction (the LLM turn and prompt stay host-side — the sealed webview gains
  no LLM/credential surface), then surfaces the result as F4 proposals — **one**
  for a selection (mapped back to its source block-union), or **one per changed
  hunk** for a whole-document rewrite (`diffToHunks`), each independently ✓/✗-able.

The pure render layer emits `data-src-start`/`data-src-end` on every block in
**both** modes (INV-36); the webview's only mapping duty is walking a selection
to its nearest `data-src` ancestor. Right-clicking a markdown tab → **Open Review
Preview** is the minimal gateway making the surface reachable end to end (#41/#42
expand it). Edit controls are disabled on a non-authorable doc (reading stays
allowed). No new model, no new persistence — pin via the F6 store, edits via the
F4 propose/accept seam with F3 attribution (INV-35..37).

Design: [`docs/superpowers/specs/2026-06-12-f11-preview-toolbar-interaction-surface.md`](docs/superpowers/specs/2026-06-12-f11-preview-toolbar-interaction-surface.md).
Live smoke: [`docs/MANUAL-SMOKE-F11.md`](docs/MANUAL-SMOKE-F11.md).

## Develop

- `npm run watch` — rebuild on change.
- `npx vitest run` — unit suite (SDK driver, schema, store, anchorer, thread
  mutations, attribution split/merge).
- `npm run test:e2e` — `@vscode/test-electron` host E2E
  (create → reply → resolve → persist → reload → re-anchor → orphan; drives
  `cowriting.applyAgentEdit` directly — no LLM required).
- `npm run smoke:live` — scripted live-turn smoke test for F3; requires Claude
  Code installed and signed in. See
  [`docs/MANUAL-SMOKE-F3.md`](docs/MANUAL-SMOKE-F3.md).
- `npm run typecheck` — type-check without emit.