# Session 0021.0 — Transcript

> App: vscode-cowriting-plugin
> Start: 2026-06-11T08-33 (PST)
> End: 2026-06-11T11-52 (PST)
> Type: planning-and-executing
> Status: **FINALIZED**
> Posture: autonomous (yolo)

## Launch prompt

> /goal Plan and execute Feature #21 (F7 rendered track-changes markdown
> preview) from the graduated Solution Design at
> content `specs/coauthoring-rendered-preview.md` — 4 slices per §7.2,
> host-E2E tier, no LLM in CI.

## Plan

Plan-and-execute F7 (#21) from the graduated Solution Design
`coauthoring-rendered-preview.md`, four slices per §7.2:

- **SLICE-1** `trackChangesModel.ts` — vscode-free pure render engine: block
  diff (LCS by normalized text) + word-level prose refinement + `markdown-it`
  render + atomic code/mermaid blocks (INV-22/23). Add `markdown-it` + `diff`
  deps. Vitest suite per §6.8.
- **SLICE-2** Webview asset + build: `media/preview.ts` (receive HTML, run
  `mermaid.run()`, theme CSS), esbuild second entry → `out/media/preview.js`
  bundling mermaid; sealed CSP shell (INV-21).
- **SLICE-3** `TrackChangesPreviewController` (vscode layer) + additive F6
  `onDidChangeBaseline` event + `package.json` command/keybinding
  (`cowriting.showTrackChangesPreview`, `ctrl+alt+r`, markdown-only) +
  `CowritingApi` handle + test seam (`isOpen`/`getLastModel`); debounced live
  update.
- **SLICE-4** Host E2E (open/live/epoch/pin/non-markdown per §6.8) +
  `docs/MANUAL-SMOKE-F7.md` + README F7 section.

One PR; host-E2E tier (no browser/deploy stage); no LLM in CI.

## Pre-state

Clean `main`, in sync with `origin/main`. Epic #1 inner loop (F2–F6) fully
shipped; F6 diff-view (`#17`/`#19`) was the immediate predecessor. F7's spec
`coauthoring-rendered-preview.md` graduated in session 0020. The
implementation plan was written just-in-time from that spec
(`docs/superpowers/plans/2026-06-11-f7-rendered-track-changes-preview.md`).

## Turn-by-turn arc

1. **Init.** Classified as planning-and-executing; claimed session **0021**
   (no other sessions in flight). Verified baseline (fast-forwarded `main` 1
   commit), read the F7 spec, resolved content/roadmap repos.
2. **Plan.** Wrote the 12-task implementation plan with `superpowers:writing-plans`
   (engine → webview → controller → wiring → E2E → docs → verify), self-reviewed
   against the spec (full INV-20..23 + PUC coverage). Committed on branch
   `f7-rendered-preview`.
3. **Execute (TDD, `superpowers:executing-plans`).** Twelve tasks, each
   test-first where applicable, committed individually:
   - T1 deps (`markdown-it`, `diff`, `mermaid` + types).
   - T2–T5 `src/trackChangesModel.ts` (pure engine): `splitBlocks` → `diffBlocks`
     (LCS via jsdiff `diffArrays`, atomic fences INV-23) → `renderTrackChanges`
     (markdown-it + custom mermaid fence rule + word-level prose `<ins>`/`<del>`)
     → injectable per-block renderer + error-chip fallback (PUC-6). **18 vitest
     cases.**
   - T6 `media/preview.ts` + `media/preview.css` + esbuild **second entry**
     (browser IIFE bundling mermaid → `out/media/preview.js`; CSS imported so
     esbuild emits `out/media/preview.css`). Host bundle stayed ~68kb; webview
     bundle ~7MB (mermaid, isolated as intended).
   - T7 additive `DiffViewController.onDidChangeBaseline` event.
   - T8 `src/trackChangesPreview.ts` — `TrackChangesPreviewController` (sealed
     CSP+nonce webview, one panel/markdown doc, debounced live refresh, reuses F6
     baseline, no persistence INV-20, test seam `isOpen`/`getLastModel`).
   - T9 wired into `extension.ts` (workspace-independent like F6) + `CowritingApi`
     + `package.json` command/keybinding (`ctrl+alt+r`, markdown-only).
   - T10 host E2E `test/e2e/suite/trackChangesPreview.test.ts` (5 cases:
     open/PUC-1, type/PUC-2, propose+accept epoch advance/PUC-3, pin/PUC-4,
     non-markdown guard/PUC-6) + fixtures `preview.md` + `notes.txt`.
   - T11 `docs/MANUAL-SMOKE-F7.md` + README F7 section.
   - T12 full verification.
4. **Verify.** typecheck clean; **122 unit** passing; **33 (workspace) + 4
   (no-workspace) E2E** passing (F7's 5 among them); build produces all artifacts;
   working tree clean (INV-20 — preview wrote nothing to repo/sidecar).
5. **Ship.** Pushed branch, created **PR #23** via Gitea API, merged (merge
   commit), synced `main`, deleted branch local + remote, re-verified `main`
   green post-merge.

## Cut state

F7 (#21) shipped to `main` (PR #23, merge commit `ce01ef8`). Plan archived to the
content repo `plans/` (`0a52159`). `main` clean and in sync. Deferred follow-up
**#22** (intra-diagram mermaid diffing) remains open.

## Deferred decisions

Autonomous-mode low-confidence calls made this session (none blocked progress;
all cheap to revisit):

1. **CSP `style-src 'unsafe-inline'`** in the webview shell. Mermaid injects
   `<style>` tags into the DOM at runtime, which a nonce/hash can't cover.
   *Chosen:* allow inline styles while keeping **scripts** strictly nonce-gated
   and local-only (no remote/CDN script source) — INV-21's network seal is
   intact. *Alternative:* hash every injected style (impractical for runtime
   injection). Standard practice for mermaid-in-webview, but flagging the
   relaxation since it's security-adjacent.
2. **Block-key normalization lowercases + collapses whitespace** for diff
   matching. *Consequence:* a case-only or whitespace-only edit to a block won't
   register as a `changed` block. *Chosen:* reduce diff noise from reflow/casing.
   *Alternative:* case/whitespace-sensitive keys (more literal, noisier). Minor
   fidelity tradeoff in a pure-preview view.
3. **PR merged as a merge commit** (not squash), matching recent repo history
   (`Merge pull request …` style). The 12 conventional commits are preserved.
4. **CSS delivered via `import "./preview.css"` from the webview entry** so
   esbuild emits the sibling `out/media/preview.css` (single `localResourceRoot`,
   one build mechanism) rather than a separate copy step.

## Operator plate

- F7 is live: `Ctrl+Alt+R` / "Cowriting: Open Track-Changes Preview" on a
  markdown doc. Run the **manual smoke** (`docs/MANUAL-SMOKE-F7.md`) once to
  verify the webview's *visual* rendering (mermaid diagrams, theming) — that
  layer is intentionally not asserted in the sealed-sandbox E2E.
- **Deployment pipeline (§9):** this app is a **non-shippable VS Code extension
  POC** (spec §7.3 — no marketplace publish). There is **no deployable UI app /
  no PPE or prod stage** for it; the app's required pipeline tier is **host E2E**,
  which ran green. So "completion" = merged + host-E2E green + manual smoke, not a
  flotilla deploy. Nothing was skipped — there is no cloud stage to run.

## Next session

The open follow-up is **#22 (intra-diagram mermaid diffing)**, `type/task`. The
F7 spec §6.7 explicitly flagged it as "a large unscoped design" (diff at the
source / parsed-graph / SVG level; layout reflow) — so although typed a task, it
is design-heavy and the session may want to scope the approach first.

```
/goal Plan and execute #22 (F7 intra-diagram mermaid diffing) — extend the F7 track-changes preview beyond the whole-diagram "changed" badge to node/edge-level diffing; spec §6.7 flags it as unscoped (source vs parsed-graph vs SVG, layout reflow), so scope the approach first. Builds on src/trackChangesModel.ts (atomic mermaid blocks, INV-23) + the F7 webview; host-E2E tier, no LLM in CI.
```

Read first: memory `f7-rendered-preview-shipped.md` (what shipped + the open
follow-ups) and the F7 spec `coauthoring-rendered-preview.md` §6.7 (the deferred
mermaid-diff decision).