docs: roadmap — Frontend MVP next (Svelte + DaisyUI, mirrored-backend methodology), then dedup/storage

User-set roadmap: (1) Frontend MVP — Svelte + DaisyUI, but ONLY after a careful design pass that maps the backend's methodology (minimal core + extensions, typed contracts, pure-core/inject-effects, one-owner, asymmetric testing) onto the frontend. Old Dispatch FE is reference-only; port 24204 reserved. Seed doc at notes/frontend-design.md (IDEATION mode — design WITH the user before any summon). (2) dedup/storage growth (D5 volume-control + prefix.fingerprint + §6 retention) — already designed, sequenced after the FE. Re-sequenced the deferred storage item. When FE build begins: retire AGENTS.md 'Backend only' line + author new frontend scoped rules + update ORCHESTRATOR §3/§7.

2 files changed, 105 insertions, 1 deletions

diff --git a/notes/frontend-design.md b/notes/frontend-design.md
new file mode 100644
index 0000000..b9145e5
--- /dev/null
+++ b/notes/frontend-design.md
@@ -0,0 +1,79 @@
+# Frontend MVP — Design Scratch
+
+> **Status:** IDEATION / scratch. NOT decided, NOT building yet. This is the HOME for the
+> "carefully plan the frontend" pass the user asked for (per ORCHESTRATOR "write up before
+> pivoting"). Promote settled parts into `notes/restructure-plan.md` + `GLOSSARY.md` +
+> harness files when we commit to building.
+>
+> **Read order (fresh agent picking this up):** `ORCHESTRATOR.md` → `AGENTS.md` (the
+> backend methodology we are MIRRORING) → `GLOSSARY.md` → this file.
+> **Mode = IDEATION WITH the user** (design/discuss, do NOT build yet). The user owns the
+> boundary (§5.2) + vocabulary (§5.6) calls.
+> **Driver:** a minimal chat frontend, **Svelte + DaisyUI** (same stack family as old
+> Dispatch), built with the SAME methodology as the backend — NOT a default-SvelteKit ball
+> of mud. Old FE at `/home/tradam/projects/dispatch/dispatch-source` is REFERENCE-ONLY.
+> Ports reserved: `FRONTEND_PORT=24204` (.env).
+
+---
+
+## 0. Goal in one paragraph
+A minimal browser chat client — the FE analogue of the curl MVP: send a message and render
+the streamed, multi-turn response (`conversationId` threads history). Svelte + DaisyUI for
+the view; but the architecture must be a **minimal core + feature modules** with the same
+discipline that makes the backend testable and agent-buildable.
+
+## 1. The hard constraint — methodology parity with the backend (why this needs care)
+Translate each backend principle to the frontend (these are the constraints, not yet the
+"how"):
+- **Minimal core + feature modules / tiers.** A FE "kernel" that owns app shell + routing +
+  state-core + a module host, and **names no concrete feature**; every feature (chat view,
+  conversation list, composer, message-stream renderer, settings…) is a module/"extension".
+- **Contracts are the only cross-unit surface.** Cross-module coupling anchored to **typed
+  symbols** (no string-keyed lookups → must be a compile error so `lsp references` finds
+  every consumer). The **FE↔BE seam** is the backend's HTTP/event contract (the
+  `AgentEvent` union + `/chat` NDJSON + `conversationId`) — ideally a **shared typed
+  contract** so `lsp references` spans the boundary.
+- **Pure-core / inject-effects + no ambient state.** Pure view-models / stores / reducers /
+  formatters: zero DOM, zero I/O, exhaustively unit-testable. Svelte components + transport
+  (`fetch`/streaming) + browser effects (localStorage, history, clipboard) are the
+  **injected imperative shell**.
+- **One owner per unit**; orchestrator summons owner-agents; units communicate via
+  contracts; the orchestrator never edits implementation.
+- **Asymmetric testing** — strict zero-internal-mock + high coverage on pure logic; lenient
+  integration on components/shell. Mocking our own module = a design bug.
+- **Durability where it matters** (e.g. optimistic UI + reconcile on reconnect) — pure
+  `reconcile(state, events)`.
+
+## 2. Open questions (DECIDE in the design pass — all UNDECIDED)
+- **FE "kernel" shape:** what exactly is core vs. feature? Module-host mechanism (manifest
+  analogue?) vs. simpler composition. How far to take the kernel/extension metaphor before
+  it's cargo-culting the backend (P6 — don't copy structure that earns nothing).
+- **Unit boundaries / first units** for the MVP (composer, transport client, message-stream
+  store + renderer, conversation state). Granularity = USER's call.
+- **The FE↔BE contract package:** reuse kernel `AgentEvent`/types directly? a new shared
+  `@dispatch/protocol` package both sides depend on? how do FE pure-cores import it.
+- **Transport in the browser:** consume the `/chat` NDJSON stream (fetch + ReadableStream
+  reader) — framing, backpressure, abort, reconnect, `conversationId` threading. (Note:
+  `trace-replay`'s fixture model could even feed FE transport tests hermetically.)
+- **State approach:** Svelte stores vs runes; keep ALL logic framework-thin & pure so it's
+  testable without mounting components.
+- **Testing tools:** vitest for pure logic (already in repo); component/integration via
+  `@testing-library/svelte`; e2e via Playwright? — decide + how it joins `bun run test`.
+- **Build/tooling + monorepo placement:** `packages/frontend` vs `apps/web`; Vite + Svelte;
+  Tailwind + DaisyUI; how it fits `tsc -b` project refs, biome, the bun workspace.
+- **Harness artifacts to author:** new scoped `.dispatch/rules/frontend-*.md` (the FE
+  pure-core/shell + inject-effects + no-ambient-state rules), GLOSSARY terms (no
+  synonym-drift with backend vocab), ORCHESTRATOR additions for FE summons, and the
+  AGENTS.md scope update (**the current "Backend only for now (no frontend)" line retires
+  when FE build starts** — leave it until then).
+- **MVP scope cut:** what's in v1 (send + stream + multi-turn render) vs. deferred (history
+  list, tool-call/▷thinking rendering, settings, theming).
+
+## 3. Decisions settled
+- (none yet — IDEATION.)
+
+## 4. References (do NOT copy blindly — keep our methodology)
+- Old Dispatch FE: `/home/tradam/projects/dispatch/dispatch-source` (Svelte + DaisyUI) —
+  reference-only for UX + tech, NOT structure.
+- Backend seam: `packages/kernel/src/contracts/events.ts` (`AgentEvent`),
+  `packages/transport-http` (`/chat` NDJSON), `GLOSSARY.md`.
diff --git a/tasks.md b/tasks.md
index e643d02..51c1d13 100644
--- a/tasks.md
+++ b/tasks.md
@@ -277,7 +277,32 @@ independent of the SQLite trace-store; the lib is redaction-free (caller self-re
   Mitigation already DESIGNED, not built: D5 "Volume control" (persist body only when
   `prefix.fingerprint` changed) + §6 retention/rotation/compression; thin/fat split already
   built. `cacheReadTokens` (just added) + the future `prefix.fingerprint` are the cheap dedup
-  signals. Revisit when cache-warming / longer conversations land.
+  signals. **Sequenced AFTER the Frontend MVP** (user-set roadmap below); also relevant
+  once cache-warming / longer conversations land.
 
 Summons: prompts/phase-a-{kernel-logging,journal-sink}.md;
 reports/phase-a-{kernel-logging,journal-sink}.md.
+
+---
+
+## ROADMAP — what's next (user-decided, §5.2)
+
+### Next: Frontend MVP
+Svelte + DaisyUI (same stack as old Dispatch). **Careful design pass FIRST** — the FE
+must be built with the SAME methodology as the backend (minimal core + feature modules,
+typed contracts as the only cross-unit surface, pure-core / inject-effects / no ambient
+state, one owner per unit, asymmetric testing). A dedicated design scratch lives at
+`notes/frontend-design.md` (IDEATION mode — design WITH the user before any summon).
+
+The old Dispatch frontend (`/home/tradam/projects/dispatch/dispatch-source`) is
+REFERENCE-ONLY for UX/tech — do NOT copy its architecture. Port `FRONTEND_PORT=24204` is
+reserved in `.env`. When frontend BUILD begins: retire the AGENTS.md "Backend only for
+now (no frontend)" line, author new scoped `.dispatch/rules/frontend-*.md`, and update
+ORCHESTRATOR.md §7 (repo geography) + §3 (rule scoping map).
+
+### After Frontend MVP: dedup / storage growth
+The deferred trace-body de-duplication + rotation/compression (D5 volume-control +
+`prefix.fingerprint` + §6 retention strategy) — already designed in
+`notes/observability-design.md`, not yet built. `cacheReadTokens` (committed) is the
+cheap dedup signal; the workspace is ready. Prioritized AFTER the frontend per user
+roadmap.