Desktop harness · design note

The session is a canvas,
not a chat log.

A mental model for turning the desktop app into an HTML‑first coding harness: one living canvas of beautiful documents per session — plans, live status, final report — steered by chat, working for any repo that has Claude in it.

1 session 1 canvas N artifacts tabs, not replacement no hooks required
The one idea
A session owns a single canvas. The canvas holds a stack of artifacts shown as tabs: a live Status doc that's always current, every Plan the agent drafts (kept forever), and a Summary report when the work lands. Chat is the control surface; the canvas is how you understand what's happening.

Today the left pane shows exactly one thing and overwrites it — the plan vanishes the moment execution starts, terminal sessions get no canvas at all, and there's nowhere to attach a screenshot or pick permissions. The fix isn't more panels. It's realising the deliverable was never singular: a session produces several documents over its life, and you want to move between them without losing any.

What it looks like

One canvas, tabbed artifacts, chat alongside

acme-api · fix flaky auth tests
Status
Plan
Plan 2
Summary
● Executing — phase 2 of 4
Stabilise the auth test suite
✓ Reproduce the flake locally
✓ Isolate the shared token cache
Add per‑test teardown now
Re‑run 200× in CI next
Conversation
Here's the CI failure — can you see the pattern?
▣ ci-run-4821.png
Yes — the token cache is process‑global, so parallel tests collide. I've drafted a plan on the Plan tab.
Message the session…
SonnetacceptEditsskip‑perms ⚠＋ image
➤
Tabs never overwrite each other. Status stays live; Plan is frozen the moment it's approved; Summary appears after the diff. Chat carries images and per‑session config.
The data model

Three artifact kinds, one lifecycle

SESSION STATE (ANY REPO) Transcript + todos jsonl · TodoWrite · diff Plan writes plans/*.html · plan‑md Turn results git diff · result event SYNTHESISE → ARTIFACT Status doc always current · 1 per session Plan doc(s) frozen on approve · 0..N Summary doc after diff · 0..1 CANVAS Status Plan tabbed viewer switch · never overwrite
Status — live, synthesised, one per session Plan — frozen artifact, many per session Summary — final report after the diff

The crucial move: artifacts are derived, then pinned. A Status doc is regenerated from live session state every time it changes. A Plan doc is a real file that gets frozen the instant it's approved — execution edits a fresh copy or the code, never the approved plan. That's how you keep the original plan artifact while still watching progress.

How the four asks map in

Every fix is one consequence of the model

1

Canvas for a terminal session

A session can hold many plans + one running status. Solve it with the tab stack, and synthesise the Status doc from the transcript so it works with zero hooks.

Tabs = artifacts; Status is generated, not hook‑fed
2

Images + full chat, HTML‑first

Chat becomes the harness: attach screenshots, converse freely; the canvas shows plan → status → summary report after the diff.

Image blocks over stream‑json; Summary artifact on turn end
3

Keep the original plan

Execution never overwrites the approved plan. The Plan tab is frozen; a separate live Status tab shows the latest — both visible at once.

Freeze‑on‑approve + a distinct Status artifact
4

Tools & configs per session

Model, permission mode, and dangerously‑skip‑permissions chosen per session and switchable live — surfaced as pills on the composer.

Session config → CLI flags (‑‑dangerously‑skip‑permissions)
Build order

Shipping it in slices

  1. Session config & tools — permission mode incl. dangerously‑skip‑permissions, model, live switch. Smallest, self‑contained. building now
  2. Tabbed artifact canvas — the tab shell + artifact model; Status + frozen Plan for app sessions. next
  3. Synthesised Status for terminal sessions — generate the live status doc from any transcript, so any repo with Claude gets a canvas.
  4. Screenshots & full chat — image attachments through the CLI, richer conversation.
  5. Summary report — a beautiful diff‑based final report artifact when the work lands.