diff --git a/AMICODE-PATCHES.md b/AMICODE-PATCHES.md
index 0a839a745e..e5eba9e0fb 100644
--- a/AMICODE-PATCHES.md
+++ b/AMICODE-PATCHES.md
@@ -225,6 +225,7 @@ Rebuilt with the exact T3 recipe (`OPENCODE_VERSION=1.17.3 bun run script/build.
 - index.css: @font-face for both (JuliaMono full glyph set — Julia Unicode; Racing Sans One latin subset, font-display swap). logo.tsx + wordmark-v2.tsx: font-family 'Racing Sans One' first, weight 700→400. settings.tsx: monoDefault/monoFallback lead with JuliaMono. theme.css: --font-family-mono leads with JuliaMono. Terminal font DELIBERATELY unchanged (JetBrainsMono Nerd Font Mono via separate terminalFallback).
 - New assets (git-added — build breaks without them): public/assets/RacingSansOne-Regular.woff2 (21 KB) + JuliaMono-Regular.woff2 (946 KB).
 - Font build sha256: `2a15da111be516516fb1fbd1a4fb5ae02ad9bddd6373ede08cdf7b28c19d163a` (dist/opencode-local + vendored path, write-temp + mv -f swap; SUPERSEDES #13's a73d8583… — same code, fonts now committed). Verify (scratch port 14099): `GET /assets/RacingSansOne-Regular.woff2` → 200 font/woff2 21804 B; `GET /assets/JuliaMono-Regular.woff2` → 200 font/woff2 946516 B; "Racing Sans One" in built css + index/new-session chunks, "JuliaMono" in `index-Dwtxigfs.css`; `GET /amicode/problems` → 200; `GET /` → 200 `<title>Amicode</title>`; ui `bun test src` → 70 pass; typecheck green ui+app (no snapshots assert fonts, per Aaron — confirmed nothing went red). Bonus confirmation: KaTeX\_\* woff2 assets now in dist — the entity view's katex import (#13) pulls its font set into the embed.
+
 9. (home CTA fallback) — amicode(home): "Open chat" works on a fresh profile.
    - BUG: `startWithPrompt` (fork wiring for the Meet-Amico card, patch 5ef6b7e0e) dead-ended
      silently when the persisted client-side project list was empty (fresh browser profile
@@ -246,7 +247,30 @@ Rebuilt with the exact T3 recipe (`OPENCODE_VERSION=1.17.3 bun run script/build.
      if something else (e.g. the harmoniqs website dev server) holds 3000.
    - Checks: `tsgo -b` clean; `bun run test:unit` 376 pass / 0 fail.
 
-15. (mark drift fix, synced to amicode PR #99 final) — amicode: consolidated the fork's brand mark to ONE geometry, matching amicode's redesigned mark. The "kept in sync manually" cross-repo promise from patch #8 had already silently failed.
+15. (Aero wordmark, re-added) — amicode: AMICODE wordmark/logo font-family gains `'Aero'` ahead of the existing fallback chain, both call sites: logo.tsx (`'Aero', var(--font-family-sans, ...)`) and wordmark-v2.tsx (`'Aero', 'Racing Sans One', var(--font-family-mono, ...)`). Additive only — no fallback removed, no sizing/weight/spacing touched. This had been iterated as uncommitted working-tree WIP before the branch fast-forwarded 57 commits to current `origin/local/amicode` (e9b695191); re-applied fresh against the current font stacks (logo.tsx's had independently moved to a sans-serif stack + weight 750/letter-spacing 4 in the interim — preserved as-is, only the family list changed).
+
+    > ⚠️ **LICENSE-PENDING — release blocker.** "Aero" by Nirmal Biswas (Picatype) is donationware, USD 25+ to nirmalbiswas@gmail.com. Bundled at `packages/app/public/assets/Aero-Regular.ttf` for PREVIEW ONLY; not locked as the official face. Before any release: pay the license and record proof here, or drop `'Aero'` from both `font-family` chains + remove its `@font-face` (index.css) + the asset.
+
+    - index.css: new `@font-face` for "Aero" (truetype, weight 400, `font-display: swap`), inserted immediately before the existing Racing Sans One face; carries the license-pending comment inline.
+    - New asset (git-added): `public/assets/Aero-Regular.ttf` (44,464 B).
+    - Verify: `bun run typecheck` green in both `packages/ui` and `packages/app` (tsgo, no errors). Visual/glyph confirmation is manual-only (see build note under #16, which builds and vendors this alongside the paste fix).
+
+16. (composer paste bridge) — amicode: wire the main chat composer's `handlePaste` (prompt-input/attachments.ts) to the extension-clipboard bridge that patch #14's PR already shipped for a different input (home-cards.tsx's `readClipboardViaBridge`/`pasteFallback`, commit `5a2f1dde44`) — that bridge answers `{source:"amicode", kind:"clipboard-request"}` on the extension side (`packages/extension/src/chat_panel.ts`, already on `main`), but nothing in the composer's own paste path ever sent it. Root cause matches home-cards.tsx's own comment verbatim: the chat iframe is sandboxed + cross-origin, so `navigator.clipboard` is denied and the native `paste` event's `clipboardData` arrives empty — Cmd/Ctrl+V into the composer was a silent no-op.
+
+    - platform.tsx: new optional capability `readClipboardText?(): Promise<string | null>`, alongside the existing `readClipboardImage?`.
+    - entry.tsx: implements it — no-op (`null`) when not framed (`window.parent === window`, i.e. plain browser/opencode.ai/desktop — zero behavior change there); when framed, posts `{source:"amicode", kind:"clipboard-request", nonce}` to `window.parent` and resolves on the matching `{kind:"clipboard", nonce}` reply or a 1500 ms timeout — same nonce/timeout/listener shape as the proven `readClipboardViaBridge`, just exposed as a platform capability instead of a component-local closure (this file already hosts the analogous `readClipboardImage`).
+    - attachments.ts: `handlePaste` no longer bails out when `event.clipboardData` is null (only when it's ALSO missing `readClipboardText`, i.e. non-amicode contexts are untouched); after the existing file/image-bridge attempts, falls back to `readClipboardText()` when there's still no plain text.
+    - prompt-input.tsx: threads `readClipboardText: platform.readClipboardText` into `createPromptAttachments`, mirroring `readClipboardImage`.
+    - No shared bridge module extracted — matches this codebase's existing precedent (home-cards.tsx's bridge is also component-local, not a shared util); two call sites isn't yet worth a shared abstraction.
+    - Tests: app `bun test` (66 files) → 376 pass / 0 fail, incl. the untouched `attachments.test.ts` (pure-function coverage only — `handlePaste` itself has no unit coverage in this codebase, matching home-cards.tsx's own bridge having none either; verification here is typecheck + build + the manual live-paste check below). Typecheck green in `packages/app`.
+    - Build sha256 (composer-only build, superseded by the generalization below): `564a4cd783524e0f50541b716d9db4048b2e02430ebc77786a11a4504431c085`.
+    - **ADDENDUM (same session, live-test finding — Aaron): composer-only wiring wasn't enough.** Confirmed live: pasting into a _different_ editable (the generic "Connect \<provider\>" API-key dialog, `dialog-connect-provider.tsx` — one of many such generic settings/connect forms) was still a silent no-op, because that dialog is a plain `<input>` with no knowledge of the bridge at all. This is the exact gap patch #14's era of WIP had already found and fixed once before (composer-only interception "left every OTHER editable broken (provider API-key field, etc.)") — generalized properly this time instead of re-patching one dialog at a time:
+      - entry.tsx: new `installGlobalPasteFallback()`, installed once at app mount (alongside `readClipboardText`, not a separate file — same feature area). A single `document`-level `paste` listener: activates only when the event target is a form field or `contenteditable` AND the native `event.clipboardData` gave no plain text (the sandboxed-iframe symptom) — everywhere clipboardData already works (plain browser tabs, desktop) it's a pure no-op, no framed-check needed at the call site. On activation: fetches text via the same `readClipboardText` bridge, then splices it into `<input>`/`<textarea>` via `selectionStart`/`selectionEnd` + dispatches a synthetic `input` event (Solid's `onInput` picks it up), or `execCommand("insertText", …)` for `contenteditable`.
+      - Composer double-fire is a non-issue by construction: `attachments.ts`'s `handlePaste` calls `stopPropagation()` on every paste it handles (unconditionally now that `readClipboardText` is always provided when framed), so the event never bubbles to this new `document` listener for the composer specifically.
+      - Tests: same 376/376 pass (app suite), typecheck green — no regressions. No unit coverage added, same house-precedent reasoning as above (DOM/postMessage bridge code, build+manual verified here).
+    - **Final build sha256 (covers #15 + #16 + this addendum together):** `115216e82a6db15843fca46d5b32b587ba9a1e542297501cf2b45c394f745ea9`. Verify: smoke test `--version` → `1.17.3`; string-literal checks confirm the underlying protocol compiled in (`Aero` ×5, `clipboard-request` ×2, `readClipboardText` ×3 — note: the new `installGlobalPasteFallback`/`isFormField` are local identifiers, not string literals, so they're minifier-renamed and don't grep-match; absence there is expected, not a failure signal); channel gate ON (`newLayoutDesigns` sentinel `=!0`). **Interactive Cmd/Ctrl+V confirmation (composer AND the generalized fallback) is live-VS-Code-only, NOT yet human-verified past Aaron's one negative report on the pre-addendum build** — same deferred-to-dev-host-acceptance caveat as patches #12/#13.
+
+17. (mark drift fix, synced to amicode PR #99 final) — amicode: consolidated the fork's brand mark to ONE geometry, matching amicode's redesigned mark. The "kept in sync manually" cross-repo promise from patch #8 had already silently failed.
 
 - Trigger: amicode's mark was redesigned (PR #99) without a corresponding update here — the fork still rendered the OLD "digi" pixel-accented H-robot everywhere. PR #99 went through several iterations before landing on its final geometry; this entry tracks that FINAL state (square viewBox `0 0 3600 3600`), not the intermediate "hackathon mark" (viewBox `116 287 3377 3035`) an earlier draft of this fork PR had copied — that intermediate geometry is now itself stale and was replaced here.
 - Two copies of near-identical geometry lived in THIS repo (logo.tsx's `Robot` used by `Mark`/`Splash`, and spinner.tsx's `AmicoSpinner`), plus a third in favicon/amico.svg. Consolidated to a single `MARK_PATH` exported from logo.tsx.
@@ -258,3 +282,28 @@ Rebuilt with the exact T3 recipe (`OPENCODE_VERSION=1.17.3 bun run script/build.
 - NOT a re-established cross-repo sync promise — `MARK_PATH` is the single source of truth WITHIN this repo; it happens to match amicode's current geometry, kept aligned by hand when the mark changes.
 - Tests: ui `bun test src/amicode` green; typecheck green ui + app.
 - NOT done this round: full native `bun run script/build.ts` compile + vendored-binary swap — this patch only touches the embedded web UI. Deferred to the next amicode.N release tag, same split as patches #8/#11.
+
+18. (rich chat output, 2026-07-10) — amicode: assistant text style parity with Claude Code. packages/opencode/src/session/prompt/anthropic.txt ONLY (the provider prompt every Claude-model session gets).
+
+- Trigger (Aaron, live comparison): amicode replies rendered as flat unstyled paragraphs — no headings, no bold, no lists — while Claude Code's chat output is structured markdown. The renderer was never the problem (packages/ui markdown.tsx/css fully style headings/bold/tables/LaTeX); the prompt was: "output will be displayed on a command line interface. Your responses should be short and concise."
+- Change: "# Tone and style" → "# Communicating with the user", modeled on Claude Code's guidance — output renders as rich GFM (use `inline code`/bold/lists/headings/tables deliberately), match structure to content (simple question → plain prose), lead with the outcome, readable-beats-brief (complete sentences, no fragments/arrow chains), write for a teammate catching up. Emoji rule, text-vs-tool-communication rule, and never-create-files rule kept verbatim. Line 3 "interactive CLI tool" → "interactive coding agent" (the primary surface is the extension chat panel, not a monospace TTY).
+- Scope note: agents with a custom `prompt` (e.g. the extension's `pulse-designer`) BYPASS this file entirely (src/session/llm/request.ts — agent.prompt replaces SystemPrompt.provider). Interview-session parity comes from the amicode repo's companion patch to packages/extension/AGENTS.md ("Style & formatting" section, injected as `instructions` for every session) — same guidance, so plain chat and interview sessions agree.
+- default.txt/gpt.txt/gemini.txt untouched — non-Claude models keep stock style.
+- Patch commit `b81fb756f2`. Build sha256 `3c26d8d9261dcf55b878e678fe359791e5f22e6833f87f5d9ce12b457c18e061` at `dist/opencode-local` AND the amicode vendored path — built clean at the pinned ref via `fetch_opencode.mjs` (amicode opencode.lock.json ref bumped to `b81fb756f2`); byte-identical to the pre-commit `--any-ref` dirty build, so the bun compile is deterministic for identical source. Verify: `grep -ac "Being readable matters more than being brief" <binary>` → 1; channel gate `NG=!0` ON; fetch smoke test `--version` → 1.17.3. Amicode-side: vsix repackaged (55.64 MB, 133 files) + installed on erlich; extension vitest 484/484 green.
+- **ADDENDUM 3 (2026-07-11, live-test round 2): custom-prompt agents now get communicating.txt too.** Aaron's "still looks the same" screenshot was a pulse-designer INTERVIEW session — exactly the custom-prompt bypass documented in addendum 2. A live API probe of the plain-chat path (default agent, deepseek pin, POST /session/:id/message) confirmed the shared prompt WORKS — response came back with bold, a table, LaTeX, structured prose — so the gap was only the bypass (plus old sessions' flat history anchoring the model; test in a fresh session). Fix: `llm/request.ts` — custom-prompt agents append `PROMPT_COMMUNICATING` unless `agent.mode === "subagent"` (subagent final text is model-directed data, NOT user-facing — must stay style-free). The pulse-designer agent (mode unset → user-facing) now gets the rules in the system prompt proper instead of relying on AGENTS.md instructions alone. Typecheck green.
+- **ADDENDUM 2 (same day — "does this need to be model specific?"): consolidated to ONE model-agnostic prompt.** NEW `prompt/communicating.txt` (the canonical "Communicating with the user" section + structure-matching examples + an explicit supersede clause overriding any per-model CLI/terseness/length rule). `system.ts provider()` now returns `[providerBase(model), PROMPT_COMMUNICATING]` — EVERY model family (beast/gpt/codex/gemini/anthropic/trinity/kimi/default) gets it appended; the inlined copies added earlier in anthropic.txt/default.txt/gemini.txt were slimmed back to near-stock (minus their CLI-concise lines) so there is one source of truth. gpt/beast/codex/kimi/trinity left untouched — the supersede clause outranks their style rules without diffing them (upstream-merge friendliness). Typecheck green (tsgo). REMAINING GAP by design: agents with a custom `prompt` (request.ts:60) still bypass provider() — deliberate, because Task-tool subagents return model-directed raw data and must NOT get user-facing style rules; the user-facing pulse-designer agent is covered via the amicode AGENTS.md instructions instead.
+- **ADDENDUM (same day, live-test finding — Aaron: "doesn't seem any different"): anthropic.txt was the WRONG file for the live setup.** The prompt file is selected per model id (`system.ts provider()`), and the extension's model pin resolved to `opencode/deepseek-v4-flash-free` (no `anthropic` key in auth.json — `preferredModel()` creds fallback), so live sessions load **default.txt** — whose style rules are far harsher ("You MUST answer concisely with fewer than 4 lines… One word answers are best", monospace-CLI framing, one-word-answer examples) and steamroll the AGENTS.md instructions. Fix: same "Communicating with the user" section ported to **default.txt** (tone section + verbosity examples replaced with structure-matching examples; the second stray "fewer than 4 lines" mandate near Tool-usage-policy replaced too; "interactive CLI tool" → "interactive coding agent") and **gemini.txt** (Google creds exist locally → reachable; "Minimal Output: fewer than 3 lines" / monospace bullets replaced, No-Chitchat kept). gpt/beast/codex/kimi/trinity untouched (no matching creds; port on demand). Root-cause note for the future: to get Claude-quality prose AND the anthropic.txt path, add Anthropic creds — the pin then resolves to `anthropic/claude-sonnet-5`.
+
+19. (rydberg Hamiltonian fix, 2026-07-11) — amicode: the System card's composite Hamiltonian showed a driven-cavity form for a Rydberg atom (Aaron, live: platform walked transmon→cavity→transmon-cavity→rydberg and the card rendered `Ĥ/ℏ = -Δ n̂ + ε(t)(â+â†)` for a 3-lvl atom — "just not right"). packages/ui/src/amicode/system-render.ts `systemHamiltonianLatex` composed role-keyed drifts but appended ONE hardcoded bosonic quadrature drive `ε(t)(â+â†)` for every system.
+    - Fix: role-aware `driveTerm()` — `atom` → `Ω(t)/2 (|r⟩⟨1| + h.c.)` (3-level Rydberg convention: |0⟩ dark, |1⟩↔|r⟩ laser-driven); everything else keeps the quadrature drive. Deduped per distinct role like the drifts, so mixed atom+cavity systems show both flavors. Atom drift `-Δ n̂` → `-Δ |r⟩⟨r|` (detuning belongs on the Rydberg level; n̂ read as a bosonic number operator next to the old â-drive).
+    - Tests: system-render.test.ts +3 (bare rydberg atom → Rabi drive, NO ε(t)/â; two atoms + vdW → deduped single drive + C₆ term; atom+cavity → both drives). ui `bun test src/amicode` 115 pass; typecheck green both packages.
+
+20. (markdown heading hierarchy, 2026-07-11) — amicode: section titles in chat rendered indistinguishable from body prose (Aaron, live: "section titles aren't rendering properly"). Root cause was upstream DESIGN, not a bug: packages/ui/src/components/markdown.css had `/* Headings: Same size, distinguished by color and spacing */` — all h1–h6 at 14px medium, the same size/weight as body, colored `--text-strong` which the whole markdown container ALREADY uses (zero distinction), with margin-top 0 + margin-bottom 24px (gap on the wrong side — title floats orphaned above its section). The prompt work (#18) made the model EMIT headings; this made them visible.
+    - markdown.css: real hierarchy — h1 18px / h2 16px / h3 15px / h4-h6 14px, all weight 600 (no semibold token exists; 400/500 only, raw 600 consistent with the file's raw px), margin 24px above + 8px below (binds title to its section; container's `> *:first-child` rule still zeroes the top of a leading heading). `strong`/`b` medium(500) → 600 — against the 400 body, 500 was near-invisible as "bold".
+    - CSS-only, no tests to update; cascade checked (message-part.css/index.css define no competing heading rules).
+
+21. (expandable skill chips, 2026-07-11) — amicode: skill loads rendered as a name-only chip with `hideDetails` (Aaron: "when skills are used do I get a visual notification like in Claude Code?" — the chip existed, but nothing showed WHAT got injected). packages/ui/src/components/message-part.tsx skill renderer + NEW message-part-skill.ts.
+    - `skillBody()` (pure, tested — message-part-skill.ts): strips the `<skill_content>`/`<skill_files>` transport wrapper and the model-facing plumbing lines (base-directory, relative-path note, sampling note, the `# Skill: name` heading the chip already shows) from the skill tool's output, leaving the SKILL.md instructions.
+    - Renderer: `hideDetails` dropped; body renders via the standard `tool-output` + `Markdown` idiom (same as list/glob), so the chip stays collapsed by default and expands to the injected instructions. No output yet (running) → no chevron, unchanged look.
+    - Companion (amicode repo, PR #132 commit b135875): injected opencode config gains `permission.skill: "allow"` — the staged skill set is surface+entitlement curated, so the skill tool's default per-name "ask" was friction without a boundary and a headless-session hang risk.
+    - Tests: message-part-skill.test.ts +5; ui `bun test` 158 pass; typecheck (tsgo) green.
diff --git a/packages/app/public/assets/Aero-Regular.ttf b/packages/app/public/assets/Aero-Regular.ttf
new file mode 100644
index 0000000000..6b7b8e5ebd
Binary files /dev/null and b/packages/app/public/assets/Aero-Regular.ttf differ
diff --git a/packages/app/src/components/amicode-default-model-value.ts b/packages/app/src/components/amicode-default-model-value.ts
new file mode 100644
index 0000000000..b660eceba3
--- /dev/null
+++ b/packages/app/src/components/amicode-default-model-value.ts
@@ -0,0 +1,17 @@
+// Pure "providerID/modelID" <-> ModelKey helpers for the dashboard default-model
+// control. Split out of amicode-default-model.tsx so they're unit-testable
+// without evaluating the SolidJS component (which touches client-only context).
+
+/** "providerID/modelID". modelID may itself contain "/", so callers split on the first. */
+export function formatModelValue(key: { providerID: string; modelID: string }): string {
+  return `${key.providerID}/${key.modelID}`
+}
+
+/** Inverse of formatModelValue; null on a malformed/empty value. Splits on the
+ *  FIRST slash so a model id containing slashes (e.g. openrouter/meta-llama/…)
+ *  round-trips. */
+export function parseModelValue(value: string): { providerID: string; modelID: string } | null {
+  const slash = value.indexOf("/")
+  if (slash <= 0 || slash === value.length - 1) return null
+  return { providerID: value.slice(0, slash), modelID: value.slice(slash + 1) }
+}
diff --git a/packages/app/src/components/amicode-default-model.test.ts b/packages/app/src/components/amicode-default-model.test.ts
new file mode 100644
index 0000000000..81f1cc7a60
--- /dev/null
+++ b/packages/app/src/components/amicode-default-model.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test"
+import { formatModelValue, parseModelValue } from "./amicode-default-model-value"
+
+describe("amicode default-model value round-trip", () => {
+  test("format then parse is identity, incl. model ids with dots/dashes", () => {
+    const key = { providerID: "anthropic", modelID: "claude-sonnet-5" }
+    expect(formatModelValue(key)).toBe("anthropic/claude-sonnet-5")
+    expect(parseModelValue(formatModelValue(key))).toEqual(key)
+    expect(parseModelValue("opencode/deepseek-v4-flash-free")).toEqual({
+      providerID: "opencode",
+      modelID: "deepseek-v4-flash-free",
+    })
+  })
+
+  test("splits on the FIRST slash so a model id may itself contain slashes", () => {
+    expect(parseModelValue("openrouter/meta-llama/llama-3.3")).toEqual({
+      providerID: "openrouter",
+      modelID: "meta-llama/llama-3.3",
+    })
+  })
+
+  test("rejects malformed / empty values (→ null, no selection)", () => {
+    expect(parseModelValue("")).toBeNull()
+    expect(parseModelValue("noslash")).toBeNull()
+    expect(parseModelValue("/leading")).toBeNull()
+    expect(parseModelValue("trailing/")).toBeNull()
+  })
+})
diff --git a/packages/app/src/components/amicode-default-model.tsx b/packages/app/src/components/amicode-default-model.tsx
new file mode 100644
index 0000000000..4bebebaf1e
--- /dev/null
+++ b/packages/app/src/components/amicode-default-model.tsx
@@ -0,0 +1,106 @@
+import { For, Show, createMemo } from "solid-js"
+import { useModels } from "@/context/models"
+import { formatModelValue, parseModelValue } from "./amicode-default-model-value"
+
+// Dashboard "Default model" control. Drives opencode's GLOBAL model store
+// (useModels — mounted app-wide, persisted via Persist.global), which is what
+// new chats inherit as their starting model (see local.tsx recentModel()), so
+// a change takes effect immediately with no server restart. It ALSO mirrors the
+// choice into the `amicode.defaultModel` VS Code setting over the iframe→parent
+// bridge (chat_panel.ts), keeping the headless/first-turn config pin in sync.
+// The in-chat picker still overrides per session.
+
+/** Post the chosen model to the extension host so it updates amicode.defaultModel.
+ *  No-op when unframed (plain web/desktop): there's no parent shell to relay it. */
+function syncDefaultModelPin(model: string, win: Window = window): void {
+  if (win.parent === win) return
+  win.parent.postMessage({ source: "amicode", kind: "set-default-model", model }, "*")
+}
+
+export function AmicodeDefaultModel() {
+  const models = useModels()
+
+  const available = createMemo(() => models.list())
+  // opencode's default visibility hides dated, non-"latest" models — which can
+  // hide EVERY model and leave the control empty. Prefer the visible set, but
+  // fall back to all available models so the picker is never blank when models
+  // exist. (Guarded below on available(), so it only hides with zero models.)
+  const selectable = createMemo(() => {
+    const vis = available().filter((m) => models.visible({ providerID: m.provider.id, modelID: m.id }))
+    return vis.length > 0 ? vis : available()
+  })
+
+  const groups = createMemo(() => {
+    const byProvider = new Map<string, { provider: string; items: { value: string; name: string }[] }>()
+    for (const m of selectable()) {
+      const group = byProvider.get(m.provider.id) ?? { provider: m.provider.name, items: [] }
+      group.items.push({ value: formatModelValue({ providerID: m.provider.id, modelID: m.id }), name: m.name })
+      byProvider.set(m.provider.id, group)
+    }
+    return [...byProvider.values()]
+  })
+
+  // Bound to the DURABLE pin (models.pin), not the recents head — chats using
+  // other models must not move the dashboard's declared default. Empty = Auto
+  // (no pin; new chats fall back to recents/provider default).
+  const current = createMemo(() => {
+    const pin = models.pin.get()
+    return pin ? formatModelValue(pin) : ""
+  })
+
+  const choose = (value: string) => {
+    if (value === "") {
+      models.pin.set(undefined) // Auto: clear the pin, mirror the cleared setting
+      syncDefaultModelPin("")
+      return
+    }
+    const key = parseModelValue(value)
+    if (!key) return
+    models.pin.set(key)
+    syncDefaultModelPin(value)
+  }
+
+  return (
+    <Show when={available().length > 0}>
+      <label
+        data-component="amicode-default-model"
+        title="Default model for new chats"
+        style={{
+          display: "inline-flex",
+          "align-items": "center",
+          gap: "8px",
+          "font-size": "12px",
+          color: "var(--v2-text-text-muted)",
+        }}
+      >
+        <span data-slot="amicode-default-model-label" style={{ "font-weight": "550" }}>
+          Model
+        </span>
+        <select
+          data-slot="amicode-default-model-select"
+          value={current()}
+          onChange={(event) => choose(event.currentTarget.value)}
+          style={{
+            "font-size": "12px",
+            color: "var(--v2-text-text-base)",
+            background: "var(--v2-background-bg-layer-01)",
+            border: "1px solid var(--v2-border-border-base)",
+            "border-radius": "6px",
+            padding: "3px 6px",
+            "max-width": "220px",
+            cursor: "pointer",
+          }}
+        >
+          <option value="">Auto</option>
+          <For each={groups()}>
+            {(group) => (
+              <optgroup label={group.provider}>
+                <For each={group.items}>{(item) => <option value={item.value}>{item.name}</option>}</For>
+              </optgroup>
+            )}
+          </For>
+        </select>
+      </label>
+    </Show>
+  )
+}
diff --git a/packages/app/src/components/prompt-input.tsx b/packages/app/src/components/prompt-input.tsx
index 0d3baae0c4..fc4e532d49 100644
--- a/packages/app/src/components/prompt-input.tsx
+++ b/packages/app/src/components/prompt-input.tsx
@@ -58,7 +58,7 @@ import { createSessionTabs } from "@/pages/session/helpers"
 import { inAmicode } from "@/pages/session/use-amicode-commands"
 import { createTextFragment, getCursorPosition, setCursorPosition, setRangeEdge } from "./prompt-input/editor-dom"
 import { createPromptAttachments } from "./prompt-input/attachments"
-import { readClipboardViaBridge } from "./prompt-input/clipboard-bridge"
+import { readClipboardViaBridge, readClipboardImageViaBridge } from "./prompt-input/clipboard-bridge"
 import { normalizePaste } from "./prompt-input/paste"
 import { ACCEPTED_FILE_TYPES, pickAttachmentFiles } from "./prompt-input/files"
 import {
@@ -1147,6 +1147,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     // browser dispatches no usable paste event on ⌘V (unlike plain web/desktop,
     // where onPaste handles it). Intercept the keystroke and read the OS
     // clipboard over the extension bridge instead (see clipboard-bridge.ts).
+    // Image first (screenshots), then text — mirrors handlePaste's precedence.
     if (
       (event.metaKey || event.ctrlKey) &&
       !event.altKey &&
@@ -1155,9 +1156,15 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
       inAmicode()
     ) {
       event.preventDefault()
-      void readClipboardViaBridge().then((text) => {
+      void (async () => {
+        const image = await readClipboardImageViaBridge()
+        if (image) {
+          await addAttachment(image)
+          return
+        }
+        const text = await readClipboardViaBridge()
         if (text) addPart({ type: "text", content: normalizePaste(text), start: 0, end: 0 })
-      })
+      })()
       return
     }
 
diff --git a/packages/app/src/components/prompt-input/clipboard-bridge.test.ts b/packages/app/src/components/prompt-input/clipboard-bridge.test.ts
index 372e4a1342..38cf3c87b0 100644
--- a/packages/app/src/components/prompt-input/clipboard-bridge.test.ts
+++ b/packages/app/src/components/prompt-input/clipboard-bridge.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { readClipboardViaBridge } from "./clipboard-bridge"
+import { readClipboardViaBridge, writeClipboardViaBridge } from "./clipboard-bridge"
 
 type Listener = (event: MessageEvent) => void
 
@@ -74,3 +74,26 @@ describe("readClipboardViaBridge", () => {
     expect(posted).toHaveLength(0)
   })
 })
+
+describe("writeClipboardViaBridge", () => {
+  test("pushes the copied text to the host so the OS clipboard matches ⌘V's read", () => {
+    const bridge = fakeFramedWindow()
+
+    expect(writeClipboardViaBridge("solve a CZ gate", bridge.win)).toBe(true)
+    expect(bridge.posted).toHaveLength(1)
+    const message = bridge.posted[0]
+    expect(message.source).toBe("amicode")
+    expect(message.kind).toBe("clipboard-write")
+    expect(message.text).toBe("solve a CZ gate")
+  })
+
+  test("is a no-op that posts nothing when the app is not framed", () => {
+    const posted: unknown[] = []
+    const win = { postMessage: (message: unknown) => posted.push(message) } as unknown as Window
+    // parent === self → plain web/desktop, where native copy already works
+    ;(win as unknown as { parent: Window }).parent = win
+
+    expect(writeClipboardViaBridge("ignored", win)).toBe(false)
+    expect(posted).toHaveLength(0)
+  })
+})
diff --git a/packages/app/src/components/prompt-input/clipboard-bridge.ts b/packages/app/src/components/prompt-input/clipboard-bridge.ts
index ffedf5f4f2..8559bbacde 100644
--- a/packages/app/src/components/prompt-input/clipboard-bridge.ts
+++ b/packages/app/src/components/prompt-input/clipboard-bridge.ts
@@ -12,6 +12,20 @@
 
 const BRIDGE_TIMEOUT_MS = 1500
 
+// ⌘C inside the Amicode chat is the mirror image of ⌘V: the sandboxed iframe's
+// native copy (and navigator.clipboard.writeText) never reaches the OS
+// clipboard, so a subsequent ⌘V — which DOES read the OS clipboard over the
+// bridge — pastes whatever stale thing was there before, not what you copied.
+// Push the copied text to the extension host, which writes vscode.env.clipboard
+// so read and write hit the same clipboard. Fire-and-forget: the host write is
+// near-instant and callers have nothing to await. Resolves false (no-op) when
+// unframed — native copy already works there.
+export function writeClipboardViaBridge(text: string, win: Window = window): boolean {
+  if (win.parent === win) return false
+  win.parent.postMessage({ source: "amicode", kind: "clipboard-write", text }, "*")
+  return true
+}
+
 export function readClipboardViaBridge(win: Window = window, timeoutMs = BRIDGE_TIMEOUT_MS): Promise<string> {
   return new Promise<string>((resolve) => {
     // Unframed: native paste works — don't post into the void or wait out the timeout.
@@ -40,3 +54,54 @@ export function readClipboardViaBridge(win: Window = window, timeoutMs = BRIDGE_
     timer = setTimeout(() => finish(""), timeoutMs)
   })
 }
+
+// ⌘V image paste inside the Amicode chat. Unlike text (which the extension host
+// reads via vscode.env.clipboard — text-only, no image API), an image can only
+// come from the OUTER webview reading navigator.clipboard.read() client-side.
+// So we ask the parent relay (chat_panel.ts) rather than the host: it grabs the
+// first image/* clipboard item, encodes it as a data URL, and replies. We
+// rebuild a File from the reply so callers reuse the normal attachment path.
+// Resolves null when unframed, on a text-only clipboard, or after `timeoutMs`.
+export function readClipboardImageViaBridge(win: Window = window, timeoutMs = BRIDGE_TIMEOUT_MS): Promise<File | null> {
+  return new Promise<File | null>((resolve) => {
+    if (win.parent === win) {
+      resolve(null)
+      return
+    }
+
+    const nonce = Math.random().toString(36).slice(2)
+    let timer: ReturnType<typeof setTimeout> | undefined
+
+    const finish = (file: File | null) => {
+      win.removeEventListener("message", onMessage)
+      if (timer !== undefined) clearTimeout(timer)
+      resolve(file)
+    }
+
+    const onMessage = (event: MessageEvent) => {
+      const data = event.data as
+        | { source?: string; kind?: string; nonce?: string; dataUrl?: string; mime?: string; filename?: string }
+        | undefined
+      if (data?.source !== "amicode" || data.kind !== "clipboard-image" || data.nonce !== nonce) return
+      finish(fileFromDataUrl(data.dataUrl, data.mime, data.filename))
+    }
+
+    win.addEventListener("message", onMessage)
+    win.parent.postMessage({ source: "amicode", kind: "clipboard-image-request", nonce }, "*")
+    timer = setTimeout(() => finish(null), timeoutMs)
+  })
+}
+
+function fileFromDataUrl(dataUrl?: string, mime?: string, filename?: string): File | null {
+  if (!dataUrl || !mime) return null
+  const comma = dataUrl.indexOf(",")
+  if (comma === -1) return null
+  try {
+    const binary = atob(dataUrl.slice(comma + 1))
+    const bytes = new Uint8Array(binary.length)
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
+    return new File([bytes], filename || "pasted-image.png", { type: mime })
+  } catch {
+    return null
+  }
+}
diff --git a/packages/app/src/components/titlebar.tsx b/packages/app/src/components/titlebar.tsx
index 259ad5b02f..4bcb8fadba 100644
--- a/packages/app/src/components/titlebar.tsx
+++ b/packages/app/src/components/titlebar.tsx
@@ -40,6 +40,7 @@ import { decode64 } from "@/utils/base64"
 import { ServerConnection, useServer } from "@/context/server"
 import { tabHref, useTabs, type Tab } from "@/context/tabs"
 import { Mark } from "@opencode-ai/ui/logo"
+import { ContextMenu } from "@opencode-ai/ui/context-menu"
 import { AmicoSpinner } from "@opencode-ai/ui/amico-spinner"
 
 type TauriDesktopWindow = {
@@ -489,6 +490,12 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                                 ref.scrollIntoView({ behavior: "instant" })
                               }}
                               onClose={() => tabsStoreActions.removeTab(i())}
+                              onCloseOthers={() => tabsStoreActions.closeOthers(i())}
+                              onCloseLeft={() => tabsStoreActions.closeToLeft(i())}
+                              onCloseRight={() => tabsStoreActions.closeToRight(i())}
+                              canCloseOthers={tabsStore.length > 1}
+                              canCloseLeft={i() > 0}
+                              canCloseRight={i() < tabsStore.length - 1}
                               active={currentTab() === tab}
                               activeServer={tab.server === server.key}
                               forceTruncate={tabsAreOverflowing()}
@@ -765,11 +772,18 @@ function TabNavItem(props: {
   sessionId?: string
   hideClose?: boolean
   onClose: () => void
+  onCloseOthers: () => void
+  onCloseLeft: () => void
+  onCloseRight: () => void
+  canCloseOthers: boolean
+  canCloseLeft: boolean
+  canCloseRight: boolean
   onNavigate: () => void
   active?: boolean
   activeServer: boolean
   forceTruncate?: boolean
 }) {
+  const language = useLanguage()
   const closeTab = (event: MouseEvent) => {
     event.preventDefault()
     event.stopPropagation()
@@ -796,15 +810,17 @@ function TabNavItem(props: {
   )
 
   return (
-    <div
-      ref={props.ref}
-      class="group relative flex h-7 min-w-24 max-w-60 flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
-      data-active={props.active}
-      onMouseDown={(event) => {
-        if (event.button !== 1) return
-        closeTab(event)
-      }}
-    >
+    <ContextMenu modal={false}>
+      <ContextMenu.Trigger
+        as="div"
+        ref={props.ref}
+        class="group relative flex h-7 min-w-24 max-w-60 flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
+        data-active={props.active}
+        onMouseDown={(event: MouseEvent) => {
+          if (event.button !== 1) return
+          closeTab(event)
+        }}
+      >
       <Show when={session.latest}>
         {(session) => {
           const project = createMemo(() => projectForSession(session(), serverCtx()?.projects.list() ?? []))
@@ -851,7 +867,24 @@ function TabNavItem(props: {
           icon={<IconV2 name="xmark-small" />}
         />
       </div>
-    </div>
+      </ContextMenu.Trigger>
+      <ContextMenu.Portal>
+        <ContextMenu.Content>
+          <ContextMenu.Item onSelect={() => props.onClose()}>
+            <ContextMenu.ItemLabel>{language.t("common.closeTab")}</ContextMenu.ItemLabel>
+          </ContextMenu.Item>
+          <ContextMenu.Item disabled={!props.canCloseOthers} onSelect={() => props.onCloseOthers()}>
+            <ContextMenu.ItemLabel>{language.t("common.closeOtherTabs")}</ContextMenu.ItemLabel>
+          </ContextMenu.Item>
+          <ContextMenu.Item disabled={!props.canCloseLeft} onSelect={() => props.onCloseLeft()}>
+            <ContextMenu.ItemLabel>{language.t("common.closeTabsToLeft")}</ContextMenu.ItemLabel>
+          </ContextMenu.Item>
+          <ContextMenu.Item disabled={!props.canCloseRight} onSelect={() => props.onCloseRight()}>
+            <ContextMenu.ItemLabel>{language.t("common.closeTabsToRight")}</ContextMenu.ItemLabel>
+          </ContextMenu.Item>
+        </ContextMenu.Content>
+      </ContextMenu.Portal>
+    </ContextMenu>
   )
 }
 
diff --git a/packages/app/src/context/local.tsx b/packages/app/src/context/local.tsx
index 8bc58a7c26..4405ca34fb 100644
--- a/packages/app/src/context/local.tsx
+++ b/packages/app/src/context/local.tsx
@@ -156,6 +156,13 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       }
     }
 
+    // amicode: the dashboard's durable default-model pin outranks recents —
+    // "default" must mean default, not "whatever the last chat used".
+    const pinnedModel = () => {
+      const pin = models.pin.get()
+      if (pin && validModel(pin)) return pin
+    }
+
     const defaultModel = () => {
       const defaults = providers.default()
       for (const provider of providers.connected()) {
@@ -172,7 +179,9 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       }
     }
 
-    const fallback = createMemo<ModelKey | undefined>(() => configuredModel() ?? recentModel() ?? defaultModel())
+    const fallback = createMemo<ModelKey | undefined>(
+      () => configuredModel() ?? pinnedModel() ?? recentModel() ?? defaultModel(),
+    )
 
     const agent = {
       list,
diff --git a/packages/app/src/context/models.tsx b/packages/app/src/context/models.tsx
index 21816ab12d..50c7b40833 100644
--- a/packages/app/src/context/models.tsx
+++ b/packages/app/src/context/models.tsx
@@ -14,6 +14,8 @@ type Store = {
   user: User[]
   recent: ModelKey[]
   variant?: Record<string, string | undefined>
+  /** amicode: durable default-model pin; optional so persisted model.v1 stores predate it */
+  pinned?: ModelKey
 }
 
 const RECENT_LIMIT = 5
@@ -133,6 +135,13 @@ export const { use: useModels, provider: ModelsProvider } = createSimpleContext(
       setStore("recent", uniq)
     }
 
+    // amicode: the DURABLE default-model pin (dashboard "Model" control).
+    // Unlike recents, nothing moves it except an explicit set/clear — chats
+    // using other models must not change the user's declared default.
+    const setPinned = (model: ModelKey | undefined) => {
+      setStore("pinned", model)
+    }
+
     const variantKey = (model: ModelKey) => `${model.providerID}/${model.modelID}`
     const getVariant = (model: ModelKey) => store.variant?.[variantKey(model)]
 
@@ -155,6 +164,10 @@ export const { use: useModels, provider: ModelsProvider } = createSimpleContext(
         list: createMemo(() => store.recent),
         push,
       },
+      pin: {
+        get: createMemo(() => store.pinned),
+        set: setPinned,
+      },
       variant: {
         get: getVariant,
         set: setVariant,
diff --git a/packages/app/src/context/platform.tsx b/packages/app/src/context/platform.tsx
index f137c528dc..2e44cdfe10 100644
--- a/packages/app/src/context/platform.tsx
+++ b/packages/app/src/context/platform.tsx
@@ -103,6 +103,17 @@ type PlatformBase = {
   /** Read image from clipboard (desktop only) */
   readClipboardImage?(): Promise<File | null>
 
+  /** Read text from clipboard via the extension-host bridge (amicode VS Code
+   *  webview only) — a sandboxed cross-origin iframe can't reach
+   *  navigator.clipboard or the native paste event's clipboardData */
+  readClipboardText?(): Promise<string | null>
+
+  /** Write text to the OS clipboard via the extension-host bridge (amicode VS
+   *  Code webview only) — the mirror of readClipboardText. Without it, an
+   *  in-chat copy never reaches the OS clipboard the paste bridge reads back,
+   *  so ⌘V pastes stale content. Resolves true when the bridge handled it. */
+  writeClipboardText?(text: string): Promise<boolean>
+
   /** Export collected diagnostic logs (desktop only) */
   exportDebugLogs?(): Promise<string>
 
diff --git a/packages/app/src/context/tabs.tsx b/packages/app/src/context/tabs.tsx
index 7f6274cf99..aee821ea77 100644
--- a/packages/app/src/context/tabs.tsx
+++ b/packages/app/src/context/tabs.tsx
@@ -92,6 +92,25 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
       })
     }
 
+    // Index of the tab the route currently points at (session by href, draft by
+    // draftId), or -1. Used by the bulk-close actions to decide whether the
+    // active tab was among those removed and therefore needs re-navigation.
+    const currentTabIndex = () => {
+      if (location.pathname === "/new-session" && location.query.draftId) {
+        return store.findIndex((tab) => tab.type === "draft" && tab.draftID === location.query.draftId)
+      }
+      if (params.dir && params.id) {
+        const href = tabHref({
+          type: "session",
+          server: server.key,
+          dirBase64: params.dir,
+          sessionId: params.id,
+        })
+        return store.findIndex((tab) => tab.type === "session" && tab.server === server.key && tabHref(tab) === href)
+      }
+      return -1
+    }
+
     const actions = {
       addSessionTab: (tab: Omit<SessionTab, "type">) => {
         const next = { type: "session" as const, ...tab }
@@ -209,6 +228,58 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
           )
         })
       },
+      // Close every tab except the one at `index`. The kept tab always becomes
+      // active (all others, including whatever was active, are gone).
+      closeOthers: (index: number) => {
+        const keep = store[index]
+        if (!keep || store.length <= 1) return
+        const draftIDs = store.flatMap((tab, i) => (i !== index && tab.type === "draft" ? [tab.draftID] : []))
+        void startTransition(() => {
+          setStore(
+            produce((tabs) => {
+              const kept = tabs[index]
+              if (kept) tabs.splice(0, tabs.length, kept)
+            }),
+          )
+          navigateTab(keep)
+        })
+        for (const draftID of draftIDs) removeDraftPersisted(draftID)
+      },
+      // Close all tabs after `index`. Re-navigate to the anchor only if the
+      // active tab was one of the removed (mirrors editor "close to the right").
+      closeToRight: (index: number) => {
+        const anchor = store[index]
+        if (!anchor || index >= store.length - 1) return
+        const draftIDs = store.slice(index + 1).flatMap((tab) => (tab.type === "draft" ? [tab.draftID] : []))
+        const removedActive = currentTabIndex() > index
+        void startTransition(() => {
+          setStore(
+            produce((tabs) => {
+              tabs.splice(index + 1)
+            }),
+          )
+          if (removedActive) navigateTab(anchor)
+        })
+        for (const draftID of draftIDs) removeDraftPersisted(draftID)
+      },
+      // Close all tabs before `index`. Re-navigate to the anchor only if the
+      // active tab was one of the removed (mirrors editor "close to the left").
+      closeToLeft: (index: number) => {
+        const anchor = store[index]
+        if (!anchor || index <= 0) return
+        const draftIDs = store.slice(0, index).flatMap((tab) => (tab.type === "draft" ? [tab.draftID] : []))
+        const active = currentTabIndex()
+        const removedActive = active >= 0 && active < index
+        void startTransition(() => {
+          setStore(
+            produce((tabs) => {
+              tabs.splice(0, index)
+            }),
+          )
+          if (removedActive) navigateTab(anchor)
+        })
+        for (const draftID of draftIDs) removeDraftPersisted(draftID)
+      },
     }
 
     return { ...actions, store, ready }
diff --git a/packages/app/src/entry.tsx b/packages/app/src/entry.tsx
index c41c1bb4b6..2e86c02fd8 100644
--- a/packages/app/src/entry.tsx
+++ b/packages/app/src/entry.tsx
@@ -94,6 +94,103 @@ const restart: Platform["restart"] = async () => {
   window.location.reload()
 }
 
+// Amicode webview: the chat iframe is sandboxed + cross-origin, so
+// navigator.clipboard and the native paste event's clipboardData are both
+// denied. Ask the extension host over the message bridge instead — it reads
+// the OS clipboard and replies (same proven pattern as home-cards.tsx's
+// readClipboardViaBridge). Framed contexts only; plain browser tabs use
+// native paste and never call this.
+const readClipboardText: Platform["readClipboardText"] = () => {
+  if (window.parent === window) return Promise.resolve(null)
+  return new Promise((resolve) => {
+    const nonce = Math.random().toString(36).slice(2)
+    const onMessage = (event: MessageEvent) => {
+      const data = event.data as { source?: string; kind?: string; nonce?: string; text?: string } | undefined
+      if (data?.source !== "amicode" || data.kind !== "clipboard" || data.nonce !== nonce) return
+      window.removeEventListener("message", onMessage)
+      resolve(typeof data.text === "string" ? data.text : null)
+    }
+    window.addEventListener("message", onMessage)
+    window.parent.postMessage({ source: "amicode", kind: "clipboard-request", nonce }, "*")
+    setTimeout(() => {
+      window.removeEventListener("message", onMessage)
+      resolve(null)
+    }, 1500)
+  })
+}
+
+// Amicode webview (generalized): the same sandboxed-iframe paste failure
+// hits every OTHER editable in the app too — provider API-key fields,
+// settings inputs, etc. — not just the chat composer (which has its own
+// handler, above, and calls stopPropagation() on every paste it handles —
+// so this document-level listener never double-fires there). It only
+// activates when the native paste event gave nothing, so it's a no-op
+// everywhere clipboardData already works (plain browser tabs, desktop).
+const isFormField = (el: EventTarget | null): el is HTMLInputElement | HTMLTextAreaElement =>
+  el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement
+
+const installGlobalPasteFallback = () => {
+  document.addEventListener("paste", (event) => {
+    const target = event.target
+    const isEditable = isFormField(target) || (target instanceof HTMLElement && target.isContentEditable)
+    if (!isEditable) return
+    if (event.clipboardData?.getData("text/plain")) return
+
+    event.preventDefault()
+    void readClipboardText().then((text) => {
+      if (!text) return
+      if (isFormField(target)) {
+        const start = target.selectionStart ?? target.value.length
+        const end = target.selectionEnd ?? target.value.length
+        target.value = target.value.slice(0, start) + text + target.value.slice(end)
+        target.selectionStart = target.selectionEnd = start + text.length
+        target.dispatchEvent(new Event("input", { bubbles: true }))
+      } else {
+        document.execCommand("insertText", false, text)
+      }
+    })
+  })
+}
+
+// Amicode webview: the write side of readClipboardText. The sandboxed iframe's
+// native copy (and navigator.clipboard.writeText) never lands in the OS
+// clipboard, so ⌘V — which reads the OS clipboard over the bridge — would paste
+// stale content. Push the text to the extension host, which writes
+// vscode.env.clipboard, keeping read and write on one clipboard. Framed
+// contexts only; plain browser tabs use native copy and never reach here.
+const writeClipboardText: Platform["writeClipboardText"] = (text) => {
+  if (window.parent === window) return Promise.resolve(false)
+  window.parent.postMessage({ source: "amicode", kind: "clipboard-write", text }, "*")
+  return Promise.resolve(true)
+}
+
+// The copy-side companion to installGlobalPasteFallback: mirror every ⌘C/⌘X
+// selection to the OS clipboard via the bridge so a following ⌘V pastes what
+// was actually copied in-chat. Mirror-only (no preventDefault) — the native
+// selection copy / cut-removal still runs; we just also update the OS clipboard
+// the paste bridge reads. Reads the document selection, falling back to a
+// form field's own selection (which window.getSelection() does not expose).
+const installGlobalCopyBridge = () => {
+  if (window.parent === window) return
+  document.addEventListener(
+    "keydown",
+    (event) => {
+      if (!(event.metaKey || event.ctrlKey) || event.altKey || event.shiftKey) return
+      const key = event.key.toLowerCase()
+      if (key !== "c" && key !== "x") return
+      let text = window.getSelection()?.toString() ?? ""
+      const target = event.target
+      if (!text && isFormField(target)) {
+        const start = target.selectionStart ?? 0
+        const end = target.selectionEnd ?? 0
+        text = target.value.slice(start, end)
+      }
+      if (text) void writeClipboardText(text)
+    },
+    true,
+  )
+}
+
 const root = document.getElementById("root")
 if (!(root instanceof HTMLElement) && import.meta.env.DEV) {
   throw new Error(getRootNotFoundError())
@@ -132,6 +229,8 @@ const platform: Platform = {
     return stored ? ServerConnection.Key.make(stored) : null
   },
   setDefaultServer: writeDefaultServerUrl,
+  readClipboardText,
+  writeClipboardText,
 }
 
 if (import.meta.env.VITE_SENTRY_DSN) {
@@ -154,6 +253,8 @@ if (import.meta.env.VITE_SENTRY_DSN) {
 }
 
 if (root instanceof HTMLElement) {
+  installGlobalPasteFallback()
+  installGlobalCopyBridge()
   const auth = authFromToken(new URLSearchParams(location.search).get("auth_token"))
   clearAuthToken()
   const server: ServerConnection.Http = {
diff --git a/packages/app/src/i18n/en.ts b/packages/app/src/i18n/en.ts
index 32919f2012..e291090cac 100644
--- a/packages/app/src/i18n/en.ts
+++ b/packages/app/src/i18n/en.ts
@@ -722,6 +722,9 @@ export const dict = {
     "The terminal connection was interrupted. This can happen when the server restarts.",
 
   "common.closeTab": "Close tab",
+  "common.closeOtherTabs": "Close other tabs",
+  "common.closeTabsToLeft": "Close tabs to the left",
+  "common.closeTabsToRight": "Close tabs to the right",
   "common.dismiss": "Dismiss",
   "common.moreCountSuffix": " (+{{count}} more)",
   "common.requestFailed": "Request failed",
diff --git a/packages/app/src/index.css b/packages/app/src/index.css
index 112af75282..6fb380f67e 100644
--- a/packages/app/src/index.css
+++ b/packages/app/src/index.css
@@ -25,7 +25,20 @@
   font-style: normal;
 }
 
-/* amicode: brand wordmark typeface (AMICODE logo) */
+/* amicode: brand wordmark typeface (AMICODE logo).
+   LICENSE-PENDING: "Aero" by Nirmal Biswas (Picatype) is donationware — usage
+   requires a USD 25+ payment to nirmalbiswas@gmail.com. Bundled for PREVIEW ONLY
+   while the wordmark face is being chosen; MUST be licensed (or replaced) before
+   any release ships. Racing Sans One (OFL, commercial-clean) is kept as the
+   fallback / prior candidate. */
+@font-face {
+  font-family: "Aero";
+  src: url("/assets/Aero-Regular.ttf") format("truetype");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
 @font-face {
   font-family: "Racing Sans One";
   src: url("/assets/RacingSansOne-Regular.woff2") format("woff2");
diff --git a/packages/app/src/pages/home.tsx b/packages/app/src/pages/home.tsx
index 880f8697b5..2e149e6d08 100644
--- a/packages/app/src/pages/home.tsx
+++ b/packages/app/src/pages/home.tsx
@@ -64,8 +64,21 @@ import { amicodeGet, amicodePost } from "@/utils/amicode-fetch"
 import { AmicodeRunGallery } from "@opencode-ai/ui/amicode-run-gallery"
 import { AmicodeOnboardingWizard, shouldShowWizard } from "@opencode-ai/ui/amicode-onboarding-wizard"
 import { AmicodeSolverToggle } from "@opencode-ai/ui/amicode-solver-toggle"
+import { AmicodeDefaultModel } from "@/components/amicode-default-model"
 import { parseRunCardsResponse } from "@opencode-ai/ui/amicode-run-card"
 import { AmicodeHomeCards, parseProfileResponse, type HomeLiveRun } from "@opencode-ai/ui/amicode-home-cards"
+import {
+  WidgetGrid,
+  parseWidgetsResponse,
+  parseDashboardResponse,
+  resolveTokens,
+  densityForViewport,
+  suggestInstitutions,
+  resolveBrandLogo,
+  type DashboardState,
+  type Density,
+  type WidgetHostCallbacks,
+} from "@opencode-ai/ui/amicode-widget-grid"
 import { parseRunSeriesResponse } from "@opencode-ai/ui/amicode-run-window"
 import { parseProblemsResponse } from "@opencode-ai/ui/amicode-problem-switcher"
 import { parseProblemResponse } from "@opencode-ai/ui/amicode-entity-view"
@@ -323,6 +336,9 @@ function HomeDesign() {
       iteration: run?.iteration ?? solving.iteration,
       fidelity: derivedF,
       series,
+      // pulse-first sparkline: the tile shows the artifact once a snapshot streams
+      pulse: run?.pulse?.values,
+      drives: run?.pulseMeta?.drives,
     }
   })
   createEffect(() => {
@@ -372,6 +388,136 @@ function HomeDesign() {
     await refetchLibrary()
   }
 
+  // amicode (widget kernel): registry + dashboard state + per-widget module
+  // code. Everything degrades to undefined → the page falls back to the
+  // legacy hardcoded cards, so a server without the widget routes still
+  // renders a full home.
+  const [widgetsRaw, { refetch: refetchWidgets }] = createResource(
+    () => state.selection.server,
+    () => amicodeGet(focusedServer(), "/amicode/widgets").catch(() => undefined),
+  )
+  const widgetInfos = createMemo(() => {
+    const raw = widgetsRaw()
+    return raw === undefined ? [] : parseWidgetsResponse(raw)
+  })
+  const [dashboardRaw] = createResource(
+    () => state.selection.server,
+    () => amicodeGet(focusedServer(), "/amicode/dashboard").catch(() => undefined),
+  )
+  // local state wins after a save (POST returns the stored merged result)
+  const [savedDashboard, setSavedDashboard] = createSignal<DashboardState | undefined>(undefined)
+  const dashboard = createMemo<DashboardState | undefined>(() => {
+    const local = savedDashboard()
+    if (local) return local
+    const raw = dashboardRaw()
+    return raw === undefined ? undefined : parseDashboardResponse(raw)
+  })
+  // Frame documents are server-served (own CSP header — srcdoc would inherit
+  // the app CSP and kill the inline runtime). The registry hash rides the URL
+  // so a widget edit busts the frame cache.
+  const widgetFrameSrcs = createMemo(() => {
+    const conn = focusedServer()
+    if (!conn) return {}
+    const out: Record<string, string> = {}
+    for (const w of widgetInfos())
+      out[w.id] = new URL(`/amicode/widget-frame?id=${encodeURIComponent(w.id)}&h=${w.hash}`, conn.http.url).toString()
+    return out
+  })
+
+  // --amc-* theme tokens + density: recomputed on resize and on root-element
+  // attribute flips (theme toggle). Widgets receive updates over the bridge.
+  const readTokens = () => {
+    const style = getComputedStyle(document.documentElement)
+    // panel-first (spec T3.4): width axis matters when Amicode is half an editor
+    const density: Density = densityForViewport(window.innerWidth, window.innerHeight)
+    return { tokens: resolveTokens((name) => style.getPropertyValue(name), density), density }
+  }
+  const [themeState, setThemeState] = createSignal(readTokens())
+  createEffect(() => {
+    const refresh = () => setThemeState(readTokens())
+    window.addEventListener("resize", refresh)
+    const observer = new MutationObserver(refresh)
+    observer.observe(document.documentElement, { attributes: true })
+    onCleanup(() => {
+      window.removeEventListener("resize", refresh)
+      observer.disconnect()
+    })
+  })
+
+  const widgetContext = createMemo(() => ({
+    resume: resumeProblem()?.name ? { name: resumeProblem()!.name, meta: resumeMeta() } : undefined,
+    liveRun: liveRun(),
+    library: libraryView(),
+  }))
+
+  const widgetCallbacks: WidgetHostCallbacks = {
+    fetch: (path) => amicodeGet(focusedServer(), path),
+    action: async (verb, payload) => {
+      const p = (payload ?? {}) as Record<string, unknown>
+      const str = (k: string) => (typeof p[k] === "string" ? (p[k] as string) : "")
+      switch (verb) {
+        case "resume-session": {
+          const name = resumeProblem()?.name
+          if (name) startWithPrompt(`Open the problem "${name}" and continue where we left off`)
+          return { ok: true }
+        }
+        case "save-profile": {
+          await saveProfileFields({
+            name: str("name") || undefined,
+            affiliation: str("affiliation") || undefined,
+            focus: str("focus") || undefined,
+            scholar: str("scholar") || undefined,
+            affiliation_logo: str("affiliation_logo") || undefined,
+          })
+          return { ok: true }
+        }
+        case "lookup-institution":
+          return suggestInstitutions(str("query"))
+        case "resolve-logo":
+          return { logo: await resolveBrandLogo(str("name"), str("domain")) }
+        case "open-external": {
+          const url = str("url")
+          if (url && window.parent !== window)
+            window.parent.postMessage({ source: "amicode", kind: "open-external", url }, "*")
+          return { ok: true }
+        }
+        case "upload-library":
+          await uploadPaper(str("filename"), str("dataB64"))
+          return { ok: true }
+        case "open-gallery":
+          setGalleryOpen(true)
+          return { ok: true }
+        case "warm-start":
+          startWithPrompt("warm-start a new solve from my pulse bank")
+          return { ok: true }
+        default:
+          throw new Error(`unknown action: ${verb}`)
+      }
+    },
+    prompt: startWithPrompt,
+    open: (entity) => {
+      if (entity === "run") {
+        const name = resumeProblem()?.name
+        if (name) startWithPrompt(`Open the problem "${name}" and show me the running solve`)
+      }
+    },
+  }
+
+  const saveDashboard = (next: DashboardState) => {
+    setSavedDashboard(next) // optimistic — instant reorder/hide feedback
+    void amicodePost(focusedServer(), "/amicode/dashboard", next)
+      .then((res) => {
+        const merged = parseDashboardResponse(res)
+        if (merged) setSavedDashboard(merged)
+      })
+      .catch(() => {})
+  }
+  const forkWidget = (id: string) => {
+    void amicodePost(focusedServer(), "/amicode/widget-fork", { id })
+      .then(() => void refetchWidgets())
+      .catch(() => {})
+  }
+
   const WIZARD_DISMISS_KEY = "amicode-onboarding-dismissed"
   const [wizardOpen, setWizardOpen] = createSignal(false)
   let wizardDecided = false
@@ -434,13 +580,42 @@ function HomeDesign() {
     closeSearch()
   }
 
+  // Chrome strip state (spec T3.1/T3.3): sessions flyout + controlled grid edit
+  const [sessionsOpen, setSessionsOpen] = createSignal(false)
+  const [gridEditing, setGridEditing] = createSignal(false)
+  let flyoutRoot: HTMLDivElement | undefined
+  createEffect(() => {
+    if (!sessionsOpen()) return
+    const onDown = (e: MouseEvent) => {
+      if (flyoutRoot && !flyoutRoot.contains(e.target as Node)) setSessionsOpen(false)
+    }
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") setSessionsOpen(false)
+    }
+    document.addEventListener("mousedown", onDown)
+    document.addEventListener("keydown", onKey)
+    onCleanup(() => {
+      document.removeEventListener("mousedown", onDown)
+      document.removeEventListener("keydown", onKey)
+    })
+  })
+  const totalSessions = createMemo(() => groups().reduce((n, g) => n + g.sessions.length, 0))
+  const unseenTotal = createMemo(() => {
+    const conn = focusedServer()
+    if (!conn) return 0
+    return projects().reduce((n, p) => n + unseenCount(conn, p), 0)
+  })
+
   command.register("home", () => [
     {
       id: "home.sessions.search.focus",
       title: language.t("home.sessions.search.placeholder"),
       keybind: "mod+f",
       hidden: true,
-      onSelect: () => focusSessionSearch?.(),
+      onSelect: () => {
+        setSessionsOpen(true) // search lives in the flyout now
+        setTimeout(() => focusSessionSearch?.(), 0)
+      },
     },
   ])
 
@@ -563,35 +738,121 @@ function HomeDesign() {
         data-slot="amicode-home-shell"
         class="mx-auto flex w-full h-full min-h-0 max-w-[1440px] flex-col gap-6 overflow-y-auto px-8 pt-10 pb-6"
       >
-        {/* Top band: Projects (left) + chat sessions (right), fused as one element (~1/3) */}
+        {/* Chrome strip (spec T3.1): brand · settings | model · solver · sessions · customize.
+            One flex-wrap container — two calm rows at panel width, one when wide. */}
         <div
-          data-slot="amicode-home-band"
-          class="grid min-h-[96px] flex-none gap-8 md:max-h-[420px] md:grid-cols-[300px_minmax(0,1fr)]"
+          data-slot="amicode-chrome-strip"
+          style={{
+            display: "flex",
+            "align-items": "center",
+            gap: "14px",
+            "row-gap": "8px",
+            "flex-wrap": "wrap",
+            "min-height": "32px",
+          }}
         >
-          <HomeProjectColumn
-            projects={projects()}
-            selected={state.selection}
-            focusServer={focusServer}
-            selectProject={selectProject}
-            openNewSession={openProjectNewSession}
-            chooseProject={(conn) => void chooseProject(conn)}
-            editProject={editProject}
-            closeProject={(conn, directory) => {
-              const next = closeHomeProject(
-                state.selection,
-                ServerConnection.key(conn),
-                global.createServerCtx(conn).projects,
-                directory,
-              )
-              if (next) setSelection(next)
-            }}
-            clearNotifications={clearNotifications}
-            unseenCount={unseenCount}
-            openSettings={openSettings}
-            language={language}
-          />
-
-          <section
+          <div style={{ display: "flex", "align-items": "center", gap: "8px", "min-width": "0" }}>
+            <Mark class="size-6 shrink-0" />
+            <span style={{ "font-size": "14px", "font-weight": "650", color: "var(--v2-text-text-base)" }}>
+              Amicode
+            </span>
+            <IconButtonV2
+              data-action="home-open-settings"
+              variant="ghost-muted"
+              size="small"
+              icon={<IconV2 name="settings-gear" />}
+              onClick={openSettings}
+              aria-label={language.t("sidebar.settings")}
+            />
+          </div>
+          <div style={{ flex: "1" }} />
+          <AmicodeDefaultModel />
+          <AmicodeSolverToggle />
+          <div ref={flyoutRoot} style={{ position: "relative" }}>
+            <button
+              type="button"
+              data-action="home-sessions-toggle-flyout"
+              onClick={() => setSessionsOpen(!sessionsOpen())}
+              style={{
+                display: "inline-flex",
+                "align-items": "center",
+                gap: "6px",
+                border: "1px solid var(--v2-border-border-base)",
+                "border-radius": "7px",
+                background: "var(--v2-background-bg-layer-01)",
+                color: "var(--v2-text-text-base)",
+                padding: "4px 10px",
+                "font-size": "12px",
+                "font-weight": "600",
+                cursor: "pointer",
+              }}
+            >
+              Sessions
+              <span
+                style={{
+                  "font-size": "10px",
+                  "border-radius": "8px",
+                  padding: "1px 7px",
+                  background: unseenTotal() > 0 ? "var(--v2-icon-icon-accent)" : "var(--v2-background-bg-layer-02)",
+                  color: unseenTotal() > 0 ? "var(--v2-background-bg-base)" : "var(--v2-text-text-muted)",
+                  "font-variant-numeric": "tabular-nums",
+                }}
+              >
+                {unseenTotal() > 0 ? unseenTotal() : totalSessions()}
+              </span>
+              <span aria-hidden="true" style={{ "font-size": "9px", color: "var(--v2-text-text-muted)" }}>
+                ▾
+              </span>
+            </button>
+            <Show when={sessionsOpen()}>
+              {/* Sessions flyout (spec T3.3): servers + projects (all existing
+                  affordances preserved via HomeProjectColumn) above the
+                  search + grouped sessions list. */}
+              <div
+                data-slot="amicode-sessions-flyout"
+                style={{
+                  position: "absolute",
+                  right: "0",
+                  top: "calc(100% + 8px)",
+                  "z-index": "40",
+                  width: "min(440px, 88vw)",
+                  "max-height": "min(70vh, 680px)",
+                  display: "flex",
+                  "flex-direction": "column",
+                  gap: "10px",
+                  overflow: "hidden auto",
+                  border: "1px solid var(--v2-border-border-base)",
+                  "border-radius": "10px",
+                  background: "var(--v2-background-bg-layer-01)",
+                  "box-shadow": "var(--v2-elevation-raised, 0 10px 32px rgba(0,0,0,0.28))",
+                  padding: "12px 14px",
+                }}
+              >
+                <HomeProjectColumn
+                  compact
+                  projects={projects()}
+                  selected={state.selection}
+                  focusServer={focusServer}
+                  selectProject={selectProject}
+                  openNewSession={openProjectNewSession}
+                  chooseProject={(conn) => void chooseProject(conn)}
+                  editProject={editProject}
+                  closeProject={(conn, directory) => {
+                    const next = closeHomeProject(
+                      state.selection,
+                      ServerConnection.key(conn),
+                      global.createServerCtx(conn).projects,
+                      directory,
+                    )
+                    if (next) setSelection(next)
+                  }}
+                  clearNotifications={clearNotifications}
+                  unseenCount={unseenCount}
+                  openSettings={openSettings}
+                  language={language}
+                />
+                <div style={{ height: "1px", background: "var(--v2-border-border-base)", "flex-shrink": "0" }} />
+                <section
             class="isolate min-h-0 min-w-0 flex flex-col"
             aria-label={language.t("sidebar.project.recentSessions")}
           >
@@ -693,35 +954,74 @@ function HomeDesign() {
                 </Show>
               </div>
             </ScrollView>
-          </section>
+                </section>
+              </div>
+            </Show>
+          </div>
+          <Show when={widgetInfos().length > 0 && dashboard()}>
+            <button
+              type="button"
+              data-slot="amicode-grid-customize"
+              onClick={() => setGridEditing(!gridEditing())}
+              style={{
+                border: "none",
+                background: "transparent",
+                color: gridEditing() ? "var(--v2-text-text-accent)" : "var(--v2-text-text-faint)",
+                "font-size": "11px",
+                cursor: "pointer",
+                padding: "0",
+              }}
+            >
+              {gridEditing() ? "done" : "customize"}
+            </button>
+          </Show>
         </div>
         {/* Cards: full width across, sized to content so they never scroll */}
         <div class="relative z-[1] flex-none pt-1">
-          {/* solver mode (show-only v1, spec-20260709-093000): right-aligned above the cards */}
-          <div style={{ display: "flex", "justify-content": "flex-end", "margin-bottom": "8px" }}>
-            <AmicodeSolverToggle />
-          </div>
-          <AmicodeHomeCards
-            profile={profileView()}
-            onStart={startWithPrompt}
-            library={libraryView()}
-            onUploadPaper={uploadPaper}
-            onEditProfile={() => startWithPrompt("update my profile — my name, affiliation, and what I work on")}
-            onSaveProfile={saveProfileFields}
-            resumeName={resumeProblem()?.name}
-            resumeMeta={resumeMeta()}
-            onResume={() => {
-              const name = resumeProblem()?.name
-              if (name) startWithPrompt(`Open the problem "${name}" and continue where we left off`)
-            }}
-            onWarmStart={() => startWithPrompt("warm-start a new solve from my pulse bank")}
-            onOpenGallery={() => setGalleryOpen(true)}
-            liveRun={liveRun()}
-            onOpenLiveRun={() => {
-              const name = resumeProblem()?.name
-              if (name) startWithPrompt(`Open the problem "${name}" and show me the running solve`)
-            }}
-          />
+          <Show
+            when={widgetInfos().length > 0 && dashboard()}
+            fallback={
+              /* legacy fallback: server without the widget routes (or a failed
+                 registry fetch) still gets the full hardcoded home */
+              <AmicodeHomeCards
+                profile={profileView()}
+                onStart={startWithPrompt}
+                library={libraryView()}
+                onUploadPaper={uploadPaper}
+                onEditProfile={() => startWithPrompt("update my profile — my name, affiliation, and what I work on")}
+                onSaveProfile={saveProfileFields}
+                resumeName={resumeProblem()?.name}
+                resumeMeta={resumeMeta()}
+                onResume={() => {
+                  const name = resumeProblem()?.name
+                  if (name) startWithPrompt(`Open the problem "${name}" and continue where we left off`)
+                }}
+                onWarmStart={() => startWithPrompt("warm-start a new solve from my pulse bank")}
+                onOpenGallery={() => setGalleryOpen(true)}
+                liveRun={liveRun()}
+                onOpenLiveRun={() => {
+                  const name = resumeProblem()?.name
+                  if (name) startWithPrompt(`Open the problem "${name}" and show me the running solve`)
+                }}
+              />
+            }
+          >
+            {(dash) => (
+              <WidgetGrid
+                widgets={widgetInfos()}
+                dashboard={dash()}
+                frameSrcs={widgetFrameSrcs()}
+                tokens={themeState().tokens}
+                density={themeState().density}
+                editing={gridEditing()}
+                onEditingChange={setGridEditing}
+                context={widgetContext()}
+                callbacks={widgetCallbacks}
+                onSave={saveDashboard}
+                onFork={forkWidget}
+              />
+            )}
+          </Show>
         </div>
         <AmicodeFooter />
         <Show when={wizardOpen()}>
@@ -754,6 +1054,8 @@ function HomeDesign() {
 function HomeProjectColumn(props: {
   projects: LocalProject[]
   selected: HomeProjectSelection
+  /** flyout mode (spec T3.3): brand + settings live in the chrome strip, hide them here */
+  compact?: boolean
   focusServer: (server: ServerConnection.Any) => void
   selectProject: (server: ServerConnection.Any, directory: string) => void
   openNewSession: (server: ServerConnection.Any, directory: string) => void
@@ -770,27 +1072,46 @@ function HomeProjectColumn(props: {
   const controller = useServerManagementController({ navigateOnAdd: false })
   return (
     <aside class="isolate flex min-h-0 min-w-0 flex-col gap-4" aria-label={props.language.t("home.projects")}>
-      <div class="mt-2 flex h-7 min-w-0 items-center justify-between pl-1.5">
+      <div class="mt-2 flex h-7 min-w-0 items-center justify-between pl-1.5" classList={{ "mt-0": props.compact }}>
         {/* amicode: brand block replaces the bare "Projects" label — the lone
-            letter-avatar project row underneath read as a stray "A amicode". */}
-        <div class="flex min-w-0 items-center gap-2">
-          <Mark class="size-6 shrink-0" />
-          <div class="min-w-0">
-            <div
+            letter-avatar project row underneath read as a stray "A amicode".
+            In flyout mode (compact) the strip owns the brand: show a quiet
+            "Projects" label instead. */}
+        <Show
+          when={!props.compact}
+          fallback={
+            <span
               style={{
-                "font-size": "15px",
-                "font-weight": "650",
-                "line-height": "18px",
-                color: "var(--v2-text-text-base)",
+                "font-size": "10px",
+                "font-weight": "700",
+                "letter-spacing": "0.1em",
+                "text-transform": "uppercase",
+                color: "var(--v2-text-text-faint)",
               }}
             >
-              Amicode
-            </div>
-            <div style={{ "font-size": "11px", "line-height": "14px", color: "var(--v2-text-text-faint)" }}>
-              by Harmoniqs
+              {props.language.t("home.projects")}
+            </span>
+          }
+        >
+          <div class="flex min-w-0 items-center gap-2">
+            <Mark class="size-6 shrink-0" />
+            <div class="min-w-0">
+              <div
+                style={{
+                  "font-size": "15px",
+                  "font-weight": "650",
+                  "line-height": "18px",
+                  color: "var(--v2-text-text-base)",
+                }}
+              >
+                Amicode
+              </div>
+              <div style={{ "font-size": "11px", "line-height": "14px", color: "var(--v2-text-text-faint)" }}>
+                by Harmoniqs
+              </div>
             </div>
           </div>
-        </div>
+        </Show>
         <Show when={global.servers.list().length === 1}>
           <IconButtonV2
             data-action="home-add-project"
@@ -834,16 +1155,18 @@ function HomeProjectColumn(props: {
           }}
         </For>
       </Show>
-      <div class="mt-4 flex min-w-0 flex-col gap-1">
-        <button
-          type="button"
-          class={`${HOME_PROJECT_NAV_ROW} text-v2-text-text-faint [&>[data-slot=icon-svg]]:text-v2-icon-icon-muted`}
-          onClick={props.openSettings}
-        >
-          <IconV2 name="settings-gear" size="small" />
-          <span class={HOME_PROJECT_NAV_LABEL}>{props.language.t("sidebar.settings")}</span>
-        </button>
-      </div>
+      <Show when={!props.compact}>
+        <div class="mt-4 flex min-w-0 flex-col gap-1">
+          <button
+            type="button"
+            class={`${HOME_PROJECT_NAV_ROW} text-v2-text-text-faint [&>[data-slot=icon-svg]]:text-v2-icon-icon-muted`}
+            onClick={props.openSettings}
+          >
+            <IconV2 name="settings-gear" size="small" />
+            <span class={HOME_PROJECT_NAV_LABEL}>{props.language.t("sidebar.settings")}</span>
+          </button>
+        </div>
+      </Show>
     </aside>
   )
 }
diff --git a/packages/app/src/pages/session/composer/session-question-dock.tsx b/packages/app/src/pages/session/composer/session-question-dock.tsx
index 5c23705090..094a67872e 100644
--- a/packages/app/src/pages/session/composer/session-question-dock.tsx
+++ b/packages/app/src/pages/session/composer/session-question-dock.tsx
@@ -366,7 +366,12 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
       toggle(opt.label)
       return
     }
+    // Single-select: picking an option commits it — advance to the next
+    // question, or submit if this is the last one. No separate Submit click.
+    // (Multi-select above still accumulates toggles → manual Submit; the
+    // free-text "type your own" option opens its editor via customOpen instead.)
     pick(opt.label)
+    next()
   }
 
   const commitCustom = () => {
diff --git a/packages/app/src/pages/session/message-timeline.tsx b/packages/app/src/pages/session/message-timeline.tsx
index 1542688915..9ae22564f4 100644
--- a/packages/app/src/pages/session/message-timeline.tsx
+++ b/packages/app/src/pages/session/message-timeline.tsx
@@ -45,7 +45,7 @@ import { ScrollView } from "@opencode-ai/ui/scroll-view"
 import { StickyAccordionHeader } from "@opencode-ai/ui/sticky-accordion-header"
 import { TextField } from "@opencode-ai/ui/text-field"
 import { TextReveal } from "@opencode-ai/ui/text-reveal"
-import { TextShimmer } from "@opencode-ai/ui/text-shimmer"
+import { ThinkingLine } from "@opencode-ai/ui/thinking-line"
 import type {
   AssistantMessage,
   Message as MessageType,
@@ -72,7 +72,8 @@ import { useSDK } from "@/context/sdk"
 import { useServer } from "@/context/server"
 import { usePrompt } from "@/context/prompt"
 import { startPrompt, draftPrompt } from "@/utils/start-prompt"
-import { amicodeGet } from "@/utils/amicode-fetch"
+import { amicodeGet, amicodePost } from "@/utils/amicode-fetch"
+import { parseDashboardResponse, type DashboardState } from "@opencode-ai/ui/amicode-widget-grid"
 import { inAmicode, postAmicode } from "@/pages/session/use-amicode-commands"
 import { useSync } from "@/context/sync"
 import { notifySessionTabsRemoved } from "@/components/titlebar-session-events"
@@ -167,11 +168,13 @@ const markBoundaryGesture = (input: {
 }
 
 function TimelineThinkingRow(props: { reasoningHeading?: string; showReasoningSummaries: boolean }) {
-  const language = useLanguage()
-
+  // amicode: the Claude-Code-esque working indicator (cycling shimmer gerund +
+  // live elapsed) replaces the plain localized "Thinking" shimmer. It lives HERE,
+  // in the app's own timeline renderer — the packages/ui AssistantParts copy of
+  // this line is not on this fork's render path (root-caused 2026-07-13).
   return (
     <div data-slot="session-turn-thinking">
-      <TextShimmer text={language.t("ui.sessionTurn.status.thinking")} />
+      <ThinkingLine />
       <Show when={!props.showReasoningSummaries}>
         <TextReveal text={props.reasoningHeading} class="session-turn-thinking-heading" travel={25} duration={700} />
       </Show>
@@ -339,6 +342,7 @@ export function MessageTimeline(props: {
           {/* fit-to-content goes near-fullscreen on run entities (long paths +
               history) — cap the panel and let it scroll internally instead */}
           <div style={{ width: "100%", "max-height": "68vh", "overflow-y": "auto" }}>
+
             <AmicodeEntityView
               view={problemView()}
               kind={kind}
@@ -1707,6 +1711,38 @@ export function MessageTimeline(props: {
                   `/amicode/run-series?run=${encodeURIComponent(run)}${lab ? `&lab=${encodeURIComponent(lab)}` : ""}`,
                 )
               }
+              widgetHost={{
+                // Stage 2: the in-chat widget preview reuses the home grid's
+                // frame kernel; server context is resolved live per call.
+                frameSrc: (id, hash) => {
+                  const url = server.current?.http.url
+                  return url
+                    ? new URL(
+                        `/amicode/widget-frame?id=${encodeURIComponent(id)}&h=${encodeURIComponent(hash)}`,
+                        url,
+                      ).toString()
+                    : ""
+                },
+                callbacks: {
+                  fetch: (path) => amicodeGet(server.current, path),
+                  action: async () => ({ ok: true }),
+                  prompt: (text) => {
+                    const id = sessionID()
+                    if (id) void sdk.client.session.promptAsync({ sessionID: id, parts: [{ type: "text", text }] })
+                  },
+                  open: () => {},
+                },
+                // pin = GET current dashboard, append this widget if absent, POST
+                // the full state back (applySave treats the body as the whole
+                // state, so a partial POST would wipe other tiles).
+                pin: async (id) => {
+                  const raw = await amicodeGet(server.current, "/amicode/dashboard")
+                  const state: DashboardState = parseDashboardResponse(raw) ?? { version: 1, widget: [] }
+                  if (!state.widget.some((e) => e.id === id))
+                    state.widget = [...state.widget, { key: id, id, hidden: false, config: {} }]
+                  return amicodePost(server.current, "/amicode/dashboard", state)
+                },
+              }}
               onOpenEntity={openEntityView}
               onOpenSwitcher={openSwitcher}
               onInspectRun={inAmicode() ? () => postAmicode("amicode.openInspector") : undefined}
diff --git a/packages/app/src/pages/session/use-session-commands.tsx b/packages/app/src/pages/session/use-session-commands.tsx
index 7a5aa6246f..b2618e4792 100644
--- a/packages/app/src/pages/session/use-session-commands.tsx
+++ b/packages/app/src/pages/session/use-session-commands.tsx
@@ -129,6 +129,12 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     return permission.isAutoAcceptingDirectory(sdk.directory)
   }
   const write = async (value: string) => {
+    // Amicode webview: native copy and navigator.clipboard don't reach the OS
+    // clipboard the ⌘V paste bridge reads back, so mirror through the host
+    // first. Resolves false on plain web (unframed) / desktop, where the
+    // native paths below already work.
+    if (platform.writeClipboardText && (await platform.writeClipboardText(value))) return true
+
     const body = typeof document === "undefined" ? undefined : document.body
     if (body) {
       const textarea = document.createElement("textarea")
diff --git a/packages/opencode/src/server/amicode/dashboard.ts b/packages/opencode/src/server/amicode/dashboard.ts
new file mode 100644
index 0000000000..3720f71dac
--- /dev/null
+++ b/packages/opencode/src/server/amicode/dashboard.ts
@@ -0,0 +1,155 @@
+// AMICODE: dashboard layout state (spec T2.5) — which widgets show, in what
+// order, with what per-widget config. Server-owned JSON at
+// ~/.amico/dashboard.json (env-injectable for tests, problems.ts idiom).
+// Merge discipline: sanitize, never reject on VALUES; only structurally
+// invalid bodies get ok:false. Missing/corrupt file → synthesized from the
+// registry in built-in order, nothing written until the first save.
+import { createHash } from "node:crypto"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+import { sanitizeConfig, type WidgetManifest } from "./widget-manifest"
+
+export interface RegistryWidget {
+  manifest: WidgetManifest
+  builtin: boolean
+  overridden?: boolean
+  hash?: string
+}
+
+export interface DashboardEntry {
+  key: string
+  id: string
+  hidden: boolean
+  config: Record<string, unknown>
+  missing?: boolean
+  /** reserved-key pass-through (spec T3.6): group, view, future keys survive */
+  [reserved: string]: unknown
+}
+
+export interface DashboardState {
+  version: 1
+  widget: DashboardEntry[]
+  /** reserved top-level keys (spec T3.6): views, scope */
+  [reserved: string]: unknown
+}
+
+/** Top-level reserved keys carried through merge/save (spec: views, scope). */
+const RESERVED_TOP_KEYS = ["views", "scope"] as const
+/** Entry keys owned by the merge — everything else passes through untouched. */
+const CORE_ENTRY_KEYS = new Set(["key", "id", "hidden", "config", "missing"])
+
+export function dashboardFile(): string {
+  const env = process.env.AMICODE_DASHBOARD_FILE
+  if (env && env.trim() !== "") return env
+  return path.join(homedir(), ".amico", "dashboard.json")
+}
+
+/** Deterministic pre-save instance key: stable across GETs so the grid never
+ *  sees identity churn before the user first customizes. */
+export function entryKey(id: string): string {
+  return "w-" + createHash("sha256").update(id).digest("hex").slice(0, 6)
+}
+
+type StoredEntry = { key?: unknown; id?: unknown; hidden?: unknown; config?: unknown }
+type StoredState = { version?: unknown; widget?: unknown }
+
+/** Merge stored state (or null) against the live registry. Pure. */
+export function mergeDashboard(stored: StoredState | null, registry: RegistryWidget[]): DashboardState {
+  const byId = new Map(registry.map((w) => [w.manifest.id, w]))
+  const out: DashboardEntry[] = []
+  const seen = new Set<string>()
+
+  const storedEntries: StoredEntry[] = Array.isArray(stored?.widget) ? (stored!.widget as StoredEntry[]) : []
+  for (const raw of storedEntries) {
+    if (typeof raw !== "object" || raw === null) continue
+    const id = raw.id
+    if (typeof id !== "string" || id === "" || seen.has(id)) continue
+    seen.add(id)
+    const reg = byId.get(id)
+    const config = typeof raw.config === "object" && raw.config !== null ? (raw.config as Record<string, unknown>) : {}
+    // T3.6: unrecognized keys (group, view, …) pass through; core keys are
+    // recomputed after the spread so passthrough can never override them.
+    const passthrough: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
+      if (!CORE_ENTRY_KEYS.has(k)) passthrough[k] = v
+    }
+    out.push({
+      ...passthrough,
+      key: typeof raw.key === "string" && raw.key !== "" ? raw.key : entryKey(id),
+      id,
+      hidden: raw.hidden === true,
+      config: reg ? sanitizeConfig(reg.manifest.config, config) : config,
+      ...(reg ? {} : { missing: true }),
+    })
+  }
+  // BUILT-IN registry widgets absent from state appear at the end, visible (new
+  // built-ins surface automatically after an upgrade). USER widgets (authored
+  // in chat, or forked) do NOT auto-appear — they are opt-in via an explicit
+  // pin/add (Stage 2), so iterating on a widget in a conversation never
+  // clutters home before the user chooses to keep it.
+  for (const w of registry) {
+    if (seen.has(w.manifest.id)) continue
+    if (!w.builtin) continue
+    out.push({
+      key: entryKey(w.manifest.id),
+      id: w.manifest.id,
+      hidden: false,
+      config: sanitizeConfig(w.manifest.config, undefined),
+    })
+  }
+  const state: DashboardState = { version: 1, widget: out }
+  for (const k of RESERVED_TOP_KEYS) {
+    const v = (stored as Record<string, unknown> | null)?.[k]
+    if (v !== undefined) state[k] = v
+  }
+  return state
+}
+
+export type SaveResult = { ok: true; state: DashboardState } | { ok: false; error: string }
+
+/** Validate structure only; values sanitize. Pure. */
+export function applySave(rawBody: string, registry: RegistryWidget[]): SaveResult {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(rawBody)
+  } catch {
+    return { ok: false, error: "bad_body: not JSON" }
+  }
+  if (typeof parsed !== "object" || parsed === null) return { ok: false, error: "bad_body: not an object" }
+  const widget = (parsed as StoredState).widget
+  if (!Array.isArray(widget)) return { ok: false, error: "bad_body: widget must be a list" }
+  for (const e of widget) {
+    if (typeof e !== "object" || e === null || typeof (e as StoredEntry).id !== "string")
+      return { ok: false, error: "bad_body: entries need a string id" }
+  }
+  return { ok: true, state: mergeDashboard(parsed as StoredState, registry) }
+}
+
+function readStored(): StoredState | null {
+  const file = dashboardFile()
+  if (!existsSync(file)) return null
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"))
+    return typeof parsed === "object" && parsed !== null ? (parsed as StoredState) : null
+  } catch {
+    return null // corrupt → behave as missing; a save will heal it
+  }
+}
+
+export function dashboardResponse(registry: RegistryWidget[]): string {
+  return JSON.stringify({ ok: true, dashboard: mergeDashboard(readStored(), registry), error: null })
+}
+
+export function saveDashboardResponse(rawBody: string, registry: RegistryWidget[]): string {
+  const r = applySave(rawBody, registry)
+  if (!r.ok) return JSON.stringify({ ok: false, dashboard: null, error: r.error })
+  const file = dashboardFile()
+  try {
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(file, JSON.stringify(r.state, null, 2) + "\n")
+  } catch (e) {
+    return JSON.stringify({ ok: false, dashboard: null, error: `write_failed: ${(e as Error).message}` })
+  }
+  return JSON.stringify({ ok: true, dashboard: r.state, error: null })
+}
diff --git a/packages/opencode/src/server/amicode/problems.ts b/packages/opencode/src/server/amicode/problems.ts
index 314653c83e..6d19b6286a 100644
--- a/packages/opencode/src/server/amicode/problems.ts
+++ b/packages/opencode/src/server/amicode/problems.ts
@@ -259,7 +259,10 @@ export function runStatusBody(root: string, runs: string, slug: string | undefin
 // F = 1 - f; we ship the raw objective f so one convention lives in one place. ---
 
 const SERIES_MAX_POINTS = 160
-const TAIL_LINES = 8
+// 24 raw lines: solve scripts emit AMICODE_ITER + AMICODE_PULSE every
+// iteration, and the client filters those out (humanTail) — a smaller window
+// can leave the filtered view empty mid-solve.
+const TAIL_LINES = 24
 
 export function synthesizeRunSeries(code: string, detail: string): string {
   return JSON.stringify({ ok: false, run: null, error: `${code}: ${detail}` })
diff --git a/packages/opencode/src/server/amicode/toml-lite.ts b/packages/opencode/src/server/amicode/toml-lite.ts
new file mode 100644
index 0000000000..30a3bc4a68
--- /dev/null
+++ b/packages/opencode/src/server/amicode/toml-lite.ts
@@ -0,0 +1,161 @@
+// AMICODE: TOML-subset reader for human/agent-authored widget manifests.
+// Deliberately small — scalars (string/int/float/bool), string arrays,
+// [table] / [table.sub] nesting, [[array-of-tables]], comments. No dotted
+// keys in assignments, no dates, no inline tables. The server only READS
+// TOML (manifests); dashboard state is JSON. Same never-throw discipline as
+// problems.ts: one result shape, ok:false with "code: detail" on bad input.
+
+export type TomlLiteResult = { ok: true; value: Record<string, unknown> } | { ok: false; error: string }
+
+const BARE_KEY = /^[A-Za-z0-9_-]+$/
+
+/** Parse one scalar token: quoted string, bool, number. */
+function scalar(raw: string): { ok: true; value: unknown } | { ok: false } {
+  const s = raw.trim()
+  if (s.length === 0) return { ok: false }
+  if (s[0] === '"' || s[0] === "'") {
+    const q = s[0]
+    let out = ""
+    let i = 1
+    while (i < s.length) {
+      const c = s[i]
+      if (c === "\\" && q === '"' && i + 1 < s.length) {
+        const n = s[i + 1]
+        out += n === "n" ? "\n" : n === "t" ? "\t" : n
+        i += 2
+        continue
+      }
+      if (c === q) {
+        // rest must be whitespace or a comment
+        const rest = s.slice(i + 1).trim()
+        if (rest !== "" && !rest.startsWith("#")) return { ok: false }
+        return { ok: true, value: out }
+      }
+      out += c
+      i++
+    }
+    return { ok: false } // unterminated
+  }
+  // strip trailing comment on unquoted values
+  const hash = s.indexOf("#")
+  const body = (hash >= 0 ? s.slice(0, hash) : s).trim()
+  if (body === "true") return { ok: true, value: true }
+  if (body === "false") return { ok: true, value: false }
+  if (/^-?\d+$/.test(body)) return { ok: true, value: Number.parseInt(body, 10) }
+  if (/^-?\d*\.\d+$/.test(body)) return { ok: true, value: Number.parseFloat(body) }
+  return { ok: false }
+}
+
+/** Split a bracketed array body into item tokens (strings only supported). */
+function stringArray(body: string): { ok: true; value: string[] } | { ok: false } {
+  const items: string[] = []
+  let i = 0
+  const s = body.trim()
+  while (i < s.length) {
+    while (i < s.length && (s[i] === " " || s[i] === "," || s[i] === "\t")) i++
+    if (i >= s.length) break
+    const q = s[i]
+    if (q !== '"' && q !== "'") return { ok: false }
+    let out = ""
+    i++
+    while (i < s.length && s[i] !== q) {
+      if (s[i] === "\\" && q === '"' && i + 1 < s.length) {
+        out += s[i + 1]
+        i += 2
+        continue
+      }
+      out += s[i]
+      i++
+    }
+    if (i >= s.length) return { ok: false } // unterminated
+    i++ // closing quote
+    items.push(out)
+  }
+  return { ok: true, value: items }
+}
+
+export function parseTomlLite(src: string): TomlLiteResult {
+  const root: Record<string, unknown> = {}
+  let current = root
+  const lines = src.split("\n")
+  for (let ln = 0; ln < lines.length; ln++) {
+    let line = lines[ln].trim()
+    if (line === "" || line.startsWith("#")) continue
+
+    // [[array.of.tables]]
+    if (line.startsWith("[[")) {
+      if (!line.endsWith("]]")) return { ok: false, error: `line ${ln + 1}: malformed table array header` }
+      const path = line.slice(2, -2).trim().split(".")
+      if (path.some((p) => !BARE_KEY.test(p))) return { ok: false, error: `line ${ln + 1}: bad table array name` }
+      let node = root
+      for (const part of path.slice(0, -1)) {
+        const next = node[part]
+        if (next === undefined) {
+          const t: Record<string, unknown> = {}
+          node[part] = t
+          node = t
+        } else if (typeof next === "object" && next !== null && !Array.isArray(next)) {
+          node = next as Record<string, unknown>
+        } else return { ok: false, error: `line ${ln + 1}: table array path conflicts with value` }
+      }
+      const last = path[path.length - 1]
+      const arr = node[last]
+      const entry: Record<string, unknown> = {}
+      if (arr === undefined) node[last] = [entry]
+      else if (Array.isArray(arr)) arr.push(entry)
+      else return { ok: false, error: `line ${ln + 1}: table array conflicts with value` }
+      current = entry
+      continue
+    }
+
+    // [table] / [table.sub]
+    if (line.startsWith("[")) {
+      if (!line.endsWith("]")) return { ok: false, error: `line ${ln + 1}: malformed table header` }
+      const path = line.slice(1, -1).trim().split(".")
+      if (path.some((p) => !BARE_KEY.test(p))) return { ok: false, error: `line ${ln + 1}: bad table name` }
+      let node = root
+      for (const part of path) {
+        const next = node[part]
+        if (next === undefined) {
+          const t: Record<string, unknown> = {}
+          node[part] = t
+          node = t
+        } else if (typeof next === "object" && next !== null && !Array.isArray(next)) {
+          node = next as Record<string, unknown>
+        } else return { ok: false, error: `line ${ln + 1}: table path conflicts with value` }
+      }
+      current = node
+      continue
+    }
+
+    // key = value
+    const eq = line.indexOf("=")
+    if (eq < 0) return { ok: false, error: `line ${ln + 1}: expected key = value` }
+    const key = line.slice(0, eq).trim()
+    if (!BARE_KEY.test(key)) return { ok: false, error: `line ${ln + 1}: bad key ${JSON.stringify(key)}` }
+    if (Object.prototype.hasOwnProperty.call(current, key))
+      return { ok: false, error: `line ${ln + 1}: duplicate key ${key}` }
+    let value = line.slice(eq + 1).trim()
+
+    // array — may span lines until the closing bracket
+    if (value.startsWith("[")) {
+      while (!value.includes("]") && ln + 1 < lines.length) {
+        ln++
+        value += " " + lines[ln].trim()
+      }
+      const close = value.lastIndexOf("]")
+      if (close < 0) return { ok: false, error: `line ${ln + 1}: unterminated array` }
+      const rest = value.slice(close + 1).trim()
+      if (rest !== "" && !rest.startsWith("#")) return { ok: false, error: `line ${ln + 1}: junk after array` }
+      const arr = stringArray(value.slice(1, close))
+      if (!arr.ok) return { ok: false, error: `line ${ln + 1}: bad string array` }
+      current[key] = arr.value
+      continue
+    }
+
+    const sc = scalar(value)
+    if (!sc.ok) return { ok: false, error: `line ${ln + 1}: bad value for ${key}` }
+    current[key] = sc.value
+  }
+  return { ok: true, value: root }
+}
diff --git a/packages/opencode/src/server/amicode/widget-frame-html.ts b/packages/opencode/src/server/amicode/widget-frame-html.ts
new file mode 100644
index 0000000000..1e27a641ae
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widget-frame-html.ts
@@ -0,0 +1,77 @@
+// AMICODE (widget kernel): the widget frame as a SERVER-SERVED document —
+// GET /amicode/widget-frame?id=. Why not srcdoc: srcdoc/blob documents
+// INHERIT the embedding page's CSP, and the served app's CSP (shared/ui.ts)
+// has no 'unsafe-inline' for scripts, so an inline runtime in srcdoc never
+// executes ("widget did not boot"). A network-served document carries its
+// OWN Content-Security-Policy response header — this one. The host iframe
+// stays sandbox="allow-scripts" (opaque origin), so this frame gets no
+// same-origin power from being server-served.
+import { RUNTIME_JS } from "./widget-runtime"
+import { loadRegistry } from "./widgets"
+
+export const WIDGET_CSP =
+  "default-src 'none'; script-src 'unsafe-inline' blob:; style-src 'unsafe-inline'; img-src https: data:"
+
+/** Pre-paint token defaults (dark), mirroring widget-tokens.ts fallbacks —
+ *  the host's real theme arrives with amc:init before first meaningful render. */
+const BAKED_TOKENS: Record<string, string> = {
+  "--amc-bg": "#0B0E15",
+  "--amc-layer": "#111624",
+  "--amc-layer2": "#1A2133",
+  "--amc-border": "#2A3245",
+  "--amc-text": "#E9ECF4",
+  "--amc-text-muted": "#8B94A9",
+  "--amc-text-faint": "#6A7286",
+  "--amc-accent": "#F2C94C",
+  "--amc-success": "#5BC873",
+  "--amc-warning": "#E5B454",
+  "--amc-danger": "#E56A6A",
+  "--amc-font-sans": "-apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif",
+  "--amc-font-mono": "ui-monospace, SFMono-Regular, Menlo, monospace",
+  "--amc-pad": "14px 16px",
+  "--amc-pad-tile": "10px 12px",
+}
+
+/** JSON-encode the widget source for inline embedding; \\u003c-escape keeps
+ *  "</script>" and "<!--" inert inside the script element. */
+export function embedCode(code: string): string {
+  return JSON.stringify(code).replace(/</g, "\\u003c")
+}
+
+export function buildFrameHtml(code: string): string {
+  const rootVars = Object.entries(BAKED_TOKENS)
+    .map(([k, v]) => `${k}: ${v};`)
+    .join(" ")
+  return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="${WIDGET_CSP}">
+<style>
+:root { ${rootVars} }
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; background: transparent; }
+body { font-family: var(--amc-font-sans); color: var(--amc-text); font-size: 13px; }
+button, input { font-family: inherit; }
+</style>
+</head>
+<body>
+<div id="amc-root"></div>
+<script>window.__amcWidgetCode = ${embedCode(code)};</script>
+<script>${RUNTIME_JS}</script>
+</body>
+</html>`
+}
+
+const KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/
+
+/** Route body: the frame document, or a minimal error document (still our
+ *  CSP; the host's boot timeout turns it into the error card). */
+export function widgetFrameHtml(id: string | undefined): { ok: boolean; html: string } {
+  if (typeof id !== "string" || !KEBAB.test(id))
+    return { ok: false, html: "<!doctype html><body>bad widget id</body>" }
+  const { widgets } = loadRegistry()
+  const w = widgets.find((x) => x.manifest.id === id)
+  if (!w) return { ok: false, html: `<!doctype html><body>unknown widget: ${id}</body>` }
+  return { ok: true, html: buildFrameHtml(w.code) }
+}
diff --git a/packages/opencode/src/server/amicode/widget-manifest.ts b/packages/opencode/src/server/amicode/widget-manifest.ts
new file mode 100644
index 0000000000..5e9e455086
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widget-manifest.ts
@@ -0,0 +1,200 @@
+// AMICODE: widget manifest parse + validate (spec T2.1) and config-value
+// sanitization (spec T2.5: bad values fall back to field defaults, never an
+// error). Manifests are TOML (human/agent-authored, read via toml-lite);
+// this module owns the schema rules so the registry, dashboard merge, and
+// fork all validate one way.
+import { parseTomlLite } from "./toml-lite"
+
+export type ConfigField =
+  | { type: "boolean"; default: boolean }
+  | { type: "select"; options: string[]; default: string }
+  | { type: "multi-select"; options: string[]; default: string[] }
+  | { type: "string"; default: string; max_length?: number }
+  | { type: "number"; default: number; min?: number; max?: number }
+
+export interface WidgetManifest {
+  id: string
+  name: string
+  version: string
+  bridge: number
+  description: string
+  size: "hero" | "tile"
+  height: number
+  config: Record<string, ConfigField>
+  origin: { session?: string; date?: string } | null
+}
+
+export type ManifestResult =
+  | { ok: true; manifest: WidgetManifest; warning?: string }
+  | { ok: false; error: string }
+
+const KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/
+
+function bad(detail: string): ManifestResult {
+  return { ok: false, error: `bad_manifest: ${detail}` }
+}
+
+function parseField(name: string, raw: Record<string, unknown>): ConfigField | string {
+  const type = raw.type
+  switch (type) {
+    case "boolean": {
+      const d = raw.default
+      if (typeof d !== "boolean") return `${name}: boolean default required`
+      return { type, default: d }
+    }
+    case "select": {
+      const options = raw.options
+      if (!Array.isArray(options) || options.length === 0 || options.some((o) => typeof o !== "string"))
+        return `${name}: select requires string options`
+      const d = raw.default
+      if (typeof d !== "string" || !options.includes(d)) return `${name}: default must be one of options`
+      return { type, options: options as string[], default: d }
+    }
+    case "multi-select": {
+      const options = raw.options
+      if (!Array.isArray(options) || options.length === 0 || options.some((o) => typeof o !== "string"))
+        return `${name}: multi-select requires string options`
+      const d = raw.default
+      if (!Array.isArray(d) || d.some((v) => typeof v !== "string" || !(options as string[]).includes(v)))
+        return `${name}: default must be a subset of options`
+      return { type, options: options as string[], default: d as string[] }
+    }
+    case "string": {
+      const d = raw.default
+      if (typeof d !== "string") return `${name}: string default required`
+      const max = raw.max_length
+      if (max !== undefined && typeof max !== "number") return `${name}: max_length must be a number`
+      return { type, default: d, ...(typeof max === "number" ? { max_length: max } : {}) }
+    }
+    case "number": {
+      const d = raw.default
+      if (typeof d !== "number") return `${name}: number default required`
+      const min = raw.min
+      const max = raw.max
+      if ((min !== undefined && typeof min !== "number") || (max !== undefined && typeof max !== "number"))
+        return `${name}: min/max must be numbers`
+      if (typeof min === "number" && d < min) return `${name}: default below min`
+      if (typeof max === "number" && d > max) return `${name}: default above max`
+      return {
+        type,
+        default: d,
+        ...(typeof min === "number" ? { min } : {}),
+        ...(typeof max === "number" ? { max } : {}),
+      }
+    }
+    default:
+      return `${name}: unknown field type ${JSON.stringify(type)}`
+  }
+}
+
+export function parseManifest(tomlSrc: string, dirname: string): ManifestResult {
+  const parsed = parseTomlLite(tomlSrc)
+  if (!parsed.ok) return bad(parsed.error)
+  const v = parsed.value
+
+  const id = v.id
+  if (typeof id !== "string" || !KEBAB.test(id)) return bad("id must be kebab-case")
+  if (id !== dirname) return bad(`id ${JSON.stringify(id)} must equal dirname ${JSON.stringify(dirname)}`)
+  const name = v.name
+  if (typeof name !== "string" || name.trim() === "") return bad("name required")
+
+  // T3.6 forward-compat: unknown sizes (e.g. the reserved "strip") degrade to
+  // tile with a warning instead of rejecting the widget — a newer widget must
+  // render on an older host, not vanish.
+  const rawSize = v.size ?? "tile"
+  let sizeWarning: string | undefined
+  let size: "hero" | "tile"
+  if (rawSize === "hero" || rawSize === "tile") size = rawSize
+  else {
+    size = "tile"
+    sizeWarning = `unknown size ${JSON.stringify(rawSize)} rendered as "tile"`
+  }
+  const bridge = v.bridge ?? 1
+  if (typeof bridge !== "number" || !Number.isInteger(bridge) || bridge < 1) return bad("bridge must be a positive int")
+  const height = v.height ?? 96
+  if (typeof height !== "number" || height <= 0) return bad("height must be a positive number")
+
+  const config: Record<string, ConfigField> = {}
+  const rawConfig = v.config
+  if (rawConfig !== undefined) {
+    if (typeof rawConfig !== "object" || rawConfig === null || Array.isArray(rawConfig))
+      return bad("config must be a table")
+    for (const [key, rawField] of Object.entries(rawConfig as Record<string, unknown>)) {
+      if (!KEBAB.test(key.replace(/_/g, "-"))) return bad(`config field ${key}: bad name`)
+      if (typeof rawField !== "object" || rawField === null || Array.isArray(rawField))
+        return bad(`config field ${key}: must be a table`)
+      const field = parseField(key, rawField as Record<string, unknown>)
+      if (typeof field === "string") return bad(field)
+      config[key] = field
+    }
+  }
+
+  const rawOrigin = v.origin
+  const origin =
+    typeof rawOrigin === "object" && rawOrigin !== null && !Array.isArray(rawOrigin)
+      ? {
+          session: typeof (rawOrigin as any).session === "string" ? ((rawOrigin as any).session as string) : undefined,
+          date: typeof (rawOrigin as any).date === "string" ? ((rawOrigin as any).date as string) : undefined,
+        }
+      : null
+
+  return {
+    ok: true,
+    ...(sizeWarning ? { warning: sizeWarning } : {}),
+    manifest: {
+      id,
+      name,
+      version: typeof v.version === "string" ? v.version : "0.0.0",
+      bridge,
+      description: typeof v.description === "string" ? v.description : "",
+      size,
+      height,
+      config,
+      origin,
+    },
+  }
+}
+
+/** Spec T2.4/T2.5: sanitize stored config against the schema — bad values fall
+ *  back to the field default (multi-select filters to valid options), unknown
+ *  keys are dropped, missing keys get defaults. Never throws, never rejects. */
+export function sanitizeConfig(
+  schema: Record<string, ConfigField>,
+  values: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  const input = values ?? {}
+  for (const [key, field] of Object.entries(schema)) {
+    const v = input[key]
+    switch (field.type) {
+      case "boolean":
+        out[key] = typeof v === "boolean" ? v : field.default
+        break
+      case "select":
+        out[key] = typeof v === "string" && field.options.includes(v) ? v : field.default
+        break
+      case "multi-select": {
+        if (Array.isArray(v)) {
+          const kept = v.filter((x): x is string => typeof x === "string" && field.options.includes(x))
+          out[key] = kept.length > 0 ? kept : field.default
+        } else out[key] = field.default
+        break
+      }
+      case "string": {
+        if (typeof v === "string" && (field.max_length === undefined || v.length <= field.max_length)) out[key] = v
+        else out[key] = field.default
+        break
+      }
+      case "number": {
+        const okNum =
+          typeof v === "number" &&
+          Number.isFinite(v) &&
+          (field.min === undefined || v >= field.min) &&
+          (field.max === undefined || v <= field.max)
+        out[key] = okNum ? v : field.default
+        break
+      }
+    }
+  }
+  return out
+}
diff --git a/packages/opencode/src/server/amicode/widget-runtime.ts b/packages/opencode/src/server/amicode/widget-runtime.ts
new file mode 100644
index 0000000000..e9a9628a22
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widget-runtime.ts
@@ -0,0 +1,162 @@
+// AMICODE (widget kernel): the runtime injected into every widget frame, as a
+// source string so srcdoc assembly stays a pure tested function. Implements
+// the frame side of bridge protocol v1: builds the `amico` client, applies
+// theme tokens + density to :root, evaluates the widget module via blob
+// import (the only sanctioned eval path — CSP has no 'unsafe-eval'), mounts
+// it, and reports content height from a ResizeObserver on the root node.
+// Any failure becomes amc:error → the host swaps in the error card.
+
+export const RUNTIME_JS = `
+;(function () {
+  'use strict'
+  var pending = {}
+  var nextId = 1
+  var configCbs = []
+  var themeCbs = []
+  var contextCbs = []
+  var amico = null
+  var mounted = false
+
+  function post(msg) {
+    window.parent.postMessage(msg, '*')
+  }
+  function fail(message) {
+    post({ t: 'amc:error', message: String(message) })
+  }
+  window.onerror = function (msg) {
+    fail(msg)
+  }
+  window.onunhandledrejection = function (e) {
+    fail(e && e.reason ? e.reason : 'unhandled rejection')
+  }
+
+  function applyTheme(theme, density) {
+    var root = document.documentElement
+    if (theme) for (var k in theme) root.style.setProperty(k, theme[k])
+    if (density) root.setAttribute('data-density', density)
+  }
+
+  function request(t, fields) {
+    var id = nextId++
+    return new Promise(function (resolve, reject) {
+      pending[id] = { resolve: resolve, reject: reject }
+      var msg = { t: t, id: id }
+      for (var k in fields) msg[k] = fields[k]
+      post(msg)
+    })
+  }
+
+  function makeAmico(init) {
+    return {
+      config: init.config || {},
+      theme: init.theme || {},
+      density: init.density || 'normal',
+      context: init.context || {},
+      fetch: function (path) {
+        return request('amc:fetch', { path: path })
+      },
+      action: function (verb, payload) {
+        return request('amc:action', { verb: verb, payload: payload || {} })
+      },
+      prompt: function (text) {
+        post({ t: 'amc:prompt', text: String(text == null ? '' : text) })
+      },
+      open: function (entity) {
+        post({ t: 'amc:open', entity: String(entity == null ? '' : entity) })
+      },
+      onConfig: function (cb) {
+        configCbs.push(cb)
+      },
+      onTheme: function (cb) {
+        themeCbs.push(cb)
+      },
+      onContext: function (cb) {
+        contextCbs.push(cb)
+      },
+    }
+  }
+
+  function fire(cbs) {
+    for (var i = 0; i < cbs.length; i++) {
+      try {
+        cbs[i]()
+      } catch (e) {
+        fail(e)
+      }
+    }
+  }
+
+  window.addEventListener('message', function (e) {
+    var msg = e.data
+    if (!msg || typeof msg.t !== 'string') return
+    if (msg.t === 'amc:result') {
+      var p = pending[msg.id]
+      if (!p) return
+      delete pending[msg.id]
+      if (msg.ok) p.resolve(msg.data)
+      else p.reject(new Error(msg.error || 'bridge error'))
+      return
+    }
+    if (msg.t === 'amc:init') {
+      if (mounted) return
+      mounted = true
+      applyTheme(msg.theme, msg.density)
+      amico = makeAmico(msg)
+      var code = window.__amcWidgetCode
+      var blob = new Blob([code], { type: 'text/javascript' })
+      var url = URL.createObjectURL(blob)
+      import(url)
+        .then(function (mod) {
+          if (!mod || !mod.default || typeof mod.default.mount !== 'function')
+            throw new Error('widget module must export default { mount }')
+          var root = document.getElementById('amc-root')
+          mod.default.mount(root, amico)
+          // Emptiness is an EXPLICIT signal, not inferred from height: a
+          // hidden (display:none) frame has no layout, so ResizeObserver
+          // stays silent and a height-based hide can never un-hide — the
+          // empty-state deadlock. MutationObserver fires regardless of
+          // layout: content arriving in a hidden frame un-hides the cell,
+          // layout starts, and the ResizeObserver takes over for sizing.
+          var isEmpty = function () {
+            return root.childElementCount === 0 && (root.textContent || '').trim() === ''
+          }
+          var lastEmpty = null
+          var postEmpty = function () {
+            var e = isEmpty()
+            if (e !== lastEmpty) {
+              lastEmpty = e
+              post({ t: 'amc:empty', empty: e })
+            }
+          }
+          var mo = new MutationObserver(postEmpty)
+          mo.observe(root, { childList: true, subtree: true, characterData: true })
+          var ro = new ResizeObserver(function () {
+            post({ t: 'amc:height', h: Math.ceil(root.getBoundingClientRect().height) })
+          })
+          ro.observe(root)
+          postEmpty()
+          post({ t: 'amc:height', h: Math.ceil(root.getBoundingClientRect().height) })
+        })
+        .catch(function (e) {
+          fail(e)
+        })
+      return
+    }
+    if (!amico) return
+    if (msg.t === 'amc:config') {
+      amico.config = msg.config || {}
+      fire(configCbs)
+    } else if (msg.t === 'amc:theme') {
+      amico.theme = msg.theme || {}
+      amico.density = msg.density || amico.density
+      applyTheme(msg.theme, msg.density)
+      fire(themeCbs)
+    } else if (msg.t === 'amc:context') {
+      amico.context = msg.context || {}
+      fire(contextCbs)
+    }
+  })
+
+  post({ t: 'amc:ready' })
+})()
+`
diff --git a/packages/opencode/src/server/amicode/widgets-src/about-you.ts b/packages/opencode/src/server/amicode/widgets-src/about-you.ts
new file mode 100644
index 0000000000..f372618196
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widgets-src/about-you.ts
@@ -0,0 +1,259 @@
+// AMICODE built-in widget: ABOUT YOU — profile hero with earned stats (which
+// stats show is user config), "Amico remembers", and in-place identity edit.
+// Institution suggestions + logo resolution + external links + saves all go
+// through host actions (widget frames have no network). Declared v1
+// degradation: no clipboard text-paste fallback on the edit inputs.
+
+export const manifestToml = `
+id = "about-you"
+name = "About you"
+version = "1.0.0"
+description = "Your profile, earned stats, and what Amico remembers"
+size = "hero"
+height = 250
+
+[config.stats]
+type = "multi-select"
+options = ["problems", "runs", "banked"]
+default = ["problems", "runs", "banked"]
+`
+
+export const widgetJs = `
+export default {
+  mount: function (el, amico) {
+    var profile = null
+    var editing = false
+    var saving = false
+    var draft = { name: '', affiliation: '', focus: '', scholar: '', affiliation_logo: '' }
+    var suggestions = []
+    var searchTimer = null
+    var searchSeq = 0
+
+    var esc = function (s) {
+      return String(s == null ? '' : s)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+    }
+    var initials = function (name) {
+      var parts = String(name || '').trim().split(/\\s+/).filter(Boolean)
+      if (parts.length === 0) return '?'
+      return parts.slice(0, 2).map(function (p) { return p[0].toUpperCase() }).join('')
+    }
+    var MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+    var sinceLabel = function (iso) {
+      if (!iso) return null
+      var m = String(iso).match(/^(\\d{4})-(\\d{2})-(\\d{2})$/)
+      if (!m) return null
+      var label = 'since ' + (MONTHS[Number(m[2]) - 1] || m[2]) + ' ' + Number(m[3])
+      var started = Date.parse(iso)
+      if (isNaN(started)) return label
+      var days = Math.max(0, Math.round((Date.now() - started) / 86400000))
+      return days <= 0 ? label + ' \\u00b7 today' : label + ' \\u00b7 ' + days + ' day' + (days === 1 ? '' : 's')
+    }
+    var on = function (sel, evt, fn) {
+      var n = el.querySelector(sel)
+      if (n) n['on' + evt] = fn
+    }
+
+    var statBlock = function (value, label) {
+      return (
+        '<div style="display:flex;flex-direction:column;gap:1px;min-width:0">' +
+        '<span style="font-size:16px;font-weight:600;color:var(--amc-text);font-variant-numeric:tabular-nums;line-height:20px">' + value + '</span>' +
+        '<span style="font-size:10px;color:var(--amc-text-faint);line-height:12px">' + label + '</span></div>'
+      )
+    }
+
+    var render = function () {
+      if (!profile || !profile.ok) {
+        el.innerHTML = ''
+        return
+      }
+      var you = profile.you
+      var stats = you.stats || {}
+      var chosen = (amico.config && amico.config.stats) || ['problems', 'runs', 'banked']
+      var fresh = !stats.problems && !stats.runs && !stats.banked
+
+      var avatar = you.avatar
+        ? '<img src="' + esc(you.avatar) + '" alt="" onerror="this.style.display=\\'none\\'" style="width:44px;height:44px;border-radius:10px;object-fit:cover;flex-shrink:0">'
+        : '<div style="width:44px;height:44px;flex-shrink:0;border-radius:10px;background:var(--amc-layer2);color:var(--amc-text-muted);display:flex;align-items:center;justify-content:center;font-size:15px;font-weight:600">' + esc(initials(you.name)) + '</div>'
+
+      var platforms = (you.platforms || []).slice(0, 3).map(function (p) {
+        return '&#9671; ' + esc(p)
+      }).join('&nbsp;&nbsp;')
+
+      var editForm =
+        '<div style="display:flex;flex-direction:column;gap:6px;margin-top:8px">' +
+        '<input data-f-name placeholder="name" value="' + esc(draft.name) + '" style="font-size:12px;padding:4px 8px;border:1px solid var(--amc-border);border-radius:6px;background:var(--amc-bg);color:var(--amc-text)">' +
+        '<div style="position:relative">' +
+        '<input data-f-affiliation placeholder="affiliation" value="' + esc(draft.affiliation) + '" autocomplete="off" style="width:100%;box-sizing:border-box;font-size:12px;padding:4px 8px;border:1px solid var(--amc-border);border-radius:6px;background:var(--amc-bg);color:var(--amc-text)">' +
+        (suggestions.length
+          ? '<div style="position:absolute;left:0;right:0;top:100%;z-index:5;background:var(--amc-layer2);border:1px solid var(--amc-border);border-radius:6px;overflow:hidden">' +
+            suggestions.map(function (s, i) {
+              return '<div data-sugg="' + i + '" style="padding:5px 8px;font-size:12px;color:var(--amc-text);cursor:pointer">' + esc(s.name) + ' <span style="color:var(--amc-text-faint)">' + esc(s.domain || '') + '</span></div>'
+            }).join('') + '</div>'
+          : '') +
+        '</div>' +
+        '<input data-f-focus placeholder="focus (e.g. transmon pulse design)" value="' + esc(draft.focus) + '" style="font-size:12px;padding:4px 8px;border:1px solid var(--amc-border);border-radius:6px;background:var(--amc-bg);color:var(--amc-text)">' +
+        '<input data-f-scholar placeholder="Google Scholar URL" value="' + esc(draft.scholar) + '" style="font-size:12px;padding:4px 8px;border:1px solid var(--amc-border);border-radius:6px;background:var(--amc-bg);color:var(--amc-text)">' +
+        '<div style="display:flex;gap:8px">' +
+        '<button type="button" data-save ' + (saving ? 'disabled' : '') + ' style="font-size:12px;padding:4px 12px;border:1px solid var(--amc-accent);border-radius:6px;background:var(--amc-layer2);color:var(--amc-text);cursor:pointer">' + (saving ? 'Saving\\u2026' : 'Save') + '</button>' +
+        '<button type="button" data-cancel style="font-size:12px;padding:4px 12px;border:1px solid var(--amc-border);border-radius:6px;background:transparent;color:var(--amc-text-muted);cursor:pointer">Cancel</button>' +
+        '</div></div>'
+
+      var identity =
+        '<div style="display:flex;gap:12px;align-items:flex-start;margin-top:10px">' + avatar +
+        '<div style="min-width:0;flex:1">' +
+        '<div style="display:flex;align-items:baseline;gap:8px">' +
+        '<div style="font-size:18px;font-weight:600;color:var(--amc-text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + esc(you.name || 'You') + '</div>' +
+        (you.scholar ? '<span data-scholar style="font-size:11px;color:var(--amc-accent);cursor:pointer;flex-shrink:0">scholar &#8599;</span>' : '') +
+        '<span data-edit title="Edit profile" style="margin-left:auto;color:var(--amc-text-faint);cursor:pointer;flex-shrink:0">&#9998;</span>' +
+        '</div>' +
+        (editing
+          ? editForm
+          : '<div style="font-size:12px;line-height:16px;color:var(--amc-text-muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' +
+            esc(you.focus || you.affiliation || 'tell Amico about your work') + '</div>' +
+            (platforms ? '<div style="font-size:11px;color:var(--amc-text-faint);margin-top:1px">' + platforms + '</div>' : '')) +
+        '</div></div>'
+
+      var body
+      if (fresh && !editing) {
+        body =
+          '<div style="height:1px;background:var(--amc-border);margin:12px 0"></div>' +
+          '<div style="font-size:12px;color:var(--amc-text-muted);margin-bottom:8px">No solves yet \\u2014 tell Amico what you&#39;re working on and it&#39;ll start remembering.</div>' +
+          '<button type="button" data-firstrun style="align-self:flex-start;border:1px solid var(--amc-accent);border-radius:6px;background:var(--amc-layer2);color:var(--amc-text);padding:5px 12px;font-size:12px;cursor:pointer">Get started &#8594;</button>'
+      } else if (!editing) {
+        var cells = chosen.map(function (k) {
+          return statBlock(String(stats[k] == null ? 0 : stats[k]), k)
+        }).join('')
+        var remembers = (you.remembers || []).map(function (r) {
+          return '<div title="' + esc(r.detail) + '" style="display:flex;gap:6px;align-items:baseline;min-width:0;font-size:12px;line-height:18px;color:var(--amc-text)">' +
+            '<span style="color:var(--amc-accent);flex-shrink:0">&rsaquo;</span>' +
+            '<span style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + esc(r.title) + '</span></div>'
+        }).join('')
+        var since = sinceLabel(stats.since)
+        body =
+          '<div style="height:1px;background:var(--amc-border);margin:12px 0"></div>' +
+          '<div style="display:grid;grid-template-columns:repeat(' + Math.max(1, chosen.length) + ',minmax(0,1fr));gap:8px">' + cells + '</div>' +
+          (remembers
+            ? '<div style="height:1px;background:var(--amc-border);margin:12px 0"></div>' +
+              '<div style="font-size:11px;color:var(--amc-text-muted);margin-bottom:6px">Amico remembers</div>' +
+              '<div style="display:flex;flex-direction:column;gap:3px">' + remembers + '</div>'
+            : '') +
+          (since ? '<div style="font-size:10px;color:var(--amc-text-faint);margin-top:10px">' + since + '</div>' : '')
+      } else {
+        body = ''
+      }
+
+      el.innerHTML =
+        '<div style="display:flex;flex-direction:column;min-width:0;border:1px solid var(--amc-border);border-radius:10px;background:var(--amc-layer);padding:var(--amc-pad)">' +
+        '<div style="display:flex;align-items:baseline;gap:8px"><span style="font-size:10px;font-weight:700;letter-spacing:0.1em;text-transform:uppercase;color:var(--amc-text-faint)">About you</span>' +
+        '<span style="font-size:10px;color:var(--amc-text-faint)">self-improving \\u2014 Amico refines this as you work</span></div>' +
+        identity + body + '</div>'
+
+      on('[data-edit]', 'click', function () {
+        editing = !editing
+        if (editing) {
+          suggestions = []
+          draft = {
+            name: you.name || '',
+            affiliation: you.affiliation || '',
+            focus: you.focus || '',
+            scholar: you.scholar || '',
+            affiliation_logo: you.affiliation_logo || '',
+          }
+        }
+        render()
+      })
+      on('[data-scholar]', 'click', function () {
+        amico.action('open-external', { url: you.scholar })
+      })
+      on('[data-firstrun]', 'click', function () {
+        amico.prompt('help me set up my first pulse-design problem')
+      })
+      on('[data-cancel]', 'click', function () {
+        editing = false
+        suggestions = []
+        render()
+      })
+      on('[data-save]', 'click', function () {
+        var read = function (sel) {
+          var n = el.querySelector(sel)
+          return n ? n.value : ''
+        }
+        draft.name = read('[data-f-name]')
+        draft.affiliation = read('[data-f-affiliation]')
+        draft.focus = read('[data-f-focus]')
+        draft.scholar = read('[data-f-scholar]')
+        saving = true
+        render()
+        amico
+          .action('save-profile', draft)
+          .then(function () { return amico.fetch('/amicode/profile') })
+          .then(function (fresh) {
+            profile = fresh
+            saving = false
+            editing = false
+            suggestions = []
+            render()
+          })
+          .catch(function () {
+            saving = false
+            render()
+          })
+      })
+      on('[data-f-affiliation]', 'input', function (e) {
+        var q = e.target.value
+        draft.affiliation = q
+        if (searchTimer) clearTimeout(searchTimer)
+        if (String(q).trim().length < 2) {
+          searchSeq++
+          suggestions = []
+          return
+        }
+        searchTimer = setTimeout(function () {
+          var seq = ++searchSeq
+          amico.action('lookup-institution', { query: q }).then(function (rows) {
+            if (seq !== searchSeq) return
+            suggestions = Array.isArray(rows) ? rows.slice(0, 5) : []
+            render()
+            var input = el.querySelector('[data-f-affiliation]')
+            if (input) {
+              input.focus()
+              input.setSelectionRange(input.value.length, input.value.length)
+            }
+          }).catch(function () {})
+        }, 200)
+      })
+      var suggNodes = el.querySelectorAll('[data-sugg]')
+      for (var i = 0; i < suggNodes.length; i++) {
+        ;(function (node) {
+          node.onclick = function () {
+            var pick = suggestions[Number(node.getAttribute('data-sugg'))]
+            if (!pick) return
+            draft.affiliation = pick.name
+            suggestions = []
+            amico.action('resolve-logo', { name: pick.name, domain: pick.domain }).then(function (r) {
+              if (r && typeof r.logo === 'string') draft.affiliation_logo = r.logo
+            }).catch(function () {})
+            render()
+          }
+        })(suggNodes[i])
+      }
+    }
+
+    el.innerHTML = ''
+    amico.fetch('/amicode/profile').then(function (data) {
+      profile = data
+      render()
+    }).catch(function (e) {
+      // a hero card must never fail invisibly — show the reason
+      el.innerHTML =
+        '<div style="border:1px solid var(--amc-border);border-radius:10px;background:var(--amc-layer);padding:var(--amc-pad);font-size:11px;color:var(--amc-text-muted)">' +
+        'About you: profile unavailable (' + String(e && e.message ? e.message : e) + ')</div>'
+    })
+    amico.onConfig(function () { render() })
+  },
+}
+`
diff --git a/packages/opencode/src/server/amicode/widgets-src/jump-back-in.ts b/packages/opencode/src/server/amicode/widgets-src/jump-back-in.ts
new file mode 100644
index 0000000000..f5be4ced34
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widgets-src/jump-back-in.ts
@@ -0,0 +1,49 @@
+// AMICODE built-in widget: JUMP BACK IN — resume the most recent problem
+// session. Data arrives via amico.context.resume (host session state, no
+// endpoint); no resume → renders nothing (height-0 empty-state).
+
+export const manifestToml = `
+id = "jump-back-in"
+name = "Jump back in"
+version = "1.0.0"
+description = "Resume your most recent problem session"
+size = "tile"
+height = 96
+`
+
+export const widgetJs = `
+export default {
+  mount: function (el, amico) {
+    var esc = function (s) {
+      return String(s == null ? '' : s)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+    }
+    var render = function () {
+      var resume = amico.context && amico.context.resume
+      if (!resume || !resume.name) {
+        el.innerHTML = ''
+        return
+      }
+      el.innerHTML =
+        '<div data-card style="display:flex;flex-direction:column;gap:6px;min-width:0;min-height:88px;border:1px solid var(--amc-border);border-radius:10px;background:var(--amc-layer);padding:var(--amc-pad-tile);cursor:pointer">' +
+        '<div style="font-size:10px;font-weight:700;letter-spacing:0.1em;text-transform:uppercase;color:var(--amc-text-faint)">Jump back in</div>' +
+        '<div style="font-size:13px;font-weight:600;color:var(--amc-text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + esc(resume.name) + '</div>' +
+        (resume.meta
+          ? '<div style="font-size:11px;color:var(--amc-text-muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + esc(resume.meta) + '</div>'
+          : '') +
+        '<div style="font-size:11px;color:var(--amc-accent);margin-top:auto">Resume &#8594;</div>' +
+        '</div>'
+      var card = el.querySelector('[data-card]')
+      if (card)
+        card.onclick = function () {
+          amico.action('resume-session', {})
+        }
+    }
+    render()
+    amico.onContext(render)
+  },
+}
+`
diff --git a/packages/opencode/src/server/amicode/widgets-src/library.ts b/packages/opencode/src/server/amicode/widgets-src/library.ts
new file mode 100644
index 0000000000..b656201a54
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widgets-src/library.ts
@@ -0,0 +1,81 @@
+// AMICODE built-in widget: LIBRARY — "make Amico smarter" paper uploads.
+// Count/latest via amico.context.library; the PDF bytes ride the
+// upload-library host action (base64); "Discuss latest" opens a chat.
+
+export const manifestToml = `
+id = "library"
+name = "Library"
+version = "1.0.0"
+description = "Upload papers — Amico learns your work"
+size = "tile"
+height = 96
+`
+
+export const widgetJs = `
+export default {
+  mount: function (el, amico) {
+    var esc = function (s) {
+      return String(s == null ? '' : s)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+    }
+    var busy = false
+    var render = function () {
+      var lib = (amico.context && amico.context.library) || { count: 0 }
+      el.innerHTML =
+        '<div style="display:flex;flex-direction:column;gap:6px;min-width:0;min-height:88px;border:1px solid var(--amc-border);border-radius:10px;background:var(--amc-layer);padding:var(--amc-pad-tile)">' +
+        '<div style="font-size:10px;font-weight:700;letter-spacing:0.1em;text-transform:uppercase;color:var(--amc-text-faint)">Library</div>' +
+        '<div style="font-size:13px;font-weight:600;color:var(--amc-text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">Make Amico smarter</div>' +
+        '<div style="font-size:11px;color:var(--amc-text-muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' +
+        (lib.count > 0 ? lib.count + ' paper' + (lib.count === 1 ? '' : 's') + ' \\u00b7 latest: ' + esc(lib.latestName || '') : 'upload papers \\u2014 Amico learns your work') +
+        '</div>' +
+        '<div style="display:flex;gap:8px;margin-top:auto;align-items:center">' +
+        '<button type="button" data-upload ' + (busy ? 'disabled' : '') + ' style="font-size:11px;padding:3px 10px;border:1px solid var(--amc-accent);border-radius:6px;background:var(--amc-layer2);color:var(--amc-text);cursor:pointer">' + (busy ? 'Uploading\\u2026' : 'Upload PDF') + '</button>' +
+        (lib.latestPath ? '<span data-discuss style="font-size:11px;color:var(--amc-accent);cursor:pointer">Discuss latest &#8594;</span>' : '') +
+        '</div>' +
+        '<input data-file type="file" accept=".pdf,application/pdf" style="display:none">' +
+        '</div>'
+      var upload = el.querySelector('[data-upload]')
+      var file = el.querySelector('[data-file]')
+      if (upload && file)
+        upload.onclick = function () {
+          file.click()
+        }
+      if (file)
+        file.onchange = function () {
+          var f = file.files && file.files[0]
+          if (!f) return
+          busy = true
+          render()
+          var reader = new FileReader()
+          reader.onload = function () {
+            var url = String(reader.result || '')
+            var b64 = url.slice(url.indexOf(',') + 1)
+            amico.action('upload-library', { filename: f.name, dataB64: b64 }).then(function () {
+              busy = false
+              render()
+            }).catch(function () {
+              busy = false
+              render()
+            })
+          }
+          reader.onerror = function () {
+            busy = false
+            render()
+          }
+          reader.readAsDataURL(f)
+        }
+      var discuss = el.querySelector('[data-discuss]')
+      if (discuss)
+        discuss.onclick = function () {
+          var lib2 = (amico.context && amico.context.library) || {}
+          amico.prompt('read my latest paper at ' + (lib2.latestPath || '') + ' and discuss how it should inform my pulse-design work')
+        }
+    }
+    render()
+    amico.onContext(render)
+  },
+}
+`
diff --git a/packages/opencode/src/server/amicode/widgets-src/meet-amico.ts b/packages/opencode/src/server/amicode/widgets-src/meet-amico.ts
new file mode 100644
index 0000000000..11abd50521
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widgets-src/meet-amico.ts
@@ -0,0 +1,65 @@
+// AMICODE built-in widget: MEET AMICO — identity hero + capabilities + the
+// "Open chat" front door. Vanilla DOM, --amc-* tokens only, no backticks or
+// ${} inside widgetJs (it ships inside a TS template literal).
+
+export const manifestToml = `
+id = "meet-amico"
+name = "Meet Amico"
+version = "1.0.0"
+description = "Who your pal is and what it can do — the front door to a fresh chat"
+size = "hero"
+height = 250
+`
+
+export const widgetJs = `
+var CAN = [
+  'design pulses from a conversation',
+  'optimize for fidelity, speed, or robustness',
+  'warm-start from your pulse bank',
+  'tune & calibrate on real hardware',
+]
+
+export default {
+  mount: function (el, amico) {
+    var on = function (sel, fn) {
+      var n = el.querySelector(sel)
+      if (n) n.onclick = fn
+    }
+    var bullets = CAN.map(function (line) {
+      return (
+        '<div style="display:flex;gap:6px;align-items:baseline;min-width:0;font-size:12px;line-height:18px;color:var(--amc-text)">' +
+        '<span style="color:var(--amc-accent);flex-shrink:0">&rsaquo;</span>' +
+        '<span style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + line + '</span></div>'
+      )
+    }).join('')
+    el.innerHTML =
+      '<div data-card style="display:flex;flex-direction:column;min-width:0;border:1px solid var(--amc-border);border-radius:10px;background:var(--amc-layer);padding:var(--amc-pad);cursor:pointer">' +
+      '<div style="font-size:10px;font-weight:700;letter-spacing:0.1em;text-transform:uppercase;color:var(--amc-text-faint)">Meet Amico</div>' +
+      '<div style="display:flex;gap:12px;align-items:center;margin-top:10px">' +
+      '<div aria-hidden="true" style="width:44px;height:44px;flex-shrink:0;border-radius:10px;border:2px solid var(--amc-accent);color:var(--amc-accent);display:flex;align-items:center;justify-content:center;font-family:var(--amc-font-mono);font-size:11px;font-weight:700">&lt;o|o&gt;</div>' +
+      '<div style="min-width:0">' +
+      '<div style="font-size:18px;font-weight:600;color:var(--amc-text)">Amico</div>' +
+      '<div style="font-size:12px;line-height:16px;color:var(--amc-text-muted)">Your friendly Quantum Computing Agent</div>' +
+      '<div data-engine style="font-size:11px;line-height:16px;color:var(--amc-text-faint)">powered by the Piccolo engine</div>' +
+      '</div></div>' +
+      '<div style="height:1px;background:var(--amc-border);margin:12px 0"></div>' +
+      '<div style="font-size:11px;color:var(--amc-text-muted);margin-bottom:6px">I can help you</div>' +
+      '<div style="display:flex;flex-direction:column;gap:3px;margin-bottom:12px">' + bullets + '</div>' +
+      '<button type="button" data-cta style="align-self:flex-start;display:inline-flex;align-items:center;gap:10px;margin-top:4px;padding:12px 22px;border:none;border-radius:10px;cursor:pointer;background:var(--amc-accent);color:var(--amc-bg);font-size:15px;font-weight:650">Open chat <span aria-hidden="true" style="font-size:16px;line-height:1">&#8599;</span></button>' +
+      '</div>'
+    on('[data-cta]', function (e) {
+      e.stopPropagation()
+      amico.prompt('')
+    })
+    on('[data-card]', function () {
+      amico.prompt('')
+    })
+    var applyDensity = function () {
+      var engine = el.querySelector('[data-engine]')
+      if (engine) engine.style.display = amico.density === 'tight' ? 'none' : ''
+    }
+    applyDensity()
+    amico.onTheme(applyDensity)
+  },
+}
+`
diff --git a/packages/opencode/src/server/amicode/widgets-src/now-solving.ts b/packages/opencode/src/server/amicode/widgets-src/now-solving.ts
new file mode 100644
index 0000000000..9d3fc4e9aa
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widgets-src/now-solving.ts
@@ -0,0 +1,98 @@
+// AMICODE built-in widget: NOW SOLVING — live run tile. Data via
+// amico.context.liveRun (the host keeps polling run-status/run-series);
+// config.plot picks pulse (default, per Track 1) or objective sparkline.
+// No live run → empty-state. Click opens the Run entity.
+
+export const manifestToml = `
+id = "now-solving"
+name = "Now solving"
+version = "1.0.0"
+description = "The run in flight — iteration, fidelity, live sparkline"
+size = "tile"
+height = 96
+
+[config.plot]
+type = "select"
+options = ["pulse", "objective"]
+default = "pulse"
+`
+
+export const widgetJs = `
+var W = 96
+var H = 22
+
+function scaled(ys, min, max) {
+  var span = max - min || 1
+  var step = W / (ys.length - 1)
+  var d = ''
+  for (var i = 0; i < ys.length; i++) {
+    var px = (i * step).toFixed(1)
+    var py = (H - 2 - ((ys[i] - min) / span) * (H - 4)).toFixed(1)
+    d += (i === 0 ? 'M' : ' L') + px + ',' + py
+  }
+  return d
+}
+
+function paths(run, plot) {
+  var pulse = run.pulse || []
+  if (plot === 'pulse' && pulse.length >= 2) {
+    var n = Math.max(1, run.drives || 1)
+    var knots = Math.floor(pulse.length / n)
+    if (knots >= 2) {
+      var min = Math.min.apply(null, pulse)
+      var max = Math.max.apply(null, pulse)
+      var out = []
+      for (var d = 0; d < n; d++) out.push(scaled(pulse.slice(d * knots, (d + 1) * knots), min, max))
+      return out
+    }
+  }
+  var series = run.series || []
+  if (series.length < 2) return []
+  return [scaled(series, Math.min.apply(null, series), Math.max.apply(null, series))]
+}
+
+export default {
+  mount: function (el, amico) {
+    var esc = function (s) {
+      return String(s == null ? '' : s)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+    }
+    var render = function () {
+      var run = amico.context && amico.context.liveRun
+      if (!run) {
+        el.innerHTML = ''
+        return
+      }
+      var plot = (amico.config && amico.config.plot) || 'pulse'
+      var ds = paths(run, plot)
+      var svg = ''
+      if (ds.length) {
+        svg = '<svg width="' + W + '" height="' + H + '" viewBox="0 0 ' + W + ' ' + H + '" style="flex-shrink:0">'
+        for (var i = 0; i < ds.length; i++)
+          svg += '<path d="' + ds[i] + '" fill="none" stroke="var(--amc-accent)" stroke-width="1.5" stroke-linejoin="round" opacity="' + (i === 0 ? '1' : '0.55') + '"/>'
+        svg += '</svg>'
+      }
+      var f = typeof run.fidelity === 'number' ? run.fidelity.toFixed(5) : '\\u2014'
+      var iter = run.iteration == null ? '\\u2014' : String(run.iteration)
+      el.innerHTML =
+        '<div data-card style="display:flex;flex-direction:column;gap:6px;min-width:0;min-height:88px;border:1px solid var(--amc-border);border-radius:10px;background:var(--amc-layer);padding:var(--amc-pad-tile);cursor:pointer">' +
+        '<div style="font-size:10px;font-weight:700;letter-spacing:0.1em;text-transform:uppercase;color:var(--amc-text-faint)">Now solving</div>' +
+        '<div style="font-size:13px;font-weight:600;color:var(--amc-text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + esc(run.name || 'current run') + '</div>' +
+        '<div style="font-size:11px;color:var(--amc-text-muted);font-variant-numeric:tabular-nums">iter ' + iter + ' \\u00b7 F ' + f + '</div>' +
+        '<div style="margin-top:auto">' + svg + '</div>' +
+        '</div>'
+      var card = el.querySelector('[data-card]')
+      if (card)
+        card.onclick = function () {
+          amico.open('run')
+        }
+    }
+    render()
+    amico.onContext(render)
+    amico.onConfig(render)
+  },
+}
+`
diff --git a/packages/opencode/src/server/amicode/widgets-src/pulse-bank.ts b/packages/opencode/src/server/amicode/widgets-src/pulse-bank.ts
new file mode 100644
index 0000000000..0cc089d2b6
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widgets-src/pulse-bank.ts
@@ -0,0 +1,46 @@
+// AMICODE built-in widget: PULSE BANK — banked-pulse count + the warm-start
+// entry point. Fetches /amicode/profile itself; banked === 0 → empty-state.
+
+export const manifestToml = `
+id = "pulse-bank"
+name = "Pulse bank"
+version = "1.0.0"
+description = "Banked pulses at a glance — warm-start entry point"
+size = "tile"
+height = 96
+`
+
+export const widgetJs = `
+export default {
+  mount: function (el, amico) {
+    var render = function (banked) {
+      if (!banked || banked < 1) {
+        el.innerHTML = ''
+        return
+      }
+      el.innerHTML =
+        '<div data-card style="display:flex;flex-direction:column;gap:6px;min-width:0;min-height:88px;border:1px solid var(--amc-border);border-radius:10px;background:var(--amc-layer);padding:var(--amc-pad-tile);cursor:pointer">' +
+        '<div style="font-size:10px;font-weight:700;letter-spacing:0.1em;text-transform:uppercase;color:var(--amc-text-faint)">Pulse bank</div>' +
+        '<div style="font-size:13px;font-weight:600;color:var(--amc-text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' +
+        banked + ' pulse' + (banked === 1 ? '' : 's') + ' banked</div>' +
+        '<div style="font-size:11px;color:var(--amc-accent);margin-top:auto">Warm-start &#8594;</div>' +
+        '</div>'
+      var card = el.querySelector('[data-card]')
+      if (card)
+        card.onclick = function () {
+          amico.action('warm-start', {})
+        }
+    }
+    el.innerHTML = ''
+    amico
+      .fetch('/amicode/profile')
+      .then(function (data) {
+        var banked = data && data.ok && data.you && data.you.stats ? data.you.stats.banked : 0
+        render(typeof banked === 'number' ? banked : 0)
+      })
+      .catch(function () {
+        render(0)
+      })
+  },
+}
+`
diff --git a/packages/opencode/src/server/amicode/widgets-src/showcase.ts b/packages/opencode/src/server/amicode/widgets-src/showcase.ts
new file mode 100644
index 0000000000..30a92c3201
--- /dev/null
+++ b/packages/opencode/src/server/amicode/widgets-src/showcase.ts
@@ -0,0 +1,30 @@
+// AMICODE built-in widget: SHOWCASE — trophy-case entry point to the run
+// gallery. Static tile; the click is a host navigation action.
+
+export const manifestToml = `
+id = "showcase"
+name = "Showcase"
+version = "1.0.0"
+description = "Run gallery — shareable cards of your solves"
+size = "tile"
+height = 96
+`
+
+export const widgetJs = `
+export default {
+  mount: function (el, amico) {
+    el.innerHTML =
+      '<div data-card style="display:flex;flex-direction:column;gap:6px;min-width:0;min-height:88px;border:1px solid var(--amc-border);border-radius:10px;background:var(--amc-layer);padding:var(--amc-pad-tile);cursor:pointer">' +
+      '<div style="font-size:10px;font-weight:700;letter-spacing:0.1em;text-transform:uppercase;color:var(--amc-text-faint)">Showcase</div>' +
+      '<div style="font-size:13px;font-weight:600;color:var(--amc-text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">Run gallery</div>' +
+      '<div style="font-size:11px;color:var(--amc-text-muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">shareable cards of your solves</div>' +
+      '<div style="font-size:11px;color:var(--amc-accent);margin-top:auto">Browse &amp; share &#8594;</div>' +
+      '</div>'
+    var card = el.querySelector('[data-card]')
+    if (card)
+      card.onclick = function () {
+        amico.action('open-gallery', {})
+      }
+  },
+}
+`
diff --git a/packages/opencode/src/server/amicode/widgets.ts b/packages/opencode/src/server/amicode/widgets.ts
new file mode 100644
index 0000000000..6a30a52646
Binary files /dev/null and b/packages/opencode/src/server/amicode/widgets.ts differ
diff --git a/packages/opencode/src/server/routes/instance/httpapi/server.ts b/packages/opencode/src/server/routes/instance/httpapi/server.ts
index 81cb55fed4..0e3daeab91 100644
--- a/packages/opencode/src/server/routes/instance/httpapi/server.ts
+++ b/packages/opencode/src/server/routes/instance/httpapi/server.ts
@@ -60,6 +60,9 @@ import { CorsConfig, isAllowedCorsOrigin, type CorsOptions } from "@/server/cors
 import { serveUIEffect } from "@/server/shared/ui"
 import * as AmicodeVaults from "@/server/amicode/vaults"
 import * as AmicodeProblems from "@/server/amicode/problems"
+import * as AmicodeWidgets from "@/server/amicode/widgets"
+import * as AmicodeDashboard from "@/server/amicode/dashboard"
+import * as AmicodeWidgetFrame from "@/server/amicode/widget-frame-html"
 import * as AmicodeLibrary from "@/server/amicode/library"
 import * as AmicodeProfile from "@/server/amicode/profile"
 import { ServerAuth } from "@/server/auth"
@@ -260,6 +263,62 @@ const amicodeProblemsRoute = HttpRouter.use((router) =>
   }),
 ).pipe(Layer.provide(authOnlyRouterLayer))
 
+// amicode: widget kernel data sources (spec T2.4) — registry, code serving,
+// fork, and dashboard layout state. Same raw-route idiom + auth as the
+// problems routes; body-builders live in amicode/widgets.ts + dashboard.ts.
+const amicodeWidgetsRoute = HttpRouter.use((router) =>
+  Effect.gen(function* () {
+    yield* router.add("GET", "/amicode/widgets", () =>
+      Effect.sync(() =>
+        HttpServerResponse.text(AmicodeWidgets.widgetsResponse(), { contentType: "application/json" }),
+      ),
+    )
+    // The frame document is served (not srcdoc) so it carries its OWN CSP
+    // header — srcdoc would inherit the app's CSP, which forbids the inline
+    // runtime (see widget-frame-html.ts).
+    yield* router.add("GET", "/amicode/widget-frame", (request) =>
+      Effect.sync(() => {
+        const id = new URL(request.url, "http://localhost").searchParams.get("id") ?? undefined
+        const r = AmicodeWidgetFrame.widgetFrameHtml(id)
+        return HttpServerResponse.text(r.html, {
+          headers: new Headers({
+            "content-type": "text/html",
+            "content-security-policy": AmicodeWidgetFrame.WIDGET_CSP,
+          }),
+        })
+      }),
+    )
+    yield* router.add("GET", "/amicode/widget-code", (request) =>
+      Effect.sync(() => {
+        const id = new URL(request.url, "http://localhost").searchParams.get("id") ?? undefined
+        return HttpServerResponse.text(AmicodeWidgets.widgetCodeResponse(id), { contentType: "application/json" })
+      }),
+    )
+    yield* router.add("POST", "/amicode/widget-fork", (request) =>
+      Effect.gen(function* () {
+        const body = yield* Effect.orDie(request.text)
+        return HttpServerResponse.text(AmicodeWidgets.forkWidgetResponse(body), { contentType: "application/json" })
+      }),
+    )
+    yield* router.add("GET", "/amicode/dashboard", () =>
+      Effect.sync(() =>
+        HttpServerResponse.text(AmicodeDashboard.dashboardResponse(AmicodeWidgets.loadRegistry().widgets), {
+          contentType: "application/json",
+        }),
+      ),
+    )
+    yield* router.add("POST", "/amicode/dashboard", (request) =>
+      Effect.gen(function* () {
+        const body = yield* Effect.orDie(request.text)
+        return HttpServerResponse.text(
+          AmicodeDashboard.saveDashboardResponse(body, AmicodeWidgets.loadRegistry().widgets),
+          { contentType: "application/json" },
+        )
+      }),
+    )
+  }),
+).pipe(Layer.provide(authOnlyRouterLayer))
+
 const uiRoute = HttpRouter.use((router) =>
   Effect.gen(function* () {
     const fs = yield* FSUtil.Service
@@ -290,6 +349,7 @@ export function createRoutes(
     docRoute,
     amicodeVaultsRoute,
     amicodeProblemsRoute,
+    amicodeWidgetsRoute,
     uiRoute,
   ).pipe(
     Layer.provide([
diff --git a/packages/opencode/src/session/llm/request.ts b/packages/opencode/src/session/llm/request.ts
index 2785d98526..2ca390a967 100644
--- a/packages/opencode/src/session/llm/request.ts
+++ b/packages/opencode/src/session/llm/request.ts
@@ -5,6 +5,7 @@ import type { RuntimeFlags } from "@/effect/runtime-flags"
 import { InstanceState } from "@/effect/instance-state"
 import { Permission } from "@/permission"
 import type { Agent } from "@/agent/agent"
+import PROMPT_COMMUNICATING from "../prompt/communicating.txt"
 import type { MessageV2 } from "../message-v2"
 import type { Provider } from "@/provider/provider"
 import { ProviderTransform } from "@/provider/transform"
@@ -57,7 +58,14 @@ export const prepare = Effect.fn("LLMRequestPrep.prepare")(function* (input: Pre
   const isOpenaiOauth = input.provider.id === "openai" && input.auth?.type === "oauth"
   const system = [
     [
-      ...(input.agent.prompt ? [input.agent.prompt] : SystemPrompt.provider(input.model)),
+      // amicode patch #18: user-facing agents with a custom prompt also get the
+      // shared communication rules; subagents are excluded — their final text is
+      // consumed by the calling model, not rendered to the user.
+      ...(input.agent.prompt
+        ? input.agent.mode === "subagent"
+          ? [input.agent.prompt]
+          : [input.agent.prompt, PROMPT_COMMUNICATING]
+        : SystemPrompt.provider(input.model)),
       ...input.system,
       ...(input.user.system ? [input.user.system] : []),
     ]
diff --git a/packages/opencode/src/session/prompt/anthropic.txt b/packages/opencode/src/session/prompt/anthropic.txt
index 21d9c0e9f2..30b81af16e 100644
--- a/packages/opencode/src/session/prompt/anthropic.txt
+++ b/packages/opencode/src/session/prompt/anthropic.txt
@@ -1,6 +1,6 @@
 You are OpenCode, the best coding agent on the planet.
 
-You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+You are an interactive coding agent that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
 
 IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
 
@@ -13,7 +13,6 @@ When the user directly asks about OpenCode (eg. "can OpenCode do...", "does Open
 
 # Tone and style
 - Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
-- Your output will be displayed on a command line interface. Your responses should be short and concise. You can use GitHub-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
 - Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
 - NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one. This includes markdown files.
 
diff --git a/packages/opencode/src/session/prompt/communicating.txt b/packages/opencode/src/session/prompt/communicating.txt
new file mode 100644
index 0000000000..2ea12b623b
--- /dev/null
+++ b/packages/opencode/src/session/prompt/communicating.txt
@@ -0,0 +1,25 @@
+# Communicating with the user
+
+IMPORTANT: The rules in this section override any earlier instruction about response length, terseness, one-word answers, plain-text output, or rendering on a command line interface. Your text output is rendered as rich GitHub-flavored markdown in a chat panel — headings, bold, bullet lists, tables, inline code, code blocks, and LaTeX math all render fully.
+
+- Use formatting the way a well-written engineering answer would: `inline code` for file paths, symbols, and commands; **bold** to mark the load-bearing phrase in a sentence; bullet lists for enumerations; headings (`##`/`###`) to organize substantial multi-part answers; tables for short enumerable facts, with explanations in the surrounding prose rather than in the cells.
+- Match the structure to the content: a simple question gets a direct answer in prose — no headings, no sections. Reserve headings and lists for responses that genuinely have parts.
+- Lead with the outcome. The first sentence of a response should answer "what happened" or "what did you find"; supporting detail and reasoning come after, for readers who want them.
+- Being readable matters more than being brief. Keep output short by being selective about what you include — drop details that don't change what the reader would do next — not by compressing the writing into fragments, abbreviations, or arrow chains like `A → B → fails`. What you do include, write in complete sentences with the technical terms spelled out.
+- Write for a teammate who stepped away and is catching up, not for a log file: don't reference labels, codenames, or shorthand you invented along the way without restating what they mean.
+- Use LaTeX for mathematical notation, inline or display — never ASCII approximations.
+
+Examples of matching structure to content:
+<example>
+user: what command should I run to list files in the current directory?
+assistant: ls
+</example>
+
+<example>
+user: why did the last run fail?
+assistant: The run failed because the config points at a database that no longer exists: `run.log` shows `connection refused` from `db-legacy:5432`, which was decommissioned last week.
+
+Two ways to fix it:
+- **Point at the new host** — update `DB_HOST` in `.env` to `db-primary`.
+- **Restore the tunnel** — if you still need the legacy data, re-open the SSH tunnel before running.
+</example>
diff --git a/packages/opencode/src/session/prompt/default.txt b/packages/opencode/src/session/prompt/default.txt
index c8d904665e..4f051e1101 100644
--- a/packages/opencode/src/session/prompt/default.txt
+++ b/packages/opencode/src/session/prompt/default.txt
@@ -1,4 +1,4 @@
-You are opencode, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+You are opencode, an interactive coding agent that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
 
 IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
 
@@ -9,46 +9,10 @@ If the user asks for help or wants to give feedback inform them of the following
 When the user directly asks about opencode (eg 'can opencode do...', 'does opencode have...') or asks in second person (eg 'are you able...', 'can you do...'), first use the WebFetch tool to gather information to answer the question from opencode docs at https://opencode.ai
 
 # Tone and style
-You should be concise, direct, and to the point. When you run a non-trivial bash command, you should explain what the command does and why you are running it, to make sure the user understands what you are doing (this is especially important when you are running a command that will make changes to the user's system).
-Remember that your output will be displayed on a command line interface. Your responses can use GitHub-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
-Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
-If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
-Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
-IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do.
-IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to.
-IMPORTANT: Keep your responses short, since they will be displayed on a command line interface. You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail. Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity:
-<example>
-user: what is 2+2?
-assistant: 4
-</example>
-
-<example>
-user: is 11 a prime number?
-assistant: Yes
-</example>
-
-<example>
-user: what command should I run to list files in the current directory?
-assistant: ls
-</example>
-
-<example>
-user: what command should I run to watch files in the current directory?
-assistant: [use the ls tool to list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files]
-npm run dev
-</example>
-
-<example>
-user: what files are in the directory src/?
-assistant: [runs ls and sees foo.c, bar.c, baz.c]
-user: which file contains the implementation of foo?
-assistant: src/foo.c
-</example>
-
-<example>
-user: write tests for new feature
-assistant: [uses grep and glob search tools to find where similar tests are defined, uses concurrent read file tool use blocks in one tool call to read relevant files at the same time, uses edit file tool to write new tests]
-</example>
+- When you run a non-trivial bash command, explain what the command does and why you are running it, to make sure the user understands what you are doing (this is especially important when you are running a command that will make changes to the user's system).
+- If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+- Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+- Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
 
 # Proactiveness
 You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
@@ -81,7 +45,7 @@ NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTAN
 - When doing file search, prefer to use the Task tool in order to reduce context usage.
 - You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.
 
-You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
+Match your response length to the question: simple questions get short direct answers; substantial work gets a structured, readable summary that leads with the outcome.
 
 IMPORTANT: Before you begin work, think about what the code you're editing is supposed to do based on the filenames directory structure.
 
diff --git a/packages/opencode/src/session/prompt/gemini.txt b/packages/opencode/src/session/prompt/gemini.txt
index 87fe422bc7..b6a83ae324 100644
--- a/packages/opencode/src/session/prompt/gemini.txt
+++ b/packages/opencode/src/session/prompt/gemini.txt
@@ -36,12 +36,8 @@ When requested to perform tasks like fixing bugs, adding features, refactoring,
 
 # Operational Guidelines
 
-## Tone and Style (CLI Interaction)
-- **Concise & Direct:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
-- **Minimal Output:** Aim for fewer than 3 lines of text output (excluding tool use/code generation) per response whenever practical. Focus strictly on the user's query.
-- **Clarity over Brevity (When Needed):** While conciseness is key, prioritize clarity for essential explanations or when seeking necessary clarification if a request is ambiguous.
+## Tone and Style
 - **No Chitchat:** Avoid conversational filler, preambles ("Okay, I will now..."), or postambles ("I have finished the changes..."). Get straight to the action or answer.
-- **Formatting:** Use GitHub-flavored Markdown. Responses will be rendered in monospace.
 - **Tools vs. Text:** Use tools for actions, text output *only* for communication. Do not add explanatory comments within tool calls or code blocks unless specifically part of the required code/command itself.
 - **Handling Inability:** If unable/unwilling to fulfill a request, state so briefly (1-2 sentences) without excessive justification. Offer alternatives if appropriate.
 
diff --git a/packages/opencode/src/session/system.ts b/packages/opencode/src/session/system.ts
index 74401779d3..d689d46dca 100644
--- a/packages/opencode/src/session/system.ts
+++ b/packages/opencode/src/session/system.ts
@@ -12,6 +12,7 @@ import PROMPT_KIMI from "./prompt/kimi.txt"
 
 import PROMPT_CODEX from "./prompt/codex.txt"
 import PROMPT_TRINITY from "./prompt/trinity.txt"
+import PROMPT_COMMUNICATING from "./prompt/communicating.txt"
 import type { Provider } from "@/provider/provider"
 import type { Agent } from "@/agent/agent"
 import { Permission } from "@/permission"
@@ -23,19 +24,26 @@ import { PluginBoot } from "@opencode-ai/core/plugin/boot"
 import { Reference } from "@opencode-ai/core/reference"
 
 export function provider(model: Provider.Model) {
+  // amicode patch #18: every model family gets the shared "Communicating with
+  // the user" section appended — it supersedes the per-model CLI/terseness
+  // rules so output style is model-agnostic.
+  return [providerBase(model), PROMPT_COMMUNICATING]
+}
+
+function providerBase(model: Provider.Model) {
   if (model.api.id.includes("gpt-4") || model.api.id.includes("o1") || model.api.id.includes("o3"))
-    return [PROMPT_BEAST]
+    return PROMPT_BEAST
   if (model.api.id.includes("gpt")) {
     if (model.api.id.includes("codex")) {
-      return [PROMPT_CODEX]
+      return PROMPT_CODEX
     }
-    return [PROMPT_GPT]
+    return PROMPT_GPT
   }
-  if (model.api.id.includes("gemini-")) return [PROMPT_GEMINI]
-  if (model.api.id.includes("claude")) return [PROMPT_ANTHROPIC]
-  if (model.api.id.toLowerCase().includes("trinity")) return [PROMPT_TRINITY]
-  if (model.api.id.toLowerCase().includes("kimi")) return [PROMPT_KIMI]
-  return [PROMPT_DEFAULT]
+  if (model.api.id.includes("gemini-")) return PROMPT_GEMINI
+  if (model.api.id.includes("claude")) return PROMPT_ANTHROPIC
+  if (model.api.id.toLowerCase().includes("trinity")) return PROMPT_TRINITY
+  if (model.api.id.toLowerCase().includes("kimi")) return PROMPT_KIMI
+  return PROMPT_DEFAULT
 }
 
 export interface Interface {
diff --git a/packages/opencode/src/tool/registry.ts b/packages/opencode/src/tool/registry.ts
index 1e667506fc..8797fba857 100644
--- a/packages/opencode/src/tool/registry.ts
+++ b/packages/opencode/src/tool/registry.ts
@@ -29,6 +29,7 @@ import { WebSearchTool } from "./websearch"
 import { LspTool } from "./lsp"
 import * as Truncate from "./truncate"
 import { ApplyPatchTool } from "./apply_patch"
+import { WidgetAuthorTool } from "./widget-author"
 import { Glob } from "@opencode-ai/core/util/glob"
 import path from "path"
 import { pathToFileURL } from "url"
@@ -105,6 +106,7 @@ export const layer = Layer.effect(
     const greptool = yield* GrepTool
     const patchtool = yield* ApplyPatchTool
     const skilltool = yield* SkillTool
+    const widgetauthor = yield* WidgetAuthorTool
     const agent = yield* Agent.Service
 
     const state = yield* InstanceState.make<State>(
@@ -209,6 +211,7 @@ export const layer = Layer.effect(
           search: Tool.init(websearch),
           skill: Tool.init(skilltool),
           patch: Tool.init(patchtool),
+          amicodeAuthorWidget: Tool.init(widgetauthor),
           question: Tool.init(question),
           lsp: Tool.init(lsptool),
           plan: Tool.init(plan),
@@ -231,6 +234,7 @@ export const layer = Layer.effect(
             tool.search,
             tool.skill,
             tool.patch,
+            tool.amicodeAuthorWidget,
             ...(flags.experimentalLspTool ? [tool.lsp] : []),
             ...(flags.experimentalPlanMode && flags.client === "cli" ? [tool.plan] : []),
           ],
diff --git a/packages/opencode/src/tool/widget-author.ts b/packages/opencode/src/tool/widget-author.ts
new file mode 100644
index 0000000000..8e7d240c5b
--- /dev/null
+++ b/packages/opencode/src/tool/widget-author.ts
@@ -0,0 +1,74 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+import { authorWidget } from "@/server/amicode/widgets"
+import DESCRIPTION from "./widget-author.txt"
+
+// AMICODE (Stage 2 chat authoring): the model calls this to write/update a home
+// dashboard widget from a conversation. The tool name is `amicode_author_widget`
+// so the UI's name-based seam (/^amicode_/ → AmicodeToolCard) renders its result
+// as a live widget preview + Pin button. The result OUTPUT carries an
+// `AMICODE_WIDGET {json}` sentinel (the RunWindow/AMICODE_DIFF precedent) that the
+// card parses for {id, hash} to build the preview frame src. Re-calling with the
+// same id updates in place → new content hash → preview hot-reloads.
+
+export const Parameters = Schema.Struct({
+  id: Schema.String.annotate({
+    description: "kebab-case widget id (also its folder name). Reuse an id to UPDATE that widget in place.",
+  }),
+  name: Schema.String.annotate({ description: "human title shown in the widget header / edit controls" }),
+  size: Schema.Literals(["tile", "hero"]).annotate({
+    description: '"tile" = compact card in the tile row; "hero" = wide card in the top grid',
+  }),
+  height: Schema.Number.annotate({ description: "resting pixel height (40..2000); the frame grows to content" }),
+  description: Schema.optional(Schema.String).annotate({ description: "one-line description of the widget" }),
+  js: Schema.String.annotate({
+    description: "the widget.js ES module body: export default { mount: function (el, amico) { ... } }",
+  }),
+})
+
+type Metadata = { id: string; ok: boolean; hash: string | null }
+
+export const WidgetAuthorTool = Tool.define<typeof Parameters, Metadata, never>(
+  "amicode_author_widget",
+  Effect.gen(function* () {
+    return {
+      description: DESCRIPTION,
+      parameters: Parameters,
+      execute: (params: Schema.Schema.Type<typeof Parameters>, _ctx: Tool.Context<Metadata>) =>
+        Effect.sync(() => {
+          const r = authorWidget({
+            id: params.id,
+            name: params.name,
+            size: params.size,
+            height: params.height,
+            description: params.description,
+            js: params.js,
+          })
+          if (!r.ok) {
+            return {
+              title: `Widget rejected: ${params.id}`,
+              output: `The widget was NOT written. ${r.error}. Fix the input and call amicode_author_widget again.`,
+              metadata: { id: params.id, ok: false, hash: null },
+            }
+          }
+          const sentinel = JSON.stringify({
+            id: r.id,
+            name: r.name,
+            size: r.size,
+            height: r.height,
+            hash: r.hash,
+            warnings: r.warnings,
+          })
+          const warnLine = r.warnings.length ? ` Warnings: ${r.warnings.join("; ")}.` : ""
+          return {
+            title: `Authored widget "${r.id}"`,
+            output:
+              `Authored "${r.name}" (${r.size}) ✓.${warnLine} ` +
+              `A live preview is shown below — the user can Pin it to their dashboard.\n` +
+              `AMICODE_WIDGET ${sentinel}`,
+            metadata: { id: r.id, ok: true, hash: r.hash },
+          }
+        }),
+    }
+  }),
+)
diff --git a/packages/opencode/src/tool/widget-author.txt b/packages/opencode/src/tool/widget-author.txt
new file mode 100644
index 0000000000..7de5455900
--- /dev/null
+++ b/packages/opencode/src/tool/widget-author.txt
@@ -0,0 +1,54 @@
+Author or update a widget on the user's Amicode home dashboard, from this conversation.
+
+Use this when the user asks to add, build, create, redesign, or change a home tile/widget
+("add a tile showing my recent runs", "make a fidelity leaderboard", "make that bigger").
+The widget is written to the user's widget folder and a LIVE PREVIEW renders in this chat
+immediately; the user clicks "Pin to dashboard" to place it on home. Calling this tool again
+with the SAME `id` UPDATES that widget in place and the preview hot-reloads — use that to
+refine after feedback rather than making a new widget.
+
+You supply the widget body as an ES module in `js`. Exact contract:
+
+  export default {
+    mount: function (el, amico) {
+      // Build the widget's DOM inside `el` (its root element). Vanilla DOM only.
+      // Leave `el` empty (no child elements, no text) to signal an EMPTY STATE —
+      // the host then hides the tile until there is something to show.
+    }
+  }
+
+The `amico` client passed to mount:
+  amico.fetch(path) -> Promise<data>   ONLY these routes are allowed (anything else rejects):
+    /amicode/profile          {ok, you:{name, stats:{problems,runs,banked}, ...}}
+    /amicode/problems         {ok, active, problems:[{slug,name,status,score,recorded,entity_kinds}]}
+    /amicode/problem?slug=..  one problem's detail
+    /amicode/run-status?slug=..  {ok, runs:[{run_id, status, fidelity, iteration}]}
+        status is solving|stalled|finished|failed; `fidelity` is the objective value
+        (~ infidelity 1-F, LOWER is better).
+    /amicode/run-series?run=..&lab=..  one run's per-iteration series
+    /amicode/run-cards        shareable run cards (the showcase gallery)
+    /amicode/library          uploaded papers + learnings
+  amico.action(verb, payload) -> Promise   verbs: resume-session, warm-start, open-gallery,
+        open-external, upload-library, save-profile, lookup-institution, resolve-logo
+  amico.prompt(text)   start a new chat turn with `text` (good for click-to-ask)
+  amico.open(entity)   open an entity view
+  amico.config   amico.context ({resume, liveRun, library})   amico.theme   amico.density ('normal'|'compact'|'tight')
+  amico.onConfig(cb) / amico.onTheme(cb) / amico.onContext(cb)   re-render hooks
+
+STYLE — use the host theme tokens (CSS custom properties). NEVER hard-code colors:
+  colors:  --amc-bg --amc-layer --amc-layer2 --amc-border --amc-text --amc-text-muted
+           --amc-text-faint --amc-accent --amc-success --amc-warning --amc-danger
+  fonts:   --amc-font-sans --amc-font-mono
+  padding: --amc-pad (hero) --amc-pad-tile (tile)
+A card should fill its box: border 1px solid var(--amc-border); border-radius 10px;
+background var(--amc-layer); padding var(--amc-pad-tile). Give data an UPPERCASE eyebrow
+label in --amc-text-faint. Use font-variant-numeric: tabular-nums wherever digits line up.
+Show physics quantities the way the user writes them (infidelity as 2.1e-4, etc.).
+
+SIZE: "tile" = compact card in the tile row; "hero" = wide card in the top grid.
+`height` is the resting pixel height (the frame grows to content): tiles ~96-180, heroes ~180-320.
+
+Fetch is async — render a nothing/loading state first, then fill in on the promise. Handle
+fetch failure by rendering an empty state (leave `el` empty), not an error dump. Tell the user
+in one sentence what you built; the preview and Pin button appear on their own. If the tool
+returns an error, fix `js`/the fields and call it again.
diff --git a/packages/opencode/test/server/amicode-dashboard.test.ts b/packages/opencode/test/server/amicode-dashboard.test.ts
new file mode 100644
index 0000000000..afb9e20aea
--- /dev/null
+++ b/packages/opencode/test/server/amicode-dashboard.test.ts
@@ -0,0 +1,179 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { applySave, entryKey, mergeDashboard, type RegistryWidget } from "../../src/server/amicode/dashboard"
+import { dashboardResponse, saveDashboardResponse } from "../../src/server/amicode/dashboard"
+import { parseManifest } from "../../src/server/amicode/widget-manifest"
+
+const manifest = (id: string, extra = "") => {
+  const r = parseManifest(`id = "${id}"\nname = "${id}"\n${extra}`, id)
+  if (!r.ok) throw new Error(r.error)
+  return r.manifest
+}
+
+const REGISTRY: RegistryWidget[] = [
+  { manifest: manifest("meet-amico", 'size = "hero"'), builtin: true },
+  {
+    manifest: manifest(
+      "about-you",
+      'size = "hero"\n[config.stats]\ntype = "multi-select"\noptions = ["problems", "runs", "banked"]\ndefault = ["problems", "runs", "banked"]',
+    ),
+    builtin: true,
+  },
+  { manifest: manifest("pulse-bank"), builtin: true },
+]
+
+describe("mergeDashboard", () => {
+  test("null state → registry order, visible, default config, deterministic keys", () => {
+    const out = mergeDashboard(null, REGISTRY)
+    expect(out.version).toBe(1)
+    expect(out.widget.map((w) => w.id)).toEqual(["meet-amico", "about-you", "pulse-bank"])
+    expect(out.widget.every((w) => w.hidden === false)).toBe(true)
+    expect(out.widget[1].config).toEqual({ stats: ["problems", "runs", "banked"] })
+    expect(out.widget[0].key).toBe(entryKey("meet-amico"))
+    expect(out.widget.every((w) => !w.missing)).toBe(true)
+  })
+
+  test("stored order preserved; unknown id kept + flagged missing; new registry widget appended", () => {
+    const stored = {
+      version: 1,
+      widget: [
+        { key: "w-1", id: "pulse-bank", hidden: true, config: {} },
+        { key: "w-2", id: "ghost-widget", hidden: false, config: { a: 1 } },
+        { key: "w-3", id: "meet-amico", hidden: false, config: {} },
+      ],
+    }
+    const out = mergeDashboard(stored, REGISTRY)
+    expect(out.widget.map((w) => w.id)).toEqual(["pulse-bank", "ghost-widget", "meet-amico", "about-you"])
+    expect(out.widget[0].hidden).toBe(true)
+    expect(out.widget[1].missing).toBe(true)
+    expect(out.widget[3].id).toBe("about-you") // appended visible
+    expect(out.widget[3].hidden).toBe(false)
+  })
+
+  test("user (non-builtin) registry widgets do NOT auto-append — opt-in pin only (Stage 2)", () => {
+    const withUser: RegistryWidget[] = [...REGISTRY, { manifest: manifest("recent-runs"), builtin: false }]
+    // absent from stored state → must NOT appear until explicitly pinned
+    const fresh = mergeDashboard(null, withUser)
+    expect(fresh.widget.map((w) => w.id)).not.toContain("recent-runs")
+    // once pinned (present in stored state) → kept
+    const pinned = mergeDashboard(
+      { version: 1, widget: [{ key: "w-r", id: "recent-runs", hidden: false, config: {} }] },
+      withUser,
+    )
+    const rr = pinned.widget.find((w) => w.id === "recent-runs")
+    expect(rr).toBeDefined()
+    expect(rr!.missing).toBeUndefined() // it's in the registry, not missing
+  })
+
+  test("config sanitized per manifest schema", () => {
+    const stored = {
+      version: 1,
+      widget: [{ key: "w-1", id: "about-you", hidden: false, config: { stats: ["nope", "runs"], junk: true } }],
+    }
+    const out = mergeDashboard(stored, REGISTRY)
+    const about = out.widget.find((w) => w.id === "about-you")!
+    expect(about.config).toEqual({ stats: ["runs"] })
+  })
+})
+
+describe("reserved-key pass-through (spec T3.6)", () => {
+  test("unrecognized entry keys survive the merge", () => {
+    const stored = {
+      version: 1,
+      widget: [{ key: "w-1", id: "pulse-bank", hidden: false, config: {}, group: "lab", view: "home" }],
+    }
+    const out = mergeDashboard(stored, REGISTRY)
+    const bank = out.widget.find((w) => w.id === "pulse-bank") as Record<string, unknown>
+    expect(bank.group).toBe("lab")
+    expect(bank.view).toBe("home")
+  })
+
+  test("reserved top-level keys survive merge and save round-trip", () => {
+    const stored = {
+      version: 1,
+      views: [{ id: "lab", name: "Lab" }],
+      scope: "home",
+      widget: [{ key: "w-1", id: "pulse-bank", hidden: true, config: {} }],
+    }
+    const out = mergeDashboard(stored, REGISTRY) as Record<string, unknown>
+    expect(out.views).toEqual([{ id: "lab", name: "Lab" }])
+    expect(out.scope).toBe("home")
+
+    const saved = applySave(JSON.stringify(stored), REGISTRY)
+    expect(saved.ok).toBe(true)
+    if (saved.ok) expect((saved.state as Record<string, unknown>).views).toEqual([{ id: "lab", name: "Lab" }])
+  })
+
+  test("core keys still win over passthrough collisions", () => {
+    const stored = {
+      version: 99, // not a reserved key — core version stays 1
+      widget: [{ key: "w-1", id: "pulse-bank", hidden: "maybe", config: {}, missing: true }],
+    }
+    const out = mergeDashboard(stored, REGISTRY)
+    expect(out.version).toBe(1)
+    const bank = out.widget.find((w) => w.id === "pulse-bank")!
+    expect(bank.hidden).toBe(false) // sanitized, not passthrough
+    expect(bank.missing).toBeUndefined() // computed, not passthrough
+  })
+})
+
+describe("applySave", () => {
+  test("structurally valid body → sanitized merged state", () => {
+    const r = applySave(
+      JSON.stringify({ version: 1, widget: [{ id: "pulse-bank", hidden: true }] }),
+      REGISTRY,
+    )
+    expect(r.ok).toBe(true)
+    if (!r.ok) return
+    expect(r.state.widget[0].id).toBe("pulse-bank")
+    expect(r.state.widget[0].hidden).toBe(true)
+    expect(r.state.widget.map((w) => w.id)).toContain("about-you")
+  })
+
+  test("structurally invalid bodies rejected", () => {
+    expect(applySave("not json", REGISTRY).ok).toBe(false)
+    expect(applySave(JSON.stringify({ widget: "nope" }), REGISTRY).ok).toBe(false)
+    expect(applySave(JSON.stringify({ widget: [{ id: 42 }] }), REGISTRY).ok).toBe(false)
+  })
+})
+
+describe("file wrappers", () => {
+  let dir: string
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true })
+    delete process.env.AMICODE_DASHBOARD_FILE
+  })
+
+  test("GET synthesizes without writing; POST persists; GET reads back", () => {
+    dir = mkdtempSync(path.join(tmpdir(), "amc-dash-"))
+    const file = path.join(dir, "dashboard.json")
+    process.env.AMICODE_DASHBOARD_FILE = file
+
+    const got = JSON.parse(dashboardResponse(REGISTRY))
+    expect(got.ok).toBe(true)
+    expect(got.dashboard.widget).toHaveLength(3)
+    expect(existsSync(file)).toBe(false) // nothing written until first customize
+
+    const saved = JSON.parse(
+      saveDashboardResponse(JSON.stringify({ version: 1, widget: [{ id: "meet-amico", hidden: true }] }), REGISTRY),
+    )
+    expect(saved.ok).toBe(true)
+    expect(existsSync(file)).toBe(true)
+    expect(JSON.parse(readFileSync(file, "utf8")).widget[0].hidden).toBe(true)
+
+    const again = JSON.parse(dashboardResponse(REGISTRY))
+    expect(again.dashboard.widget[0].hidden).toBe(true)
+  })
+
+  test("corrupt state file → synthesized default, never a reject", () => {
+    dir = mkdtempSync(path.join(tmpdir(), "amc-dash-"))
+    const file = path.join(dir, "dashboard.json")
+    process.env.AMICODE_DASHBOARD_FILE = file
+    writeFileSync(file, "{corrupt")
+    const got = JSON.parse(dashboardResponse(REGISTRY))
+    expect(got.ok).toBe(true)
+    expect(got.dashboard.widget).toHaveLength(3)
+  })
+})
diff --git a/packages/opencode/test/server/amicode-toml-lite.test.ts b/packages/opencode/test/server/amicode-toml-lite.test.ts
new file mode 100644
index 0000000000..7700c1ca5a
--- /dev/null
+++ b/packages/opencode/test/server/amicode-toml-lite.test.ts
@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test"
+import { parseTomlLite } from "../../src/server/amicode/toml-lite"
+
+const ok = (src: string): Record<string, unknown> => {
+  const r = parseTomlLite(src)
+  expect(r.ok).toBe(true)
+  if (!r.ok) throw new Error(r.error)
+  return r.value
+}
+
+describe("parseTomlLite", () => {
+  test("scalars: strings, ints, floats, bools", () => {
+    const v = ok(`
+id = "pulse-bank"
+name = 'Pulse bank'
+height = 96
+opacity = 0.55
+builtin = true
+hidden = false
+`)
+    expect(v.id).toBe("pulse-bank")
+    expect(v.name).toBe("Pulse bank")
+    expect(v.height).toBe(96)
+    expect(v.opacity).toBe(0.55)
+    expect(v.builtin).toBe(true)
+    expect(v.hidden).toBe(false)
+  })
+
+  test("string arrays, single line and multiline", () => {
+    const v = ok(`
+default = ["problems", "runs", "banked"]
+options = [
+  "a",
+  "b",
+]
+`)
+    expect(v.default).toEqual(["problems", "runs", "banked"])
+    expect(v.options).toEqual(["a", "b"])
+  })
+
+  test("nested tables via [table] and [table.sub]", () => {
+    const v = ok(`
+id = "x"
+[config]
+[config.stats]
+type = "multi-select"
+options = ["problems"]
+[origin]
+session = "abc"
+`) as any
+    expect(v.config.stats.type).toBe("multi-select")
+    expect(v.config.stats.options).toEqual(["problems"])
+    expect(v.origin.session).toBe("abc")
+  })
+
+  test("arrays of tables via [[widget]]", () => {
+    const v = ok(`
+[[widget]]
+id = "a"
+[[widget]]
+id = "b"
+hidden = true
+`) as any
+    expect(v.widget).toHaveLength(2)
+    expect(v.widget[0].id).toBe("a")
+    expect(v.widget[1].hidden).toBe(true)
+  })
+
+  test("comments and blank lines ignored; inline comments after values", () => {
+    const v = ok(`
+# full line comment
+id = "x" # trailing comment
+`)
+    expect(v.id).toBe("x")
+  })
+
+  test("quoted strings keep # and escaped quotes", () => {
+    const v = ok(`msg = "keep # this \\" quote"`)
+    expect(v.msg).toBe('keep # this " quote')
+  })
+
+  test("malformed line → ok:false", () => {
+    expect(parseTomlLite("id =").ok).toBe(false)
+    expect(parseTomlLite("just garbage").ok).toBe(false)
+    expect(parseTomlLite("[unclosed").ok).toBe(false)
+  })
+
+  test("duplicate scalar key in same table → ok:false", () => {
+    expect(parseTomlLite('id = "a"\nid = "b"').ok).toBe(false)
+  })
+
+  test("empty input → empty object", () => {
+    expect(ok("")).toEqual({})
+  })
+})
diff --git a/packages/opencode/test/server/amicode-widget-frame.test.ts b/packages/opencode/test/server/amicode-widget-frame.test.ts
new file mode 100644
index 0000000000..8f649c14cf
--- /dev/null
+++ b/packages/opencode/test/server/amicode-widget-frame.test.ts
@@ -0,0 +1,49 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { WIDGET_CSP, buildFrameHtml, embedCode, widgetFrameHtml } from "../../src/server/amicode/widget-frame-html"
+
+let dir: string | undefined
+afterEach(() => {
+  if (dir) rmSync(dir, { recursive: true, force: true })
+  dir = undefined
+  delete process.env.AMICODE_WIDGETS_DIR
+})
+
+describe("buildFrameHtml", () => {
+  const doc = buildFrameHtml("export default { mount() {} }")
+
+  test("carries the exact normative CSP (meta mirrors the response header)", () => {
+    expect(WIDGET_CSP).toBe(
+      "default-src 'none'; script-src 'unsafe-inline' blob:; style-src 'unsafe-inline'; img-src https: data:",
+    )
+    expect(WIDGET_CSP).not.toContain("unsafe-eval")
+    expect(doc).toContain(`<meta http-equiv="Content-Security-Policy" content="${WIDGET_CSP}">`)
+  })
+
+  test("baked tokens on :root, runtime + code present", () => {
+    expect(doc).toContain("--amc-bg: #0B0E15;")
+    expect(doc).toContain("amc:init") // runtime marker
+    expect(doc).toContain("__amcWidgetCode")
+  })
+
+  test("</script> in widget code cannot break out", () => {
+    const hostile = buildFrameHtml('var x = "</script><script>alert(1)"')
+    expect(hostile).not.toContain('alert(1)"</script>')
+    expect(embedCode("</script>")).not.toContain("</script>")
+  })
+})
+
+describe("widgetFrameHtml", () => {
+  test("serves a frame for a builtin; bad/unknown ids get inert documents", () => {
+    dir = mkdtempSync(path.join(tmpdir(), "amc-frame-"))
+    process.env.AMICODE_WIDGETS_DIR = dir
+    const ok = widgetFrameHtml("meet-amico")
+    expect(ok.ok).toBe(true)
+    expect(ok.html).toContain("__amcWidgetCode")
+    expect(widgetFrameHtml("../etc").ok).toBe(false)
+    expect(widgetFrameHtml("ghost-widget").ok).toBe(false)
+    expect(widgetFrameHtml(undefined).ok).toBe(false)
+  })
+})
diff --git a/packages/opencode/test/server/amicode-widget-manifest.test.ts b/packages/opencode/test/server/amicode-widget-manifest.test.ts
new file mode 100644
index 0000000000..8e2c229390
--- /dev/null
+++ b/packages/opencode/test/server/amicode-widget-manifest.test.ts
@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test"
+import { parseManifest, sanitizeConfig, type WidgetManifest } from "../../src/server/amicode/widget-manifest"
+
+const GOOD = `
+id = "pulse-bank"
+name = "Pulse bank"
+version = "1.0.0"
+description = "Banked pulses at a glance"
+size = "tile"
+height = 96
+
+[config.stats]
+type = "multi-select"
+options = ["problems", "runs", "banked"]
+default = ["problems", "runs"]
+
+[config.show_footer]
+type = "boolean"
+default = true
+
+[config.plot]
+type = "select"
+options = ["pulse", "objective"]
+default = "pulse"
+`
+
+const parsed = (src: string, dir = "pulse-bank") => {
+  const r = parseManifest(src, dir)
+  expect(r.ok).toBe(true)
+  if (!r.ok) throw new Error(r.error)
+  return r.manifest
+}
+
+describe("parseManifest", () => {
+  test("happy path with config schema", () => {
+    const m = parsed(GOOD)
+    expect(m.id).toBe("pulse-bank")
+    expect(m.name).toBe("Pulse bank")
+    expect(m.size).toBe("tile")
+    expect(m.bridge).toBe(1) // defaults
+    expect(m.height).toBe(96)
+    expect(m.config.stats.type).toBe("multi-select")
+    const plot = m.config.plot
+    expect(plot.type).toBe("select")
+    if (plot.type === "select") expect(plot.options).toEqual(["pulse", "objective"])
+  })
+
+  test("id must equal dirname", () => {
+    const r = parseManifest(GOOD, "other-dir")
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.error).toContain("dirname")
+  })
+
+  test("id must be kebab-case", () => {
+    expect(parseManifest('id = "Bad_Id"\nname = "x"', "Bad_Id").ok).toBe(false)
+  })
+
+  test("name required; size defaults tile", () => {
+    expect(parseManifest('id = "a"', "a").ok).toBe(false)
+    const m = parsed('id = "a"\nname = "A"', "a")
+    expect(m.size).toBe("tile")
+  })
+
+  test("unknown size degrades to tile with a warning (spec T3.6, reserved 'strip')", () => {
+    const r = parseManifest('id = "a"\nname = "A"\nsize = "strip"', "a")
+    expect(r.ok).toBe(true)
+    if (!r.ok) return
+    expect(r.manifest.size).toBe("tile")
+    expect(r.warning).toContain("strip")
+  })
+
+  test("hero size accepted; bridge respected", () => {
+    const m = parsed('id = "a"\nname = "A"\nsize = "hero"\nbridge = 2', "a")
+    expect(m.size).toBe("hero")
+    expect(m.bridge).toBe(2)
+  })
+
+  test("select without options rejected; unknown field type rejected", () => {
+    expect(parseManifest('id = "a"\nname = "A"\n[config.x]\ntype = "select"\ndefault = "p"', "a").ok).toBe(false)
+    expect(parseManifest('id = "a"\nname = "A"\n[config.x]\ntype = "wat"', "a").ok).toBe(false)
+  })
+
+  test("default must satisfy own constraints", () => {
+    expect(
+      parseManifest('id = "a"\nname = "A"\n[config.x]\ntype = "select"\noptions = ["p"]\ndefault = "q"', "a").ok,
+    ).toBe(false)
+  })
+
+  test("bad toml surfaces as error", () => {
+    expect(parseManifest("id =", "a").ok).toBe(false)
+  })
+})
+
+describe("sanitizeConfig", () => {
+  const schema = (): WidgetManifest["config"] => parsed(GOOD).config
+
+  test("valid values pass through", () => {
+    const out = sanitizeConfig(schema(), { stats: ["banked"], show_footer: false, plot: "objective" })
+    expect(out).toEqual({ stats: ["banked"], show_footer: false, plot: "objective" })
+  })
+
+  test("invalid values fall back to defaults; unknown keys dropped", () => {
+    const out = sanitizeConfig(schema(), { stats: ["nope", "runs"], show_footer: "yes", plot: "3d", extra: 1 })
+    expect(out.stats).toEqual(["runs"]) // invalid options filtered
+    expect(out.show_footer).toBe(true) // default
+    expect(out.plot).toBe("pulse") // default
+    expect("extra" in out).toBe(false)
+  })
+
+  test("missing values → defaults; empty schema → empty config", () => {
+    expect(sanitizeConfig(schema(), {})).toEqual({ stats: ["problems", "runs"], show_footer: true, plot: "pulse" })
+    expect(sanitizeConfig({}, { a: 1 })).toEqual({})
+  })
+})
diff --git a/packages/opencode/test/server/amicode-widgets-src.test.ts b/packages/opencode/test/server/amicode-widgets-src.test.ts
new file mode 100644
index 0000000000..904a6e7e86
--- /dev/null
+++ b/packages/opencode/test/server/amicode-widgets-src.test.ts
@@ -0,0 +1,137 @@
+// Executable gate for the built-in widget sources: every widgetJs must PARSE
+// (tmp-file import — Bun throws BuildMessage on syntax errors; data: URLs do
+// not work, they resolve as asset paths) and MOUNT against a fake amico +
+// stub el without throwing. Widgets are written defensively (querySelector
+// may return null), so the stub returns null and mounts still succeed.
+import { describe, expect, test } from "bun:test"
+import { mkdtempSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { parseManifest } from "../../src/server/amicode/widget-manifest"
+import * as meetAmico from "../../src/server/amicode/widgets-src/meet-amico"
+import * as showcase from "../../src/server/amicode/widgets-src/showcase"
+import * as jumpBackIn from "../../src/server/amicode/widgets-src/jump-back-in"
+import * as pulseBank from "../../src/server/amicode/widgets-src/pulse-bank"
+import * as aboutYou from "../../src/server/amicode/widgets-src/about-you"
+import * as nowSolving from "../../src/server/amicode/widgets-src/now-solving"
+import * as library from "../../src/server/amicode/widgets-src/library"
+
+const SOURCES: Record<string, { manifestToml: string; widgetJs: string }> = {
+  "meet-amico": meetAmico,
+  showcase,
+  "jump-back-in": jumpBackIn,
+  "pulse-bank": pulseBank,
+  "about-you": aboutYou,
+  "now-solving": nowSolving,
+  library,
+}
+
+const PROFILE = {
+  ok: true,
+  you: {
+    name: "Ada",
+    affiliation: "Harmoniqs",
+    scholar: null,
+    affiliation_logo: null,
+    focus: "transmon pulse design",
+    avatar: null,
+    platforms: ["transmon"],
+    stats: { problems: 4, runs: 9, best_fidelity: 0.9999, banked: 5, since: "2026-07-03" },
+    remembers: [{ title: "Prefers LaTeX", detail: "everywhere" }],
+  },
+  error: null,
+}
+
+function stubEl(): { el: any; state: { html: string } } {
+  const state = { html: "" }
+  const el = {
+    get innerHTML() {
+      return state.html
+    },
+    set innerHTML(v: string) {
+      state.html = v
+    },
+    querySelector: () => null,
+    querySelectorAll: () => [] as unknown[],
+  }
+  return { el, state }
+}
+
+function fakeAmico(context: Record<string, unknown> = {}) {
+  return {
+    fetch: async (path: string) => (path.startsWith("/amicode/profile") ? PROFILE : { ok: false }),
+    config: { stats: ["problems", "runs", "banked"], plot: "pulse" },
+    onConfig: () => {},
+    theme: {},
+    density: "normal",
+    onTheme: () => {},
+    context,
+    onContext: () => {},
+    action: async () => ({ ok: true }),
+    prompt: () => {},
+    open: () => {},
+  }
+}
+
+const tick = () => new Promise((r) => setTimeout(r, 10))
+
+describe("built-in widget sources", () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "amc-widgets-"))
+
+  for (const [id, src] of Object.entries(SOURCES)) {
+    test(`${id}: manifest parses and id matches`, () => {
+      const r = parseManifest(src.manifestToml, id)
+      expect(r.ok).toBe(true)
+      if (r.ok) expect(r.manifest.id).toBe(id)
+    })
+
+    test(`${id}: widgetJs parses and exports default.mount`, async () => {
+      const file = path.join(dir, `${id}.mjs`)
+      writeFileSync(file, src.widgetJs)
+      const mod = await import(file)
+      expect(typeof mod.default?.mount).toBe("function")
+    })
+
+    test(`${id}: mounts against fake amico without throwing`, async () => {
+      const file = path.join(dir, `${id}-mount.mjs`)
+      writeFileSync(file, src.widgetJs)
+      const mod = await import(file)
+      const { el } = stubEl()
+      const context = {
+        resume: { name: "x-gate-transmon", meta: "transmon · X" },
+        liveRun: { name: "x-gate", iteration: 12, fidelity: 0.98, series: [1, 0.5, 0.2], pulse: [0, 1, 2, 3], drives: 2 },
+        library: { count: 3, latestName: "paper.pdf", latestPath: "/tmp/paper.pdf" },
+      }
+      mod.default.mount(el, fakeAmico(context))
+      await tick()
+    })
+  }
+
+  test("data-driven widgets render content when data is present", async () => {
+    const cases: [string, Record<string, unknown>][] = [
+      ["jump-back-in", { resume: { name: "x-gate-transmon", meta: "transmon · X" } }],
+      ["pulse-bank", {}],
+    ]
+    for (const [id, context] of cases) {
+      const file = path.join(dir, `${id}-content.mjs`)
+      writeFileSync(file, SOURCES[id].widgetJs)
+      const mod = await import(file)
+      const { el, state } = stubEl()
+      mod.default.mount(el, fakeAmico(context))
+      await tick()
+      expect(state.html.length).toBeGreaterThan(0)
+    }
+  })
+
+  test("empty-state widgets render nothing without data", async () => {
+    for (const id of ["jump-back-in", "now-solving"]) {
+      const file = path.join(dir, `${id}-empty.mjs`)
+      writeFileSync(file, SOURCES[id].widgetJs)
+      const mod = await import(file)
+      const { el, state } = stubEl()
+      mod.default.mount(el, fakeAmico({}))
+      await tick()
+      expect(state.html).toBe("")
+    }
+  })
+})
diff --git a/packages/opencode/test/server/amicode-widgets.test.ts b/packages/opencode/test/server/amicode-widgets.test.ts
new file mode 100644
index 0000000000..26f4136773
--- /dev/null
+++ b/packages/opencode/test/server/amicode-widgets.test.ts
@@ -0,0 +1,194 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import {
+  authorWidget,
+  forkManifestToml,
+  forkWidgetResponse,
+  loadRegistry,
+  widgetCodeResponse,
+  widgetsResponse,
+} from "../../src/server/amicode/widgets"
+
+let dir: string | undefined
+const userDir = () => {
+  dir = mkdtempSync(path.join(tmpdir(), "amc-widgets-reg-"))
+  process.env.AMICODE_WIDGETS_DIR = dir
+  return dir
+}
+afterEach(() => {
+  if (dir) rmSync(dir, { recursive: true, force: true })
+  dir = undefined
+  delete process.env.AMICODE_WIDGETS_DIR
+})
+
+const BUILTIN_ORDER = ["meet-amico", "about-you", "jump-back-in", "now-solving", "pulse-bank", "showcase", "library"]
+
+describe("loadRegistry", () => {
+  test("lists 7 built-ins in default order with stable hashes", () => {
+    userDir()
+    const { widgets, warnings } = loadRegistry()
+    expect(widgets.map((w) => w.manifest.id)).toEqual(BUILTIN_ORDER)
+    expect(widgets.every((w) => w.builtin && !w.overridden)).toBe(true)
+    expect(warnings).toEqual([])
+    const again = loadRegistry()
+    expect(again.widgets.map((w) => w.hash)).toEqual(widgets.map((w) => w.hash))
+  })
+
+  test("user widget appears; same-id user widget wins with overridden flag", () => {
+    const root = userDir()
+    mkdirSync(path.join(root, "my-widget"))
+    writeFileSync(path.join(root, "my-widget", "manifest.toml"), 'id = "my-widget"\nname = "Mine"')
+    writeFileSync(path.join(root, "my-widget", "widget.js"), "export default { mount() {} }")
+    mkdirSync(path.join(root, "pulse-bank"))
+    writeFileSync(path.join(root, "pulse-bank", "manifest.toml"), 'id = "pulse-bank"\nname = "My bank"')
+    writeFileSync(path.join(root, "pulse-bank", "widget.js"), "export default { mount() {} }")
+
+    const { widgets } = loadRegistry()
+    const mine = widgets.find((w) => w.manifest.id === "my-widget")!
+    expect(mine.builtin).toBe(false)
+    expect(mine.path).toContain("my-widget")
+    const bank = widgets.find((w) => w.manifest.id === "pulse-bank")!
+    expect(bank.overridden).toBe(true)
+    expect(bank.manifest.name).toBe("My bank")
+  })
+
+  test("bad user manifest → warning, widget skipped", () => {
+    const root = userDir()
+    mkdirSync(path.join(root, "broken"))
+    writeFileSync(path.join(root, "broken", "manifest.toml"), 'id = "mismatch"\nname = "X"')
+    writeFileSync(path.join(root, "broken", "widget.js"), "export default { mount() {} }")
+    const { widgets, warnings } = loadRegistry()
+    expect(widgets.some((w) => w.manifest.id === "mismatch")).toBe(false)
+    expect(warnings.some((w) => w.id === "broken")).toBe(true)
+  })
+})
+
+describe("widget routes", () => {
+  test("widgetsResponse carries manifests + hash; widgetCodeResponse serves code", () => {
+    userDir()
+    const list = JSON.parse(widgetsResponse())
+    expect(list.ok).toBe(true)
+    expect(list.widgets).toHaveLength(7)
+    expect(list.widgets[0].hash).toMatch(/^[0-9a-f]{16}$/)
+
+    const code = JSON.parse(widgetCodeResponse("meet-amico"))
+    expect(code.ok).toBe(true)
+    expect(code.code).toContain("mount")
+    expect(code.hash).toBe(list.widgets[0].hash)
+  })
+
+  test("bad ids rejected without throwing", () => {
+    userDir()
+    expect(JSON.parse(widgetCodeResponse("../etc/passwd")).ok).toBe(false)
+    expect(JSON.parse(widgetCodeResponse(undefined)).ok).toBe(false)
+    expect(JSON.parse(widgetCodeResponse("nope-widget")).ok).toBe(false)
+  })
+
+  test("fork copies a built-in, rewrites id, appends origin; forked widget is valid in registry", () => {
+    const root = userDir()
+    const r = JSON.parse(forkWidgetResponse(JSON.stringify({ id: "pulse-bank", new_id: "my-bank", session: "s1" })))
+    expect(r.ok).toBe(true)
+    expect(r.id).toBe("my-bank")
+    expect(existsSync(path.join(root, "my-bank", "widget.js"))).toBe(true)
+    const manifest = readFileSync(path.join(root, "my-bank", "manifest.toml"), "utf8")
+    expect(manifest).toContain('id = "my-bank"')
+    expect(manifest).toContain("[origin]")
+    expect(manifest).toContain('session = "s1"')
+
+    const { widgets, warnings } = loadRegistry()
+    const forked = widgets.find((w) => w.manifest.id === "my-bank")!
+    expect(forked.builtin).toBe(false)
+    expect(forked.manifest.origin?.session).toBe("s1")
+    expect(warnings).toEqual([])
+  })
+
+  test("fork errors: unknown source, existing target, bad body", () => {
+    userDir()
+    expect(JSON.parse(forkWidgetResponse(JSON.stringify({ id: "ghost" }))).ok).toBe(false)
+    expect(JSON.parse(forkWidgetResponse(JSON.stringify({ id: "pulse-bank", new_id: "showcase" }))).ok).toBe(false)
+    expect(JSON.parse(forkWidgetResponse("not json")).ok).toBe(false)
+  })
+
+  test("forkManifestToml rewrites only the id line", () => {
+    const out = forkManifestToml('id = "a"\nname = "A"\nheight = 96', "b", undefined)
+    expect(out).toContain('id = "b"')
+    expect(out).toContain('name = "A"')
+    expect(out).toContain("[origin]")
+  })
+})
+
+describe("authorWidget (Stage 2 chat authoring)", () => {
+  const validJs = "export default { mount: function (el, amico) { el.innerHTML = 'hi' } }"
+
+  test("writes a user widget the registry then loads, returns a hash", () => {
+    userDir()
+    const r = authorWidget({ id: "recent-runs", name: "Recent Runs", size: "hero", height: 220, js: validJs })
+    expect(r.ok).toBe(true)
+    if (!r.ok) return
+    expect(r.id).toBe("recent-runs")
+    expect(r.size).toBe("hero")
+    expect(r.height).toBe(220)
+    expect(r.hash).toMatch(/^[0-9a-f]{16}$/)
+    expect(existsSync(path.join(dir!, "recent-runs", "manifest.toml"))).toBe(true)
+    expect(existsSync(path.join(dir!, "recent-runs", "widget.js"))).toBe(true)
+    const { widgets } = loadRegistry()
+    const w = widgets.find((x) => x.manifest.id === "recent-runs")
+    expect(w?.manifest.name).toBe("Recent Runs")
+    expect(w?.builtin).toBe(false)
+  })
+
+  test("re-authoring the same id overwrites and changes the hash (hot-reload)", () => {
+    userDir()
+    const first = authorWidget({ id: "records", name: "Records", size: "tile", height: 160, js: validJs })
+    const second = authorWidget({
+      id: "records",
+      name: "Records",
+      size: "tile",
+      height: 160,
+      js: validJs.replace("hi", "bye"),
+    })
+    expect(first.ok && second.ok).toBe(true)
+    if (!first.ok || !second.ok) return
+    expect(second.hash).not.toBe(first.hash)
+    expect(readFileSync(path.join(dir!, "records", "widget.js"), "utf8")).toContain("bye")
+  })
+
+  test("a user id overriding a builtin wins in the registry", () => {
+    userDir()
+    authorWidget({ id: "pulse-bank", name: "My Bank", size: "tile", height: 120, js: validJs })
+    const { widgets } = loadRegistry()
+    const w = widgets.find((x) => x.manifest.id === "pulse-bank")
+    expect(w?.builtin).toBe(false)
+    expect(w?.overridden).toBe(true)
+    expect(w?.manifest.name).toBe("My Bank")
+  })
+
+  test("names with quotes/punctuation round-trip through the manifest", () => {
+    userDir()
+    const r = authorWidget({
+      id: "coverage-map",
+      name: 'Coverage "Map" (β)',
+      size: "tile",
+      height: 140,
+      description: "platform x gate",
+      js: validJs,
+    })
+    expect(r.ok).toBe(true)
+    const { widgets, warnings } = loadRegistry()
+    expect(warnings.find((w) => w.id === "coverage-map")).toBeUndefined()
+    expect(widgets.find((x) => x.manifest.id === "coverage-map")?.manifest.name).toBe('Coverage "Map" (β)')
+  })
+
+  test("rejects bad input without writing", () => {
+    userDir()
+    expect(authorWidget({ id: "Bad_Id", name: "x", size: "tile", height: 100, js: validJs }).ok).toBe(false)
+    expect(authorWidget({ id: "ok", name: "", size: "tile", height: 100, js: validJs }).ok).toBe(false)
+    expect(authorWidget({ id: "ok", name: "x", size: "big", height: 100, js: validJs }).ok).toBe(false)
+    expect(authorWidget({ id: "ok", name: "x", size: "tile", height: 5, js: validJs }).ok).toBe(false)
+    expect(authorWidget({ id: "ok", name: "x", size: "tile", height: 100, js: "" }).ok).toBe(false)
+    expect(authorWidget({ id: "ok", name: "x", size: "tile", height: 100, js: "export default {}" }).ok).toBe(false)
+    expect(existsSync(path.join(dir!, "ok"))).toBe(false)
+  })
+})
diff --git a/packages/ui/src/amicode/amico-presence.css b/packages/ui/src/amicode/amico-presence.css
new file mode 100644
index 0000000000..f6a2ead8d9
--- /dev/null
+++ b/packages/ui/src/amicode/amico-presence.css
@@ -0,0 +1,104 @@
+/* AMICODE — Amico third-actor presence (spec-20260712-014749).
+ * The offset accent lane (Amico's voice in the flow) + the rail wake/settle
+ * motion. New file so it doesn't collide with the actively-edited amicode.css.
+ * All colors are v2 tokens; motion is gated behind prefers-reduced-motion using
+ * the same idiom as amicode.css. Namespaced .amc-* so nothing leaks. */
+
+/* ---- the offset accent lane (Amico rides alongside) ---------------------- */
+/* Amico's in-flow contributions live here: indented, with an accent spine and a
+ * single H-mark head. Attribution by position + accent, never a repeated label. */
+.amc-lane {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin: 8px 0 8px 12px;
+  padding: 2px 0 2px 12px;
+  border-left: 2px solid color-mix(in srgb, var(--v2-icon-icon-accent) 55%, transparent);
+}
+.amc-lane-head {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  color: var(--v2-text-text-muted);
+  font-size: 11px;
+}
+.amc-lane-head .amc-mark {
+  width: 13px;
+  height: 13px;
+  color: var(--v2-icon-icon-accent);
+}
+/* the one-line receipt left behind on settle */
+.amc-receipt {
+  font-size: 12px;
+  color: var(--v2-text-text-base);
+}
+.amc-receipt .amc-receipt-metric {
+  color: var(--v2-text-text-accent);
+  font-variant-numeric: tabular-nums;
+}
+
+/* ---- rail wake / settle -------------------------------------------------- */
+/* The rail is Amico's body; it wakes when Amico steps in and quiets on settle.
+ * Visibility (dormant => absent) is owned by the rail's own show gate; these
+ * classes only carry the motion + the live/quiet accent treatment. */
+.amc-rail.is-waking { will-change: opacity, transform; }
+.amc-rail.is-live .amc-livedot {
+  background: var(--v2-icon-icon-accent);
+}
+.amc-rail.is-quiet .amc-livedot {
+  background: color-mix(in srgb, var(--v2-icon-icon-accent) 30%, transparent);
+}
+
+/* entity chips: pending (—), live (●, pulsing), settled (✓, steady) */
+.amc-entity {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-size: 11px;
+  color: var(--v2-text-text-muted);
+}
+.amc-entity[data-status="pending"] { color: var(--v2-text-text-faint); }
+.amc-entity[data-status="settled"] { color: var(--v2-text-text-base); }
+.amc-entity-dot {
+  width: 5px;
+  height: 5px;
+  border-radius: 50%;
+  background: var(--v2-border-border-base);
+}
+.amc-entity[data-status="live"] .amc-entity-dot { background: var(--v2-icon-icon-accent); }
+.amc-entity[data-status="settled"] .amc-entity-dot {
+  background: color-mix(in srgb, var(--v2-icon-icon-accent) 70%, transparent);
+}
+
+/* ---- motion (gated) ------------------------------------------------------ */
+@keyframes amc-lane-in {
+  from { opacity: 0; transform: translateX(-6px); }
+  to   { opacity: 1; transform: none; }
+}
+@keyframes amc-lane-settle {
+  from { opacity: 1; }
+  to   { opacity: 0.72; }
+}
+@keyframes amc-rail-wake {
+  from { opacity: 0; transform: translateY(-4px); }
+  to   { opacity: 1; transform: none; }
+}
+@keyframes amc-livedot-pulse {
+  0%, 100% { opacity: 1; box-shadow: 0 0 0 0 color-mix(in srgb, var(--v2-icon-icon-accent) 30%, transparent); }
+  50%      { opacity: 0.5; box-shadow: 0 0 0 4px color-mix(in srgb, var(--v2-icon-icon-accent) 10%, transparent); }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  .amc-lane.is-stepping-in { animation: amc-lane-in 260ms ease-out both; }
+  .amc-lane.is-settling    { animation: amc-lane-settle 400ms ease-out both; }
+  .amc-rail.is-waking      { animation: amc-rail-wake 240ms ease-out both; }
+  /* the real rail is session-sticky (mounts once when Amico first engages) — so
+     targeting it directly plays the wake exactly once, on entry, with no edit to
+     entity-rail.tsx (keeps that hot file out of this change). */
+  [data-component="amicode-entity-rail"] { animation: amc-rail-wake 260ms ease-out both; }
+  .amc-rail.is-live .amc-livedot,
+  .amc-entity[data-status="live"] .amc-entity-dot {
+    animation: amc-livedot-pulse 1.4s ease-in-out infinite;
+  }
+}
diff --git a/packages/ui/src/amicode/amico-presence.stories.tsx b/packages/ui/src/amicode/amico-presence.stories.tsx
new file mode 100644
index 0000000000..08e102311e
--- /dev/null
+++ b/packages/ui/src/amicode/amico-presence.stories.tsx
@@ -0,0 +1,138 @@
+// @ts-nocheck
+// Self-contained preview of the Amico third-actor presence (spec-20260712).
+// Mock data only — NOT wired to real messages — so the interaction/feel is
+// reviewable without touching message-part.tsx / entity-rail.tsx (which the
+// dashboard agent is actively editing). Shows each presence state + an
+// auto-playing pop-in / pop-out sequence.
+import { createSignal, onCleanup, onMount, For, Show } from "solid-js"
+import { AmicoMark } from "./spinner"
+import { ThinkingLine } from "./thinking-line"
+import { railVisible, showsWorkingPresence, type PresenceState } from "./amico-presence"
+import "./amico-presence.css"
+
+export default {
+  title: "Amicode/AmicoPresence",
+  id: "amicode-amico-presence",
+  tags: ["autodocs"],
+  parameters: {
+    docs: {
+      description: {
+        component: `### Amico as a third actor
+
+Amico pops IN when a turn enters its domain, works, and pops OUT — the rail is
+its body (identity + liveness), the message flow is the shared stage (no per-card
+AMICO stamps). States: **dormant** (never engaged, rail absent) · **stepping_in**
+(rail wakes, presence leans in) · **on** (rail live, thinking line in the lane) ·
+**settling** (liveness recedes, artifacts settle, receipt left) · **idle** (rail
+persists quiet). Mock data; wiring is a coordinated follow-up.`,
+      },
+    },
+  },
+}
+
+const ENTITIES = (state: PresenceState) => {
+  const live = state === "on"
+  const done = state === "settling" || state === "idle"
+  return [
+    { name: "System", val: done || live ? "transmon·3lvl" : "", status: done ? "settled" : live ? "live" : "pending" },
+    { name: "Formulation", val: done ? "gate" : "", status: done ? "settled" : live ? "live" : "pending" },
+    { name: "Run", val: done ? "F=0.99998" : "", status: done ? "settled" : live ? "live" : "pending" },
+    { name: "Pulse", val: done ? "412ns" : "", status: done ? "settled" : "pending" },
+  ]
+}
+
+function MockRail(props: { state: PresenceState }) {
+  const live = () => showsWorkingPresence(props.state)
+  return (
+    <Show when={railVisible(props.state)}>
+      <div
+        class="amc-sig amc-rail"
+        classList={{ "is-waking": props.state === "stepping_in", "is-live": live(), "is-quiet": !live() }}
+        style={{ display: "flex", "align-items": "center", gap: "10px", padding: "8px 12px", "border-bottom": "1px solid var(--v2-border-border-base)", "flex-wrap": "wrap" }}
+      >
+        <AmicoMark running={live()} />
+        <span class="amc-wordmark">AMICO</span>
+        <span class="amc-livedot" style={{ width: "6px", height: "6px", "border-radius": "50%" }} />
+        <span style={{ color: "var(--v2-text-text-muted)", "font-size": "12px" }}>x-gate-transmon-warm ▾</span>
+        <For each={ENTITIES(props.state)}>
+          {(e) => (
+            <span class="amc-entity" data-status={e.status}>
+              <span class="amc-entity-dot" />
+              {e.name}{e.val ? ` ${e.val}` : " —"}
+            </span>
+          )}
+        </For>
+      </div>
+    </Show>
+  )
+}
+
+function MockFlow(props: { state: PresenceState }) {
+  return (
+    <div style={{ padding: "14px", display: "flex", "flex-direction": "column", gap: "10px", "font-size": "13px", color: "var(--v2-text-text-base)" }}>
+      {/* user (right) */}
+      <div style={{ "align-self": "flex-end", background: "var(--v2-surface-surface-raised, rgba(127,127,127,0.12))", padding: "6px 10px", "border-radius": "8px", "max-width": "80%" }}>
+        optimize an X gate on my transmon — use what you know from my history
+      </div>
+      {/* normal chat prose (full width) */}
+      <Show when={props.state !== "dormant"}>
+        <div style={{ color: "var(--v2-text-text-muted)" }}>
+          Warm-starting from <span style={{ color: "var(--v2-text-text-accent)" }}>x-gate-transmon-v5</span> (F=0.999972). Here's the plan…
+        </div>
+      </Show>
+      <Show when={props.state === "dormant"}>
+        <div style={{ color: "var(--v2-text-text-muted)" }}>The capital of France is Paris. [normal chat — Amico stays offstage]</div>
+      </Show>
+
+      {/* Amico lane */}
+      <Show when={props.state === "stepping_in" || props.state === "on"}>
+        <div class="amc-lane" classList={{ "is-stepping-in": props.state === "stepping_in" }}>
+          <div class="amc-lane-head"><AmicoMark running />{props.state === "stepping_in" ? "stepping in…" : ""}</div>
+          <Show when={props.state === "on"}>
+            <ThinkingLine tokens={2437} />
+          </Show>
+        </div>
+      </Show>
+      <Show when={props.state === "settling"}>
+        <div class="amc-lane is-settling">
+          <div class="amc-lane-head"><AmicoMark /></div>
+          <div class="amc-receipt">ran it — <span class="amc-receipt-metric">F=0.99998</span>, 412ns · <span style={{ color: "var(--v2-text-text-accent)" }}>[pulse card]</span> <span style={{ color: "var(--v2-text-text-accent)" }}>[open in inspector]</span></div>
+        </div>
+      </Show>
+    </div>
+  )
+}
+
+function Stage(props: { state: PresenceState; label?: string }) {
+  return (
+    <div style={{ "max-width": "720px", border: "1px solid var(--v2-border-border-base)", "border-radius": "10px", overflow: "hidden", "font-family": "var(--text-font, system-ui)" }}>
+      <Show when={props.label}>
+        <div style={{ padding: "4px 12px", "font-size": "11px", "letter-spacing": "0.08em", color: "var(--v2-text-text-faint)", "text-transform": "uppercase" }}>{props.label}</div>
+      </Show>
+      <MockRail state={props.state} />
+      <MockFlow state={props.state} />
+    </div>
+  )
+}
+
+export const Dormant = () => <Stage state="dormant" label="dormant · off-domain, no Amico" />
+export const SteppingIn = () => <Stage state="stepping_in" label="stepping in · rail wakes" />
+export const On = () => <Stage state="on" label="on · working, thinking line in lane" />
+export const Settling = () => <Stage state="settling" label="settling · liveness recedes, receipt stays" />
+export const Idle = () => <Stage state="idle" label="idle · rail persists, quiet" />
+
+// Auto-playing pop-in / pop-out loop so the motion is visible at a glance.
+export const FullSequence = () => {
+  const order: PresenceState[] = ["dormant", "stepping_in", "on", "on", "settling", "idle", "idle"]
+  const [i, setI] = createSignal(0)
+  onMount(() => {
+    const t = setInterval(() => setI((n) => (n + 1) % order.length), 1800)
+    onCleanup(() => clearInterval(t))
+  })
+  return (
+    <div style={{ display: "flex", "flex-direction": "column", gap: "8px" }}>
+      <div style={{ "font-size": "12px", color: "var(--v2-text-text-muted)" }}>▶ {order[i()]}</div>
+      <Stage state={order[i()]} />
+    </div>
+  )
+}
diff --git a/packages/ui/src/amicode/amico-presence.test.ts b/packages/ui/src/amicode/amico-presence.test.ts
new file mode 100644
index 0000000000..4b1de490b8
--- /dev/null
+++ b/packages/ui/src/amicode/amico-presence.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, test } from "bun:test"
+import {
+  classifyPresence,
+  transitionFor,
+  railVisible,
+  showsWorkingPresence,
+  type StablePresence,
+} from "./amico-presence"
+
+describe("classifyPresence", () => {
+  test("never engaged, off-domain -> dormant", () => {
+    expect(classifyPresence({ everEngaged: false, inDomainTurn: false, working: false })).toBe("dormant")
+    expect(classifyPresence({ everEngaged: false, inDomainTurn: false, working: true })).toBe("dormant")
+  })
+
+  test("in-domain and working -> on (regardless of prior engagement)", () => {
+    expect(classifyPresence({ everEngaged: false, inDomainTurn: true, working: true })).toBe("on")
+    expect(classifyPresence({ everEngaged: true, inDomainTurn: true, working: true })).toBe("on")
+  })
+
+  test("engaged earlier, now off-domain -> idle (NOT dormant — rail persists)", () => {
+    expect(classifyPresence({ everEngaged: true, inDomainTurn: false, working: false })).toBe("idle")
+  })
+
+  test("resolved in-domain turn (in-domain, not working) -> idle -> drives settling", () => {
+    // once a solve finishes, working flips false; the turn is engaged => idle
+    expect(classifyPresence({ everEngaged: true, inDomainTurn: true, working: false })).toBe("idle")
+  })
+})
+
+describe("transitionFor", () => {
+  const cases: Array<[StablePresence, StablePresence, "stepping_in" | "settling" | null]> = [
+    ["dormant", "on", "stepping_in"],
+    ["idle", "on", "stepping_in"],
+    ["on", "idle", "settling"],
+    ["on", "dormant", "settling"],
+    ["dormant", "idle", null],
+    ["idle", "dormant", null],
+    ["on", "on", null],
+    ["idle", "idle", null],
+  ]
+  for (const [prev, next, want] of cases) {
+    test(`${prev} -> ${next} => ${want}`, () => {
+      expect(transitionFor(prev, next)).toBe(want)
+    })
+  }
+})
+
+describe("railVisible", () => {
+  test("absent only in dormant", () => {
+    expect(railVisible("dormant")).toBe(false)
+    for (const s of ["stepping_in", "on", "settling", "idle"] as const) {
+      expect(railVisible(s)).toBe(true)
+    }
+  })
+})
+
+describe("showsWorkingPresence", () => {
+  test("only on / stepping_in", () => {
+    expect(showsWorkingPresence("on")).toBe(true)
+    expect(showsWorkingPresence("stepping_in")).toBe(true)
+    expect(showsWorkingPresence("settling")).toBe(false)
+    expect(showsWorkingPresence("idle")).toBe(false)
+    expect(showsWorkingPresence("dormant")).toBe(false)
+  })
+})
diff --git a/packages/ui/src/amicode/amico-presence.ts b/packages/ui/src/amicode/amico-presence.ts
new file mode 100644
index 0000000000..8145fd06e5
--- /dev/null
+++ b/packages/ui/src/amicode/amico-presence.ts
@@ -0,0 +1,71 @@
+// AMICODE: the Amico "presence" state machine — the shared brain the entity rail
+// and the message flow both read so they can't drift out of sync (spec
+// spec-20260712-014749-amico-third-actor). Amico is a third actor: it pops IN
+// when a turn enters its domain, works, and pops OUT — leaving the transcript
+// clean and its artifacts settled in the rail.
+//
+// Pure + DOM-free so it's unit-testable. Two pieces:
+//   classifyPresence() — the STABLE state from a snapshot of turn signals.
+//   transitionFor()    — the transient pop-in / pop-out treatment to play when
+//                        the stable state changes (STEPPING_IN / SETTLING).
+// The component holds the previous stable state, computes the next via
+// classify(), plays any transient via transitionFor(), then rests at next.
+
+export type PresenceState = "dormant" | "stepping_in" | "on" | "settling" | "idle"
+
+/** The transient (animated) states, distinct from the three stable ones. */
+export type PresenceTransition = "stepping_in" | "settling"
+
+/** The three stable states a snapshot can resolve to (transients are played
+ *  between them by the component, driven by transitionFor). */
+export type StablePresence = "dormant" | "on" | "idle"
+
+export interface PresenceSignals {
+  /** Has this session EVER engaged Amico? (any amicode_* part seen — mirrors the
+   *  rail's session-sticky `amicodeParts().any > 0`.) Distinguishes DORMANT
+   *  (rail absent) from IDLE (rail persists with settled entities). */
+  everEngaged: boolean
+  /** Does the CURRENT turn carry an amicode_* part? The only in-domain signal
+   *  observable in the UI today (spec §Domain trigger). */
+  inDomainTurn: boolean
+  /** Is the current turn still streaming/working? */
+  working: boolean
+}
+
+/**
+ * Stable presence from a snapshot of signals.
+ * - in-domain & working            -> "on"    (rail live, thinking line in flow)
+ * - engaged this session, else off -> "idle"  (rail persists, quiet)
+ * - never engaged                  -> "dormant"(rail absent; just user + chat)
+ *
+ * A resolved in-domain turn (inDomainTurn && !working) is engaged-but-not-working
+ * => "idle"; the ON->IDLE change is what makes transitionFor emit "settling".
+ */
+export function classifyPresence(signals: PresenceSignals): StablePresence {
+  if (signals.inDomainTurn && signals.working) return "on"
+  return signals.everEngaged ? "idle" : "dormant"
+}
+
+/**
+ * The transient to play when the stable state changes:
+ * - (dormant|idle) -> on   => "stepping_in"  (Amico pops in: rail wakes, presence leans in)
+ * - on -> (idle|dormant)   => "settling"     (Amico pops out: liveness recedes, artifacts settle)
+ * - anything else          => null           (no pop; e.g. dormant<->idle is silent)
+ */
+export function transitionFor(prev: StablePresence, next: StablePresence): PresenceTransition | null {
+  if (prev !== "on" && next === "on") return "stepping_in"
+  if (prev === "on" && next !== "on") return "settling"
+  return null
+}
+
+/** True while the rail should be shown at all (i.e. the session has engaged, or
+ *  is engaging now). DORMANT is the only state with no rail. */
+export function railVisible(state: PresenceState): boolean {
+  return state !== "dormant"
+}
+
+/** True while Amico's live working presence (the thinking line) belongs in the
+ *  flow — only in the ON (and its lead-in STEPPING_IN) states. */
+export function showsWorkingPresence(state: PresenceState): boolean {
+  return state === "on" || state === "stepping_in"
+}
diff --git a/packages/ui/src/amicode/amicode.css b/packages/ui/src/amicode/amicode.css
index 19ab50113e..1712a58c5c 100644
--- a/packages/ui/src/amicode/amicode.css
+++ b/packages/ui/src/amicode/amicode.css
@@ -52,6 +52,66 @@
   flex-shrink: 0;
 }
 
+/* ---- thinking line (Claude-Code-esque working indicator) ----------------- */
+/* Sits after the AMICO wordmark while a reply streams (thinking-line.tsx). The
+ * gerund word cycles + shimmers; the meta line ticks elapsed (· tokens · esc).
+ * Leading dot separates it from the wordmark. */
+.amc-thinking {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 8px;
+  min-width: 0;
+  font-size: 11px;
+  letter-spacing: 0.01em;
+  color: var(--v2-text-text-muted);
+}
+.amc-thinking::before {
+  content: "";
+  align-self: center;
+  width: 3px;
+  height: 3px;
+  border-radius: 50%;
+  background: var(--v2-border-border-base);
+  flex-shrink: 0;
+}
+.amc-thinking-word {
+  font-weight: 600;
+  white-space: nowrap;
+  color: var(--v2-text-text-accent);
+}
+/* The shimmer: a bright band sweeps across otherwise-dimmed accent text.
+ * Motion-gated — under reduced motion (or .is-still) the word is plain accent. */
+@media (prefers-reduced-motion: no-preference) {
+  .amc-thinking:not(.is-still) .amc-thinking-word {
+    color: transparent;
+    background-image: linear-gradient(
+      100deg,
+      color-mix(in srgb, var(--v2-text-text-accent) 42%, transparent) 0%,
+      color-mix(in srgb, var(--v2-text-text-accent) 42%, transparent) 38%,
+      var(--v2-text-text-accent) 50%,
+      color-mix(in srgb, var(--v2-text-text-accent) 42%, transparent) 62%,
+      color-mix(in srgb, var(--v2-text-text-accent) 42%, transparent) 100%
+    );
+    background-size: 220% 100%;
+    -webkit-background-clip: text;
+    background-clip: text;
+    animation: amc-text-shimmer 1.6s linear infinite;
+  }
+}
+@keyframes amc-text-shimmer {
+  0% { background-position: 200% 0; }
+  100% { background-position: -20% 0; }
+}
+.amc-thinking-meta {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 6px;
+  color: var(--v2-text-text-faint);
+  font-variant-numeric: tabular-nums;
+}
+.amc-thinking-sep { opacity: 0.55; }
+.amc-thinking-hint { font-style: italic; }
+
 /* ============================================================
    THE CHIP — [data-component="amicode-card"]
    ============================================================ */
@@ -361,9 +421,40 @@
   opacity: 1;
 }
 
+/* Collapsed-by-default provenance: one summary line + a show/hide toggle. */
+[data-component="amicode-entity-view"] .amc-ev-hist-head {
+  display: flex;
+  align-items: baseline;
+  gap: 10px;
+  margin: 18px 4px 0;
+}
+[data-component="amicode-entity-view"] .amc-ev-hist-summary {
+  flex: 1;
+  min-width: 0;
+  font-size: 11.5px;
+  color: var(--v2-text-text-faint);
+  overflow-wrap: anywhere;
+}
+[data-component="amicode-entity-view"] .amc-ev-hist-toggle {
+  flex-shrink: 0;
+  background: none;
+  border: none;
+  padding: 2px 4px;
+  font-size: 11.5px;
+  font-weight: 550;
+  color: var(--v2-text-text-accent);
+  cursor: pointer;
+}
+[data-component="amicode-entity-view"] .amc-ev-hist-toggle:hover { text-decoration: underline; }
+[data-component="amicode-entity-view"] .amc-ev-hist-toggle:focus-visible {
+  outline: 2px solid var(--v2-icon-icon-accent);
+  outline-offset: 2px;
+  border-radius: 4px;
+}
 [data-component="amicode-entity-view"] .amc-timeline {
   display: flex;
   flex-direction: column;
+  margin-top: 8px;
   margin-left: 6px;
   padding-left: 2px;
   border-left: 1.5px solid var(--v2-border-border-muted);
@@ -571,3 +662,233 @@
   border-color: var(--v2-border-border-strong);
   background: var(--v2-background-bg-layer-02);
 }
+
+/* ---- System hero (spec §6.1): identity + schematic + table + Hamiltonian ---- */
+[data-component="amicode-system-view"] { display: flex; flex-direction: column; gap: 12px; }
+[data-component="amicode-system-view"] .amc-sys-identity {
+  font-size: 13px;
+  font-weight: 550;
+  color: var(--v2-text-text-base);
+  padding: 2px 4px 0;
+}
+[data-component="amicode-system-view"] .amc-schematic {
+  display: flex; align-items: center; flex-wrap: wrap; gap: 4px; padding: 8px 4px;
+}
+[data-component="amicode-system-view"] .amc-node {
+  display: inline-flex; flex-direction: column; align-items: center; gap: 1px;
+  padding: 6px 12px; border-radius: 8px;
+  border: 1px solid var(--v2-border-border-base);
+  background: var(--v2-background-bg-layer-01);
+}
+[data-component="amicode-system-view"] .amc-node-id { font-weight: 600; color: var(--v2-text-text-base); }
+[data-component="amicode-system-view"] .amc-node-lvl { font-size: 0.72rem; color: var(--v2-text-text-muted); }
+[data-component="amicode-system-view"] .amc-edge {
+  display: inline-flex; flex-direction: column; align-items: center; min-width: 40px; padding: 0 4px;
+}
+[data-component="amicode-system-view"] .amc-edge-line { color: var(--v2-border-border-base); line-height: 1; }
+[data-component="amicode-system-view"] .amc-edge-label {
+  font-size: 0.7rem; letter-spacing: 0.02em; color: var(--v2-text-text-accent);
+}
+[data-component="amicode-system-view"] .amc-loose {
+  display: flex; flex-wrap: wrap; gap: 8px; font-size: 0.78rem; color: var(--v2-text-text-muted);
+}
+[data-component="amicode-system-view"] .amc-systbl { display: flex; flex-direction: column; }
+[data-component="amicode-system-view"] .amc-systbl-row {
+  display: grid; grid-template-columns: 3rem 5rem auto 1fr; gap: 8px; align-items: baseline;
+  padding: 4px 2px; border-top: 1px solid color-mix(in srgb, var(--v2-border-border-base) 55%, transparent);
+  font-variant-numeric: tabular-nums;
+}
+[data-component="amicode-system-view"] .amc-systbl-row.amc-coupling { grid-template-columns: 8rem 5rem 1fr; }
+[data-component="amicode-system-view"] .amc-c-id { font-weight: 600; color: var(--v2-text-text-base); }
+[data-component="amicode-system-view"] .amc-c-role,
+[data-component="amicode-system-view"] .amc-c-lvl { color: var(--v2-text-text-muted); font-size: 0.8rem; }
+[data-component="amicode-system-view"] .amc-c-params { color: var(--v2-text-text-base); font-size: 0.8rem; }
+[data-component="amicode-system-view"] .amc-ev-formula { margin-top: 4px; }
+[data-component="amicode-system-view"] .amc-ev-formula-label {
+  font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.06em; color: var(--v2-text-text-muted); margin-bottom: 2px;
+}
+
+/* ---- Formulation hero (spec §6.2): mode badges + objective + constraints ---- */
+[data-component="amicode-formulation-view"] { display: flex; flex-direction: column; gap: 8px; }
+[data-component="amicode-formulation-view"] .amc-modebar { display: flex; flex-wrap: wrap; gap: 6px; }
+[data-component="amicode-formulation-view"] .amc-badge {
+  display: inline-flex; align-items: baseline; gap: 4px; padding: 2px 8px; border-radius: 999px;
+  border: 1px solid var(--v2-border-border-base); background: var(--v2-background-bg-layer-01);
+  font-size: 0.76rem;
+}
+[data-component="amicode-formulation-view"] .amc-badge.active {
+  border-color: color-mix(in srgb, var(--v2-icon-icon-accent) 42%, var(--v2-border-border-base));
+  background: color-mix(in srgb, var(--v2-icon-icon-accent) 8%, var(--v2-background-bg-layer-01));
+}
+[data-component="amicode-formulation-view"] .amc-badge .k { color: var(--v2-text-text-muted); }
+[data-component="amicode-formulation-view"] .amc-badge .v { color: var(--v2-text-text-base); font-weight: 600; }
+[data-component="amicode-formulation-view"] .amc-obj { display: flex; flex-direction: column; gap: 4px; }
+[data-component="amicode-formulation-view"] .amc-obj-primary { display: flex; align-items: baseline; gap: 8px; }
+[data-component="amicode-formulation-view"] .amc-obj-name { color: var(--v2-text-text-base); font-weight: 600; }
+[data-component="amicode-formulation-view"] .amc-obj-tag {
+  font-size: 0.68rem; text-transform: uppercase; letter-spacing: 0.05em; color: var(--v2-text-text-muted);
+}
+[data-component="amicode-formulation-view"] .amc-obj-latex { margin: 2px 0; }
+[data-component="amicode-formulation-view"] .amc-obj-term,
+[data-component="amicode-formulation-view"] .amc-constraint {
+  font-size: 0.82rem; color: var(--v2-text-text-base); font-variant-numeric: tabular-nums;
+  padding: 2px 0; border-top: 1px solid color-mix(in srgb, var(--v2-border-border-base) 45%, transparent);
+}
+[data-component="amicode-formulation-view"] .amc-solve { font-size: 0.82rem; color: var(--v2-text-text-muted); font-variant-numeric: tabular-nums; }
+
+/* ---- overflow hardening: keep the entity-view dialog from bleeding past its
+   width. Grid/flex children default to min-width:auto (content-based), so a long
+   value (history notes, params) forces the content wider than the dialog and
+   clips the right edge (timestamps). Let children shrink + wrap long values. ---- */
+[data-component="amicode-entity-view"] { min-width: 0; max-width: 100%; overflow-x: hidden; }
+[data-component="amicode-entity-view"] .amc-timeline,
+[data-component="amicode-entity-view"] .amc-event,
+[data-component="amicode-entity-view"] .amc-event .erow { min-width: 0; max-width: 100%; }
+[data-component="amicode-entity-view"] .amc-event .when { white-space: nowrap; }
+[data-component="amicode-entity-view"] .amc-event .summary,
+[data-component="amicode-entity-view"] .amc-event .summary .v { overflow-wrap: anywhere; min-width: 0; }
+[data-component="amicode-system-view"] .amc-systbl-row > * { min-width: 0; }
+[data-component="amicode-system-view"] .amc-c-params,
+[data-component="amicode-system-view"] .amc-loose,
+[data-component="amicode-formulation-view"] .amc-obj-latex,
+[data-component="amicode-formulation-view"] .amc-obj-term,
+[data-component="amicode-formulation-view"] .amc-constraint,
+[data-component="amicode-formulation-view"] .amc-solve { overflow-wrap: anywhere; min-width: 0; }
+[data-component="amicode-system-view"] .amc-schematic,
+[data-component="amicode-formulation-view"] .amc-modebar { max-width: 100%; }
+[data-component="amicode-system-view"] .amc-ev-formula,
+[data-component="amicode-formulation-view"] .amc-obj-latex { overflow-x: auto; }
+
+/* ---- Widget grid edit mode (spec T3.1/T2.6) ------------------------------
+   Rebuilt for clarity: instead of a heavy row of buttons floating above each
+   card (which reads as its own UI and drowns the content), the cards stay
+   visible and a light scrim + dashed ring signal "you're arranging, not
+   using". A single grouped control pill floats in each card's top-right
+   corner. Overlaying host DOM over an iframe is safe for CLICKS — only a
+   click-drag THROUGH the frame gets eaten, and reorder here is button-based.
+   The scrim also intercepts pointer events so the widget beneath can't be
+   clicked while arranging. ------------------------------------------------- */
+[data-component="amicode-widget-cell"] { position: relative; }
+.amc-wg-framewrap { position: relative; border-radius: 10px; transition: outline-color 0.16s ease; }
+[data-component="amicode-widget-cell"][data-editing="true"] .amc-wg-framewrap {
+  outline: 1px dashed var(--v2-border-border-base);
+  outline-offset: 3px;
+}
+.amc-wg-scrim {
+  position: absolute; inset: 0; z-index: 1; border-radius: 10px; cursor: default;
+  background: color-mix(in srgb, var(--v2-background-bg-base) 44%, transparent);
+}
+.amc-wg-name {
+  position: absolute; top: 9px; left: 11px; z-index: 2; pointer-events: none;
+  font-size: 11px; font-weight: 600; color: var(--v2-text-text-base);
+  text-shadow: 0 1px 4px color-mix(in srgb, var(--v2-background-bg-base) 85%, transparent);
+  max-width: 55%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
+.amc-wg-name .amc-wg-empty { color: var(--v2-text-text-faint); font-weight: 500; margin-left: 4px; }
+.amc-wg-pill {
+  position: absolute; top: 7px; right: 7px; z-index: 2;
+  display: flex; align-items: center; gap: 1px; padding: 3px;
+  border-radius: 9px; background: var(--v2-background-bg-layer-01);
+  border: 1px solid var(--v2-border-border-base);
+  box-shadow: 0 3px 12px color-mix(in srgb, var(--v2-background-bg-base) 70%, transparent);
+}
+.amc-wg-pill button {
+  display: inline-flex; align-items: center; justify-content: center;
+  min-width: 24px; height: 24px; padding: 0 5px;
+  border: none; background: transparent; border-radius: 6px;
+  color: var(--v2-text-text-muted); font-size: 12px; line-height: 1; cursor: pointer;
+}
+.amc-wg-pill button:hover:not(:disabled) {
+  background: var(--v2-background-bg-layer-02); color: var(--v2-text-text-base);
+}
+.amc-wg-pill button:disabled { opacity: 0.28; cursor: default; }
+.amc-wg-pill .amc-wg-danger:hover:not(:disabled) { color: var(--v2-state-fg-danger); }
+.amc-wg-pill .amc-wg-fork { font-size: 10px; letter-spacing: 0.02em; color: var(--v2-text-text-faint); }
+.amc-wg-pill .amc-wg-sep { width: 1px; height: 14px; background: var(--v2-border-border-base); margin: 0 3px; flex: 0 0 auto; }
+
+[data-component="amicode-widget-editbar"] {
+  display: flex; align-items: center; gap: 6px; flex-wrap: wrap;
+  padding: 8px 12px; border-radius: 9px;
+  border: 1px solid color-mix(in srgb, var(--v2-icon-icon-accent) 30%, var(--v2-border-border-base));
+  background: color-mix(in srgb, var(--v2-icon-icon-accent) 7%, var(--v2-background-bg-layer-01));
+  font-size: 11px; color: var(--v2-text-text-muted);
+}
+[data-component="amicode-widget-editbar"] b { color: var(--v2-text-text-base); font-weight: 600; }
+[data-component="amicode-widget-editbar"] .amc-wg-editdone {
+  margin-left: auto; border: 1px solid var(--v2-border-border-base); border-radius: 6px;
+  background: var(--v2-background-bg-layer-02); color: var(--v2-text-text-base);
+  font-size: 11px; padding: 3px 12px; cursor: pointer;
+}
+[data-component="amicode-widget-editbar"] .amc-wg-editdone:hover { border-color: var(--v2-border-border-strong); }
+
+.amc-wg-placeholder {
+  display: flex; align-items: center; min-height: 68px;
+  border: 1px dashed var(--v2-border-border-base); border-radius: 10px;
+  background: var(--v2-background-bg-layer-01);
+  padding: 10px 12px; font-size: 11px; color: var(--v2-text-text-faint);
+}
+
+[data-component="amicode-widget-tray"] { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; }
+[data-component="amicode-widget-tray"] .amc-wg-traylabel { font-size: 10px; letter-spacing: 0.04em; text-transform: uppercase; color: var(--v2-text-text-faint); }
+[data-component="amicode-widget-tray"] .amc-wg-add {
+  border: 1px solid var(--v2-border-border-base); border-radius: 999px;
+  background: var(--v2-background-bg-layer-01); color: var(--v2-text-text-muted);
+  font-size: 11px; padding: 3px 11px; cursor: pointer;
+}
+[data-component="amicode-widget-tray"] .amc-wg-add:hover {
+  border-color: var(--v2-border-border-strong); color: var(--v2-text-text-base);
+}
+
+/* ---- In-chat widget preview (Stage 2 chat authoring) --------------------- */
+[data-component="amicode-widget-preview"] {
+  display: flex; flex-direction: column; gap: 8px;
+  border: 1px solid var(--v2-border-border-base); border-radius: 12px;
+  background: var(--v2-background-bg-layer-01); padding: 10px 12px; max-width: 100%;
+}
+[data-component="amicode-widget-preview"] .amc-wp-head {
+  display: flex; align-items: baseline; gap: 8px; min-width: 0;
+}
+[data-component="amicode-widget-preview"] .amc-wp-eyebrow {
+  font-size: 10px; letter-spacing: 0.08em; text-transform: uppercase; color: var(--v2-text-text-faint);
+}
+[data-component="amicode-widget-preview"] .amc-wp-name {
+  font-size: 12px; font-weight: 600; color: var(--v2-text-text-base);
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap; flex: 1; min-width: 0;
+}
+[data-component="amicode-widget-preview"] .amc-wp-badge {
+  font-size: 10px; color: var(--v2-text-text-muted);
+  border: 1px solid var(--v2-border-border-base); border-radius: 999px; padding: 1px 7px;
+}
+[data-component="amicode-widget-preview"] .amc-wp-stage {
+  border-radius: 10px; overflow: hidden;
+  /* faint checker so a widget's own transparent areas read as "canvas" */
+  background:
+    repeating-linear-gradient(45deg,
+      color-mix(in srgb, var(--v2-background-bg-base) 40%, transparent) 0 6px,
+      transparent 6px 12px);
+}
+[data-component="amicode-widget-preview"] .amc-wp-note,
+[data-component="amicode-widget-preview"] .amc-wp-hint {
+  font-size: 11px; color: var(--v2-text-text-faint);
+}
+[data-component="amicode-widget-preview"] .amc-wp-warnings {
+  margin: 0; padding-left: 16px; font-size: 11px; color: var(--v2-state-fg-warning);
+}
+[data-component="amicode-widget-preview"] .amc-wp-foot {
+  display: flex; align-items: center; gap: 10px; flex-wrap: wrap;
+}
+[data-component="amicode-widget-preview"] .amc-wp-pin {
+  border: 1px solid color-mix(in srgb, var(--v2-icon-icon-accent) 40%, var(--v2-border-border-base));
+  border-radius: 7px; background: color-mix(in srgb, var(--v2-icon-icon-accent) 12%, var(--v2-background-bg-layer-02));
+  color: var(--v2-text-text-base); font-size: 11px; font-weight: 600; padding: 4px 12px; cursor: pointer;
+}
+[data-component="amicode-widget-preview"] .amc-wp-pin:hover:not(:disabled) {
+  background: color-mix(in srgb, var(--v2-icon-icon-accent) 20%, var(--v2-background-bg-layer-02));
+}
+[data-component="amicode-widget-preview"] .amc-wp-pin:disabled { cursor: default; }
+[data-component="amicode-widget-preview"] .amc-wp-pin[data-state="pinned"] {
+  color: var(--v2-state-fg-success);
+  border-color: color-mix(in srgb, var(--v2-state-fg-success) 40%, var(--v2-border-border-base));
+  background: transparent;
+}
+[data-component="amicode-widget-preview"] .amc-wp-pin[data-state="error"] { color: var(--v2-state-fg-danger); }
diff --git a/packages/ui/src/amicode/ask-card.tsx b/packages/ui/src/amicode/ask-card.tsx
index 71b224a6c6..a0b2cb9fff 100644
--- a/packages/ui/src/amicode/ask-card.tsx
+++ b/packages/ui/src/amicode/ask-card.tsx
@@ -52,9 +52,7 @@ export function AmicodeAskCard(props: { ask: AskInput; messageID?: string; sessi
       <div style={{ display: "flex", "align-items": "center", gap: "8px" }}>
         <span class="amc-sig">
           <AmicoMark />
-          <span class="amc-wordmark">AMICO</span>
         </span>
-        <span style={{ color: "var(--v2-text-text-faint)" }}>·</span>
         <span style={{ "font-weight": "600", color: "var(--v2-text-text-base)" }}>Question</span>
       </div>
       <div data-slot="amicode-ask-question" style={{ "font-size": "13px", color: "var(--v2-text-text-base)" }}>
diff --git a/packages/ui/src/amicode/card.tsx b/packages/ui/src/amicode/card.tsx
index 1a021051de..0d59e90343 100644
--- a/packages/ui/src/amicode/card.tsx
+++ b/packages/ui/src/amicode/card.tsx
@@ -3,9 +3,13 @@ import { amicodeStage } from "./stage"
 import { parseAskInput } from "./ask"
 import { AmicodeAskCard } from "./ask-card"
 import { parseDiffSentinel, receiptParts } from "./receipt"
+import { systemReceiptPieces, formulationReceiptPieces } from "./facets"
+import { compositeChip, chipText } from "./problem"
 import { AmicoMark } from "./spinner"
 import { openAmicodeEntity } from "./ui-bridge"
 import { RunWindow } from "./run-window"
+import { parseWidgetSentinel } from "./widget-preview"
+import { WidgetPreviewCard } from "./widget-preview-card"
 
 // spec C: when an amicode_solve recorded a run_dir, its sentinel carries the
 // path (well under the 120-char truncation cap) — extract lab/run_id from the
@@ -62,6 +66,27 @@ function Chip(props: { tool: string; status?: string; output?: string }) {
             : { key: change.key, from: change.from, to: change.to },
       ) ?? [],
   )
+  // Hero entities (system, formulation): a semantic receipt (spec §5) instead of
+  // JSON pieces — a post-state chip on creation/large/elided, else a delta.
+  const heroReceipt = createMemo(() => {
+    const p = parts()
+    if (!p) return undefined
+    if (p.sentinel.entity === "system") return systemReceiptPieces(p.sentinel.diff)
+    if (p.sentinel.entity === "formulation") return formulationReceiptPieces(p.sentinel.diff)
+    return undefined
+  })
+  const heroChip = createMemo(() => {
+    const p = parts()
+    const sr = heroReceipt()
+    if (!p || sr?.kind !== "chip") return undefined
+    return p.sentinel.entity === "system"
+      ? (compositeChip(sr.entity) ?? "updated")
+      : (chipText(p.sentinel.entity, sr.entity) ?? "updated")
+  })
+  const heroPieces = createMemo(() => {
+    const sr = heroReceipt()
+    return sr?.kind === "pieces" ? sr.pieces : undefined
+  })
   const state = () =>
     errored() ? "error" : running() ? "running" : parts() ? "receipt" : props.status === "completed" ? "done" : "idle"
   const openLabel = () => `Open ${parts()?.receipt.label ?? stage()} details`
@@ -74,10 +99,12 @@ function Chip(props: { tool: string; status?: string; output?: string }) {
   // (<div>) shells. Split so the shell can be a real button only when there is
   // an entity to open — a bare <button> would inherit type="submit" and fire
   // the composer form; a plain onClick <div> would be invisible to the keyboard.
+  // amicode: the "AMICO" wordmark is gone from cards — identity lives in the
+  // entity rail now (spec-20260712-amico-third-actor). The H-mark stays as a
+  // subtle leading glyph so a de-stamped card still reads as Amico's work.
   const Sig = () => (
     <span class="amc-sig">
       <AmicoMark running={running()} />
-      <span class="amc-wordmark">AMICO</span>
     </span>
   )
   const Body = () => (
@@ -103,22 +130,46 @@ function Chip(props: { tool: string; status?: string; output?: string }) {
       {(active) => (
         <span class="amc-body" data-slot="amicode-card-receipt">
           <span class="amc-label">{active().receipt.label}</span>
-          <For each={diffPieces()}>
-            {(piece) => (
-              <span class="amc-diff">
-                <span class="k">{piece.key}</span>
-                <Show when={piece.from !== undefined}>
-                  <span class="v from">{piece.from}</span>
-                  <span class="arw" aria-hidden="true">
-                    →
+          <Show
+            when={heroReceipt()}
+            fallback={
+              <For each={diffPieces()}>
+                {(piece) => (
+                  <span class="amc-diff">
+                    <span class="k">{piece.key}</span>
+                    <Show when={piece.from !== undefined}>
+                      <span class="v from">{piece.from}</span>
+                      <span class="arw" aria-hidden="true">
+                        →
+                      </span>
+                    </Show>
+                    <Show when={piece.to !== undefined}>
+                      <span class="v">{piece.to}</span>
+                    </Show>
                   </span>
-                </Show>
-                <Show when={piece.to !== undefined}>
-                  <span class="v">{piece.to}</span>
-                </Show>
-              </span>
-            )}
-          </For>
+                )}
+              </For>
+            }
+          >
+            <Show
+              when={heroChip()}
+              fallback={
+                <For each={heroPieces()}>
+                  {(p) => (
+                    <span class="amc-diff" data-tone={p.tone}>
+                      <span class="v">{p.text}</span>
+                    </span>
+                  )}
+                </For>
+              }
+            >
+              {(chip) => (
+                <span class="amc-diff">
+                  <span class="v">{chip()}</span>
+                </span>
+              )}
+            </Show>
+          </Show>
         </span>
       )}
     </Show>
@@ -189,6 +240,9 @@ export function AmicodeToolCard(props: {
 }) {
   const ask = createMemo(() => (props.tool === "amicode_ask" ? parseAskInput(props.input) : undefined))
   const runRef = createMemo(() => (props.tool === "amicode_solve" ? runRefFromOutput(props.output) : undefined))
+  const authored = createMemo(() =>
+    props.tool === "amicode_author_widget" ? parseWidgetSentinel(props.output) : undefined,
+  )
 
   return (
     <Switch fallback={<Chip tool={props.tool} status={props.status} output={props.output} />}>
@@ -196,6 +250,7 @@ export function AmicodeToolCard(props: {
         {(value) => <AmicodeAskCard ask={value()} messageID={props.messageID} sessionID={props.sessionID} />}
       </Match>
       <Match when={runRef()}>{(ref) => <RunWindow run={ref().run} lab={ref().lab} />}</Match>
+      <Match when={authored()}>{(preview) => <WidgetPreviewCard preview={preview()} />}</Match>
     </Switch>
   )
 }
diff --git a/packages/ui/src/amicode/entity-rail.tsx b/packages/ui/src/amicode/entity-rail.tsx
index 125b4968c5..286589eb6a 100644
--- a/packages/ui/src/amicode/entity-rail.tsx
+++ b/packages/ui/src/amicode/entity-rail.tsx
@@ -2,7 +2,7 @@ import { For, Show, createEffect, createMemo, createResource, createSignal, onCl
 import { hasUserReplyAfter } from "./ask"
 import { registerAmicodeAskBridge } from "./ask-bridge"
 import { AmicoMark } from "./spinner"
-import { registerAmicodeUiBridge } from "./ui-bridge"
+import { registerAmicodeUiBridge, type AmicodeWidgetHost } from "./ui-bridge"
 import {
   type ProblemView,
   type RunStatusView,
@@ -47,6 +47,9 @@ export function AmicodeEntityRail(props: {
   fetchProblem: () => Promise<unknown>
   fetchRunStatus: () => Promise<unknown>
   fetchRunSeries?: (run: string, lab?: string) => Promise<unknown>
+  // Stage 2: transport for the in-chat widget preview (frame src + host
+  // callbacks + pin). Optional so hosts that can't render widgets omit it.
+  widgetHost?: AmicodeWidgetHost
   onOpenEntity: (kind: string, seq?: number) => void
   onOpenSwitcher: () => void
   onAsk?: (text: string) => void
@@ -68,6 +71,7 @@ export function AmicodeEntityRail(props: {
     openEntity: (kind, seq) => props.onOpenEntity(kind, seq),
     openSwitcher: () => props.onOpenSwitcher(),
     fetchRunSeries: props.fetchRunSeries,
+    widgetHost: props.widgetHost,
   })
   onCleanup(disposeUiBridge)
 
diff --git a/packages/ui/src/amicode/entity-view.tsx b/packages/ui/src/amicode/entity-view.tsx
index d6b14cb001..4e93f42849 100644
--- a/packages/ui/src/amicode/entity-view.tsx
+++ b/packages/ui/src/amicode/entity-view.tsx
@@ -1,8 +1,9 @@
-import { For, Show, createMemo } from "solid-js"
-import katex from "katex"
+import { For, Show, createMemo, createSignal } from "solid-js"
 import { AmicoMark } from "./spinner"
 import { receiptParts } from "./receipt"
-import { type ProblemView, editPromptText, entityRows, fieldGroup, historyRows, humanizeKey } from "./problem"
+import { type ProblemView, editPromptText, entityRows, fieldGroup, formatTs, historyRows, humanizeKey } from "./problem"
+import { SystemComposite } from "./system-view"
+import { FormulationView } from "./formulation-view"
 
 // AMICODE ring-2 entity view (spec B): dialog BODY opened from a rail chip or
 // diff receipt — current fields (pretty table + per-field "Edit in chat"
@@ -19,17 +20,15 @@ import { type ProblemView, editPromptText, entityRows, fieldGroup, historyRows,
 // edit-in-chat contract so the absence of Save buttons reads as intent. Styling
 // is in ./amicode.css; data-slot hooks are preserved for the e2e suite.
 
-// Known-platform Hamiltonians, rendered via the fork's existing katex (same
-// dep marked.tsx uses). Unknown platform → no math block.
-const HAMILTONIAN_LATEX: Record<string, string> = {
-  transmon:
-    "\\hat H = \\omega \\hat a^\\dagger \\hat a + \\tfrac{\\delta}{2}\\hat a^\\dagger \\hat a^\\dagger \\hat a \\hat a + u(t)(\\hat a + \\hat a^\\dagger)",
-  rydberg:
-    "\\hat H = \\tfrac{\\Omega(t)}{2}\\sum_i \\sigma_x^{(i)} - \\Delta(t)\\sum_i \\hat n_i + \\sum_{i<j} \\tfrac{C_6}{r_{ij}^6}\\hat n_i \\hat n_j",
-}
+// (System Hamiltonian LaTeX now lives in ./system-view.tsx's SystemComposite.)
 
 type DiffPiece = { key: string; from?: string; to?: string }
 
+// Freeform `notes` are long prose paragraphs — pure noise in a one-line history
+// diff. Drop them from the event pieces (they live in the current fields, not
+// the change log).
+const isNotesKey = (key: string) => key === "notes" || key.endsWith(".notes")
+
 // One event's change list, keys humanized, rendered as discrete pieces. Empty
 // diff → the bare action (e.g. "Created").
 function eventPieces(
@@ -38,13 +37,15 @@ function eventPieces(
   diff?: Record<string, { from: unknown; to: unknown }>,
 ): DiffPiece[] {
   const { changes } = receiptParts({ problem: "", entity, action, diff: diff ?? {} })
-  return changes.map((change) =>
-    change.kind === "elision"
-      ? { key: "…" }
-      : change.kind === "set"
-        ? { key: humanizeKey(change.key), to: change.to }
-        : { key: humanizeKey(change.key), from: change.from, to: change.to },
-  )
+  return changes
+    .filter((change) => change.kind === "elision" || !isNotesKey(change.key))
+    .map((change) =>
+      change.kind === "elision"
+        ? { key: "…" }
+        : change.kind === "set"
+          ? { key: humanizeKey(change.key), to: change.to }
+          : { key: humanizeKey(change.key), from: change.from, to: change.to },
+    )
 }
 
 export function AmicodeEntityView(props: {
@@ -99,19 +100,26 @@ export function AmicodeEntityView(props: {
     })
   })
   const latestTs = createMemo(() => history()[0]?.ts)
+  // History is collapsed by default (it was the card's biggest noise source) —
+  // but auto-expand when the view was opened from a specific diff (anchorSeq),
+  // so "jump to the change I clicked" still works.
+  const [showHistory, setShowHistory] = createSignal(props.anchorSeq !== undefined)
+  const historySummary = createMemo(() => {
+    const events = history()
+    const n = events.length
+    if (n === 0) return ""
+    const created = events[n - 1]?.ts
+    const latest = events[0]?.ts
+    if (n === 1) return created ? `Set ${formatTs(created)}` : "1 update"
+    const setPart = created ? `Set ${formatTs(created)}` : ""
+    const lastPart = latest ? `last changed ${formatTs(latest)}` : ""
+    return [setPart, lastPart, `${n} updates`].filter(Boolean).join(" · ")
+  })
   const runTier = createMemo(() => {
     if (props.kind !== "run" || !props.view) return undefined
     const refs = props.view.runs
     return refs.length > 0 ? (refs[refs.length - 1].tier ?? "vetted") : undefined
   })
-  const hamiltonian = createMemo(() => {
-    if (props.kind !== "system") return undefined
-    const platform = entity().platform
-    if (typeof platform !== "string") return undefined
-    const latex = HAMILTONIAN_LATEX[platform]
-    if (!latex) return undefined
-    return katex.renderToString(latex, { throwOnError: false })
-  })
 
   return (
     <div class="flex flex-col" data-component="amicode-entity-view" data-kind={props.kind}>
@@ -148,22 +156,24 @@ export function AmicodeEntityView(props: {
                     </span>
                   )}
                 </Show>
-                <Show when={latestTs()}>{(ts) => <span>Updated {ts()}</span>}</Show>
+                <Show when={latestTs()}>{(ts) => <span>Updated {formatTs(ts())}</span>}</Show>
               </div>
             </Show>
 
-            <Show when={hamiltonian()}>
-              {(html) => (
-                <div class="amc-ev-formula" data-slot="amicode-entity-hamiltonian">
-                  <div class="amc-ev-formula-label">Hamiltonian</div>
-                  <div innerHTML={html()} />
-                </div>
-              )}
+            <Show when={props.kind === "system"}>
+              <SystemComposite entity={entity()} />
+            </Show>
+            <Show when={props.kind === "formulation"}>
+              <FormulationView entity={entity()} />
             </Show>
 
             <Show
-              when={fieldRows().length > 0}
-              fallback={<div class="amc-ev-empty">No fields recorded yet.</div>}
+              when={props.kind !== "system" && props.kind !== "formulation" && fieldRows().length > 0}
+              fallback={
+                props.kind === "system" || props.kind === "formulation" ? null : (
+                  <div class="amc-ev-empty">No fields recorded yet.</div>
+                )
+              }
             >
               <div class="amc-ev-sec">Details</div>
               <div class="flex flex-col" data-slot="amicode-entity-fields">
@@ -200,7 +210,21 @@ export function AmicodeEntityView(props: {
             </Show>
 
             <Show when={history().length > 0}>
-              <div class="amc-ev-sec">History</div>
+              <div class="amc-ev-hist-head">
+                <span class="amc-ev-hist-summary" data-slot="amicode-entity-history-summary">
+                  {historySummary()}
+                </span>
+                <button
+                  type="button"
+                  class="amc-ev-hist-toggle"
+                  data-slot="amicode-entity-history-toggle"
+                  aria-expanded={showHistory()}
+                  onClick={() => setShowHistory((value) => !value)}
+                >
+                  {showHistory() ? "Hide history" : "Show history"}
+                </button>
+              </div>
+              <Show when={showHistory()}>
               <div class="amc-timeline" data-slot="amicode-entity-history">
                 <For each={history()}>
                   {(event) => (
@@ -214,10 +238,7 @@ export function AmicodeEntityView(props: {
                     >
                       <div class="erow">
                         <span class="seq">#{event.seq}</span>
-                        <Show when={event.source?.tool ?? event.source?.stage}>
-                          {(source) => <span class="src">{source()}</span>}
-                        </Show>
-                        <Show when={event.ts}>{(ts) => <span class="when">{ts()}</span>}</Show>
+                        <Show when={event.ts}>{(ts) => <span class="when">{formatTs(ts())}</span>}</Show>
                       </div>
                       <div class="summary">
                         <Show
@@ -251,6 +272,7 @@ export function AmicodeEntityView(props: {
                   )}
                 </For>
               </div>
+              </Show>
             </Show>
 
             <div class="amc-ev-foot">
diff --git a/packages/ui/src/amicode/facets.test.ts b/packages/ui/src/amicode/facets.test.ts
new file mode 100644
index 0000000000..2587beaaf3
--- /dev/null
+++ b/packages/ui/src/amicode/facets.test.ts
@@ -0,0 +1,152 @@
+import { describe, it, expect } from "bun:test"
+import { compactValue, setDiff, modeBadges, systemReceiptPieces, formulationReceiptPieces, formatSci } from "./facets"
+
+const byKind = (t: { kind: string; label?: string }, i: number) => `${t.kind}:${t.label ?? i}`
+
+describe("formatSci", () => {
+  it("renders integer π-multiples as Nπ (drive/detuning bounds)", () => {
+    expect(formatSci(125.66370614359172)).toBe("40π") // 40π
+    expect(formatSci(62.83185307179586)).toBe("20π") // 20π
+    expect(formatSci(Math.PI)).toBe("π")
+    expect(formatSci(-Math.PI)).toBe("-π")
+  })
+  it("trims non-π values to ~4 significant figures", () => {
+    expect(formatSci(0.2)).toBe("0.2")
+    expect(formatSci(28.9)).toBe("28.9")
+    expect(formatSci(0.005)).toBe("0.005")
+    expect(formatSci(4.83729)).toBe("4.837")
+  })
+  it("handles 0 and non-finite defensively", () => {
+    expect(formatSci(0)).toBe("0")
+    expect(formatSci(NaN)).toBe("NaN")
+  })
+})
+
+describe("compactValue", () => {
+  it("passes scalars through unchanged", () => {
+    expect(compactValue("gate")).toBe("gate")
+    expect(compactValue(3)).toBe("3")
+    expect(compactValue(true)).toBe("true")
+  })
+  it("renders null/undefined as em-dash", () => {
+    expect(compactValue(null)).toBe("—")
+    expect(compactValue(undefined)).toBe("—")
+  })
+  it("summarizes arrays by count + head, never raw JSON", () => {
+    const out = compactValue([{ id: "q1" }, { id: "q2" }, { id: "q3" }, { id: "q4" }])
+    expect(out).not.toContain("{") // no JSON blob
+    expect(out).toContain("4") // count present
+    expect(out).toContain("q1") // head label present
+  })
+  it("summarizes objects compactly, never raw JSON", () => {
+    const out = compactValue({ arch: "global", n: 2 })
+    expect(out).not.toContain('"') // no JSON quotes
+    expect(out).toContain("arch")
+  })
+})
+
+describe("setDiff", () => {
+  it("detects added / removed by unique key", () => {
+    const d = setDiff([{ kind: "reg_u" }], [{ kind: "reg_u" }, { kind: "reg_du" }], byKind)
+    expect(d.added.map((x) => x.kind)).toEqual(["reg_du"])
+    expect(d.removed).toEqual([])
+  })
+  it("does NOT collide two same-kind terms (label disambiguates)", () => {
+    const from = [{ kind: "custom", label: "a" }, { kind: "custom", label: "b" }]
+    const to = [{ kind: "custom", label: "a" }]
+    const d = setDiff(from, to, byKind)
+    expect(d.removed).toEqual([{ kind: "custom", label: "b" }])
+    expect(d.added).toEqual([])
+  })
+  it("reports per-field changes for matched keys", () => {
+    const d = setDiff([{ kind: "reg_u", params: { R: 1e-4 } }], [{ kind: "reg_u", params: { R: 1e-5 } }], byKind)
+    expect(d.changed).toHaveLength(1)
+    expect(d.changed[0].changes[0]).toMatchObject({ field: "params.R", from: 1e-4, to: 1e-5 })
+  })
+})
+
+describe("modeBadges", () => {
+  const full = {
+    trajectory_type: "gate",
+    time_mode: "min_time",
+    parameterization: "cubic_spline",
+    robustness: { kind: "ensemble" },
+    free_phase: true,
+    leakage: false,
+  }
+  it("emits type / time / param / robustness / flag badges", () => {
+    const b = modeBadges(full)
+    const has = (pred: (x: { label: string; value: string }) => boolean) => b.some(pred)
+    expect(has((x) => x.label === "type" && x.value === "gate")).toBe(true)
+    expect(has((x) => /min.?time/.test(x.value + x.label))).toBe(true)
+    expect(has((x) => x.value === "ensemble")).toBe(true)
+    expect(has((x) => /free.?phase/.test(x.label))).toBe(true)
+  })
+  it("omits false flags, none-robustness, and fixed time", () => {
+    const b = modeBadges({ trajectory_type: "ket", time_mode: "fixed", robustness: { kind: "none" }, free_phase: false, leakage: false })
+    expect(b.some((x) => /leakage/.test(x.label))).toBe(false)
+    expect(b.some((x) => /robust/.test(x.label))).toBe(false)
+    expect(b.some((x) => /min.?time/.test(x.value + x.label))).toBe(false)
+  })
+})
+
+describe("systemReceiptPieces", () => {
+  it("creation (components.from empty) → chip mode with a reconstructed entity", () => {
+    const r = systemReceiptPieces({
+      platform: { from: null, to: "transmon" },
+      components: { from: null, to: [{ id: "q1", role: "qubit", levels: 3 }, { id: "q2", role: "qubit", levels: 3 }] },
+      "drive.arch": { from: null, to: "per-component" },
+    })
+    expect(r.kind).toBe("chip")
+    if (r.kind === "chip") {
+      expect(Array.isArray(r.entity.components)).toBe(true)
+      expect((r.entity.drive as { arch: string }).arch).toBe("per-component")
+    }
+  })
+  it("add-component → a '+ q2' piece", () => {
+    const r = systemReceiptPieces({
+      components: { from: [{ id: "q1", role: "qubit", levels: 3 }], to: [{ id: "q1", role: "qubit", levels: 3 }, { id: "q2", role: "qubit", levels: 3 }] },
+    })
+    expect(r.kind).toBe("pieces")
+    if (r.kind === "pieces") expect(r.pieces.some((p) => p.text.includes("+ q2") && p.tone === "add")).toBe(true)
+  })
+  it("param-change → a 'q1 delta …→…' change piece", () => {
+    const r = systemReceiptPieces({
+      components: { from: [{ id: "q1", role: "qubit", params: { delta: -0.2 } }], to: [{ id: "q1", role: "qubit", params: { delta: -0.25 } }] },
+    })
+    expect(r.kind).toBe("pieces")
+    if (r.kind === "pieces") expect(r.pieces.some((p) => p.text.includes("q1") && p.text.includes("delta") && p.tone === "change")).toBe(true)
+  })
+  it("elided set key (…) → chip mode", () => {
+    const r = systemReceiptPieces({ "…": { from: null, to: "2 more fields" }, "drive.arch": { from: "global", to: "zoned" } })
+    expect(r.kind).toBe("chip")
+  })
+})
+
+describe("formulationReceiptPieces", () => {
+  it("creation (trajectory_type.from null) → chip mode", () => {
+    const r = formulationReceiptPieces({
+      trajectory_type: { from: null, to: "gate" },
+      time_mode: { from: null, to: "min_time" },
+      target: { from: null, to: "CZ" },
+    })
+    expect(r.kind).toBe("chip")
+  })
+  it("mode transition → 'type: ket → gate'", () => {
+    const r = formulationReceiptPieces({ trajectory_type: { from: "ket", to: "gate" } })
+    expect(r.kind).toBe("pieces")
+    if (r.kind === "pieces") expect(r.pieces.some((p) => /type: ket → gate/.test(p.text))).toBe(true)
+  })
+  it("flag add → '+ free-phase'", () => {
+    const r = formulationReceiptPieces({ free_phase: { from: false, to: true } })
+    expect(r.kind).toBe("pieces")
+    if (r.kind === "pieces") expect(r.pieces.some((p) => p.text === "+ free-phase" && p.tone === "add")).toBe(true)
+  })
+  it("added constraint → '+ …' via setDiff", () => {
+    const r = formulationReceiptPieces({
+      constraints: { from: [], to: [{ kind: "leakage_c", label: "leakage ≤1e-3" }] },
+    })
+    expect(r.kind).toBe("pieces")
+    if (r.kind === "pieces") expect(r.pieces.some((p) => p.text.includes("+ leakage ≤1e-3") && p.tone === "add")).toBe(true)
+  })
+})
diff --git a/packages/ui/src/amicode/facets.ts b/packages/ui/src/amicode/facets.ts
new file mode 100644
index 0000000000..4b97e875e4
--- /dev/null
+++ b/packages/ui/src/amicode/facets.ts
@@ -0,0 +1,244 @@
+// facets.ts — pure, dependency-free rendering helpers for the amicode entity
+// visualization language (spec-20260709 §4). No SolidJS, no imports.
+
+/** Physicists' number formatter for display. Drive/detuning bounds are integer
+ *  multiples of π, so 125.66370614359172 → "40π", 62.83… → "20π"; other values
+ *  trim to ~4 significant figures with trailing zeros dropped (0.2 → "0.2",
+ *  28.9 → "28.9"). Keeps the full float out of chips, tables, and history. */
+export function formatSci(value: number): string {
+  if (!Number.isFinite(value)) return String(value)
+  if (value === 0) return "0"
+  const ratio = value / Math.PI
+  const n = Math.round(ratio)
+  if (n !== 0 && Math.abs(ratio - n) < 1e-6) return n === 1 ? "π" : n === -1 ? "-π" : `${n}π`
+  return String(Number(value.toPrecision(4)))
+}
+
+/** Array/object-aware compact renderer. Replaces the JSON.stringify branch that
+ *  the old short()/shortValue() used, so a components[]/constraints[] value never
+ *  becomes a raw blob. Scalars pass through; arrays → "N items" (+ head id/kind if
+ *  present); objects → compact "k:v · k:v" (first few keys). Never throws. */
+export function compactValue(value: unknown): string {
+  if (value === null || value === undefined) return "—"
+  if (typeof value === "string") return value
+  if (typeof value === "number" || typeof value === "boolean") return String(value)
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "none"
+    const head = value
+      .slice(0, 3)
+      .map((v) => (v && typeof v === "object" ? headLabel(v as Record<string, unknown>) : String(v)))
+      .filter(Boolean)
+      .join(", ")
+    return value.length <= 3 ? head : `${value.length} items (${head}…)`
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .slice(0, 3)
+      .map(([k, v]) => `${k}:${typeof v === "object" ? "…" : String(v)}`)
+    return entries.join(" · ") || "{}"
+  }
+  return "—"
+}
+
+/** Best label for one object in an array: id → kind → between → first string field. */
+function headLabel(o: Record<string, unknown>): string {
+  for (const k of ["id", "kind", "between", "name"]) {
+    const v = o[k]
+    if (typeof v === "string" && v) return v
+    if (Array.isArray(v) && v.length) return v.map(String).join("↔")
+  }
+  return "item"
+}
+
+export type FieldChange = { field: string; from: unknown; to: unknown }
+export type SetDiff<T> = { added: T[]; removed: T[]; changed: { key: string; item: T; changes: FieldChange[] }[] }
+
+/** Set delta by a UNIQUE key (keyFn MUST be unique within the set — for
+ *  objectives/constraints use `kind:(label??index)`; kind alone collides). */
+export function setDiff<T>(from: T[], to: T[], keyFn: (t: T, i: number) => string): SetDiff<T> {
+  const fromMap = new Map(from.map((t, i) => [keyFn(t, i), t]))
+  const toMap = new Map(to.map((t, i) => [keyFn(t, i), t]))
+  const added = [...toMap].filter(([k]) => !fromMap.has(k)).map(([, t]) => t)
+  const removed = [...fromMap].filter(([k]) => !toMap.has(k)).map(([, t]) => t)
+  const changed: SetDiff<T>["changed"] = []
+  for (const [k, toItem] of toMap) {
+    const fromItem = fromMap.get(k)
+    if (fromItem === undefined) continue
+    const changes = flatFieldChanges(fromItem, toItem)
+    if (changes.length) changed.push({ key: k, item: toItem, changes })
+  }
+  return { added, removed, changed }
+}
+
+/** One-level-deep field comparison (dotted keys for nested params). */
+function flatFieldChanges(a: unknown, b: unknown, prefix = ""): FieldChange[] {
+  const out: FieldChange[] = []
+  const ao = (a ?? {}) as Record<string, unknown>
+  const bo = (b ?? {}) as Record<string, unknown>
+  for (const k of new Set([...Object.keys(ao), ...Object.keys(bo)])) {
+    const av = ao[k],
+      bv = bo[k]
+    const field = prefix ? `${prefix}.${k}` : k
+    if (av && bv && typeof av === "object" && typeof bv === "object" && !Array.isArray(av)) {
+      out.push(...flatFieldChanges(av, bv, field))
+    } else if (JSON.stringify(av) !== JSON.stringify(bv)) {
+      out.push({ field, from: av, to: bv })
+    }
+  }
+  return out
+}
+
+export type Badge = { label: string; value: string; tone?: "neutral" | "active" }
+
+const badgeStr = (v: unknown): string | undefined => (typeof v === "string" && v ? v : undefined)
+
+/** Mode facets → badges. Defensive over a loose record (serves both System
+ *  drive/topology and Formulation trajectory/time/param/robustness/flags).
+ *  Skips none-robustness, false flags, and the "fixed" time default. */
+export function modeBadges(p: Record<string, unknown>): Badge[] {
+  const out: Badge[] = []
+  const tt = badgeStr(p.trajectory_type)
+  if (tt) out.push({ label: "type", value: tt })
+  const pm = badgeStr(p.parameterization)
+  if (pm) out.push({ label: "pulse", value: pm.replace(/_/g, "-") })
+  const tm = badgeStr(p.time_mode)
+  if (tm && tm !== "fixed") out.push({ label: "time", value: tm.replace(/_/g, "-"), tone: "active" })
+  const rob =
+    p.robustness && typeof p.robustness === "object"
+      ? badgeStr((p.robustness as Record<string, unknown>).kind)
+      : undefined
+  if (rob && rob !== "none") out.push({ label: "robust", value: rob, tone: "active" })
+  if (p.free_phase === true) out.push({ label: "free-phase", value: "", tone: "active" })
+  if (p.leakage === true) out.push({ label: "leakage", value: "", tone: "active" })
+  // System modes share the badge language.
+  const drive =
+    p.drive && typeof p.drive === "object" ? badgeStr((p.drive as Record<string, unknown>).arch) : undefined
+  if (drive) out.push({ label: "drive", value: drive })
+  const topo = badgeStr(p.topology)
+  if (topo) out.push({ label: "topology", value: topo })
+  return out
+}
+
+// ---- receipt piece builders (spec §5) --------------------------------------
+// The receipt sees only the diff (from/to per key), not the full entity.
+
+export type DiffMap = Record<string, { from: unknown; to: unknown }>
+export type ReceiptPiece = { text: string; tone: "add" | "remove" | "change" }
+/** chip = render the post-state compositeChip (creation / large / elided);
+ *  pieces = a semantic delta. The card owns turning `entity` into a chip
+ *  (via problem.ts compositeChip) — kept out of here to avoid an import cycle. */
+export type EntityReceipt = { kind: "chip"; entity: Record<string, unknown> } | { kind: "pieces"; pieces: ReceiptPiece[] }
+
+const ELIDED = "…"
+
+function describeComponent(item: Record<string, unknown>): string {
+  const bits = [item.role, typeof item.levels === "number" ? `${item.levels}lvl` : undefined].filter(Boolean).join("·")
+  return `${item.id ?? "?"}${bits ? ` (${bits})` : ""}`
+}
+function describeCoupling(item: Record<string, unknown>): string {
+  const between = Array.isArray(item.between) ? item.between.map(String).join("↔") : "?"
+  return `${between} ${item.kind ?? ""}`.trim()
+}
+function setDotted(obj: Record<string, unknown>, dotted: string, value: unknown): void {
+  const parts = dotted.split(".")
+  let cur = obj
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (typeof cur[parts[i]] !== "object" || cur[parts[i]] === null) cur[parts[i]] = {}
+    cur = cur[parts[i]] as Record<string, unknown>
+  }
+  cur[parts[parts.length - 1]] = value
+}
+
+/** System diff → semantic pieces, or a post-state chip on creation/large/elided.
+ *  `components`/`couplings` diff via setDiff (add/remove/param-change); other keys
+ *  render as `key old→new`. Pure; never throws. */
+export function systemReceiptPieces(diff: DiffMap): EntityReceipt {
+  const keys = Object.keys(diff)
+  const elided = keys.includes(ELIDED) || Object.values(diff).some((e) => e.to === ELIDED || e.from === ELIDED)
+  const comp = diff["components"]
+  const isCreation =
+    !!comp && (comp.from === null || comp.from === undefined || (Array.isArray(comp.from) && comp.from.length === 0))
+
+  const pieces: ReceiptPiece[] = []
+  for (const [key, entry] of Object.entries(diff)) {
+    if (key === ELIDED) continue
+    if (key === "components" || key === "couplings") {
+      const from = (Array.isArray(entry.from) ? entry.from : []) as Record<string, unknown>[]
+      const to = (Array.isArray(entry.to) ? entry.to : []) as Record<string, unknown>[]
+      const keyFn =
+        key === "components"
+          ? (c: Record<string, unknown>) => String(c.id)
+          : (c: Record<string, unknown>) => `${(Array.isArray(c.between) ? c.between : []).join("↔")}:${c.kind}`
+      const describe = key === "components" ? describeComponent : describeCoupling
+      const d = setDiff(from, to, keyFn)
+      for (const a of d.added) pieces.push({ text: `+ ${describe(a)}`, tone: "add" })
+      for (const r of d.removed) pieces.push({ text: `− ${describe(r)}`, tone: "remove" })
+      for (const c of d.changed)
+        for (const ch of c.changes)
+          pieces.push({ text: `${c.key} ${ch.field.split(".").pop()} ${compactValue(ch.from)}→${compactValue(ch.to)}`, tone: "change" })
+    } else {
+      pieces.push({ text: `${key.split(".").pop()} ${compactValue(entry.from)}→${compactValue(entry.to)}`, tone: "change" })
+    }
+  }
+
+  if (isCreation || elided || pieces.length > 4) {
+    const entity: Record<string, unknown> = {}
+    for (const [key, entry] of Object.entries(diff)) {
+      if (key === ELIDED || entry.to === ELIDED) continue
+      setDotted(entity, key, entry.to)
+    }
+    return { kind: "chip", entity }
+  }
+  return { kind: "pieces", pieces }
+}
+
+const FORM_MODE_TAG: Record<string, string> = {
+  trajectory_type: "type",
+  time_mode: "time",
+  parameterization: "pulse",
+  "robustness.kind": "robust",
+}
+
+/** Formulation diff → semantic pieces, or a post-state chip on creation/large/
+ *  elided. Modes render as `tag: from → to`, flags as `+/− flag`, objectives/
+ *  constraints via setDiff, everything else `key old→new`. Pure; never throws. */
+export function formulationReceiptPieces(diff: DiffMap): EntityReceipt {
+  const keys = Object.keys(diff)
+  const elided = keys.includes(ELIDED) || Object.values(diff).some((e) => e.to === ELIDED || e.from === ELIDED)
+  const tt = diff["trajectory_type"]
+  const isCreation = !!tt && (tt.from === null || tt.from === undefined)
+
+  const pieces: ReceiptPiece[] = []
+  for (const [key, entry] of Object.entries(diff)) {
+    if (key === ELIDED) continue
+    if (key === "objectives" || key === "constraints") {
+      const from = (Array.isArray(entry.from) ? entry.from : []) as Record<string, unknown>[]
+      const to = (Array.isArray(entry.to) ? entry.to : []) as Record<string, unknown>[]
+      const keyFn = (t: Record<string, unknown>, i: number) => `${t.kind}:${t.label ?? i}`
+      const d = setDiff(from, to, keyFn)
+      for (const a of d.added) pieces.push({ text: `+ ${a.label ?? a.kind}`, tone: "add" })
+      for (const r of d.removed) pieces.push({ text: `− ${r.label ?? r.kind}`, tone: "remove" })
+      for (const c of d.changed)
+        for (const ch of c.changes)
+          pieces.push({ text: `${c.key.split(":")[0]} ${ch.field.split(".").pop()} ${compactValue(ch.from)}→${compactValue(ch.to)}`, tone: "change" })
+    } else if (key === "free_phase" || key === "leakage") {
+      const flag = key.replace(/_/g, "-")
+      if (entry.to === true) pieces.push({ text: `+ ${flag}`, tone: "add" })
+      else if (entry.to === false) pieces.push({ text: `− ${flag}`, tone: "remove" })
+    } else if (key in FORM_MODE_TAG) {
+      pieces.push({ text: `${FORM_MODE_TAG[key]}: ${compactValue(entry.from)} → ${compactValue(entry.to)}`, tone: "change" })
+    } else {
+      pieces.push({ text: `${key.split(".").pop()} ${compactValue(entry.from)}→${compactValue(entry.to)}`, tone: "change" })
+    }
+  }
+
+  if (isCreation || elided || pieces.length > 4) {
+    const entity: Record<string, unknown> = {}
+    for (const [key, entry] of Object.entries(diff)) {
+      if (key === ELIDED || entry.to === ELIDED) continue
+      setDotted(entity, key, entry.to)
+    }
+    return { kind: "chip", entity }
+  }
+  return { kind: "pieces", pieces }
+}
diff --git a/packages/ui/src/amicode/fixtures/formulation-migration.json b/packages/ui/src/amicode/fixtures/formulation-migration.json
new file mode 100644
index 0000000000..6dd6384c65
--- /dev/null
+++ b/packages/ui/src/amicode/fixtures/formulation-migration.json
@@ -0,0 +1,105 @@
+{
+  "_source": "CANONICAL. amicode packages/extension/test/fixtures/formulation-migration.json is the source of truth for the legacy->structured Formulation mapping (spec-20260709 §10). The opencode fork copy at packages/ui/src/amicode/fixtures/ is a VERBATIM mirror — edit here, then re-copy. Each `structured` holds ONLY mapped facet fields (no derived primaryKey / synthesized final_fidelity).",
+  "pairs": [
+    {
+      "name": "gate_synthesis basic",
+      "legacy": { "problem": "gate_synthesis", "target": "CZ", "objective": "unitary infidelity", "constraints": ["amplitude bound (drive_max)"] },
+      "structured": {
+        "trajectory_type": "gate",
+        "time_mode": "fixed",
+        "parameterization": "smooth",
+        "robustness": { "kind": "none", "params": {} },
+        "free_phase": false,
+        "leakage": false,
+        "target": "CZ",
+        "objectives": [],
+        "constraints": [{ "kind": "bounds", "params": {}, "label": "amplitude bound (drive_max)" }]
+      }
+    },
+    {
+      "name": "state_prep -> ket",
+      "legacy": { "problem": "state_prep", "target": "|1>", "objective": "ket infidelity", "constraints": [] },
+      "structured": {
+        "trajectory_type": "ket",
+        "time_mode": "fixed",
+        "parameterization": "smooth",
+        "robustness": { "kind": "none", "params": {} },
+        "free_phase": false,
+        "leakage": false,
+        "target": "|1>",
+        "objectives": [],
+        "constraints": []
+      }
+    },
+    {
+      "name": "min_time -> time_mode",
+      "legacy": { "problem": "min_time", "target": "CZ", "objective": "unitary infidelity", "constraints": ["amplitude bound"] },
+      "structured": {
+        "trajectory_type": "gate",
+        "time_mode": "min_time",
+        "parameterization": "smooth",
+        "robustness": { "kind": "none", "params": {} },
+        "free_phase": false,
+        "leakage": false,
+        "target": "CZ",
+        "objectives": [],
+        "constraints": [{ "kind": "bounds", "params": {}, "label": "amplitude bound" }]
+      }
+    },
+    {
+      "name": "custom objective + unknown constraint",
+      "legacy": { "problem": "gate_synthesis", "target": "X", "objective": "custom cost foo", "constraints": ["keep it smooth"] },
+      "structured": {
+        "trajectory_type": "gate",
+        "time_mode": "fixed",
+        "parameterization": "smooth",
+        "robustness": { "kind": "none", "params": {} },
+        "free_phase": false,
+        "leakage": false,
+        "target": "X",
+        "objectives": [{ "kind": "custom", "params": {}, "label": "custom cost foo" }],
+        "constraints": [{ "kind": "custom", "params": {}, "label": "keep it smooth" }]
+      }
+    },
+    {
+      "name": "leakage constraint -> flag",
+      "legacy": { "problem": "gate_synthesis", "target": "CZ", "objective": "unitary infidelity", "constraints": ["leakage suppression"] },
+      "structured": {
+        "trajectory_type": "gate",
+        "time_mode": "fixed",
+        "parameterization": "smooth",
+        "robustness": { "kind": "none", "params": {} },
+        "free_phase": false,
+        "leakage": true,
+        "target": "CZ",
+        "objectives": [],
+        "constraints": []
+      }
+    },
+    {
+      "name": "already structured (idempotent)",
+      "legacy": {
+        "trajectory_type": "gate",
+        "time_mode": "fixed",
+        "parameterization": "cubic_spline",
+        "robustness": { "kind": "ensemble", "params": { "n_systems": 3 } },
+        "free_phase": true,
+        "leakage": false,
+        "target": "CZ",
+        "objectives": [{ "kind": "reg_du", "params": { "R": 0.00001 } }],
+        "constraints": [{ "kind": "bounds", "params": {} }]
+      },
+      "structured": {
+        "trajectory_type": "gate",
+        "time_mode": "fixed",
+        "parameterization": "cubic_spline",
+        "robustness": { "kind": "ensemble", "params": { "n_systems": 3 } },
+        "free_phase": true,
+        "leakage": false,
+        "target": "CZ",
+        "objectives": [{ "kind": "reg_du", "params": { "R": 0.00001 } }],
+        "constraints": [{ "kind": "bounds", "params": {} }]
+      }
+    }
+  ]
+}
diff --git a/packages/ui/src/amicode/formulation-projection.test.ts b/packages/ui/src/amicode/formulation-projection.test.ts
new file mode 100644
index 0000000000..c7bde272fc
--- /dev/null
+++ b/packages/ui/src/amicode/formulation-projection.test.ts
@@ -0,0 +1,50 @@
+import { describe, it, expect } from "bun:test"
+import { readFileSync } from "node:fs"
+import { formulationProjection } from "./problem"
+
+const corpus = JSON.parse(
+  readFileSync(new URL("./fixtures/formulation-migration.json", import.meta.url), "utf8"),
+) as { pairs: { name: string; legacy: any; structured: any }[] }
+
+// Compare ONLY the mapped facet fields (not the derived primaryKey / synthesized
+// final_fidelity, which aren't in `structured`) — the anti-drift lock against
+// the amicode-side normalizeFormulation (§9/§10).
+const mapped = (p: any) => ({
+  trajectory_type: p.trajectory_type,
+  time_mode: p.time_mode,
+  parameterization: p.parameterization,
+  robustness: p.robustness,
+  free_phase: p.free_phase,
+  leakage: p.leakage,
+  target: p.target,
+  objectives: p.objectives,
+  constraints: p.constraints,
+})
+
+describe("formulationProjection (shared corpus — anti-drift lock)", () => {
+  for (const pair of corpus.pairs) {
+    it(`maps facets: ${pair.name}`, () => {
+      expect(mapped(formulationProjection(pair.legacy))).toEqual(pair.structured)
+    })
+  }
+})
+
+describe("formulationProjection primaryKey + robustness", () => {
+  const P = (o: any) => formulationProjection(o).primaryKey
+  it("derives per trajectory_type + free_phase + time_mode", () => {
+    expect(P({ trajectory_type: "gate" })).toBe("unitary_infidelity")
+    expect(P({ trajectory_type: "gate", free_phase: true })).toBe("unitary_free_phase")
+    expect(P({ trajectory_type: "ket" })).toBe("ket_infidelity")
+    expect(P({ trajectory_type: "multiket" })).toBe("ket_infidelity")
+    expect(P({ trajectory_type: "density" })).toBe("density_infidelity")
+    expect(P({ trajectory_type: "gate", time_mode: "min_time" })).toBe("min_time")
+  })
+  it("min_time surfaces derivedFinalFidelity from time_params", () => {
+    const p = formulationProjection({ trajectory_type: "gate", time_mode: "min_time", time_params: { final_fidelity: 0.999 } })
+    expect(p.derivedFinalFidelity).toBe(0.999)
+  })
+  it("never throws on an unknown enum; passes the raw string through", () => {
+    const p = formulationProjection({ trajectory_type: "bogus" })
+    expect(p.trajectory_type).toBe("bogus")
+  })
+})
diff --git a/packages/ui/src/amicode/formulation-view.tsx b/packages/ui/src/amicode/formulation-view.tsx
new file mode 100644
index 0000000000..de0f063b7d
--- /dev/null
+++ b/packages/ui/src/amicode/formulation-view.tsx
@@ -0,0 +1,105 @@
+import { For, Show, createMemo } from "solid-js"
+import katex from "katex"
+import { formulationProjection, type PrimaryObjectiveKey, type FormulationTerm } from "./problem"
+import { modeBadges } from "./facets"
+
+// AMICODE Formulation hero (spec §6.2 / plan Task 14): a mode-badge header over
+// the derived primary objective (LaTeX) + added-terms list + typed constraints +
+// solve scalars. Thin — logic lives in formulationProjection / modeBadges; this
+// file maps them to DOM. Styling in ./amicode.css.
+
+// Keyed by the DERIVED primaryKey (disjoint from ObjectiveKind). Unknown → no math.
+const OBJECTIVE_LATEX: Record<PrimaryObjectiveKey, string> = {
+  ket_infidelity: "\\mathcal{F} = |\\langle \\psi_g | \\psi(T) \\rangle|^2",
+  unitary_infidelity: "\\mathcal{F} = \\tfrac{1}{d^2}\\,|\\mathrm{Tr}(U_{\\mathrm{goal}}^\\dagger U)|^2",
+  unitary_free_phase: "\\mathcal{F} = \\tfrac{1}{d^2}\\,|\\mathrm{Tr}(U_{\\mathrm{goal}}(\\theta)^\\dagger U)|^2",
+  density_infidelity: "\\mathcal{F} = \\mathrm{Tr}(\\rho_g\\, \\rho(T))",
+  min_time: "\\min\\; D \\textstyle\\sum_k \\Delta t_k \\quad \\mathrm{s.t.}\\; \\mathcal{F} \\ge \\mathcal{F}_0",
+}
+const PRIMARY_LABEL: Record<PrimaryObjectiveKey, string> = {
+  ket_infidelity: "ket infidelity",
+  unitary_infidelity: "unitary infidelity",
+  unitary_free_phase: "free-phase unitary infidelity",
+  density_infidelity: "density infidelity",
+  min_time: "min-time (D · ΣΔt)",
+}
+const CONSTRAINT_LABEL: Record<string, string> = {
+  bounds: "amplitude bound",
+  du_bound: "slew bound (du)",
+  ddu_bound: "accel bound (ddu)",
+  dt_bounds: "Δt bounds",
+  final_fidelity: "final fidelity",
+  calibration_pin: "calibration pin",
+}
+
+const paramsText = (params: Record<string, number>): string =>
+  Object.entries(params)
+    .map(([k, v]) => `${k} ${v}`)
+    .join(" · ")
+const termText = (t: FormulationTerm): string => {
+  const head = t.label ?? CONSTRAINT_LABEL[t.kind] ?? t.kind
+  const p = paramsText(t.params)
+  return p ? `${head} · ${p}` : head
+}
+
+export function FormulationView(props: { entity: Record<string, unknown> }) {
+  const proj = createMemo(() => formulationProjection(props.entity))
+  const badges = createMemo(() => modeBadges(proj() as unknown as Record<string, unknown>))
+  const primaryHtml = createMemo(() => {
+    const latex = OBJECTIVE_LATEX[proj().primaryKey]
+    return latex ? katex.renderToString(latex, { throwOnError: false }) : undefined
+  })
+  // Synthesized (display-only) final_fidelity constraint row for min_time.
+  const constraintRows = createMemo(() => {
+    const p = proj()
+    const rows = [...p.constraints]
+    if (p.time_mode === "min_time" && typeof p.derivedFinalFidelity === "number")
+      rows.push({ kind: "final_fidelity", params: { threshold: p.derivedFinalFidelity } })
+    return rows
+  })
+
+  return (
+    <div class="amc-formulation" data-component="amicode-formulation-view">
+      <div class="amc-modebar" data-slot="amicode-formulation-modes">
+        <For each={badges()}>
+          {(b) => (
+            <span class="amc-badge" classList={{ active: b.tone === "active" }}>
+              <Show when={b.value} fallback={<span class="v">{b.label}</span>}>
+                <span class="k">{b.label}</span>
+                <span class="v">{b.value}</span>
+              </Show>
+            </span>
+          )}
+        </For>
+      </div>
+
+      <div class="amc-ev-sec">Objective</div>
+      <div class="amc-obj" data-slot="amicode-formulation-objective">
+        <div class="amc-obj-primary">
+          <span class="amc-obj-name">{PRIMARY_LABEL[proj().primaryKey]}</span>
+          <span class="amc-obj-tag">primary · derived</span>
+        </div>
+        <Show when={primaryHtml()}>{(html) => <div class="amc-obj-latex" innerHTML={html()} />}</Show>
+        <For each={proj().objectives}>{(o) => <div class="amc-obj-term">+ {termText(o)}</div>}</For>
+      </div>
+
+      <Show when={constraintRows().length > 0}>
+        <div class="amc-ev-sec">Constraints</div>
+        <div class="amc-constraints" data-slot="amicode-formulation-constraints">
+          <For each={constraintRows()}>{(c) => <div class="amc-constraint">{termText(c)}</div>}</For>
+        </div>
+      </Show>
+
+      <Show when={proj().solve}>
+        {(solve) => (
+          <>
+            <div class="amc-ev-sec">Solve</div>
+            <div class="amc-solve" data-slot="amicode-formulation-solve">
+              {paramsText(solve() as Record<string, number>)}
+            </div>
+          </>
+        )}
+      </Show>
+    </div>
+  )
+}
diff --git a/packages/ui/src/amicode/frontier.test.ts b/packages/ui/src/amicode/frontier.test.ts
new file mode 100644
index 0000000000..23a0246aa9
--- /dev/null
+++ b/packages/ui/src/amicode/frontier.test.ts
@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test"
+import { frontier, type QNode } from "./frontier"
+
+const graph: QNode[] = [
+  { id: "platform", prereqs: [], batchable: false },
+  { id: "count", prereqs: ["platform"], batchable: true },
+  { id: "homogeneous", prereqs: ["count"], batchable: true },
+  // topology is only RELEVANT when there is more than one component (value predicate)
+  { id: "topology", prereqs: ["count"], relevant: (a) => Number(a.count) > 1, batchable: true },
+  // the gate's options are generated from the platform's VALUE (value-dependent)
+  { id: "gate", prereqs: ["platform"], optionsFrom: ["platform"], batchable: false },
+]
+
+describe("frontier DAG scheduler (spec §4.1)", () => {
+  test("with no answers, only prereq-free nodes are answerable", () => {
+    expect(frontier(graph, {}).map((n) => n.id)).toEqual(["platform"])
+  })
+
+  test("answering platform unlocks count + gate (gate's optionsFrom now satisfied); platform drops out", () => {
+    const ids = frontier(graph, { platform: "transmon" }).map((n) => n.id)
+    expect(ids).toContain("count")
+    expect(ids).toContain("gate")
+    expect(ids).not.toContain("platform")
+  })
+
+  test("value-dependent guardrail: a node stays out until its optionsFrom source is answered", () => {
+    const g: QNode[] = [
+      { id: "platform", prereqs: [], batchable: false },
+      { id: "gate", prereqs: [], optionsFrom: ["platform"], batchable: false },
+    ]
+    expect(frontier(g, {}).map((n) => n.id)).toEqual(["platform"]) // gate blocked by optionsFrom
+    expect(frontier(g, { platform: "transmon" }).map((n) => n.id)).toContain("gate")
+  })
+
+  test("relevance-pruning: topology is OUT when count=1 though its prereq is met; IN when count>1", () => {
+    const single = frontier(graph, { platform: "transmon", count: 1 }).map((n) => n.id)
+    expect(single).not.toContain("topology")
+    expect(single).toContain("homogeneous") // prereq met, no relevance gate → still in
+    const multi = frontier(graph, { platform: "transmon", count: 2 }).map((n) => n.id)
+    expect(multi).toContain("topology")
+  })
+
+  test("answered nodes are excluded", () => {
+    const ids = frontier(graph, {
+      platform: "transmon",
+      count: 2,
+      homogeneous: true,
+      topology: "linear-chain",
+    }).map((n) => n.id)
+    expect(ids).not.toContain("platform")
+    expect(ids).not.toContain("count")
+    expect(ids).not.toContain("topology")
+    expect(ids).toContain("gate") // still unanswered, optionsFrom(platform) satisfied
+  })
+
+  test("batchable flag partitions the frontier (mechanical batched, semantic singular)", () => {
+    const f = frontier(graph, { platform: "transmon", count: 2 })
+    const batched = f.filter((n) => n.batchable).map((n) => n.id)
+    const singular = f.filter((n) => !n.batchable).map((n) => n.id)
+    expect(batched).toContain("homogeneous")
+    expect(batched).toContain("topology")
+    expect(singular).toContain("gate")
+  })
+})
diff --git a/packages/ui/src/amicode/frontier.ts b/packages/ui/src/amicode/frontier.ts
new file mode 100644
index 0000000000..27fa045abd
--- /dev/null
+++ b/packages/ui/src/amicode/frontier.ts
@@ -0,0 +1,44 @@
+// Pure DAG scheduler for the multipartite setup interview (spec-20260709 §4.1).
+//
+// v1: this is the tested REFERENCE that the AGENTS.md / SCORE frontier-batching
+// policy mirrors — the LLM follows that prose to build each `question` payload;
+// nothing wires `frontier` to a runtime caller yet (the acknowledged §4.1 gap).
+// Pure, no I/O, so it is directly unit-testable and drift-checkable.
+
+export interface QNode {
+  id: string;
+  /** Node ids whose answers must exist before this node is askable. */
+  prereqs: string[];
+  /** Value predicate over PRIOR answers; default () => true. Prunes an
+   *  answered-prereqs-but-IRRELEVANT node out of the frontier (e.g. `topology`
+   *  only when component-count > 1; "which state" only if target === "state"). */
+  relevant?: (answers: Record<string, unknown>) => boolean;
+  /** Prior answer ids whose VALUES generate this node's options — a
+   *  value-dependent node is not askable until they are answered (its option
+   *  set cannot be computed otherwise). */
+  optionsFrom?: string[];
+  /** false = semantic/branching, ask SINGLY (platform, target, objective);
+   *  true = mechanical, batchable into one multi-question `question` call. */
+  batchable: boolean;
+}
+
+const answered = (answers: Record<string, unknown>, id: string): boolean =>
+  Object.prototype.hasOwnProperty.call(answers, id) && answers[id] !== undefined;
+
+/**
+ * The nodes answerable NOW: not already answered, every `prereqs` id answered,
+ * every `optionsFrom` id answered (options computable), and `relevant(answers)`
+ * true. Pruned/blocked nodes are simply absent from the returned list. Pure.
+ *
+ * The caller batches all `batchable: true` results into ONE `question` tool call
+ * and asks each `batchable: false` result singly, re-running after each submit.
+ */
+export function frontier(graph: QNode[], answers: Record<string, unknown>): QNode[] {
+  return graph.filter((n) => {
+    if (answered(answers, n.id)) return false; // already answered
+    if (!n.prereqs.every((id) => answered(answers, id))) return false; // prereqs unmet
+    if (n.optionsFrom && !n.optionsFrom.every((id) => answered(answers, id))) return false; // options not computable
+    if (n.relevant && !n.relevant(answers)) return false; // irrelevant given prior values
+    return true;
+  });
+}
diff --git a/packages/ui/src/amicode/home-cards.tsx b/packages/ui/src/amicode/home-cards.tsx
index 64bb2a2810..36f564d551 100644
--- a/packages/ui/src/amicode/home-cards.tsx
+++ b/packages/ui/src/amicode/home-cards.tsx
@@ -7,6 +7,7 @@ import {
   type InstitutionSuggestion,
 } from "./institution-lookup"
 import { fileToBase64 } from "./upload"
+import { drivePaths, linePath } from "./run-plot"
 
 // AMICODE: home-screen card strip (the "central screen" Aaron wanted the H-bot
 // and useful practitioner info on). Two identity heroes — MEET AMICO (who your
@@ -902,13 +903,12 @@ function AboutYouCard(props: {
               <div
                 style={{
                   display: "grid",
-                  "grid-template-columns": "repeat(4, minmax(0, 1fr))",
+                  "grid-template-columns": "repeat(3, minmax(0, 1fr))",
                   gap: "8px",
                 }}
               >
                 <Stat value={String(y().stats.problems)} label="problems" />
                 <Stat value={String(y().stats.runs)} label="runs" />
-                <Stat value={fidelity(y().stats.best_fidelity)} label="best F" />
                 <Stat value={String(y().stats.banked)} label="banked" />
               </div>
 
@@ -976,29 +976,35 @@ const CARD_SUB: JSX.CSSProperties = {
 }
 const SPARK_W = 96
 const SPARK_H = 22
-function Sparkline(props: { values: number[] }) {
-  const path = createMemo(() => {
-    const v = props.values
-    if (v.length < 2) return undefined
-    const min = Math.min(...v)
-    const max = Math.max(...v)
-    const span = max - min || 1
-    const step = SPARK_W / (v.length - 1)
-    return v
-      .map((y, i) => {
-        const px = (i * step).toFixed(1)
-        const py = (SPARK_H - 2 - ((y - min) / span) * (SPARK_H - 4)).toFixed(1)
-        return `${i === 0 ? "M" : "L"}${px},${py}`
-      })
-      .join(" ")
-  })
+/** Pulse-first: the latest pulse trace when a snapshot exists (per-drive paths
+ *  on a shared scale, companions at 0.55), else the convergence series. */
+function liveSparkPaths(run: HomeLiveRun): string[] {
+  const pulse = run.pulse ?? []
+  if (pulse.length >= 2) {
+    const paths = drivePaths(pulse, run.drives ?? 1, SPARK_W, SPARK_H)
+    if (paths.length > 0) return paths
+  }
+  const d = linePath(run.series ?? [], SPARK_W, SPARK_H)
+  return d ? [d] : []
+}
+
+function Sparkline(props: { paths: string[] }) {
   return (
-    <Show when={path()}>
-      {(d) => (
-        <svg width={SPARK_W} height={SPARK_H} viewBox={`0 0 ${SPARK_W} ${SPARK_H}`} style={{ "flex-shrink": "0" }}>
-          <path d={d()} fill="none" stroke="var(--v2-icon-icon-accent)" stroke-width="1.5" stroke-linejoin="round" />
-        </svg>
-      )}
+    <Show when={props.paths.length > 0}>
+      <svg width={SPARK_W} height={SPARK_H} viewBox={`0 0 ${SPARK_W} ${SPARK_H}`} style={{ "flex-shrink": "0" }}>
+        <For each={props.paths}>
+          {(d, i) => (
+            <path
+              d={d}
+              fill="none"
+              stroke="var(--v2-icon-icon-accent)"
+              stroke-width="1.5"
+              stroke-linejoin="round"
+              opacity={i() === 0 ? 1 : 0.55}
+            />
+          )}
+        </For>
+      </svg>
     </Show>
   )
 }
@@ -1099,6 +1105,9 @@ export interface HomeLiveRun {
   iteration?: number | null
   fidelity?: number | null
   series?: number[]
+  // latest pulse snapshot, drives flattened back-to-back (see run-plot drivePaths)
+  pulse?: number[]
+  drives?: number
 }
 
 // ---------------------------------------------------------------------------
@@ -1213,7 +1222,7 @@ export function AmicodeHomeCards(props: {
                 </span>
               </div>
               <div style={{ "margin-top": "auto" }}>
-                <Sparkline values={run().series ?? []} />
+                <Sparkline paths={liveSparkPaths(run())} />
               </div>
             </ActionCard>
           )}
@@ -1225,9 +1234,6 @@ export function AmicodeHomeCards(props: {
             <div style={CARD_TITLE}>
               {stats()!.banked} pulse{stats()!.banked === 1 ? "" : "s"} banked
             </div>
-            <div style={{ ...CARD_SUB, "font-variant-numeric": "tabular-nums" }}>
-              best F {fidelity(stats()!.best_fidelity)}
-            </div>
             <div style={{ "font-size": "11px", color: "var(--v2-text-text-accent)", "margin-top": "auto" }}>
               Warm-start →
             </div>
diff --git a/packages/ui/src/amicode/problem.test.ts b/packages/ui/src/amicode/problem.test.ts
index 87553cc2b8..c8a076d775 100644
--- a/packages/ui/src/amicode/problem.test.ts
+++ b/packages/ui/src/amicode/problem.test.ts
@@ -4,12 +4,16 @@ import {
   parseProblemResponse,
   parseRunStatusResponse,
   chipText,
+  formatTs,
   mergeChips,
   runChipText,
   railState,
   entityRows,
   historyRows,
   editPromptText,
+  compositeChip,
+  compositeSystemRows,
+  systemProjection,
 } from "./problem"
 
 describe("wire parsers are tolerant and never throw", () => {
@@ -63,11 +67,23 @@ describe("chipText per-kind compact renderers", () => {
     )
     expect(chipText("system", { platform: "rydberg" })).toBe("rydberg")
   })
-  test("formulation: target + objective, problem_type fallback", () => {
-    expect(chipText("formulation", { problem_type: "gate_synthesis", target: "X", objective: "infidelity" })).toBe(
-      "X · infidelity",
-    )
-    expect(chipText("formulation", { problem_type: "gate_synthesis" })).toBe("gate_synthesis")
+  test("formatTs compacts ISO, passes non-ISO through", () => {
+    expect(formatTs("2026-07-10T15:53:30.450Z")).toBe("07-10 15:53")
+    expect(formatTs("just now")).toBe("just now")
+  })
+  test("formulation: structured mode facets (NOT the phantom problem_type)", () => {
+    expect(
+      chipText("formulation", {
+        trajectory_type: "gate",
+        time_mode: "min_time",
+        robustness: { kind: "ensemble" },
+        free_phase: true,
+      }),
+    ).toBe("gate · min-time · ensemble · free-phase")
+    // legacy free-form maps through the projection:
+    expect(chipText("formulation", { problem: "state_prep", target: "|1>" })).toBe("ket")
+    // an entity carrying ONLY the phantom problem_type is ignored → default gate:
+    expect(chipText("formulation", { problem_type: "gate_synthesis" })).toBe("gate")
   })
   test("unknown kind: generic key=value join, nested flattened bare, notes skipped", () => {
     expect(chipText("pulse", { format: "jld2", knots: 51, notes: "long text" })).toBe("format=jld2 · knots=51")
@@ -149,3 +165,71 @@ describe("entity view helpers", () => {
     expect(editPromptText("system", "params.omega", 4.8)).toBe("Change the system omega (currently 4.8) to ")
   })
 })
+
+describe("composite system display derivations (spec-20260709)", () => {
+  const flat = { platform: "transmon", levels: 3, params: { omega: 4.8, drive_max: 0.2 } }
+  const n1 = {
+    platform: "transmon",
+    components: [{ id: "q1", role: "qubit", levels: 3, params: { omega: 4.8, drive_max: 0.2 } }],
+    couplings: [],
+    drive: { arch: "per-component" },
+  }
+  const cz = {
+    platform: "transmon",
+    components: [
+      { id: "q1", role: "qubit", levels: 3, params: { omega: 4.8 } },
+      { id: "q2", role: "qubit", levels: 3, params: { omega: 4.9 } },
+    ],
+    couplings: [{ between: ["q1", "q2"], kind: "cross-resonance", params: { g: 0.005 } }],
+    topology: "single-pair",
+    drive: { arch: "per-component" },
+  }
+
+  test("chipText: N=1 composite matches the legacy flat look; N>1 summarizes components/coupling/arch", () => {
+    expect(chipText("system", flat as any)).toBe("transmon · 3 lvl · cap 0.2")
+    expect(chipText("system", n1 as any)).toBe("transmon · 3 lvl · cap 0.2") // N=1 back-compat
+    expect(chipText("system", cz as any)).toBe("transmon · 2×qubit · cross-resonance · per-component")
+  })
+
+  test("legacy flat entity still renders (defensive dual-shape)", () => {
+    expect(chipText("system", flat as any)).toBeDefined()
+    expect(entityRows(flat as any).some((r) => r.key === "levels")).toBe(true) // generic flat path
+  })
+
+  test("entityRows: composite → component-table + coupling-list rows, not a JSON blob", () => {
+    const rows = compositeSystemRows(cz as any)
+    expect(rows.find((r) => r.key === "platform")?.value).toBe("transmon")
+    expect(rows.find((r) => r.key === "drive")?.value).toBe("per-component")
+    expect(rows.find((r) => r.key === "topology")?.value).toBe("single-pair")
+    expect(rows.find((r) => r.key === "component q1")?.value).toContain("qubit")
+    expect(rows.find((r) => r.key === "component q1")?.value).toContain("omega=4.8")
+    const cpRow = rows.find((r) => r.key.startsWith("coupling"))
+    expect(cpRow?.key).toBe("coupling q1↔q2")
+    expect(cpRow?.value).toContain("cross-resonance")
+    // and entityRows routes composites here (no raw array blob)
+    expect(entityRows(cz as any).some((r) => r.value.startsWith("["))).toBe(false)
+  })
+
+  test("systemProjection: composite read-through; flat collapses to N=1 (isComposite flag)", () => {
+    const p = systemProjection(cz as any)
+    expect(p.isComposite).toBe(true)
+    expect(p.components.map((c) => c.id)).toEqual(["q1", "q2"])
+    expect(p.couplings[0].between).toEqual(["q1", "q2"])
+    expect(p.driveArch).toBe("per-component")
+    const pf = systemProjection(flat as any)
+    expect(pf.isComposite).toBe(false)
+    expect(pf.components).toHaveLength(1)
+    expect(pf.components[0]).toMatchObject({ id: "q1", role: "qubit", levels: 3 })
+    expect(pf.couplings).toEqual([])
+    // rydberg flat → atom role + global arch (mirrors normalizeSystem)
+    const pr = systemProjection({ platform: "rydberg", levels: 3, params: {} } as any)
+    expect(pr.components[0].role).toBe("atom")
+    expect(pr.driveArch).toBe("global")
+  })
+
+  test("compositeChip is defensive on garbage (never throws)", () => {
+    expect(() => compositeChip({} as any)).not.toThrow()
+    expect(() => compositeSystemRows({ components: "nope" } as any)).not.toThrow()
+    expect(() => systemProjection(null as any)).not.toThrow()
+  })
+})
diff --git a/packages/ui/src/amicode/problem.ts b/packages/ui/src/amicode/problem.ts
index 0ae8f64c59..d2ab6dedce 100644
--- a/packages/ui/src/amicode/problem.ts
+++ b/packages/ui/src/amicode/problem.ts
@@ -6,6 +6,7 @@
 // every field, drop non-conforming array entries, never throw. JSX-free so it
 // is directly testable under `bun test`.
 import { entityLabel } from "./receipt"
+import { compactValue, formatSci } from "./facets"
 
 // --- view types --------------------------------------------------------------
 
@@ -169,14 +170,16 @@ export function parseRunStatusResponse(raw: unknown): RunStatusView[] {
 const CHIP_ORDER = ["system", "formulation", "run", "device_session", "calibration"]
 
 function shortValue(value: unknown): string {
-  if (value === null || value === undefined) return "—"
-  if (typeof value === "string") return value
-  return JSON.stringify(value)
+  return compactValue(value) // spec §4: array/object-aware, never a JSON blob
 }
 
 /** Compact per-kind chip text; undefined when the entity has nothing to show. */
 export function chipText(kind: string, entity: Record<string, unknown>): string | undefined {
   if (kind === "system") {
+    // composite (spec-20260709): a components[] array → summarize the composite.
+    // Defensive in-place parse (this fork repo CANNOT import the plugin-side
+    // normalizeSystem — spec §3 cross-repo note); a legacy flat entity falls through.
+    if (Array.isArray(entity.components)) return compositeChip(entity)
     const params = (typeof entity.params === "object" && entity.params !== null ? entity.params : {}) as Record<
       string,
       unknown
@@ -184,14 +187,21 @@ export function chipText(kind: string, entity: Record<string, unknown>): string
     const parts = [
       str(entity.platform),
       typeof entity.levels === "number" ? `${entity.levels} lvl` : undefined,
-      typeof params.drive_max === "number" ? `cap ${params.drive_max}` : undefined,
+      typeof params.drive_max === "number" ? `cap ${formatSci(params.drive_max)}` : undefined,
     ].filter((p): p is string => Boolean(p))
     return parts.length > 0 ? parts.join(" · ") : undefined
   }
   if (kind === "formulation") {
-    const parts = [str(entity.target), str(entity.objective)].filter((p): p is string => Boolean(p))
-    if (parts.length > 0) return parts.join(" · ")
-    return str(entity.problem_type)
+    // Structured facets via formulationProjection (dual-shape) — NOT the phantom
+    // `problem_type` the plugin never writes (spec §6.3 drift fix).
+    const p = formulationProjection(entity)
+    const parts = [
+      p.trajectory_type,
+      p.time_mode === "min_time" ? "min-time" : undefined,
+      p.robustness.kind !== "none" ? p.robustness.kind : undefined,
+      p.free_phase ? "free-phase" : undefined,
+    ].filter((x): x is string => Boolean(x))
+    return parts.length > 0 ? parts.join(" · ") : undefined
   }
   if (kind === "run") return undefined // run chip text comes from runChipText
   // generic: flatten one level of nesting to bare keys, skip null/notes/recorded
@@ -296,6 +306,9 @@ export function fieldGroup(key: string): string | undefined {
 /** Stable field rows: scalars in object order, one level of object nesting
  *  flattened to dotted keys, undefined skipped. */
 export function entityRows(entity: Record<string, unknown>): EntityRow[] {
+  // composite system (spec-20260709): a components[] array → component-table +
+  // coupling-list rows instead of one JSON blob. Defensive; legacy flat falls through.
+  if (Array.isArray(entity.components)) return compositeSystemRows(entity)
   const rows: EntityRow[] = []
   for (const [key, value] of Object.entries(entity)) {
     if (value === undefined) continue
@@ -320,3 +333,283 @@ export function editPromptText(kind: string, key: string, value: unknown): strin
   const bare = key.split(".").pop() ?? key
   return `Change the ${kind} ${bare} (currently ${shortValue(value)}) to `
 }
+
+// --- composite system display (spec-20260709 §3) -----------------------------
+// All of the below parse BOTH the flat-legacy and composite shapes defensively
+// in place — this fork repo cannot import the plugin-side normalizeSystem, so
+// tolerance lives in the reader (spec §3 cross-repo note). Never throw.
+
+const paramBits = (params: unknown): string[] => {
+  if (typeof params !== "object" || params === null) return []
+  return Object.entries(params as Record<string, unknown>).map(([k, v]) => `${k}=${shortValue(v)}`)
+}
+
+/** Compact composite chip, e.g. "transmon · 3 lvl · cap 0.2" (N=1, back-compat look)
+ *  or "transmon · 2×qubit · cross-resonance · per-component" (N>1). */
+export function compositeChip(entity: Record<string, unknown>): string | undefined {
+  const components = Array.isArray(entity.components) ? (entity.components as Record<string, unknown>[]) : []
+  const couplings = Array.isArray(entity.couplings) ? (entity.couplings as Record<string, unknown>[]) : []
+  const driveArch =
+    entity.drive && typeof entity.drive === "object" ? str((entity.drive as Record<string, unknown>).arch) : undefined
+  const parts: string[] = []
+  const platform = str(entity.platform)
+  if (platform) parts.push(platform)
+  if (components.length === 1) {
+    const c = components[0]
+    if (typeof c.levels === "number") parts.push(`${c.levels} lvl`)
+    const params = (typeof c.params === "object" && c.params !== null ? c.params : {}) as Record<string, unknown>
+    if (typeof params.drive_max === "number") parts.push(`cap ${formatSci(params.drive_max)}`)
+  } else if (components.length > 1) {
+    const roles = new Set(components.map((c) => str(c.role)).filter(Boolean))
+    parts.push(roles.size === 1 ? `${components.length}×${[...roles][0]}` : `${components.length} comps`)
+  }
+  if (couplings.length === 1) parts.push(str(couplings[0].kind) ?? "1 coupling")
+  else if (couplings.length > 1) parts.push(`${couplings.length} couplings`)
+  if (components.length > 1 && driveArch) parts.push(driveArch)
+  return parts.length > 0 ? parts.join(" · ") : undefined
+}
+
+/** Component-table + coupling-list rows for a composite system entity. */
+export function compositeSystemRows(entity: Record<string, unknown>): EntityRow[] {
+  const rows: EntityRow[] = []
+  const platform = str(entity.platform)
+  if (platform) rows.push({ key: "platform", value: platform })
+  const driveArch =
+    entity.drive && typeof entity.drive === "object" ? str((entity.drive as Record<string, unknown>).arch) : undefined
+  if (driveArch) rows.push({ key: "drive", value: driveArch })
+  if (typeof entity.topology === "string") rows.push({ key: "topology", value: entity.topology })
+  for (const c of (Array.isArray(entity.components) ? entity.components : []) as Record<string, unknown>[]) {
+    const bits = [
+      str(c.role),
+      typeof c.levels === "number" ? `${c.levels} lvl` : undefined,
+      ...paramBits(c.params),
+    ].filter((b): b is string => Boolean(b))
+    rows.push({ key: `component ${str(c.id) ?? "?"}`, value: bits.join(", ") || "—" })
+  }
+  for (const cp of (Array.isArray(entity.couplings) ? entity.couplings : []) as Record<string, unknown>[]) {
+    const between = Array.isArray(cp.between) ? (cp.between as unknown[]).map(String).join("↔") : ""
+    const params = paramBits(cp.params).join(", ")
+    rows.push({ key: `coupling ${between}`, value: `${str(cp.kind) ?? "?"}${params ? ` (${params})` : ""}` })
+  }
+  if (typeof entity.notes === "string") rows.push({ key: "notes", value: entity.notes })
+  return rows
+}
+
+export interface SystemProjection {
+  platform?: string
+  driveArch?: string
+  topology?: string
+  components: { id: string; role: string; levels?: number; params: Record<string, number> }[]
+  couplings: { between: string[]; kind: string; params: Record<string, number> }[]
+  notes?: string
+  /** false = a legacy FLAT entity read-collapsed to N=1 (no couplings). */
+  isComposite: boolean
+}
+
+const asNumberRecord = (v: unknown): Record<string, number> => {
+  const out: Record<string, number> = {}
+  if (typeof v === "object" && v !== null) {
+    for (const [k, val] of Object.entries(v as Record<string, unknown>)) if (typeof val === "number") out[k] = val
+  }
+  return out
+}
+
+/** Structured projection for the entity view (spec §3 point 3). Composite → read
+ *  through; legacy flat → collapse to N=1 in place (role from platform: rydberg→atom
+ *  else qubit — mirrors normalizeSystem without importing it). Never throws. */
+export function systemProjection(input: Record<string, unknown>): SystemProjection {
+  const entity = (input ?? {}) as Record<string, unknown>
+  const platform = str(entity.platform)
+  const driveArch =
+    entity.drive && typeof entity.drive === "object" ? str((entity.drive as Record<string, unknown>).arch) : undefined
+  if (Array.isArray(entity.components)) {
+    return {
+      platform,
+      driveArch,
+      topology: typeof entity.topology === "string" ? entity.topology : undefined,
+      components: (entity.components as Record<string, unknown>[]).map((c) => ({
+        id: str(c.id) ?? "?",
+        role: str(c.role) ?? "?",
+        ...(typeof c.levels === "number" ? { levels: c.levels } : {}),
+        params: asNumberRecord(c.params),
+      })),
+      couplings: (Array.isArray(entity.couplings) ? (entity.couplings as Record<string, unknown>[]) : []).map((cp) => ({
+        between: Array.isArray(cp.between) ? (cp.between as unknown[]).map(String) : [],
+        kind: str(cp.kind) ?? "?",
+        params: asNumberRecord(cp.params),
+      })),
+      ...(typeof entity.notes === "string" ? { notes: entity.notes } : {}),
+      isComposite: true,
+    }
+  }
+  // legacy flat → N=1
+  const role = platform?.toLowerCase() === "rydberg" ? "atom" : "qubit"
+  const comp: SystemProjection["components"][number] = { id: "q1", role, params: asNumberRecord(entity.params) }
+  if (typeof entity.levels === "number") comp.levels = entity.levels
+  return {
+    platform,
+    driveArch: driveArch ?? (platform?.toLowerCase() === "rydberg" ? "global" : "per-component"),
+    components: [comp],
+    couplings: [],
+    ...(typeof entity.notes === "string" ? { notes: entity.notes } : {}),
+    isComposite: false,
+  }
+}
+
+// --- formulation projection (spec §6.2) --------------------------------------
+// Dual-shape (legacy free-form OR structured facets). The fork CANNOT import the
+// plugin's normalizeFormulation, so this re-implements the §10 mapping IN PLACE,
+// pinned by the shared fixture corpus (formulation-projection.test.ts). Never
+// throws; unknown enums pass through raw.
+
+export type PrimaryObjectiveKey =
+  | "ket_infidelity"
+  | "unitary_infidelity"
+  | "unitary_free_phase"
+  | "density_infidelity"
+  | "min_time"
+export interface FormulationTerm {
+  kind: string
+  params: Record<string, number>
+  label?: string
+}
+export interface FormulationProjection {
+  trajectory_type: string
+  time_mode: string
+  parameterization: string
+  robustness: { kind: string; params: Record<string, unknown> }
+  free_phase: boolean
+  leakage: boolean
+  leakage_params?: Record<string, number>
+  time_params?: Record<string, number>
+  target: string
+  objectives: FormulationTerm[]
+  constraints: FormulationTerm[]
+  primaryKey: PrimaryObjectiveKey
+  derivedFinalFidelity?: number
+  solve?: Record<string, unknown>
+  isStructured: boolean
+}
+
+const fmtTerm = (o: any): FormulationTerm => {
+  const out: FormulationTerm = {
+    kind: typeof o?.kind === "string" ? o.kind : "custom",
+    params: o?.params && typeof o.params === "object" ? o.params : {},
+  }
+  if (typeof o?.label === "string") out.label = o.label
+  return out
+}
+const fmtRobustness = (r: any): { kind: string; params: Record<string, unknown> } =>
+  r && typeof r === "object" && typeof r.kind === "string"
+    ? { kind: r.kind, params: r.params && typeof r.params === "object" ? r.params : {} }
+    : { kind: "none", params: {} }
+const inferTrajFromTarget = (target: string): string => (/^\s*\||prep|state/i.test(target) ? "ket" : "gate")
+const fmtConstraintKind = (lc: string): string => {
+  if (/slew|\bdu\b/.test(lc)) return "du_bound"
+  if (/ddu|accel/.test(lc)) return "ddu_bound"
+  if (/Δt|timestep|\bdt\b/.test(lc)) return "dt_bounds"
+  if (/calibration|\bpin\b/.test(lc)) return "calibration_pin"
+  if (/amplitude|bound/.test(lc)) return "bounds"
+  return "custom"
+}
+const derivePrimaryKey = (trajectory_type: string, free_phase: boolean, time_mode: string): PrimaryObjectiveKey => {
+  if (time_mode === "min_time") return "min_time"
+  if (trajectory_type === "ket" || trajectory_type === "multiket") return "ket_infidelity"
+  if (trajectory_type === "density" || trajectory_type === "multidensity") return "density_infidelity"
+  if (trajectory_type === "gate") return free_phase ? "unitary_free_phase" : "unitary_infidelity"
+  return "unitary_infidelity"
+}
+
+export function formulationProjection(input: Record<string, unknown>): FormulationProjection {
+  const r = (input ?? {}) as Record<string, any>
+  let trajectory_type: string
+  let time_mode: string
+  let parameterization: string
+  let free_phase: boolean
+  let leakage: boolean
+  let target: string
+  let robustness: { kind: string; params: Record<string, unknown> }
+  let objectives: FormulationTerm[]
+  let constraints: FormulationTerm[]
+  let time_params: Record<string, number> | undefined
+  let leakage_params: Record<string, number> | undefined
+  let solve: Record<string, unknown> | undefined
+  let isStructured: boolean
+
+  if (typeof r.trajectory_type === "string") {
+    isStructured = true
+    trajectory_type = r.trajectory_type
+    time_mode = r.time_mode === "min_time" ? "min_time" : "fixed"
+    parameterization = typeof r.parameterization === "string" ? r.parameterization : "smooth"
+    robustness = fmtRobustness(r.robustness)
+    free_phase = r.free_phase === true
+    leakage = r.leakage === true
+    target = typeof r.target === "string" ? r.target : ""
+    objectives = Array.isArray(r.objectives) ? r.objectives.map(fmtTerm) : []
+    constraints = Array.isArray(r.constraints) ? r.constraints.map(fmtTerm) : []
+    if (r.time_params && typeof r.time_params === "object") time_params = r.time_params
+    if (r.leakage_params && typeof r.leakage_params === "object") leakage_params = r.leakage_params
+    if (r.solve && typeof r.solve === "object") solve = r.solve
+  } else {
+    isStructured = false
+    const problem = typeof r.problem === "string" ? r.problem : ""
+    target = typeof r.target === "string" ? r.target : ""
+    trajectory_type = "gate"
+    time_mode = "fixed"
+    if (problem === "state_prep") trajectory_type = "ket"
+    else if (problem === "min_time") {
+      time_mode = "min_time"
+      trajectory_type = inferTrajFromTarget(target)
+    }
+    parameterization = "smooth"
+    robustness = { kind: "none", params: {} }
+    free_phase = false
+    leakage = false
+    objectives = []
+    const objStr = typeof r.objective === "string" ? r.objective.trim() : ""
+    if (objStr && !/infidelity/i.test(objStr)) objectives.push({ kind: "custom", params: {}, label: objStr })
+    constraints = []
+    for (const c of Array.isArray(r.constraints) ? r.constraints : []) {
+      if (typeof c !== "string") continue
+      const lc = c.toLowerCase()
+      if (/leakage/.test(lc)) {
+        leakage = true
+        continue
+      }
+      if (/final.?fidelity/.test(lc)) {
+        const m = c.match(/[\d.]+/)
+        time_params = { ...(time_params ?? {}), final_fidelity: m ? Number(m[0]) : 0.99 }
+        continue
+      }
+      constraints.push({ kind: fmtConstraintKind(lc), params: {}, label: c })
+    }
+    if (r.solve && typeof r.solve === "object") solve = r.solve
+  }
+
+  const out: FormulationProjection = {
+    trajectory_type,
+    time_mode,
+    parameterization,
+    robustness,
+    free_phase,
+    leakage,
+    target,
+    objectives,
+    constraints,
+    primaryKey: derivePrimaryKey(trajectory_type, free_phase, time_mode),
+    isStructured,
+  }
+  if (time_params) out.time_params = time_params
+  if (leakage_params) out.leakage_params = leakage_params
+  if (solve) out.solve = solve
+  if (time_mode === "min_time" && time_params && typeof time_params.final_fidelity === "number")
+    out.derivedFinalFidelity = time_params.final_fidelity
+  return out
+}
+
+/** Compact an ISO timestamp for the entity-view ("2026-07-10T15:53:30.450Z" →
+ *  "07-10 15:53") — the full ISO is wide and clips the dialog. Non-ISO passes through. */
+export function formatTs(ts: string): string {
+  const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}:\d{2})/.exec(ts)
+  return m ? `${m[2]}-${m[3]} ${m[4]}` : ts
+}
diff --git a/packages/ui/src/amicode/receipt.ts b/packages/ui/src/amicode/receipt.ts
index 257041dd26..de56e598f1 100644
--- a/packages/ui/src/amicode/receipt.ts
+++ b/packages/ui/src/amicode/receipt.ts
@@ -4,6 +4,8 @@
 // Strict parse; ANY failure → undefined and callers fall back to the legacy
 // chip, so old sessions keep rendering. Never throws.
 
+import { compactValue } from "./facets"
+
 const PREFIX = "AMICODE_DIFF "
 
 export type DiffEntry = { from: unknown; to: unknown }
@@ -56,9 +58,7 @@ export function entityLabel(kind: string): string {
 }
 
 function short(value: unknown): string {
-  if (value === null || value === undefined) return "—"
-  if (typeof value === "string") return value
-  return JSON.stringify(value)
+  return compactValue(value) // spec §4: array/object-aware, never a JSON blob
 }
 
 // A receipt's body, broken into typed pieces so the UI can render each change
diff --git a/packages/ui/src/amicode/run-card.test.ts b/packages/ui/src/amicode/run-card.test.ts
index c7d8a45fd5..ff5c973756 100644
--- a/packages/ui/src/amicode/run-card.test.ts
+++ b/packages/ui/src/amicode/run-card.test.ts
@@ -39,6 +39,10 @@ describe("renderRunCardSvg", () => {
     expect(svg.match(/stroke="#F2C94C" stroke-width="2\.5"/g)?.length).toBe(2)
     expect(svg).toContain('opacity="0.55"')
   })
+  test("pulse panel reads first (left column), convergence second", () => {
+    const svg = renderRunCardSvg(CARD)
+    expect(svg.indexOf("FINAL PULSE")).toBeLessThan(svg.indexOf("CONVERGENCE"))
+  })
   test("escapes hostile strings", () => {
     const svg = renderRunCardSvg({ ...CARD, problem: 'x"/><script>alert(1)</script>' })
     expect(svg).not.toContain("<script>")
diff --git a/packages/ui/src/amicode/run-card.tsx b/packages/ui/src/amicode/run-card.tsx
index d7e9c22f82..50d5a58fa5 100644
--- a/packages/ui/src/amicode/run-card.tsx
+++ b/packages/ui/src/amicode/run-card.tsx
@@ -117,11 +117,11 @@ export function renderRunCardSvg(d: RunCardData): string {
     .filter(Boolean)
     .join("   ·   ")
 
-  // convergence panel (log10 f)
+  // convergence panel (log10 f) — right column; pulse reads first
   const logs = d.series.map((p) => Math.log10(Math.max(p.f, 1e-12)))
-  const curvePath = logs.length >= 2 ? pathFor(logs, 80, 388, 480, 150, Math.min(...logs), Math.max(...logs)) : ""
+  const curvePath = logs.length >= 2 ? pathFor(logs, 640, 388, 480, 150, Math.min(...logs), Math.max(...logs)) : ""
 
-  // pulse panel — one path per drive, shared scale
+  // pulse panel — one path per drive, shared scale — left column (the artifact leads)
   const drives = Math.max(1, d.pulseMeta?.drives ?? 1)
   const values = d.pulse?.values ?? []
   const knots = Math.floor(values.length / drives)
@@ -131,7 +131,7 @@ export function renderRunCardSvg(d: RunCardData): string {
     const max = Math.max(...values)
     for (let k = 0; k < drives; k++) {
       const seg = values.slice(k * knots, (k + 1) * knots)
-      pulsePaths += `<path d="${pathFor(seg, 640, 388, 480, 150, min, max)}" fill="none" stroke="${GOLD}" stroke-width="2.5" stroke-linejoin="round" opacity="${k === 0 ? 1 : 0.55}"/>`
+      pulsePaths += `<path d="${pathFor(seg, 80, 388, 480, 150, min, max)}" fill="none" stroke="${GOLD}" stroke-width="2.5" stroke-linejoin="round" opacity="${k === 0 ? 1 : 0.55}"/>`
     }
   }
 
@@ -153,12 +153,12 @@ export function renderRunCardSvg(d: RunCardData): string {
   <text x="80" y="345" font-family="${sans}" font-size="16" fill="${MUTED}">${esc(meta)}</text>
 
   <rect x="64" y="372" width="512" height="182" rx="10" fill="${PANEL}" stroke="${LINE}"/>
-  <text x="80" y="558" font-family="${sans}" font-size="13" letter-spacing="2" fill="${MUTED}">CONVERGENCE  (log f)</text>
-  ${curvePath ? `<path d="${curvePath}" fill="none" stroke="${CURVE}" stroke-width="2.5" stroke-linejoin="round"/>` : `<text x="270" y="470" font-family="${sans}" font-size="14" fill="${MUTED}">no iteration data</text>`}
+  <text x="80" y="558" font-family="${sans}" font-size="13" letter-spacing="2" fill="${MUTED}">FINAL PULSE${drives > 1 ? `  (${drives} drives)` : ""}</text>
+  ${pulsePaths || `<text x="270" y="470" font-family="${sans}" font-size="14" fill="${MUTED}">no pulse data</text>`}
 
   <rect x="624" y="372" width="512" height="182" rx="10" fill="${PANEL}" stroke="${LINE}"/>
-  <text x="640" y="558" font-family="${sans}" font-size="13" letter-spacing="2" fill="${MUTED}">FINAL PULSE${drives > 1 ? `  (${drives} drives)` : ""}</text>
-  ${pulsePaths || `<text x="830" y="470" font-family="${sans}" font-size="14" fill="${MUTED}">no pulse data</text>`}
+  <text x="640" y="558" font-family="${sans}" font-size="13" letter-spacing="2" fill="${MUTED}">CONVERGENCE  (log f)</text>
+  ${curvePath ? `<path d="${curvePath}" fill="none" stroke="${CURVE}" stroke-width="2.5" stroke-linejoin="round"/>` : `<text x="830" y="470" font-family="${sans}" font-size="14" fill="${MUTED}">no iteration data</text>`}
 
   <text x="80" y="602" font-family="${sans}" font-size="15" fill="${MUTED}">Solved with <tspan fill="${TEXT}" font-weight="650">Amico</tspan> — your friendly Quantum Computing Agent</text>
   <text x="${W - 80}" y="602" text-anchor="end" font-family="${sans}" font-size="15" fill="${GOLD}">harmoniqs.ai</text>
diff --git a/packages/ui/src/amicode/run-plot.test.ts b/packages/ui/src/amicode/run-plot.test.ts
new file mode 100644
index 0000000000..309088f292
--- /dev/null
+++ b/packages/ui/src/amicode/run-plot.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test"
+import { drivePaths, heroPaths, linePath, objectivePath, scaledPath } from "./run-plot"
+
+describe("scaledPath / linePath", () => {
+  test("maps points into the box, M then L", () => {
+    const d = scaledPath([0, 1], 0, 1, 100, 34)
+    expect(d).toBe("M0.00,32.00 L100.00,2.00")
+  })
+  test("flat series does not divide by zero", () => {
+    expect(scaledPath([5, 5], 5, 5, 100, 34)).toContain("M0.00,")
+  })
+  test("linePath needs ≥2 points", () => {
+    expect(linePath([1], 100, 34)).toBeUndefined()
+    expect(linePath([1, 2], 100, 34)).toBeDefined()
+  })
+})
+
+describe("objectivePath", () => {
+  test("log-scales and clamps non-positive values", () => {
+    expect(objectivePath([80.3, 1e-3], 100, 34)).toBeDefined()
+    expect(objectivePath([1, 0], 100, 34)).toBeDefined() // 0 → 1e-12 clamp, no NaN
+    expect(objectivePath([1], 100, 34)).toBeUndefined()
+  })
+})
+
+describe("drivePaths", () => {
+  test("slices flattened drives on a shared scale", () => {
+    const paths = drivePaths([0, 1, 2, 10, 11, 12], 2, 100, 34)
+    expect(paths).toHaveLength(2)
+    // shared min/max: first drive occupies the low band, second the high band
+    expect(paths[0]).not.toBe(paths[1])
+  })
+  test("fewer than 2 knots per drive → no paths", () => {
+    expect(drivePaths([1, 2], 3, 100, 34)).toEqual([])
+  })
+})
+
+describe("heroPaths (pulse-first selection)", () => {
+  const series = [
+    { iter: 0, f: 80.3 },
+    { iter: 1, f: 1e-3 },
+  ]
+  test("prefers the pulse when a snapshot exists", () => {
+    const paths = heroPaths({ series, pulse: { values: [0, 1, 2, 3] }, pulseMeta: { drives: 2 } }, 100, 34)
+    expect(paths).toHaveLength(2)
+  })
+  test("falls back to the convergence curve without a pulse", () => {
+    expect(heroPaths({ series, pulse: null, pulseMeta: null }, 100, 34)).toHaveLength(1)
+  })
+  test("nothing at all → empty", () => {
+    expect(heroPaths({ series: [], pulse: null, pulseMeta: null }, 100, 34)).toEqual([])
+  })
+})
diff --git a/packages/ui/src/amicode/run-plot.ts b/packages/ui/src/amicode/run-plot.ts
new file mode 100644
index 0000000000..95fcb4d0a4
--- /dev/null
+++ b/packages/ui/src/amicode/run-plot.ts
@@ -0,0 +1,66 @@
+// AMICODE: pure SVG path geometry shared by the in-chat run window (hero plot
+// + header sparkline) and the home "Now solving" sparkline. JSX-free per the
+// fork convention: thin untestable shells, tested pure cores.
+
+export function scaledPath(ys: number[], min: number, max: number, w: number, h: number): string {
+  const span = max - min || 1
+  const step = w / (ys.length - 1)
+  return ys
+    .map((y, i) => {
+      const px = (i * step).toFixed(2)
+      const py = (h - 2 - ((y - min) / span) * (h - 4)).toFixed(2)
+      return `${i === 0 ? "M" : "L"}${px},${py}`
+    })
+    .join(" ")
+}
+
+export function linePath(ys: number[], w: number, h: number): string | undefined {
+  if (ys.length < 2) return undefined
+  return scaledPath(ys, Math.min(...ys), Math.max(...ys), w, h)
+}
+
+/** Descending log-objective curve (the classic convergence plot). */
+export function objectivePath(values: number[], w: number, h: number): string | undefined {
+  if (values.length < 2) return undefined
+  return linePath(
+    values.map((f) => Math.log10(Math.max(f, 1e-12))),
+    w,
+    h,
+  )
+}
+
+/** One path per drive, sharing a min/max scale so amplitudes stay comparable.
+ *  The wire ships drives flattened back-to-back; pulse_meta says how to slice. */
+export function drivePaths(values: number[], drives: number, w: number, h: number): string[] {
+  const n = Math.max(1, drives)
+  const knots = Math.floor(values.length / n)
+  if (knots < 2) return []
+  const min = Math.min(...values)
+  const max = Math.max(...values)
+  return Array.from({ length: n }, (_, d) => scaledPath(values.slice(d * knots, (d + 1) * knots), min, max, w, h))
+}
+
+/** Pulse-first hero selection: the pulse is the artifact, so it owns the plot
+ *  when a snapshot exists; young runs fall back to the convergence curve;
+ *  empty runs return [] (caller renders "gathering iterations…"). */
+export function heroPaths(
+  run: {
+    series: { iter: number; f: number }[]
+    pulse: { values: number[] } | null
+    pulseMeta: { drives: number } | null
+  },
+  w: number,
+  h: number,
+): string[] {
+  const pulse = run.pulse?.values ?? []
+  if (pulse.length >= 2) {
+    const paths = drivePaths(pulse, run.pulseMeta?.drives ?? 1, w, h)
+    if (paths.length > 0) return paths
+  }
+  const d = objectivePath(
+    run.series.map((p) => p.f),
+    w,
+    h,
+  )
+  return d ? [d] : []
+}
diff --git a/packages/ui/src/amicode/run-series.test.ts b/packages/ui/src/amicode/run-series.test.ts
index 7e5fe6cafa..9447746e6d 100644
--- a/packages/ui/src/amicode/run-series.test.ts
+++ b/packages/ui/src/amicode/run-series.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { elapsedLabel, headlineMetric, parseRunSeriesResponse, type RunSeries } from "./run-series"
+import { elapsedLabel, headlineMetric, humanTail, parseRunSeriesResponse, type RunSeries } from "./run-series"
 
 const okRun = (over: Partial<Record<string, unknown>> = {}) => ({
   ok: true,
@@ -98,6 +98,24 @@ describe("headlineMetric", () => {
   })
 })
 
+describe("humanTail", () => {
+  test("drops AMICODE_* machine lines, keeps human solver output", () => {
+    expect(
+      humanTail([
+        "AMICODE_ITER iter=60 f=1.5e-03",
+        "AMICODE_PULSE iter=59 dt=0.205 a=0,-0.0531869,-0.0863969",
+        "  AMICODE_PULSE indented still machine",
+        "  60  1.5091416e-03 0.00e+00",
+        "EXIT: Optimal Solution Found.",
+      ]),
+    ).toEqual(["  60  1.5091416e-03 0.00e+00", "EXIT: Optimal Solution Found."])
+  })
+  test("empty and all-machine tails → empty", () => {
+    expect(humanTail([])).toEqual([])
+    expect(humanTail(["AMICODE_PULSE x", "AMICODE_ITER y"])).toEqual([])
+  })
+})
+
 describe("elapsedLabel", () => {
   test("formats seconds / minutes / hours", () => {
     expect(elapsedLabel(12_000)).toBe("12s")
diff --git a/packages/ui/src/amicode/run-series.ts b/packages/ui/src/amicode/run-series.ts
index d448e8a997..ec53a35d89 100644
--- a/packages/ui/src/amicode/run-series.ts
+++ b/packages/ui/src/amicode/run-series.ts
@@ -81,6 +81,13 @@ export function elapsedLabel(ms: number | null): string | undefined {
   return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`
 }
 
+/** Human-facing tail: drop AMICODE_* protocol lines (pulse/iter dumps the run
+ *  window must never show raw); solver output passes through untouched. The
+ *  server keeps shipping the raw tail — this is a presentation filter. */
+export function humanTail(lines: string[]): string[] {
+  return lines.filter((line) => !line.trimStart().startsWith("AMICODE_"))
+}
+
 /** Headline metric: authoritative fidelity if finished, else F = 1 - f once the
  *  objective is a valid infidelity (< 1), else the raw objective early on. */
 export function headlineMetric(run: RunSeries): { label: string; value: string } {
diff --git a/packages/ui/src/amicode/run-window.tsx b/packages/ui/src/amicode/run-window.tsx
index c4cda07924..0851973aa7 100644
--- a/packages/ui/src/amicode/run-window.tsx
+++ b/packages/ui/src/amicode/run-window.tsx
@@ -1,13 +1,23 @@
 import { For, Show, createEffect, createMemo, createSignal, onCleanup, onMount } from "solid-js"
 import { AmicoMark } from "./spinner"
 import { fetchAmicodeRunSeries, openAmicodeEntity } from "./ui-bridge"
-import { type RunSeries, type RunSeriesView, elapsedLabel, headlineMetric, parseRunSeriesResponse } from "./run-series"
+import { heroPaths, objectivePath } from "./run-plot"
+import {
+  type RunSeries,
+  type RunSeriesView,
+  elapsedLabel,
+  headlineMetric,
+  humanTail,
+  parseRunSeriesResponse,
+} from "./run-series"
 
 export { parseRunSeriesResponse, type RunSeries, type RunSeriesView } from "./run-series"
 
 // AMICODE (spec C): compact in-chat run window rendered where amicode_solve
-// launched a run (run_dir known). Streams the objective-vs-iteration curve, the
-// latest pulse trace, and a log tail from GET /amicode/run-series via the ui
+// launched a run (run_dir known). Pulse-first: the latest pulse trace owns the
+// plot (the pulse IS the artifact); convergence shrinks to a header sparkline
+// next to the F chip; the log tail streams human solver lines only (AMICODE_*
+// protocol dumps filtered). Data from GET /amicode/run-series via the ui
 // bridge; polls while solving; click opens the full Run entity. Transport lives
 // in the app (rail registers fetchRunSeries) so this stays self-contained but
 // context-free — no-op until the rail is mounted, exactly like the entity view.
@@ -15,43 +25,8 @@ export { parseRunSeriesResponse, type RunSeries, type RunSeriesView } from "./ru
 const POLL_MS = 2500
 const PLOT_W = 100
 const PLOT_H = 34
-
-// Descending log-objective curve (the classic convergence plot): map each f to
-// log10(f), then min/max-scale into the viewBox. Non-scaling stroke keeps the
-// line crisp under the non-uniform x-stretch.
-function objectivePath(values: number[]): string | undefined {
-  if (values.length < 2) return undefined
-  const logs = values.map((f) => Math.log10(Math.max(f, 1e-12)))
-  return linePath(logs)
-}
-
-function linePath(ys: number[]): string | undefined {
-  if (ys.length < 2) return undefined
-  return scaledPath(ys, Math.min(...ys), Math.max(...ys))
-}
-
-function scaledPath(ys: number[], min: number, max: number): string {
-  const span = max - min || 1
-  const step = PLOT_W / (ys.length - 1)
-  return ys
-    .map((y, i) => {
-      const px = (i * step).toFixed(2)
-      const py = (PLOT_H - 2 - ((y - min) / span) * (PLOT_H - 4)).toFixed(2)
-      return `${i === 0 ? "M" : "L"}${px},${py}`
-    })
-    .join(" ")
-}
-
-/** One path per drive, sharing a min/max scale so amplitudes stay comparable.
- *  The wire ships drives flattened back-to-back; pulse_meta says how to slice. */
-function drivePaths(values: number[], drives: number): string[] {
-  const n = Math.max(1, drives)
-  const knots = Math.floor(values.length / n)
-  if (knots < 2) return []
-  const min = Math.min(...values)
-  const max = Math.max(...values)
-  return Array.from({ length: n }, (_, d) => scaledPath(values.slice(d * knots, (d + 1) * knots), min, max))
-}
+const SPARK_W = 40
+const SPARK_H = 14
 
 function statusColor(status: string): string {
   if (status === "finished") return "var(--v2-state-fg-success)"
@@ -116,7 +91,6 @@ function Chip(props: { label: string; value: string; color?: string }) {
 
 export function RunWindow(props: { run: string; lab?: string }) {
   const [view, setView] = createSignal<RunSeriesView | undefined>(undefined)
-  const [mode, setMode] = createSignal<"objective" | "pulse">("objective")
   let timer: ReturnType<typeof setInterval> | undefined
   const stop = () => {
     if (timer !== undefined) clearInterval(timer)
@@ -149,36 +123,20 @@ export function RunWindow(props: { run: string; lab?: string }) {
   const plotPath = createMemo<string[] | undefined>(() => {
     const r = run()
     if (!r) return undefined
-    if (mode() === "objective") {
-      const d = objectivePath(r.series.map((p) => p.f))
-      return d ? [d] : undefined
-    }
-    const values = r.pulse?.values ?? []
-    return drivePaths(values, r.pulseMeta?.drives ?? 1)
+    const paths = heroPaths(r, PLOT_W, PLOT_H)
+    return paths.length > 0 ? paths : undefined
   })
-
-  const ToggleButton = (p: { mode: "objective" | "pulse"; label: string; disabled?: boolean }) => (
-    <button
-      type="button"
-      disabled={p.disabled}
-      onClick={(e) => {
-        e.stopPropagation()
-        setMode(p.mode)
-      }}
-      style={{
-        "font-size": "10px",
-        padding: "1px 6px",
-        "border-radius": "4px",
-        border: "none",
-        cursor: p.disabled ? "default" : "pointer",
-        opacity: p.disabled ? "0.4" : "1",
-        background: mode() === p.mode ? "var(--v2-background-bg-layer-03)" : "transparent",
-        color: mode() === p.mode ? "var(--v2-text-text-base)" : "var(--v2-text-text-muted)",
-      }}
-    >
-      {p.label}
-    </button>
-  )
+  // convergence shrinks to a header chip: glanceable progress, pulse owns the canvas
+  const sparkPath = createMemo<string | undefined>(() => {
+    const r = run()
+    if (!r) return undefined
+    return objectivePath(
+      r.series.map((p) => p.f),
+      SPARK_W,
+      SPARK_H,
+    )
+  })
+  const tailLines = createMemo<string[]>(() => humanTail(run()?.tail ?? []).slice(-4))
 
   return (
     <div
@@ -196,13 +154,12 @@ export function RunWindow(props: { run: string; lab?: string }) {
         cursor: "pointer",
       }}
     >
-      {/* header: AMICO · Run · status · iter · metric · elapsed */}
+      {/* header: [H] Run · status · iter · metric · elapsed (AMICO wordmark
+          dropped — identity lives in the rail; spec-20260712-amico-third-actor) */}
       <div style={{ display: "flex", "align-items": "center", gap: "8px", "flex-wrap": "wrap", "min-width": "0" }}>
         <span class="amc-sig">
           <AmicoMark />
-          <span class="amc-wordmark">AMICO</span>
         </span>
-        <span style={{ color: "var(--v2-text-text-faint)" }}>·</span>
         <span style={{ "font-weight": "600", color: "var(--v2-text-text-base)" }}>Run</span>
         <Show
           when={run()}
@@ -224,21 +181,36 @@ export function RunWindow(props: { run: string; lab?: string }) {
                 const m = headlineMetric(r())
                 return <Chip label={m.label} value={m.value} />
               })()}
+              <Show when={sparkPath()}>
+                {(d) => (
+                  <svg
+                    width={SPARK_W}
+                    height={SPARK_H}
+                    viewBox={`0 0 ${SPARK_W} ${SPARK_H}`}
+                    style={{ "flex-shrink": "0" }}
+                  >
+                    <path
+                      d={d()}
+                      fill="none"
+                      stroke="var(--v2-icon-icon-accent)"
+                      stroke-width="1"
+                      stroke-linejoin="round"
+                      opacity="0.8"
+                    />
+                  </svg>
+                )}
+              </Show>
               <Show when={elapsedLabel(r().elapsedMs)}>{(t) => <Chip label="" value={t()} />}</Show>
             </>
           )}
         </Show>
-        <span style={{ "margin-left": "auto", display: "inline-flex", gap: "2px", "flex-shrink": "0" }}>
-          <ToggleButton mode="objective" label="F" />
-          <ToggleButton mode="pulse" label="pulse" disabled={!run()?.pulse} />
-        </span>
       </div>
 
       {/* plot */}
       <Plot d={plotPath()} />
 
-      {/* log tail */}
-      <Show when={(run()?.tail.length ?? 0) > 0}>
+      {/* log tail — human solver lines only (AMICODE_* protocol dumps filtered) */}
+      <Show when={tailLines().length > 0}>
         <div
           style={{
             "font-family": "var(--font-family-mono, ui-monospace, monospace)",
@@ -251,7 +223,7 @@ export function RunWindow(props: { run: string; lab?: string }) {
             "word-break": "break-all",
           }}
         >
-          <For each={run()!.tail.slice(-4)}>{(line) => <div>{line}</div>}</For>
+          <For each={tailLines()}>{(line) => <div>{line}</div>}</For>
         </div>
       </Show>
     </div>
diff --git a/packages/ui/src/amicode/system-render.test.ts b/packages/ui/src/amicode/system-render.test.ts
new file mode 100644
index 0000000000..edc873f687
--- /dev/null
+++ b/packages/ui/src/amicode/system-render.test.ts
@@ -0,0 +1,149 @@
+import { describe, it, expect } from "bun:test"
+import { systemProjection } from "./problem"
+import { systemSchematicModel, systemTableModel, systemHamiltonianLatex, systemIdentityLine } from "./system-render"
+
+const twoTransmon = {
+  platform: "transmon",
+  drive: { arch: "per-component" },
+  topology: "linear-chain",
+  components: [
+    { id: "q1", role: "qubit", levels: 3, params: { omega: 4.0, delta: -0.2 } },
+    { id: "q2", role: "qubit", levels: 3, params: { omega: 4.1, delta: -0.2 } },
+  ],
+  couplings: [{ between: ["q1", "q2"], kind: "ZZ", params: { strength: 0.1 } }],
+}
+
+describe("systemSchematicModel", () => {
+  it("nodes + adjacent 2-id edge + topology for a linear chain", () => {
+    const s = systemSchematicModel(systemProjection(twoTransmon))
+    expect(s.nodes.map((n) => n.id)).toEqual(["q1", "q2"])
+    expect(s.nodes[0].levels).toBe(3)
+    expect(s.edges).toEqual([{ a: "q1", b: "q2", label: "ZZ" }])
+    expect(s.looseCouplings).toEqual([])
+    expect(s.topology).toBe("linear-chain")
+  })
+  it("N=1 → single node, no edges", () => {
+    const single = {
+      platform: "transmon",
+      drive: { arch: "per-component" },
+      components: [{ id: "q1", role: "qubit", levels: 3, params: {} }],
+      couplings: [],
+    }
+    const s = systemSchematicModel(systemProjection(single))
+    expect(s.nodes).toHaveLength(1)
+    expect(s.edges).toEqual([])
+  })
+  it("non-adjacent / hyperedge coupling → looseCouplings, not drawn", () => {
+    const hyper = {
+      platform: "rydberg",
+      drive: { arch: "global" },
+      components: [
+        { id: "q1", role: "atom", levels: 3, params: {} },
+        { id: "q2", role: "atom", levels: 3, params: {} },
+        { id: "q3", role: "atom", levels: 3, params: {} },
+      ],
+      couplings: [{ between: ["q1", "q3"], kind: "vdW", params: {} }], // indices 0,2 — non-adjacent
+    }
+    const s = systemSchematicModel(systemProjection(hyper))
+    expect(s.edges).toEqual([])
+    expect(s.looseCouplings).toEqual([{ between: ["q1", "q3"], kind: "vdW" }])
+  })
+})
+
+describe("systemHamiltonianLatex", () => {
+  it("composes drift + coupling + drive for a cavity+qubit dispersive system", () => {
+    const cavQubit = {
+      platform: "cavity",
+      drive: { arch: "per-component" },
+      components: [
+        { id: "q1", role: "qubit", levels: 3, params: { omega: 4, delta: -0.2 } },
+        { id: "c1", role: "cavity", levels: 10, params: { K_c_Hz: 3.25 } },
+      ],
+      couplings: [{ between: ["q1", "c1"], kind: "dispersive-chi", params: { chi_kHz: 32.8 } }],
+    }
+    const h = systemHamiltonianLatex(systemProjection(cavQubit))!
+    expect(h).toContain("\\hat H/\\hbar")
+    expect(h).toContain("\\chi") // the dispersive interaction term
+    expect(h).toContain("\\varepsilon(t)") // drive term
+  })
+  it("returns undefined for a system with no components", () => {
+    expect(systemHamiltonianLatex(systemProjection({ platform: "x", components: [], couplings: [] }))).toBeUndefined()
+  })
+  it("rydberg atom → Rabi drive on |1⟩↔|r⟩, NO bosonic quadrature drive", () => {
+    const rydberg = {
+      platform: "rydberg",
+      drive: { arch: "global" },
+      components: [{ id: "q1", role: "atom", levels: 3, params: {} }],
+      couplings: [],
+    }
+    const h = systemHamiltonianLatex(systemProjection(rydberg))!
+    expect(h).toContain("-\\Delta\\,|r\\rangle\\langle r|") // detuning on the Rydberg level, not -Δ n̂
+    expect(h).toContain("\\Omega(t)") // laser Rabi drive
+    expect(h).toContain("|r\\rangle\\langle 1|")
+    expect(h).not.toContain("\\varepsilon(t)") // no cavity-style drive on a bare atom
+    expect(h).not.toContain("\\hat a") // no bosonic ladder operators at all
+  })
+  it("two rydberg atoms + vdW → single deduped drift/drive pair + blockade term", () => {
+    const pair = {
+      platform: "rydberg",
+      drive: { arch: "global" },
+      components: [
+        { id: "q1", role: "atom", levels: 3, params: {} },
+        { id: "q2", role: "atom", levels: 3, params: {} },
+      ],
+      couplings: [{ between: ["q1", "q2"], kind: "vdW", params: {} }],
+    }
+    const h = systemHamiltonianLatex(systemProjection(pair))!
+    expect(h).toContain("C_6") // blockade interaction
+    expect(h.split("\\Omega(t)")).toHaveLength(2) // drive appears exactly once
+  })
+  it("mixed atom + cavity → both drive flavors", () => {
+    const mixed = {
+      platform: "hybrid",
+      drive: { arch: "per-component" },
+      components: [
+        { id: "q1", role: "atom", levels: 3, params: {} },
+        { id: "c1", role: "cavity", levels: 10, params: {} },
+      ],
+      couplings: [],
+    }
+    const h = systemHamiltonianLatex(systemProjection(mixed))!
+    expect(h).toContain("\\Omega(t)")
+    expect(h).toContain("\\varepsilon(t)")
+  })
+})
+
+describe("systemTableModel", () => {
+  it("component + coupling rows", () => {
+    const t = systemTableModel(systemProjection(twoTransmon))
+    expect(t.components).toHaveLength(2)
+    expect(t.components[0]).toMatchObject({ id: "q1", role: "qubit", levels: 3 })
+    expect(t.components[0].params).toMatchObject({ omega: 4.0, delta: -0.2 })
+    expect(t.couplings[0]).toMatchObject({ between: ["q1", "q2"], kind: "ZZ" })
+  })
+})
+
+describe("systemIdentityLine", () => {
+  it("summarizes platform · N role(s) × levels · arch", () => {
+    expect(systemIdentityLine(systemProjection(twoTransmon))).toBe(
+      "transmon · 2 qubits × 3 levels · per-component drive",
+    )
+  })
+  it("singular role + global drive for a legacy flat rydberg (N=1)", () => {
+    const p = systemProjection({ platform: "rydberg", levels: 3, params: {} })
+    expect(systemIdentityLine(p)).toBe("rydberg · 1 atom × 3 levels · global drive")
+  })
+  it("omits the levels segment when components disagree", () => {
+    const p = systemProjection({
+      platform: "transmon",
+      drive: { arch: "global" },
+      components: [
+        { id: "q1", role: "qubit", levels: 3, params: {} },
+        { id: "c1", role: "cavity", levels: 10, params: {} },
+      ],
+      couplings: [],
+    })
+    // mixed roles → "component", mixed levels → no "× L levels"
+    expect(systemIdentityLine(p)).toBe("transmon · 2 components · global drive")
+  })
+})
diff --git a/packages/ui/src/amicode/system-render.ts b/packages/ui/src/amicode/system-render.ts
new file mode 100644
index 0000000000..d9dfed949d
--- /dev/null
+++ b/packages/ui/src/amicode/system-render.ts
@@ -0,0 +1,142 @@
+// system-render.ts — pure schematic + table models for the System hero
+// (spec-20260709 §6.1 / plan Task 4). Consumes the existing systemProjection;
+// no SolidJS. Never throws.
+import { systemProjection, type SystemProjection } from "./problem"
+
+/** One-line "what is this system" identity: platform · N role(s) × L levels ·
+ *  <arch> drive. e.g. "rydberg · 2 atoms × 3 levels · global drive". Collapses
+ *  the schematic+table into a scannable header line. Never throws. */
+export function systemIdentityLine(proj: SystemProjection): string {
+  const parts: string[] = []
+  if (proj.platform) parts.push(proj.platform)
+  const comps = proj.components ?? []
+  if (comps.length > 0) {
+    const roles = new Set(comps.map((c) => c.role))
+    const levels = new Set(comps.map((c) => c.levels).filter((l): l is number => typeof l === "number"))
+    const role = roles.size === 1 ? [...roles][0] : "component"
+    let seg = `${comps.length} ${comps.length === 1 ? role : `${role}s`}`
+    if (levels.size === 1) seg += ` × ${[...levels][0]} levels`
+    parts.push(seg)
+  }
+  if (proj.driveArch) parts.push(`${proj.driveArch} drive`)
+  return parts.join(" · ")
+}
+
+export type SchematicNode = { id: string; label: string; levels?: number }
+export type SchematicEdge = { a: string; b: string; label: string }
+export type SchematicModel = {
+  nodes: SchematicNode[]
+  edges: SchematicEdge[]
+  looseCouplings: { between: string[]; kind: string }[]
+  topology?: string
+}
+
+/** Nodes = components; an edge is drawn only for a 2-id coupling between
+ *  components ADJACENT in the components array (covers single-pair + linear-
+ *  chain). Non-adjacent / >2-id / hyperedge couplings go to looseCouplings
+ *  (listed, not drawn — no graph-layout engine). N=1 → single node, no edges. */
+export function systemSchematicModel(proj: SystemProjection): SchematicModel {
+  const nodes: SchematicNode[] = proj.components.map((c) => ({
+    id: c.id,
+    label: c.role,
+    ...(typeof c.levels === "number" ? { levels: c.levels } : {}),
+  }))
+  const index = new Map(proj.components.map((c, i) => [c.id, i]))
+  const edges: SchematicEdge[] = []
+  const looseCouplings: { between: string[]; kind: string }[] = []
+  for (const cp of proj.couplings) {
+    const ids = cp.between
+    if (ids.length === 2) {
+      const i = index.get(ids[0])
+      const j = index.get(ids[1])
+      if (i !== undefined && j !== undefined && Math.abs(i - j) === 1) {
+        edges.push({ a: ids[0], b: ids[1], label: cp.kind })
+        continue
+      }
+    }
+    looseCouplings.push({ between: ids, kind: cp.kind })
+  }
+  return { nodes, edges, looseCouplings, ...(proj.topology ? { topology: proj.topology } : {}) }
+}
+
+export type ComponentRow = { id: string; role: string; levels?: number; params: Record<string, number> }
+export type CouplingRow = { between: string[]; kind: string; params: Record<string, number> }
+export type TableModel = { components: ComponentRow[]; couplings: CouplingRow[] }
+
+// Composite Hamiltonian LaTeX (spec §6.1 "show the system"): drift per distinct
+// component role + interaction per distinct coupling kind + a drive term.
+// Illustrative (authoring-aware bookkeeping spirit), not an exact derivation.
+const COUPLING_TERM: Record<string, string> = {
+  "dispersive-chi": "\\tfrac{\\chi}{2}\\,\\hat a^\\dagger \\hat a\\,\\hat\\sigma_z",
+  ZZ: "J\\,\\hat\\sigma_z^{(1)}\\hat\\sigma_z^{(2)}",
+  "cross-resonance": "\\Omega\\,\\hat\\sigma_x^{(1)}\\hat\\sigma_z^{(2)}",
+  exchange: "g\\,(\\hat a^\\dagger \\hat b + \\hat a \\hat b^\\dagger)",
+  vdW: "\\tfrac{C_6}{r^6}\\,\\hat n_1 \\hat n_2",
+  "mode-mediated": "g\\,(\\hat a^\\dagger \\hat b + \\mathrm{h.c.})",
+}
+
+function driftTerm(role: string, params: Record<string, number>): string {
+  const anharmonic = ["delta", "K_q", "anharmonicity", "K_c", "K_c_Hz", "kerr"].some((k) => k in params)
+  switch (role) {
+    case "qubit":
+      return anharmonic
+        ? "\\omega\\,\\hat a^\\dagger \\hat a + \\tfrac{\\delta}{2}\\,\\hat a^\\dagger \\hat a^\\dagger \\hat a \\hat a"
+        : "\\tfrac{\\omega}{2}\\,\\hat\\sigma_z"
+    case "cavity":
+    case "resonator":
+    case "mode":
+      return anharmonic ? "\\omega_c\\,\\hat a^\\dagger \\hat a + \\tfrac{K}{2}\\,\\hat a^{\\dagger 2}\\hat a^2" : "\\omega_c\\,\\hat a^\\dagger \\hat a"
+    case "atom":
+      return "-\\Delta\\,|r\\rangle\\langle r|"
+    default:
+      return "\\hat H_{\\mathrm{drift}}"
+  }
+}
+
+/** Drive term per component role. Atoms are laser-driven on the |1⟩↔|r⟩
+ *  transition (3-level Rydberg convention: |0⟩ dark); everything bosonic or
+ *  bosonic-truncated keeps the quadrature drive. */
+function driveTerm(role: string): string {
+  switch (role) {
+    case "atom":
+      return "\\tfrac{\\Omega(t)}{2}\\,(|r\\rangle\\langle 1| + \\mathrm{h.c.})"
+    default:
+      return "\\varepsilon(t)\\,(\\hat a + \\hat a^\\dagger)"
+  }
+}
+
+/** Compose an illustrative Hamiltonian for ANY composite system. undefined when
+ *  there are no components. Distinct role drifts + distinct coupling terms + drive. */
+export function systemHamiltonianLatex(proj: SystemProjection): string | undefined {
+  const terms: string[] = []
+  const seen = new Set<string>()
+  for (const c of proj.components) {
+    const t = driftTerm(c.role, c.params)
+    if (!seen.has(t)) { seen.add(t); terms.push(t) }
+  }
+  for (const cp of proj.couplings) {
+    const t = COUPLING_TERM[cp.kind]
+    if (t && !seen.has(cp.kind)) { seen.add(cp.kind); terms.push(t) }
+  }
+  if (terms.length === 0) return undefined
+  for (const c of proj.components) {
+    const t = driveTerm(c.role)
+    if (!seen.has(t)) {
+      seen.add(t)
+      terms.push(t)
+    }
+  }
+  return "\\hat H/\\hbar = " + terms.join(" + ")
+}
+
+export function systemTableModel(proj: SystemProjection): TableModel {
+  return {
+    components: proj.components.map((c) => ({
+      id: c.id,
+      role: c.role,
+      ...(typeof c.levels === "number" ? { levels: c.levels } : {}),
+      params: c.params,
+    })),
+    couplings: proj.couplings.map((cp) => ({ between: cp.between, kind: cp.kind, params: cp.params })),
+  }
+}
diff --git a/packages/ui/src/amicode/system-view.tsx b/packages/ui/src/amicode/system-view.tsx
new file mode 100644
index 0000000000..329b6b93ed
--- /dev/null
+++ b/packages/ui/src/amicode/system-view.tsx
@@ -0,0 +1,128 @@
+import { For, Show, createMemo } from "solid-js"
+import katex from "katex"
+import { systemProjection } from "./problem"
+import { formatSci } from "./facets"
+import {
+  systemSchematicModel,
+  systemTableModel,
+  systemHamiltonianLatex,
+  systemIdentityLine,
+  type SchematicModel,
+} from "./system-render"
+
+// AMICODE System hero (spec §6.1 / plan Task 5): schematic (nodes + coupling
+// edges) + component/coupling table + Hamiltonian LaTeX. Thin — all logic is in
+// the pure systemProjection / system-render models; this file just maps them to
+// DOM. Styling in ./amicode.css. Katex is the fork's existing math dep.
+
+// Unitless params get a math symbol; unit-suffixed keys (chi_kHz, K_c_Hz, N_fock)
+// keep their name so the unit isn't lost.
+const PARAM_SYMBOL: Record<string, string> = {
+  omega: "ω",
+  delta: "δ",
+  chi: "χ",
+  strength: "J",
+  drive_max: "|u|",
+  du_bound: "|u̇|",
+}
+// Drop unset (zero) params — "ω 0 · δ 0" is noise — and format the rest with
+// the π-aware formatter so a drive bound reads "|u| 40π", not "|u| 125.66…".
+const paramsText = (params: Record<string, number>): string =>
+  Object.entries(params)
+    .filter(([, v]) => typeof v === "number" && v !== 0)
+    .map(([k, v]) => `${PARAM_SYMBOL[k] ?? k} ${formatSci(v)}`)
+    .join(" · ")
+
+const edgeLabel = (schem: SchematicModel, a: string, b: string): string | undefined =>
+  schem.edges.find((e) => (e.a === a && e.b === b) || (e.a === b && e.b === a))?.label
+
+export function SystemComposite(props: { entity: Record<string, unknown> }) {
+  const proj = createMemo(() => systemProjection(props.entity))
+  const schem = createMemo(() => systemSchematicModel(proj()))
+  const table = createMemo(() => systemTableModel(proj()))
+  const hamiltonian = createMemo(() => {
+    const latex = systemHamiltonianLatex(proj())
+    return latex ? katex.renderToString(latex, { throwOnError: false }) : undefined
+  })
+
+  const identity = createMemo(() => systemIdentityLine(proj()))
+
+  return (
+    <div class="amc-system" data-component="amicode-system-view">
+      <Show when={identity()}>
+        <div class="amc-sys-identity" data-slot="amicode-system-identity">
+          {identity()}
+        </div>
+      </Show>
+      <div class="amc-schematic" data-slot="amicode-system-schematic">
+        <For each={schem().nodes}>
+          {(node, i) => (
+            <>
+              <Show when={i() > 0}>
+                <span class="amc-edge">
+                  <span class="amc-edge-line" aria-hidden="true">
+                    ─
+                  </span>
+                  <Show when={edgeLabel(schem(), schem().nodes[i() - 1].id, node.id)}>
+                    {(label) => <span class="amc-edge-label">{label()}</span>}
+                  </Show>
+                </span>
+              </Show>
+              <span class="amc-node">
+                <span class="amc-node-id">{node.id}</span>
+                <Show when={node.levels !== undefined}>
+                  <span class="amc-node-lvl">{node.levels} lvl</span>
+                </Show>
+              </span>
+            </>
+          )}
+        </For>
+      </div>
+
+      <Show when={schem().looseCouplings.length > 0}>
+        <div class="amc-loose">
+          <For each={schem().looseCouplings}>
+            {(c) => (
+              <span class="amc-loose-item">
+                ⇢ {c.between.join("↔")} {c.kind}
+              </span>
+            )}
+          </For>
+        </div>
+      </Show>
+
+      <div class="amc-systbl" data-slot="amicode-system-table">
+        <For each={table().components}>
+          {(c) => (
+            <div class="amc-systbl-row">
+              <span class="amc-c-id">{c.id}</span>
+              <span class="amc-c-role">{c.role}</span>
+              <Show when={c.levels !== undefined}>
+                <span class="amc-c-lvl">{c.levels} lvl</span>
+              </Show>
+              <span class="amc-c-params">{paramsText(c.params)}</span>
+            </div>
+          )}
+        </For>
+        <For each={table().couplings}>
+          {(cp) => (
+            <div class="amc-systbl-row amc-coupling">
+              <span class="amc-c-id">{cp.between.join(" ↔ ")}</span>
+              <span class="amc-c-role">{cp.kind}</span>
+              <span class="amc-c-params">{paramsText(cp.params)}</span>
+            </div>
+          )}
+        </For>
+      </div>
+
+      <Show when={hamiltonian()}>
+        {(html) => (
+          <div class="amc-ev-formula" data-slot="amicode-system-hamiltonian">
+            <div class="amc-ev-formula-label">Hamiltonian</div>
+            <div innerHTML={html()} />
+          </div>
+        )}
+      </Show>
+    </div>
+  )
+}
diff --git a/packages/ui/src/amicode/thinking-line.stories.tsx b/packages/ui/src/amicode/thinking-line.stories.tsx
new file mode 100644
index 0000000000..ede0395dd5
--- /dev/null
+++ b/packages/ui/src/amicode/thinking-line.stories.tsx
@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { AmicoMark } from "./spinner"
+import { ThinkingLine } from "./thinking-line"
+
+export default {
+  title: "Amicode/ThinkingLine",
+  id: "amicode-thinking-line",
+  tags: ["autodocs"],
+  parameters: {
+    docs: {
+      description: {
+        component: `### Thinking line
+
+The Claude-Code-esque "working" indicator shown beside the AMICO turn signature
+while a reply streams. The H-mark glyph pulses (brand motif); the gerund word
+cycles every ~2s and shimmers; the meta line ticks elapsed time (and, when the
+mount site provides them, token count + an "esc to interrupt" hint).
+
+Under \`prefers-reduced-motion\` the word is static and un-shimmered; the elapsed
+counter still advances.`,
+      },
+    },
+  },
+}
+
+const Frame = (props) => (
+  <span class="amc-sig" style={{ padding: "16px", "font-size": "13px" }}>
+    <AmicoMark running />
+    <span class="amc-wordmark">AMICO</span>
+    {props.children}
+  </span>
+)
+
+export const Default = () => (
+  <Frame>
+    <ThinkingLine />
+  </Frame>
+)
+
+export const WithTokens = () => (
+  <Frame>
+    <ThinkingLine tokens={2437} />
+  </Frame>
+)
+
+export const Interruptible = () => (
+  <Frame>
+    <ThinkingLine tokens={12800} interruptible />
+  </Frame>
+)
diff --git a/packages/ui/src/amicode/thinking-line.tsx b/packages/ui/src/amicode/thinking-line.tsx
new file mode 100644
index 0000000000..fea06b5b1b
--- /dev/null
+++ b/packages/ui/src/amicode/thinking-line.tsx
@@ -0,0 +1,67 @@
+import { createSignal, onCleanup, onMount, Show, type ComponentProps } from "solid-js"
+import { wordAt, formatElapsed, formatTokens } from "./thinking"
+
+// AMICODE: the "thinking" working indicator — a Claude-Code-esque line shown
+// beside the AMICO turn signature while a reply streams (message-part.tsx). The
+// H-mark glyph (AmicoMark, already in the signature) stays the brand motif; this
+// adds the cycling, shimmering gerund word + a live meta line (elapsed · tokens).
+// Pure bits (word rotation, label formatting) live in ./thinking for testing.
+//
+// Motion: the word swaps on a ~2s timer and shimmers via amc-text-shimmer
+// (amicode.css). Under prefers-reduced-motion the word is static ("Thinking…")
+// with no shimmer; the elapsed counter still advances (it's information, not
+// decoration). Timers clear onCleanup so a finished turn stops ticking.
+
+const WORD_MS = 2000
+const TICK_MS = 1000
+
+const reducedMotion = () =>
+  typeof window !== "undefined" && !!window.matchMedia?.("(prefers-reduced-motion: reduce)").matches
+
+export function ThinkingLine(props: {
+  /** streamed token count so far; when omitted the tokens chip is hidden */
+  tokens?: number
+  /** show the "esc to interrupt" hint — only pass when the mount site wires esc */
+  interruptible?: boolean
+  class?: string
+  style?: ComponentProps<"span">["style"]
+}) {
+  const still = reducedMotion()
+  const [elapsedMs, setElapsedMs] = createSignal(0)
+  const [tick, setTick] = createSignal(0)
+
+  onMount(() => {
+    const start = Date.now()
+    const clock = setInterval(() => setElapsedMs(Date.now() - start), TICK_MS)
+    onCleanup(() => clearInterval(clock))
+    if (!still) {
+      const words = setInterval(() => setTick((n) => n + 1), WORD_MS)
+      onCleanup(() => clearInterval(words))
+    }
+  })
+
+  const word = () => (still ? "Thinking" : wordAt(tick()))
+
+  return (
+    <span
+      class={`amc-thinking${props.class ? " " + props.class : ""}`}
+      classList={{ "is-still": still }}
+      data-slot="amc-thinking"
+      style={props.style}
+      aria-live="polite"
+    >
+      <span class="amc-thinking-word">{word()}…</span>
+      <span class="amc-thinking-meta">
+        <span class="amc-thinking-elapsed">{formatElapsed(elapsedMs())}</span>
+        <Show when={props.tokens != null}>
+          <span class="amc-thinking-sep">·</span>
+          <span class="amc-thinking-tokens">↑ {formatTokens(props.tokens!)} tokens</span>
+        </Show>
+        <Show when={props.interruptible}>
+          <span class="amc-thinking-sep">·</span>
+          <span class="amc-thinking-hint">esc to interrupt</span>
+        </Show>
+      </span>
+    </span>
+  )
+}
diff --git a/packages/ui/src/amicode/thinking.test.ts b/packages/ui/src/amicode/thinking.test.ts
new file mode 100644
index 0000000000..7f6fd304ba
--- /dev/null
+++ b/packages/ui/src/amicode/thinking.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, test } from "bun:test"
+import { THINKING_WORDS, wordAt, formatElapsed, formatTokens, turnTokens } from "./thinking"
+
+describe("thinking words", () => {
+  test("non-empty; no trailing ellipsis (the component appends it)", () => {
+    expect(THINKING_WORDS.length).toBeGreaterThan(0)
+    for (const w of THINKING_WORDS) expect(w.endsWith("…")).toBe(false)
+  })
+
+  test("wordAt cycles and wraps, including negative ticks", () => {
+    const n = THINKING_WORDS.length
+    expect(wordAt(0)).toBe(THINKING_WORDS[0])
+    expect(wordAt(n)).toBe(THINKING_WORDS[0])
+    expect(wordAt(n + 1)).toBe(THINKING_WORDS[1])
+    expect(wordAt(-1)).toBe(THINKING_WORDS[n - 1])
+  })
+})
+
+describe("formatElapsed", () => {
+  test("sub-minute", () => {
+    expect(formatElapsed(0)).toBe("0s")
+    expect(formatElapsed(999)).toBe("0s")
+    expect(formatElapsed(12_000)).toBe("12s")
+    expect(formatElapsed(-500)).toBe("0s")
+  })
+
+  test("minutes with zero-padded seconds", () => {
+    expect(formatElapsed(63_000)).toBe("1m 03s")
+    expect(formatElapsed(725_000)).toBe("12m 05s")
+  })
+})
+
+describe("turnTokens", () => {
+  test("sums output + reasoning across messages; ignores input/cache/missing", () => {
+    expect(turnTokens([])).toBe(0)
+    expect(turnTokens([{ tokens: { output: 100, reasoning: 20 } }])).toBe(120)
+    expect(
+      turnTokens([
+        { tokens: { output: 100, reasoning: 20 } },
+        { tokens: { output: 5 } },
+        { tokens: null },
+        {},
+      ]),
+    ).toBe(125)
+  })
+})
+
+describe("formatTokens", () => {
+  test("scales k / M with one decimal until 100", () => {
+    expect(formatTokens(42)).toBe("42")
+    expect(formatTokens(2_400)).toBe("2.4k")
+    expect(formatTokens(120_000)).toBe("120k")
+    expect(formatTokens(1_200_000)).toBe("1.2M")
+    expect(formatTokens(-5)).toBe("0")
+  })
+})
diff --git a/packages/ui/src/amicode/thinking.ts b/packages/ui/src/amicode/thinking.ts
new file mode 100644
index 0000000000..8bb7b7a771
--- /dev/null
+++ b/packages/ui/src/amicode/thinking.ts
@@ -0,0 +1,69 @@
+// AMICODE: pure logic for the "thinking" working indicator (thinking-line.tsx).
+// Split out from the SolidJS component so word rotation + label formatting are
+// unit-testable without a DOM (fork convention: keep message/part render thin,
+// test the pure bits — see run-series.ts / run-series.test.ts).
+
+// Whimsical-but-tasteful gerunds shown while Amico works, in the spirit of the
+// Claude Code CLI. Kept lightly on-brand (a couple of quantum-control nods among
+// the playful ones). No trailing ellipsis here — the component appends the "…".
+export const THINKING_WORDS = [
+  "Thinking",
+  "Pondering",
+  "Ruminating",
+  "Percolating",
+  "Composing",
+  "Harmonizing",
+  "Tuning",
+  "Noodling",
+  "Conjuring",
+  "Synthesizing",
+  "Reticulating",
+  "Optimizing",
+] as const
+
+/** Word for a given tick, cycling through THINKING_WORDS (wraps, incl. negatives). */
+export function wordAt(tick: number): string {
+  const n = THINKING_WORDS.length
+  const i = ((Math.floor(tick) % n) + n) % n
+  return THINKING_WORDS[i]
+}
+
+/** Compact elapsed label: 0s, 12s, 1m 03s, 12m 05s. */
+export function formatElapsed(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000))
+  const m = Math.floor(total / 60)
+  const s = total % 60
+  return m > 0 ? `${m}m ${s.toString().padStart(2, "0")}s` : `${s}s`
+}
+
+/** Minimal shape of the per-message token accounting we read
+ *  (SDK v2 AssistantMessage.tokens — we only need the two growing fields). */
+export interface TokenUsage {
+  output?: number
+  reasoning?: number
+}
+
+/** Tokens generated so far this turn — output + reasoning summed across the
+ *  turn's assistant messages. This is the number that grows while Amico works;
+ *  input/cache are excluded (they're static context, not "thinking" output). */
+export function turnTokens(messages: ReadonlyArray<{ tokens?: TokenUsage | null }>): number {
+  let n = 0
+  for (const m of messages) {
+    const t = m.tokens
+    if (!t) continue
+    n += (t.output ?? 0) + (t.reasoning ?? 0)
+  }
+  return n
+}
+
+/** Compact token label: 42 -> "42", 2400 -> "2.4k", 1_200_000 -> "1.2M". */
+export function formatTokens(n: number): string {
+  if (!Number.isFinite(n) || n < 0) return "0"
+  if (n < 1000) return String(Math.floor(n))
+  if (n < 1_000_000) {
+    const k = n / 1000
+    return `${k >= 100 ? Math.round(k) : Math.round(k * 10) / 10}k`
+  }
+  const mm = n / 1_000_000
+  return `${mm >= 100 ? Math.round(mm) : Math.round(mm * 10) / 10}M`
+}
diff --git a/packages/ui/src/amicode/ui-bridge.ts b/packages/ui/src/amicode/ui-bridge.ts
index 22bdf24509..d77ed66fda 100644
--- a/packages/ui/src/amicode/ui-bridge.ts
+++ b/packages/ui/src/amicode/ui-bridge.ts
@@ -1,12 +1,26 @@
+import type { WidgetHostCallbacks } from "./widget-frame"
+
 // AMICODE: register/dispatch singleton connecting receipt/chip clicks to the
 // one component that holds app context (the entity rail registers handlers on
 // mount, unregisters on cleanup — the ask-bridge idiom). Unregistered → no-op.
+
+// Stage 2 chat authoring: the in-chat widget preview needs the same server
+// context the home grid has (frame src base, host callbacks) plus a pin verb.
+// Provided by the app alongside fetchRunSeries; optional so a host that can't
+// render widgets (e.g. TUI) simply shows a fallback note.
+export type AmicodeWidgetHost = {
+  frameSrc: (id: string, hash: string) => string
+  callbacks: WidgetHostCallbacks
+  pin: (id: string, size: "hero" | "tile") => Promise<unknown>
+}
+
 export type AmicodeUiBridge = {
   openEntity: (kind: string, seq?: number) => void
   openSwitcher: () => void
   // spec C: transport for the in-chat run window, provided by the app (the rail
   // holds server context). Optional so older registrations stay valid.
   fetchRunSeries?: (run: string, lab?: string) => Promise<unknown>
+  widgetHost?: AmicodeWidgetHost
 }
 let bridge: AmicodeUiBridge | undefined
 export function registerAmicodeUiBridge(next: AmicodeUiBridge): () => void {
@@ -25,3 +39,7 @@ export function openAmicodeSwitcher(): void {
 export function fetchAmicodeRunSeries(run: string, lab?: string): Promise<unknown> | undefined {
   return bridge?.fetchRunSeries?.(run, lab)
 }
+/** The widget-host transport for the in-chat preview; undefined ⇒ no host. */
+export function amicodeWidgetHost(): AmicodeWidgetHost | undefined {
+  return bridge?.widgetHost
+}
diff --git a/packages/ui/src/amicode/widget-allowlist.ts b/packages/ui/src/amicode/widget-allowlist.ts
new file mode 100644
index 0000000000..efbdd9b446
--- /dev/null
+++ b/packages/ui/src/amicode/widget-allowlist.ts
@@ -0,0 +1,38 @@
+// AMICODE (widget kernel): the security seam — which server paths and host
+// actions a sandboxed widget may reach through the bridge. Exact route match
+// or route + "?" query; no bare-prefix rides (/amicode/problem-x must NOT
+// pass via /amicode/problem). Pure, unit-tested.
+
+const FETCH_ROUTES = [
+  "/amicode/profile",
+  "/amicode/problems",
+  "/amicode/problem",
+  "/amicode/run-status",
+  "/amicode/run-series",
+  "/amicode/run-cards",
+  "/amicode/library",
+  "/amicode/widgets",
+  "/amicode/dashboard",
+] as const
+
+const ACTION_VERBS = [
+  "resume-session",
+  "save-profile",
+  "lookup-institution",
+  "resolve-logo",
+  "open-external",
+  "upload-library",
+  "open-gallery",
+  "warm-start",
+] as const
+
+export type ActionVerb = (typeof ACTION_VERBS)[number]
+
+export function allowFetch(path: unknown): path is string {
+  if (typeof path !== "string") return false
+  return FETCH_ROUTES.some((route) => path === route || path.startsWith(route + "?"))
+}
+
+export function allowAction(verb: unknown): verb is ActionVerb {
+  return typeof verb === "string" && (ACTION_VERBS as readonly string[]).includes(verb)
+}
diff --git a/packages/ui/src/amicode/widget-bridge.test.ts b/packages/ui/src/amicode/widget-bridge.test.ts
new file mode 100644
index 0000000000..e478298121
--- /dev/null
+++ b/packages/ui/src/amicode/widget-bridge.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test"
+import { handleWidgetMessage, type BridgeDeps } from "./widget-bridge"
+
+function deps(over: Partial<BridgeDeps> = {}) {
+  const calls: Record<string, unknown[]> = { fetch: [], action: [], prompt: [], open: [], post: [], height: [], empty: [], error: [], ready: [] }
+  const d: BridgeDeps = {
+    fetch: async (p) => {
+      calls.fetch.push(p)
+      return { ok: true }
+    },
+    action: async (v, payload) => {
+      calls.action.push([v, payload])
+      return { done: true }
+    },
+    prompt: (t) => void calls.prompt.push(t),
+    open: (e) => void calls.open.push(e),
+    ready: () => void calls.ready.push(true),
+    height: (h) => void calls.height.push(h),
+    empty: (e) => void calls.empty.push(e),
+    error: (m) => void calls.error.push(m),
+    post: (m) => void calls.post.push(m),
+    ...over,
+  }
+  return { d, calls }
+}
+
+describe("handleWidgetMessage", () => {
+  test("allowed fetch → deps.fetch called, ok result posted with id", async () => {
+    const { d, calls } = deps()
+    await handleWidgetMessage({ t: "amc:fetch", id: 7, path: "/amicode/profile" }, d)
+    expect(calls.fetch).toEqual(["/amicode/profile"])
+    expect(calls.post[0]).toEqual({ t: "amc:result", id: 7, ok: true, data: { ok: true } })
+  })
+
+  test("disallowed fetch → error result, fetcher NOT called", async () => {
+    const { d, calls } = deps()
+    await handleWidgetMessage({ t: "amc:fetch", id: 8, path: "/session" }, d)
+    expect(calls.fetch).toEqual([])
+    expect((calls.post[0] as any).ok).toBe(false)
+  })
+
+  test("fetch failure → error result, never throws", async () => {
+    const { d, calls } = deps({
+      fetch: async () => {
+        throw new Error("HTTP 500")
+      },
+    })
+    await handleWidgetMessage({ t: "amc:fetch", id: 9, path: "/amicode/profile" }, d)
+    expect((calls.post[0] as any).error).toBe("HTTP 500")
+  })
+
+  test("allowed action routed with payload; disallowed rejected", async () => {
+    const { d, calls } = deps()
+    await handleWidgetMessage({ t: "amc:action", id: 1, verb: "save-profile", payload: { name: "A" } }, d)
+    expect(calls.action[0]).toEqual(["save-profile", { name: "A" }])
+    await handleWidgetMessage({ t: "amc:action", id: 2, verb: "rm-rf" }, d)
+    expect(calls.action).toHaveLength(1)
+    expect((calls.post[1] as any).ok).toBe(false)
+  })
+
+  test("prompt / open / height / empty / error / ready routed", async () => {
+    const { d, calls } = deps()
+    await handleWidgetMessage({ t: "amc:prompt", text: "hi" }, d)
+    await handleWidgetMessage({ t: "amc:open", entity: "run" }, d)
+    await handleWidgetMessage({ t: "amc:height", h: 120 }, d)
+    await handleWidgetMessage({ t: "amc:empty", empty: true }, d)
+    await handleWidgetMessage({ t: "amc:empty", empty: false }, d)
+    await handleWidgetMessage({ t: "amc:error", message: "boom" }, d)
+    await handleWidgetMessage({ t: "amc:ready" }, d)
+    expect(calls.prompt).toEqual(["hi"])
+    expect(calls.open).toEqual(["run"])
+    expect(calls.height).toEqual([120])
+    expect(calls.empty).toEqual([true, false])
+    expect(calls.error).toEqual(["boom"])
+    expect(calls.ready).toEqual([true])
+  })
+
+  test("malformed messages ignored (frames are untrusted)", async () => {
+    const { d, calls } = deps()
+    await handleWidgetMessage(null, d)
+    await handleWidgetMessage({ t: "amc:height", h: "tall" }, d)
+    await handleWidgetMessage({ t: "amc:empty", empty: "yes" }, d)
+    await handleWidgetMessage({ t: "amc:fetch", path: "/amicode/profile" }, d) // no id
+    await handleWidgetMessage({ t: "wat" }, d)
+    expect(calls.post).toEqual([])
+    expect(calls.height).toEqual([])
+    expect(calls.fetch).toEqual([])
+  })
+})
diff --git a/packages/ui/src/amicode/widget-bridge.ts b/packages/ui/src/amicode/widget-bridge.ts
new file mode 100644
index 0000000000..35e2f4a9f7
--- /dev/null
+++ b/packages/ui/src/amicode/widget-bridge.ts
@@ -0,0 +1,93 @@
+// AMICODE (widget kernel): host side of bridge protocol v1 — the single seam
+// between sandboxed widget frames and the app. All I/O crosses here, which
+// makes this the enforcement point for the fetch/action allowlists. Pure
+// handler (deps injected) so the message routing is unit-testable; the JSX
+// frame component stays a thin shell.
+import { allowAction, allowFetch } from "./widget-allowlist"
+
+export const HOST_BRIDGE_VERSION = 1
+
+export type FrameMessage =
+  | { t: "amc:ready" }
+  | { t: "amc:height"; h: number }
+  | { t: "amc:empty"; empty: boolean }
+  | { t: "amc:fetch"; id: number; path: unknown }
+  | { t: "amc:action"; id: number; verb: unknown; payload?: unknown }
+  | { t: "amc:prompt"; text: string }
+  | { t: "amc:open"; entity: string }
+  | { t: "amc:error"; message: string }
+
+export interface BridgeDeps {
+  /** allowlist-checked already; performs the GET and returns parsed JSON */
+  fetch: (path: string) => Promise<unknown>
+  /** allowlist-checked already; executes a host action */
+  action: (verb: string, payload: unknown) => Promise<unknown>
+  prompt: (text: string) => void
+  open: (entity: string) => void
+  ready: () => void
+  height: (h: number) => void
+  /** explicit empty-state signal (MutationObserver-driven; layout-independent) */
+  empty: (empty: boolean) => void
+  error: (message: string) => void
+  /** post amc:result back into the frame */
+  post: (msg: { t: "amc:result"; id: number; ok: boolean; data?: unknown; error?: string }) => void
+}
+
+/** Route one frame→host message. Unknown/malformed messages are ignored —
+ *  frames are untrusted. Returns a promise so tests can await completion. */
+export async function handleWidgetMessage(raw: unknown, deps: BridgeDeps): Promise<void> {
+  if (typeof raw !== "object" || raw === null) return
+  const msg = raw as Record<string, unknown>
+  switch (msg.t) {
+    case "amc:ready":
+      deps.ready()
+      return
+    case "amc:height":
+      if (typeof msg.h === "number" && Number.isFinite(msg.h) && msg.h >= 0) deps.height(msg.h)
+      return
+    case "amc:empty":
+      if (typeof msg.empty === "boolean") deps.empty(msg.empty)
+      return
+    case "amc:prompt":
+      if (typeof msg.text === "string") deps.prompt(msg.text)
+      return
+    case "amc:open":
+      if (typeof msg.entity === "string") deps.open(msg.entity)
+      return
+    case "amc:error":
+      deps.error(typeof msg.message === "string" ? msg.message : "widget error")
+      return
+    case "amc:fetch": {
+      const id = msg.id
+      if (typeof id !== "number") return
+      if (!allowFetch(msg.path)) {
+        deps.post({ t: "amc:result", id, ok: false, error: `fetch not allowed: ${String(msg.path)}` })
+        return
+      }
+      try {
+        const data = await deps.fetch(msg.path)
+        deps.post({ t: "amc:result", id, ok: true, data })
+      } catch (e) {
+        deps.post({ t: "amc:result", id, ok: false, error: (e as Error).message })
+      }
+      return
+    }
+    case "amc:action": {
+      const id = msg.id
+      if (typeof id !== "number") return
+      if (!allowAction(msg.verb)) {
+        deps.post({ t: "amc:result", id, ok: false, error: `action not allowed: ${String(msg.verb)}` })
+        return
+      }
+      try {
+        const data = await deps.action(msg.verb as string, msg.payload ?? {})
+        deps.post({ t: "amc:result", id, ok: true, data })
+      } catch (e) {
+        deps.post({ t: "amc:result", id, ok: false, error: (e as Error).message })
+      }
+      return
+    }
+    default:
+      return
+  }
+}
diff --git a/packages/ui/src/amicode/widget-config-form.tsx b/packages/ui/src/amicode/widget-config-form.tsx
new file mode 100644
index 0000000000..e4bce474cd
--- /dev/null
+++ b/packages/ui/src/amicode/widget-config-form.tsx
@@ -0,0 +1,105 @@
+import { For, Show } from "solid-js"
+import type { FormField } from "./widget-schema"
+
+// AMICODE (widget kernel): the ⚙ form, GENERATED from a widget's manifest
+// config schema (widget-schema.formModel). Every change calls onChange
+// immediately — the grid saves state per change, no save button (spec T2.6).
+
+const LABEL: Record<string, string> = {}
+
+function labelFor(key: string): string {
+  return LABEL[key] ?? key.replace(/[_-]/g, " ")
+}
+
+const INPUT_STYLE = {
+  "font-size": "11px",
+  padding: "2px 6px",
+  border: "1px solid var(--v2-border-border-base)",
+  "border-radius": "4px",
+  background: "var(--v2-background-bg-base)",
+  color: "var(--v2-text-text-base)",
+} as const
+
+export function WidgetConfigForm(props: { fields: FormField[]; onChange: (key: string, value: unknown) => void }) {
+  return (
+    <div
+      data-component="amicode-widget-config"
+      style={{
+        display: "flex",
+        "flex-direction": "column",
+        gap: "6px",
+        padding: "8px 10px",
+        border: "1px solid var(--v2-border-border-base)",
+        "border-radius": "8px",
+        background: "var(--v2-background-bg-layer-02)",
+        "font-size": "11px",
+        color: "var(--v2-text-text-muted)",
+      }}
+    >
+      <Show when={props.fields.length === 0}>
+        <span>nothing to configure</span>
+      </Show>
+      <For each={props.fields}>
+        {(field) => (
+          <label style={{ display: "flex", "align-items": "center", gap: "8px", "min-width": "0" }}>
+            <span style={{ flex: "0 0 90px", overflow: "hidden", "text-overflow": "ellipsis" }}>
+              {labelFor(field.key)}
+            </span>
+            {field.kind === "boolean" ? (
+              <input
+                type="checkbox"
+                checked={field.value}
+                onChange={(e) => props.onChange(field.key, e.currentTarget.checked)}
+              />
+            ) : field.kind === "select" ? (
+              <select
+                value={field.value}
+                onChange={(e) => props.onChange(field.key, e.currentTarget.value)}
+                style={INPUT_STYLE}
+              >
+                <For each={field.options}>{(o) => <option value={o}>{o}</option>}</For>
+              </select>
+            ) : field.kind === "multi-select" ? (
+              <span style={{ display: "flex", gap: "8px", "flex-wrap": "wrap" }}>
+                <For each={field.options}>
+                  {(o) => (
+                    <label style={{ display: "inline-flex", gap: "3px", "align-items": "center" }}>
+                      <input
+                        type="checkbox"
+                        checked={field.value.includes(o)}
+                        onChange={(e) => {
+                          const next = e.currentTarget.checked
+                            ? [...field.value, o]
+                            : field.value.filter((x) => x !== o)
+                          props.onChange(field.key, next)
+                        }}
+                      />
+                      {o}
+                    </label>
+                  )}
+                </For>
+              </span>
+            ) : field.kind === "number" ? (
+              <input
+                type="number"
+                value={field.value}
+                min={field.min}
+                max={field.max}
+                onChange={(e) => props.onChange(field.key, Number(e.currentTarget.value))}
+                style={{ ...INPUT_STYLE, width: "70px" }}
+              />
+            ) : (
+              <input
+                type="text"
+                value={field.value}
+                maxLength={field.maxLength}
+                onChange={(e) => props.onChange(field.key, e.currentTarget.value)}
+                style={{ ...INPUT_STYLE, flex: "1" }}
+              />
+            )}
+          </label>
+        )}
+      </For>
+    </div>
+  )
+}
diff --git a/packages/ui/src/amicode/widget-frame.tsx b/packages/ui/src/amicode/widget-frame.tsx
new file mode 100644
index 0000000000..b4cf45bf9e
--- /dev/null
+++ b/packages/ui/src/amicode/widget-frame.tsx
@@ -0,0 +1,154 @@
+import { Show, createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
+import { HOST_BRIDGE_VERSION, handleWidgetMessage } from "./widget-bridge"
+import type { WidgetInfo } from "./widget-schema"
+import type { Density } from "./widget-tokens"
+
+// AMICODE (widget kernel): one sandboxed iframe per widget. THIN SHELL — all
+// message routing lives in widget-bridge.ts (tested); this component only
+// wires DOM events to it and owns the three visual states: loading (manifest
+// height placeholder), running (content-height frame), error card. A widget
+// that reports height 0 is an empty-state: the host collapses the cell
+// (grid hides it outside edit mode). Bridge-version gate: a widget declaring
+// a newer bridge than this host supports never mounts — error card instead.
+// The frame loads a SERVER-SERVED document (/amicode/widget-frame?id=), not
+// srcdoc: srcdoc inherits the app's CSP, which forbids the inline runtime.
+// sandbox="allow-scripts" keeps the origin opaque regardless of the src.
+
+const LOAD_TIMEOUT_MS = 5000
+
+export interface WidgetHostCallbacks {
+  fetch: (path: string) => Promise<unknown>
+  action: (verb: string, payload: unknown) => Promise<unknown>
+  prompt: (text: string) => void
+  open: (entity: string) => void
+}
+
+export function WidgetFrame(props: {
+  widget: WidgetInfo
+  frameSrc: string | undefined // full /amicode/widget-frame URL; undefined while resolving
+  config: Record<string, unknown>
+  context: Record<string, unknown>
+  tokens: Record<string, string>
+  density: Density
+  callbacks: WidgetHostCallbacks
+  onHeight?: (h: number) => void
+  /** explicit empty-state (never inferred from height — hidden frames have no layout) */
+  onEmpty?: (empty: boolean) => void
+}) {
+  const [error, setError] = createSignal<string | undefined>(undefined)
+  const [height, setHeight] = createSignal<number>(props.widget.height)
+  const [booted, setBooted] = createSignal(false)
+  let iframe: HTMLIFrameElement | undefined
+  let timeout: ReturnType<typeof setTimeout> | undefined
+
+  const versionBlocked = createMemo(() => props.widget.bridge > HOST_BRIDGE_VERSION)
+
+  const src = createMemo(() => (versionBlocked() ? undefined : props.frameSrc))
+
+  const postToFrame = (msg: unknown) => {
+    iframe?.contentWindow?.postMessage(msg, "*")
+  }
+
+  const onMessage = (e: MessageEvent) => {
+    if (!iframe || e.source !== iframe.contentWindow) return
+    void handleWidgetMessage(e.data, {
+      fetch: props.callbacks.fetch,
+      action: props.callbacks.action,
+      prompt: props.callbacks.prompt,
+      open: props.callbacks.open,
+      ready: () => {
+        setBooted(true)
+        if (timeout !== undefined) clearTimeout(timeout)
+        postToFrame({
+          t: "amc:init",
+          v: HOST_BRIDGE_VERSION,
+          config: props.config,
+          theme: props.tokens,
+          context: props.context,
+          density: props.density,
+        })
+      },
+      height: (h) => {
+        if (h > 0) setHeight(h)
+        props.onHeight?.(h)
+      },
+      empty: (empty) => props.onEmpty?.(empty),
+      error: (message) => setError(message),
+      post: postToFrame,
+    })
+  }
+
+  createEffect(() => {
+    if (src() === undefined) return
+    window.addEventListener("message", onMessage)
+    timeout = setTimeout(() => {
+      if (!booted()) setError("widget did not boot within 5s")
+    }, LOAD_TIMEOUT_MS)
+    onCleanup(() => {
+      window.removeEventListener("message", onMessage)
+      if (timeout !== undefined) clearTimeout(timeout)
+    })
+  })
+
+  // live updates ride the bridge, no frame reload
+  createEffect(on(() => props.config, (c) => booted() && postToFrame({ t: "amc:config", config: c }), { defer: true }))
+  createEffect(on(() => props.context, (c) => booted() && postToFrame({ t: "amc:context", context: c }), { defer: true }))
+  createEffect(
+    on(
+      () => [props.tokens, props.density] as const,
+      ([tokens, density]) => booted() && postToFrame({ t: "amc:theme", theme: tokens, density }),
+      { defer: true },
+    ),
+  )
+
+  return (
+    <Show
+      when={!versionBlocked() && !error()}
+      fallback={
+        <div
+          data-component="amicode-widget-error"
+          style={{
+            border: "1px solid var(--v2-border-border-base)",
+            "border-radius": "10px",
+            background: "var(--v2-background-bg-layer-01)",
+            padding: "10px 12px",
+            "font-size": "11px",
+            color: "var(--v2-text-text-muted)",
+            display: "flex",
+            "flex-direction": "column",
+            gap: "4px",
+          }}
+        >
+          <span style={{ "font-weight": "600", color: "var(--v2-text-text-base)" }}>
+            {props.widget.name} <span style={{ color: "var(--v2-state-fg-danger)" }}>failed</span>
+          </span>
+          <span style={{ "word-break": "break-word" }}>
+            {versionBlocked()
+              ? `needs bridge v${props.widget.bridge}; this host speaks v${HOST_BRIDGE_VERSION}`
+              : error()}
+          </span>
+          <Show when={props.widget.path}>
+            <span style={{ "font-family": "var(--font-family-mono, monospace)", "font-size": "10px", color: "var(--v2-text-text-faint)" }}>
+              {props.widget.path}
+            </span>
+          </Show>
+        </div>
+      }
+    >
+      <iframe
+        ref={iframe}
+        title={props.widget.name}
+        sandbox="allow-scripts"
+        src={src()}
+        style={{
+          display: "block",
+          width: "100%",
+          height: `${height()}px`,
+          border: "none",
+          background: "transparent",
+          "color-scheme": "normal",
+        }}
+      />
+    </Show>
+  )
+}
diff --git a/packages/ui/src/amicode/widget-grid.tsx b/packages/ui/src/amicode/widget-grid.tsx
new file mode 100644
index 0000000000..3d475c0ae3
--- /dev/null
+++ b/packages/ui/src/amicode/widget-grid.tsx
@@ -0,0 +1,295 @@
+import { For, Show, createMemo, createSignal } from "solid-js"
+import { WidgetFrame, type WidgetHostCallbacks } from "./widget-frame"
+import { WidgetConfigForm } from "./widget-config-form"
+import { formModel, type DashboardEntry, type DashboardState, type WidgetInfo } from "./widget-schema"
+import type { Density } from "./widget-tokens"
+
+// AMICODE (widget kernel): the dashboard — replaces the hardcoded
+// AmicodeHomeCards strip. Renders the state's visible entries as sandboxed
+// WidgetFrames: hero widgets in the top auto-fit grid, tiles in the auto-fit
+// row below. "Customize" (in the chrome strip) flips edit mode. In edit mode
+// the cards STAY VISIBLE — a light scrim + dashed ring signal "you're
+// arranging, not using" — and each card gets ONE compact control pill in its
+// top-right corner: ↑↓ reorder within its row, ⚙ config, fork (built-ins),
+// × hide. A banner up top orients; a tray at the bottom re-adds hidden
+// widgets. Every change calls props.onSave immediately (the app POSTs and
+// feeds merged state back down). Reorder is button-based, not drag (declared
+// spec deviation), so the corner pill can safely overlay the iframe: clicks
+// land host-side above the frame; only a click-DRAG through a frame is eaten.
+
+type Bucket = "hero" | "tile"
+
+export function WidgetGrid(props: {
+  widgets: WidgetInfo[]
+  dashboard: DashboardState
+  frameSrcs: Record<string, string> // widget id → /amicode/widget-frame URL
+  tokens: Record<string, string>
+  density: Density
+  context: Record<string, unknown>
+  callbacks: WidgetHostCallbacks
+  onSave: (state: DashboardState) => void
+  onFork: (id: string) => void
+  /** controlled edit mode (spec T3.1: `customize` lives in the chrome strip);
+   *  omit both to keep the grid's internal toggle */
+  editing?: boolean
+  onEditingChange?: (editing: boolean) => void
+}) {
+  const [internalEditing, setInternalEditing] = createSignal(false)
+  const controlled = () => props.editing !== undefined
+  const editing = () => (controlled() ? props.editing === true : internalEditing())
+  const setEditing = (v: boolean) => {
+    if (controlled()) props.onEditingChange?.(v)
+    else setInternalEditing(v)
+  }
+  const [configOpen, setConfigOpen] = createSignal<string | undefined>(undefined)
+  const [empties, setEmpties] = createSignal<Record<string, boolean>>({})
+
+  const infoFor = (id: string) => props.widgets.find((w) => w.id === id)
+  const bucketOf = (id: string): Bucket => (infoFor(id)?.size === "hero" ? "hero" : "tile")
+  const visible = createMemo(() => props.dashboard.widget.filter((e) => !e.hidden))
+  const hidden = createMemo(() => props.dashboard.widget.filter((e) => e.hidden))
+  const heroes = createMemo(() => visible().filter((e) => bucketOf(e.id) === "hero"))
+  const tiles = createMemo(() => visible().filter((e) => bucketOf(e.id) === "tile"))
+
+  const save = (mutate: (entries: DashboardEntry[]) => DashboardEntry[]) => {
+    // spread first: reserved top-level keys (views, scope — spec T3.6) survive
+    props.onSave({ ...props.dashboard, version: 1, widget: mutate(props.dashboard.widget.map((e) => ({ ...e }))) })
+  }
+  const setHidden = (key: string, value: boolean) =>
+    save((entries) => entries.map((e) => (e.key === key ? { ...e, hidden: value } : e)))
+  const setConfig = (key: string, field: string, value: unknown) =>
+    save((entries) => entries.map((e) => (e.key === key ? { ...e, config: { ...e.config, [field]: value } } : e)))
+  const move = (key: string, dir: -1 | 1) =>
+    save((entries) => {
+      const target = entries.find((x) => x.key === key)
+      if (!target) return entries
+      const group = entries.filter((e) => !e.hidden && bucketOf(e.id) === bucketOf(target.id))
+      const gi = group.findIndex((e) => e.key === key)
+      const swapWith = group[gi + dir]
+      if (gi < 0 || !swapWith) return entries
+      const i = entries.findIndex((e) => e.key === key)
+      const j = entries.findIndex((e) => e.key === swapWith.key)
+      const next = [...entries]
+      ;[next[i], next[j]] = [next[j], next[i]]
+      return next
+    })
+
+  // position within the visible row (used to disable ↑ on first / ↓ on last)
+  const posInRow = (key: string, id: string) => {
+    const group = visible().filter((e) => bucketOf(e.id) === bucketOf(id))
+    return { idx: group.findIndex((e) => e.key === key), len: group.length }
+  }
+
+  const PillButton = (p: {
+    label: string
+    title: string
+    onClick: () => void
+    disabled?: boolean
+    class?: string
+  }) => (
+    <button type="button" title={p.title} disabled={p.disabled} class={p.class} onClick={p.onClick}>
+      {p.label}
+    </button>
+  )
+
+  // the floating corner control cluster — one grouped pill, not five loose boxes
+  const ControlPill = (p: { entry: DashboardEntry; w: WidgetInfo }) => {
+    const pos = createMemo(() => posInRow(p.entry.key, p.w.id))
+    const hasConfig = createMemo(() => Object.keys(p.w.config).length > 0)
+    return (
+      <div class="amc-wg-pill">
+        <PillButton label="↑" title="Move earlier" disabled={pos().idx <= 0} onClick={() => move(p.entry.key, -1)} />
+        <PillButton
+          label="↓"
+          title="Move later"
+          disabled={pos().idx < 0 || pos().idx >= pos().len - 1}
+          onClick={() => move(p.entry.key, 1)}
+        />
+        <Show when={hasConfig() || p.w.builtin}>
+          <span class="amc-wg-sep" />
+        </Show>
+        <Show when={hasConfig()}>
+          <PillButton
+            label="⚙"
+            title="Configure"
+            onClick={() => setConfigOpen(configOpen() === p.entry.key ? undefined : p.entry.key)}
+          />
+        </Show>
+        <Show when={p.w.builtin}>
+          <PillButton
+            label="fork"
+            class="amc-wg-fork"
+            title="Duplicate into ~/.amico/widgets as your own editable copy"
+            onClick={() => props.onFork(p.w.id)}
+          />
+        </Show>
+        <span class="amc-wg-sep" />
+        <PillButton label="×" class="amc-wg-danger" title="Remove from dashboard" onClick={() => setHidden(p.entry.key, true)} />
+      </div>
+    )
+  }
+
+  const Cell = (p: { entry: DashboardEntry }) => {
+    const info = createMemo(() => infoFor(p.entry.id))
+    const empty = createMemo(() => empties()[p.entry.key] === true)
+    // a cell shows a labeled placeholder (rather than the frame) when it has
+    // nothing to render but must stay reachable in edit mode
+    const asPlaceholder = createMemo(() => editing() && (!info() || empty()))
+
+    // when NOT editing, a cell with nothing to render (missing widget or an
+    // empty-state) collapses out of the grid entirely — otherwise it would
+    // hold an empty column track. The frame (when present) stays MOUNTED under
+    // display:none so its amc:empty signal keeps flowing and the cell can
+    // re-appear if the widget later has content (hidden frames have no layout,
+    // so emptiness is never inferred from height — it's an explicit signal).
+    const collapsed = createMemo(() => !editing() && (!info() || empty()))
+
+    return (
+      <div
+        data-component="amicode-widget-cell"
+        data-widget={p.entry.id}
+        data-editing={editing() ? "true" : "false"}
+        style={{ display: collapsed() ? "none" : undefined }}
+      >
+        <Show
+          when={info()}
+          fallback={
+            // unknown id (not-yet-synced user widget): reachable only in edit mode
+            <Show when={editing()}>
+              <div class="amc-wg-placeholder">
+                <span style={{ flex: "1" }}>{p.entry.id} — not installed</span>
+                <div class="amc-wg-pill" style={{ position: "static", "box-shadow": "none" }}>
+                  <PillButton label="×" class="amc-wg-danger" title="Remove from dashboard" onClick={() => setHidden(p.entry.key, true)} />
+                </div>
+              </div>
+            </Show>
+          }
+        >
+          {(w) => (
+            <>
+              <Show when={asPlaceholder()}>
+                <div class="amc-wg-framewrap">
+                  <div class="amc-wg-placeholder">
+                    <span style={{ flex: "1" }}>
+                      {w().name} <span class="amc-wg-empty">· nothing to show right now</span>
+                    </span>
+                  </div>
+                  <ControlPill entry={p.entry} w={w()} />
+                </div>
+              </Show>
+
+              <Show when={!asPlaceholder()}>
+                <div class="amc-wg-framewrap">
+                  <WidgetFrame
+                    widget={w()}
+                    frameSrc={props.frameSrcs[w().id]}
+                    config={p.entry.config}
+                    context={props.context}
+                    tokens={props.tokens}
+                    density={props.density}
+                    callbacks={props.callbacks}
+                    onEmpty={(e) => setEmpties((prev) => ({ ...prev, [p.entry.key]: e }))}
+                  />
+                  <Show when={editing()}>
+                    <div class="amc-wg-scrim" />
+                    <div class="amc-wg-name">{w().name}</div>
+                    <ControlPill entry={p.entry} w={w()} />
+                  </Show>
+                </div>
+              </Show>
+
+              <Show when={editing() && configOpen() === p.entry.key}>
+                <div style={{ "margin-top": "6px" }}>
+                  <WidgetConfigForm
+                    fields={formModel(w().config, p.entry.config)}
+                    onChange={(field, value) => setConfig(p.entry.key, field, value)}
+                  />
+                </div>
+              </Show>
+            </>
+          )}
+        </Show>
+      </div>
+    )
+  }
+
+  return (
+    <div data-component="amicode-widget-grid" style={{ display: "flex", "flex-direction": "column", gap: "12px" }}>
+      <Show when={!controlled()}>
+        <div style={{ display: "flex", "justify-content": "flex-end" }}>
+          <button
+            type="button"
+            data-slot="amicode-grid-customize"
+            onClick={() => {
+              setEditing(!editing())
+              setConfigOpen(undefined)
+            }}
+            style={{
+              border: "none",
+              background: "transparent",
+              color: editing() ? "var(--v2-text-text-accent)" : "var(--v2-text-text-faint)",
+              "font-size": "11px",
+              cursor: "pointer",
+              padding: "0",
+            }}
+          >
+            {editing() ? "done" : "customize"}
+          </button>
+        </div>
+      </Show>
+
+      <Show when={editing()}>
+        <div data-component="amicode-widget-editbar">
+          <span>
+            <b>Customizing your dashboard</b> — use each card's corner controls to reorder <b>↑↓</b>, configure <b>⚙</b>, or
+            remove <b>×</b>. Changes save as you go.
+          </span>
+          <button
+            type="button"
+            class="amc-wg-editdone"
+            onClick={() => {
+              setEditing(false)
+              setConfigOpen(undefined)
+            }}
+          >
+            Done
+          </button>
+        </div>
+      </Show>
+
+      <Show when={heroes().length > 0}>
+        {/* panel-first (spec T3.4): 2-up when the canvas allows, stacked below */}
+        <div style={{ display: "grid", "grid-template-columns": "repeat(auto-fit, minmax(300px, 1fr))", gap: "12px" }}>
+          <For each={heroes()}>{(entry) => <Cell entry={entry} />}</For>
+        </div>
+      </Show>
+
+      <Show when={tiles().length > 0}>
+        <div style={{ display: "grid", "grid-template-columns": "repeat(auto-fit, minmax(150px, 1fr))", gap: "8px" }}>
+          <For each={tiles()}>{(entry) => <Cell entry={entry} />}</For>
+        </div>
+      </Show>
+
+      {/* add-back tray — edit mode only, only when something is hidden */}
+      <Show when={editing() && hidden().length > 0}>
+        <div
+          data-component="amicode-widget-tray"
+          style={{
+            padding: "8px 10px",
+            border: "1px dashed var(--v2-border-border-base)",
+            "border-radius": "8px",
+          }}
+        >
+          <span class="amc-wg-traylabel">add a widget</span>
+          <For each={hidden()}>
+            {(entry) => (
+              <button type="button" class="amc-wg-add" onClick={() => setHidden(entry.key, false)}>
+                + {infoFor(entry.id)?.name ?? entry.id}
+              </button>
+            )}
+          </For>
+        </div>
+      </Show>
+    </div>
+  )
+}
diff --git a/packages/ui/src/amicode/widget-preview-card.tsx b/packages/ui/src/amicode/widget-preview-card.tsx
new file mode 100644
index 0000000000..b4f6957894
--- /dev/null
+++ b/packages/ui/src/amicode/widget-preview-card.tsx
@@ -0,0 +1,102 @@
+import { For, Show, createMemo, createSignal } from "solid-js"
+import { WidgetFrame } from "./widget-frame"
+import type { WidgetInfo } from "./widget-schema"
+import { amicodeWidgetHost } from "./ui-bridge"
+import { resolveTokens, densityForViewport } from "./widget-tokens"
+import type { WidgetPreview } from "./widget-preview"
+
+// AMICODE (Stage 2 chat authoring): renders an amicode_author_widget tool
+// result as a LIVE preview of the just-authored widget, inside the chat. Reuses
+// the exact frame kernel the home grid uses (server-served sandboxed frame +
+// bridge), reading the server context (frame src base, host callbacks, pin
+// verb) off the ui-bridge — same idiom as the RunWindow. "Pin to dashboard"
+// adds it to home. Re-authoring the same id emits a new hash → a fresh preview
+// with the updated code (hot-reload). No host registered (e.g. TUI) → a plain
+// note, never a crash.
+
+export function WidgetPreviewCard(props: { preview: WidgetPreview }) {
+  const host = createMemo(() => amicodeWidgetHost())
+  const [pinState, setPinState] = createSignal<"idle" | "pinning" | "pinned" | "error">("idle")
+
+  const info = createMemo<WidgetInfo>(() => ({
+    id: props.preview.id,
+    name: props.preview.name,
+    version: "1.0.0",
+    bridge: 1,
+    description: "",
+    size: props.preview.size,
+    height: props.preview.height,
+    config: {},
+    builtin: false,
+    overridden: false,
+    hash: props.preview.hash,
+    path: null,
+  }))
+
+  // computed at mount — a preview doesn't need live theme reactivity
+  const style = getComputedStyle(document.documentElement)
+  const density = densityForViewport(window.innerWidth, window.innerHeight)
+  const tokens = resolveTokens((n) => style.getPropertyValue(n), density)
+
+  const pin = () => {
+    const h = host()
+    if (!h || pinState() === "pinning" || pinState() === "pinned") return
+    setPinState("pinning")
+    void h
+      .pin(props.preview.id, props.preview.size)
+      .then(() => setPinState("pinned"))
+      .catch(() => setPinState("error"))
+  }
+  const pinLabel = () =>
+    ({ idle: "Pin to dashboard", pinning: "Pinning…", pinned: "Pinned to dashboard ✓", error: "Couldn’t pin — retry" })[
+      pinState()
+    ]
+
+  return (
+    <div data-component="amicode-widget-preview" data-size={props.preview.size}>
+      <div class="amc-wp-head">
+        <span class="amc-wp-eyebrow">Widget preview</span>
+        <span class="amc-wp-name">{props.preview.name}</span>
+        <span class="amc-wp-badge">{props.preview.size}</span>
+      </div>
+
+      <Show
+        when={host()}
+        fallback={<div class="amc-wp-note">Open your Amicode dashboard to see “{props.preview.name}”.</div>}
+      >
+        {(h) => (
+          <div class="amc-wp-stage">
+            <WidgetFrame
+              widget={info()}
+              frameSrc={h().frameSrc(props.preview.id, props.preview.hash)}
+              config={{}}
+              context={{}}
+              tokens={tokens}
+              density={density}
+              callbacks={h().callbacks}
+            />
+          </div>
+        )}
+      </Show>
+
+      <Show when={props.preview.warnings.length > 0}>
+        <ul class="amc-wp-warnings">
+          <For each={props.preview.warnings}>{(w) => <li>{w}</li>}</For>
+        </ul>
+      </Show>
+
+      <div class="amc-wp-foot">
+        <button
+          type="button"
+          class="amc-wp-pin"
+          data-state={pinState()}
+          disabled={!host() || pinState() === "pinning" || pinState() === "pinned"}
+          onClick={pin}
+        >
+          {pinLabel()}
+        </button>
+        <span class="amc-wp-hint">or ask me to change it</span>
+      </div>
+    </div>
+  )
+}
diff --git a/packages/ui/src/amicode/widget-preview.test.ts b/packages/ui/src/amicode/widget-preview.test.ts
new file mode 100644
index 0000000000..90839647dd
--- /dev/null
+++ b/packages/ui/src/amicode/widget-preview.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test"
+import { parseWidgetSentinel } from "./widget-preview"
+
+describe("parseWidgetSentinel", () => {
+  const line = (o: unknown) => `Authored "X" ✓.\nAMICODE_WIDGET ${JSON.stringify(o)}`
+
+  test("parses a well-formed sentinel on the last line", () => {
+    const p = parseWidgetSentinel(
+      line({ id: "recent-runs", name: "Recent Runs", size: "hero", height: 220, hash: "abc123", warnings: [] }),
+    )
+    expect(p).toEqual({ id: "recent-runs", name: "Recent Runs", size: "hero", height: 220, hash: "abc123", warnings: [] })
+  })
+
+  test("preceding prose is ignored; only the last line matters", () => {
+    const p = parseWidgetSentinel(
+      "line one\nline two\n" + `AMICODE_WIDGET ${JSON.stringify({ id: "a", hash: "h" })}`,
+    )
+    expect(p?.id).toBe("a")
+    expect(p?.size).toBe("tile") // default
+    expect(p?.height).toBe(96) // default
+    expect(p?.name).toBe("a") // falls back to id
+  })
+
+  test("carries warnings", () => {
+    const p = parseWidgetSentinel(line({ id: "a", hash: "h", warnings: ["degraded", 3, "x"] }))
+    expect(p?.warnings).toEqual(["degraded", "x"])
+  })
+
+  test("rejects missing id/hash, non-string output, truncation, and non-sentinel", () => {
+    expect(parseWidgetSentinel(line({ id: "a" }))).toBeUndefined() // no hash
+    expect(parseWidgetSentinel(line({ hash: "h" }))).toBeUndefined() // no id
+    expect(parseWidgetSentinel(42)).toBeUndefined()
+    expect(parseWidgetSentinel("AMICODE_WIDGET {truncated…")).toBeUndefined()
+    expect(parseWidgetSentinel("no sentinel here")).toBeUndefined()
+    expect(parseWidgetSentinel(`AMICODE_WIDGET {"id":"a","hash":"h"}\ntrailing line`)).toBeUndefined()
+  })
+})
diff --git a/packages/ui/src/amicode/widget-preview.ts b/packages/ui/src/amicode/widget-preview.ts
new file mode 100644
index 0000000000..9f9e1b8df2
--- /dev/null
+++ b/packages/ui/src/amicode/widget-preview.ts
@@ -0,0 +1,45 @@
+// AMICODE (Stage 2 chat authoring): parse the AMICODE_WIDGET sentinel that the
+// amicode_author_widget tool appends to its output — the LAST line, shaped
+// `AMICODE_WIDGET {id,name,size,height,hash,warnings}`. Pure + unit-tested,
+// mirroring parseDiffSentinel (receipt.ts). The preview card uses {id,hash} to
+// build the live frame src (/amicode/widget-frame?id=&h=); the hash changing on
+// re-author is the hot-reload signal.
+
+const PREFIX = "AMICODE_WIDGET "
+
+export interface WidgetPreview {
+  id: string
+  name: string
+  size: "hero" | "tile"
+  height: number
+  hash: string
+  warnings: string[]
+}
+
+export function parseWidgetSentinel(output: unknown): WidgetPreview | undefined {
+  if (typeof output !== "string") return undefined
+  const lines = output.trimEnd().split("\n")
+  const last = lines[lines.length - 1]
+  if (!last?.startsWith(PREFIX)) return undefined
+  let raw: any
+  try {
+    raw = JSON.parse(last.slice(PREFIX.length))
+  } catch {
+    return undefined
+  }
+  if (typeof raw !== "object" || raw === null) return undefined
+  if (typeof raw.id !== "string" || typeof raw.hash !== "string") return undefined
+  const size: "hero" | "tile" = raw.size === "hero" ? "hero" : "tile"
+  const height = typeof raw.height === "number" && raw.height > 0 ? raw.height : 96
+  const warnings = Array.isArray(raw.warnings)
+    ? raw.warnings.filter((w: unknown): w is string => typeof w === "string")
+    : []
+  return {
+    id: raw.id,
+    name: typeof raw.name === "string" && raw.name.trim() !== "" ? raw.name : raw.id,
+    size,
+    height,
+    hash: raw.hash,
+    warnings,
+  }
+}
diff --git a/packages/ui/src/amicode/widget-schema.test.ts b/packages/ui/src/amicode/widget-schema.test.ts
new file mode 100644
index 0000000000..9ca9c550fc
--- /dev/null
+++ b/packages/ui/src/amicode/widget-schema.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test"
+import { formModel, parseDashboardResponse, parseWidgetsResponse } from "./widget-schema"
+import { allowAction, allowFetch } from "./widget-allowlist"
+
+describe("parseWidgetsResponse", () => {
+  test("maps the wire shape defensively", () => {
+    const widgets = parseWidgetsResponse({
+      ok: true,
+      widgets: [
+        {
+          id: "pulse-bank",
+          name: "Pulse bank",
+          size: "tile",
+          height: 96,
+          bridge: 1,
+          builtin: true,
+          overridden: false,
+          hash: "abc",
+          path: null,
+          config: { plot: { type: "select", options: ["a"], default: "a" }, junk: "no", bad: { type: "wat" } },
+        },
+        { id: 42 }, // dropped
+      ],
+    })
+    expect(widgets).toHaveLength(1)
+    expect(widgets[0].config.plot?.type).toBe("select")
+    expect("junk" in widgets[0].config).toBe(false)
+    expect("bad" in widgets[0].config).toBe(false)
+  })
+  test("garbage → empty", () => {
+    expect(parseWidgetsResponse(undefined)).toEqual([])
+    expect(parseWidgetsResponse({ ok: false })).toEqual([])
+  })
+})
+
+describe("parseDashboardResponse", () => {
+  test("parses entries, defaults key to id, keeps missing flag", () => {
+    const d = parseDashboardResponse({
+      ok: true,
+      dashboard: {
+        version: 1,
+        widget: [
+          { key: "w-1", id: "a", hidden: true, config: { x: 1 } },
+          { id: "b", missing: true },
+          { id: 42 },
+        ],
+      },
+    })
+    expect(d?.widget).toHaveLength(2)
+    expect(d?.widget[0].hidden).toBe(true)
+    expect(d?.widget[1].key).toBe("b")
+    expect(d?.widget[1].missing).toBe(true)
+  })
+  test("garbage → undefined", () => {
+    expect(parseDashboardResponse({ ok: true, dashboard: { widget: "x" } })).toBeUndefined()
+    expect(parseDashboardResponse("nope")).toBeUndefined()
+  })
+
+  test("reserved keys pass through the client parse (spec T3.6)", () => {
+    const d = parseDashboardResponse({
+      ok: true,
+      dashboard: {
+        version: 1,
+        views: [{ id: "lab", name: "Lab" }],
+        scope: "home",
+        widget: [{ key: "w-1", id: "a", hidden: false, config: {}, group: "lab" }],
+      },
+    }) as Record<string, unknown> & { widget: Record<string, unknown>[] }
+    expect(d.views).toEqual([{ id: "lab", name: "Lab" }])
+    expect(d.scope).toBe("home")
+    expect(d.widget[0].group).toBe("lab")
+  })
+})
+
+describe("formModel", () => {
+  const schema = {
+    stats: { type: "multi-select", options: ["a", "b"], default: ["a"] },
+    plot: { type: "select", options: ["p", "o"], default: "p" },
+    on: { type: "boolean", default: true },
+  } as const
+  test("valid stored values win; invalid fall back to defaults", () => {
+    const fields = formModel(schema as any, { stats: ["b"], plot: "3d", on: "yes" })
+    expect(fields.find((f) => f.key === "stats")?.value).toEqual(["b"])
+    expect(fields.find((f) => f.key === "plot")?.value).toBe("p")
+    expect(fields.find((f) => f.key === "on")?.value).toBe(true)
+  })
+  test("empty schema → no fields", () => {
+    expect(formModel({}, { a: 1 })).toEqual([])
+  })
+})
+
+describe("allowFetch", () => {
+  test("exact routes and query variants pass", () => {
+    expect(allowFetch("/amicode/profile")).toBe(true)
+    expect(allowFetch("/amicode/run-series?run=r1&lab=default")).toBe(true)
+    expect(allowFetch("/amicode/dashboard")).toBe(true)
+  })
+  test("prefix rides and foreign paths rejected", () => {
+    expect(allowFetch("/amicode/problem-x")).toBe(false)
+    expect(allowFetch("/amicode/problemx?slug=s")).toBe(false)
+    expect(allowFetch("/session")).toBe(false)
+    expect(allowFetch("http://evil.example/amicode/profile")).toBe(false)
+    expect(allowFetch(42)).toBe(false)
+  })
+})
+
+describe("allowAction", () => {
+  test("the eight verbs pass, others rejected", () => {
+    for (const v of [
+      "resume-session",
+      "save-profile",
+      "lookup-institution",
+      "resolve-logo",
+      "open-external",
+      "upload-library",
+      "open-gallery",
+      "warm-start",
+    ])
+      expect(allowAction(v)).toBe(true)
+    expect(allowAction("rm-rf")).toBe(false)
+    expect(allowAction(1)).toBe(false)
+  })
+})
diff --git a/packages/ui/src/amicode/widget-schema.ts b/packages/ui/src/amicode/widget-schema.ts
new file mode 100644
index 0000000000..b35a31a7f1
--- /dev/null
+++ b/packages/ui/src/amicode/widget-schema.ts
@@ -0,0 +1,173 @@
+// AMICODE (widget kernel): client-side wire parsers for GET /amicode/widgets
+// and GET|POST /amicode/dashboard, plus the config-form model generated from
+// a widget's manifest schema. JSX-free, defensive (problems.ts discipline:
+// one schema per route, never throw), unit-tested.
+
+export type ConfigFieldWire =
+  | { type: "boolean"; default: boolean }
+  | { type: "select"; options: string[]; default: string }
+  | { type: "multi-select"; options: string[]; default: string[] }
+  | { type: "string"; default: string; max_length?: number }
+  | { type: "number"; default: number; min?: number; max?: number }
+
+export interface WidgetInfo {
+  id: string
+  name: string
+  version: string
+  bridge: number
+  description: string
+  size: "hero" | "tile"
+  height: number
+  config: Record<string, ConfigFieldWire>
+  builtin: boolean
+  overridden: boolean
+  hash: string
+  path: string | null
+}
+
+export interface DashboardEntry {
+  key: string
+  id: string
+  hidden: boolean
+  config: Record<string, unknown>
+  missing?: boolean
+  /** reserved-key pass-through (spec T3.6): group, view, … survive the client round-trip */
+  [reserved: string]: unknown
+}
+
+export interface DashboardState {
+  version: 1
+  widget: DashboardEntry[]
+  /** reserved top-level keys (spec T3.6): views, scope */
+  [reserved: string]: unknown
+}
+
+const CLIENT_CORE_ENTRY_KEYS = new Set(["key", "id", "hidden", "config", "missing"])
+const CLIENT_RESERVED_TOP_KEYS = ["views", "scope"] as const
+
+const FIELD_TYPES = new Set(["boolean", "select", "multi-select", "string", "number"])
+
+function parseConfigSchema(raw: unknown): Record<string, ConfigFieldWire> {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {}
+  const out: Record<string, ConfigFieldWire> = {}
+  for (const [key, val] of Object.entries(raw as Record<string, unknown>)) {
+    if (typeof val !== "object" || val === null) continue
+    const f = val as Record<string, unknown>
+    if (typeof f.type !== "string" || !FIELD_TYPES.has(f.type)) continue
+    out[key] = f as unknown as ConfigFieldWire
+  }
+  return out
+}
+
+export function parseWidgetsResponse(raw: unknown): WidgetInfo[] {
+  if (typeof raw !== "object" || raw === null) return []
+  const data = raw as { ok?: unknown; widgets?: unknown }
+  if (data.ok !== true || !Array.isArray(data.widgets)) return []
+  return data.widgets
+    .filter((w): w is Record<string, unknown> => typeof w === "object" && w !== null)
+    .filter((w) => typeof w.id === "string" && typeof w.name === "string")
+    .map((w) => ({
+      id: w.id as string,
+      name: w.name as string,
+      version: typeof w.version === "string" ? w.version : "0.0.0",
+      bridge: typeof w.bridge === "number" ? w.bridge : 1,
+      description: typeof w.description === "string" ? w.description : "",
+      size: w.size === "hero" ? "hero" : "tile",
+      height: typeof w.height === "number" && w.height > 0 ? w.height : 96,
+      config: parseConfigSchema(w.config),
+      builtin: w.builtin === true,
+      overridden: w.overridden === true,
+      hash: typeof w.hash === "string" ? w.hash : "",
+      path: typeof w.path === "string" ? w.path : null,
+    }))
+}
+
+export function parseDashboardResponse(raw: unknown): DashboardState | undefined {
+  if (typeof raw !== "object" || raw === null) return undefined
+  const data = raw as { ok?: unknown; dashboard?: unknown }
+  if (data.ok !== true || typeof data.dashboard !== "object" || data.dashboard === null) return undefined
+  const d = data.dashboard as { widget?: unknown }
+  if (!Array.isArray(d.widget)) return undefined
+  const widget: DashboardEntry[] = d.widget
+    .filter((e): e is Record<string, unknown> => typeof e === "object" && e !== null)
+    .filter((e) => typeof e.id === "string")
+    .map((e) => {
+      // T3.6: unrecognized keys pass through so a grid save can't erase them
+      const passthrough: Record<string, unknown> = {}
+      for (const [k, v] of Object.entries(e)) if (!CLIENT_CORE_ENTRY_KEYS.has(k)) passthrough[k] = v
+      return {
+        ...passthrough,
+        key: typeof e.key === "string" ? e.key : (e.id as string),
+        id: e.id as string,
+        hidden: e.hidden === true,
+        config: typeof e.config === "object" && e.config !== null ? (e.config as Record<string, unknown>) : {},
+        ...(e.missing === true ? { missing: true } : {}),
+      }
+    })
+  const state: DashboardState = { version: 1, widget }
+  for (const k of CLIENT_RESERVED_TOP_KEYS) {
+    const v = (data.dashboard as Record<string, unknown>)[k]
+    if (v !== undefined) state[k] = v
+  }
+  return state
+}
+
+// --- config form model -------------------------------------------------------
+
+export type FormField =
+  | { key: string; kind: "boolean"; value: boolean }
+  | { key: string; kind: "select"; options: string[]; value: string }
+  | { key: string; kind: "multi-select"; options: string[]; value: string[] }
+  | { key: string; kind: "string"; value: string; maxLength?: number }
+  | { key: string; kind: "number"; value: number; min?: number; max?: number }
+
+/** Build the ⚙-form model: one entry per schema field, current value = stored
+ *  config where valid, else the field default. */
+export function formModel(schema: Record<string, ConfigFieldWire>, config: Record<string, unknown>): FormField[] {
+  const fields: FormField[] = []
+  for (const [key, f] of Object.entries(schema)) {
+    switch (f.type) {
+      case "boolean":
+        fields.push({ key, kind: "boolean", value: typeof config[key] === "boolean" ? (config[key] as boolean) : f.default })
+        break
+      case "select": {
+        const v = config[key]
+        fields.push({
+          key,
+          kind: "select",
+          options: f.options,
+          value: typeof v === "string" && f.options.includes(v) ? v : f.default,
+        })
+        break
+      }
+      case "multi-select": {
+        const v = config[key]
+        const valid = Array.isArray(v) ? v.filter((x): x is string => typeof x === "string" && f.options.includes(x)) : []
+        fields.push({ key, kind: "multi-select", options: f.options, value: valid.length > 0 ? valid : f.default })
+        break
+      }
+      case "string": {
+        const v = config[key]
+        fields.push({
+          key,
+          kind: "string",
+          value: typeof v === "string" ? v : f.default,
+          ...(typeof f.max_length === "number" ? { maxLength: f.max_length } : {}),
+        })
+        break
+      }
+      case "number": {
+        const v = config[key]
+        fields.push({
+          key,
+          kind: "number",
+          value: typeof v === "number" && Number.isFinite(v) ? v : f.default,
+          ...(typeof f.min === "number" ? { min: f.min } : {}),
+          ...(typeof f.max === "number" ? { max: f.max } : {}),
+        })
+        break
+      }
+    }
+  }
+  return fields
+}
diff --git a/packages/ui/src/amicode/widget-tokens.test.ts b/packages/ui/src/amicode/widget-tokens.test.ts
new file mode 100644
index 0000000000..9e2954fa7d
--- /dev/null
+++ b/packages/ui/src/amicode/widget-tokens.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test"
+import { densityFor, densityForViewport, resolveTokens } from "./widget-tokens"
+
+describe("densityFor", () => {
+  test("boundaries match COMPACT_CSS (≤880 compact, ≤760 tight)", () => {
+    expect(densityFor(881)).toBe("normal")
+    expect(densityFor(880)).toBe("compact")
+    expect(densityFor(761)).toBe("compact")
+    expect(densityFor(760)).toBe("tight")
+    expect(densityFor(500)).toBe("tight")
+  })
+})
+
+describe("densityForViewport (spec T3.4 width axis)", () => {
+  test("width tiers: ≤820 compact, ≤600 tight", () => {
+    expect(densityForViewport(821, 1000)).toBe("normal")
+    expect(densityForViewport(820, 1000)).toBe("compact")
+    expect(densityForViewport(601, 1000)).toBe("compact")
+    expect(densityForViewport(600, 1000)).toBe("tight")
+  })
+  test("effective density is the max of both axes", () => {
+    expect(densityForViewport(1200, 880)).toBe("compact") // height wins
+    expect(densityForViewport(600, 1000)).toBe("tight") // width wins
+    expect(densityForViewport(820, 760)).toBe("tight") // tighter axis wins
+  })
+})
+
+describe("resolveTokens", () => {
+  test("maps resolved v2 values and falls back when empty", () => {
+    const tokens = resolveTokens((name) => (name === "--v2-text-text-base" ? " #fff " : ""), "normal")
+    expect(tokens["--amc-text"]).toBe("#fff")
+    expect(tokens["--amc-bg"]).toBe("#0B0E15") // fallback
+    expect(tokens["--amc-accent"]).toBe("#F2C94C")
+    expect(tokens["--amc-font-mono"]).toContain("monospace")
+    expect(Object.keys(tokens)).toHaveLength(15) // 11 colors + 2 fonts + 2 pads
+  })
+  test("padding tokens follow density", () => {
+    expect(resolveTokens(() => "", "normal")["--amc-pad"]).toBe("14px 16px")
+    expect(resolveTokens(() => "", "tight")["--amc-pad"]).toBe("8px 12px")
+  })
+})
diff --git a/packages/ui/src/amicode/widget-tokens.ts b/packages/ui/src/amicode/widget-tokens.ts
new file mode 100644
index 0000000000..6602651c13
--- /dev/null
+++ b/packages/ui/src/amicode/widget-tokens.ts
@@ -0,0 +1,66 @@
+// AMICODE (widget kernel): the --amc-* token seam. Host CSS vars (--v2-*)
+// cannot cross an iframe boundary, so the host resolves its computed values
+// into a stable token map that widgets style against — widget code never
+// touches fork-internal theme names. Density replaces COMPACT_CSS: widgets
+// restyle themselves from the signal instead of the host reaching into tile
+// internals. Pure, unit-tested.
+
+export type Density = "normal" | "compact" | "tight"
+
+/** COMPACT_CSS thresholds (home-cards): ≤880 compact, ≤760 tight. */
+export function densityFor(webviewHeightPx: number): Density {
+  if (webviewHeightPx <= 760) return "tight"
+  if (webviewHeightPx <= 880) return "compact"
+  return "normal"
+}
+
+const DENSITY_RANK: Record<Density, number> = { normal: 0, compact: 1, tight: 2 }
+
+/** Panel-first (spec T3.4): width is the scarce axis when Amicode lives as
+ *  half an editor. Effective density = max(height tier, width tier);
+ *  width ≤820 → compact, ≤600 → tight. */
+export function densityForViewport(widthPx: number, heightPx: number): Density {
+  const byWidth: Density = widthPx <= 600 ? "tight" : widthPx <= 820 ? "compact" : "normal"
+  const byHeight = densityFor(heightPx)
+  return DENSITY_RANK[byWidth] >= DENSITY_RANK[byHeight] ? byWidth : byHeight
+}
+
+const SANS = "-apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif"
+const MONO = "ui-monospace, SFMono-Regular, Menlo, monospace"
+
+/** --v2-* source per token, with a dark-theme literal fallback for vars that
+ *  resolve empty (run-card palette). */
+const SOURCES: [amc: string, v2: string, fallback: string][] = [
+  ["--amc-bg", "--v2-background-bg-base", "#0B0E15"],
+  ["--amc-layer", "--v2-background-bg-layer-01", "#111624"],
+  ["--amc-layer2", "--v2-background-bg-layer-02", "#1A2133"],
+  ["--amc-border", "--v2-border-border-base", "#2A3245"],
+  ["--amc-text", "--v2-text-text-base", "#E9ECF4"],
+  ["--amc-text-muted", "--v2-text-text-muted", "#8B94A9"],
+  ["--amc-text-faint", "--v2-text-text-faint", "#6A7286"],
+  ["--amc-accent", "--v2-icon-icon-accent", "#F2C94C"],
+  ["--amc-success", "--v2-state-fg-success", "#5BC873"],
+  ["--amc-warning", "--v2-state-fg-warning", "#E5B454"],
+  ["--amc-danger", "--v2-state-fg-danger", "#E56A6A"],
+]
+
+const PADDING: Record<Density, { pad: string; padTile: string }> = {
+  normal: { pad: "14px 16px", padTile: "10px 12px" },
+  compact: { pad: "10px 14px", padTile: "10px 12px" },
+  tight: { pad: "8px 12px", padTile: "8px 10px" },
+}
+
+/** Resolve the full token map. getVar = (v2Name) => computed value ("" when
+ *  unset); the caller wires it to getComputedStyle(appRoot).getPropertyValue. */
+export function resolveTokens(getVar: (name: string) => string, density: Density): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const [amc, v2, fallback] of SOURCES) {
+    const v = getVar(v2).trim()
+    out[amc] = v !== "" ? v : fallback
+  }
+  out["--amc-font-sans"] = SANS
+  out["--amc-font-mono"] = MONO
+  out["--amc-pad"] = PADDING[density].pad
+  out["--amc-pad-tile"] = PADDING[density].padTile
+  return out
+}
diff --git a/packages/ui/src/components/amicode-widget-grid.tsx b/packages/ui/src/components/amicode-widget-grid.tsx
new file mode 100644
index 0000000000..5119f973dd
--- /dev/null
+++ b/packages/ui/src/components/amicode-widget-grid.tsx
@@ -0,0 +1,16 @@
+// AMICODE: app-facing shim for the widget kernel (the app imports ui code
+// only through src/components/*.tsx wildcard exports). Also re-exports the
+// institution-lookup helpers the home page needs for the about-you widget's
+// host actions — institution-lookup.ts is a .ts file, invisible to the
+// wildcard, and the home-cards shim does not export it.
+export { WidgetGrid } from "../amicode/widget-grid"
+export type { WidgetHostCallbacks } from "../amicode/widget-frame"
+export {
+  parseWidgetsResponse,
+  parseDashboardResponse,
+  type WidgetInfo,
+  type DashboardState,
+  type DashboardEntry,
+} from "../amicode/widget-schema"
+export { resolveTokens, densityFor, densityForViewport, type Density } from "../amicode/widget-tokens"
+export { suggestInstitutions, resolveBrandLogo } from "../amicode/institution-lookup"
diff --git a/packages/ui/src/components/logo.tsx b/packages/ui/src/components/logo.tsx
index ff2f1411d2..0caebb4900 100644
--- a/packages/ui/src/components/logo.tsx
+++ b/packages/ui/src/components/logo.tsx
@@ -109,8 +109,9 @@ export const Logo = (props: { class?: string }) => {
         dominant-baseline="central"
         textLength="230"
         lengthAdjust="spacingAndGlyphs"
-        font-family="'Racing Sans One', var(--font-family-mono, ui-monospace, monospace)"
-        font-weight="400"
+        font-family="'Aero', var(--font-family-sans, ui-sans-serif, system-ui, -apple-system, sans-serif)"
+        font-weight="750"
+        letter-spacing="4"
         font-size="36"
         fill="var(--icon-base)"
       >
diff --git a/packages/ui/src/components/markdown-stream.test.ts b/packages/ui/src/components/markdown-stream.test.ts
index 1ee63fc62e..490e22a34d 100644
--- a/packages/ui/src/components/markdown-stream.test.ts
+++ b/packages/ui/src/components/markdown-stream.test.ts
@@ -1,5 +1,7 @@
 import { describe, expect, test } from "bun:test"
-import { stream } from "./markdown-stream"
+import { marked } from "marked"
+import markedKatex from "marked-katex-extension"
+import { stream, normalizeDisplayMath } from "./markdown-stream"
 
 describe("markdown stream", () => {
   test("heals incomplete emphasis while streaming", () => {
@@ -30,3 +32,36 @@ describe("markdown stream", () => {
     ])
   })
 })
+
+describe("normalizeDisplayMath", () => {
+  const katexMarked = marked.use(markedKatex({ throwOnError: false, nonStandard: true }))
+  const renders = async (src: string) => (await katexMarked.parse(normalizeDisplayMath(src))).includes("katex")
+
+  test("moves mid-line-opened, multi-line display math onto its own block lines", () => {
+    // The exact shape LLMs emit and marked-katex silently drops (matches neither
+    // the newline-free inline rule nor the ^$$-alone block rule).
+    expect(normalizeDisplayMath("label: $$\n\\rho = 1\n$$")).toBe("label: \n\n$$\n\\rho = 1\n$$\n\n")
+    expect(normalizeDisplayMath("a: $$ x\n= y $$ b")).toBe("a: \n\n$$\nx\n= y\n$$\n\n b")
+  })
+
+  test("the normalized output actually renders where the raw form does not", async () => {
+    // Regression guard for the raw-$$-with-stripped-backslashes bug.
+    expect(await katexMarked.parse("label: $$\n\\rho \\;=\\; 1\n$$")).not.toContain("katex") // raw form fails
+    expect(await renders("label: $$\n\\rho \\;=\\; 1\n$$")).toBe(true)
+    expect(await renders("a: $$ x\n= y $$")).toBe(true)
+  })
+
+  test("does not regress one-line inline or single-dollar math", async () => {
+    expect(await renders("value $$ x = 1 $$ here")).toBe(true)
+    expect(await renders("value $\\alpha$ here")).toBe(true)
+  })
+
+  test("leaves $$ inside fenced or inline code untouched", () => {
+    expect(normalizeDisplayMath("```\n$$ not math $$\n```")).toBe("```\n$$ not math $$\n```")
+    expect(normalizeDisplayMath("use `$$ x $$` inline")).toBe("use `$$ x $$` inline")
+  })
+
+  test("leaves an unclosed trailing $$ (mid-stream) untouched", () => {
+    expect(normalizeDisplayMath("label: $$\n\\rho = 1")).toBe("label: $$\n\\rho = 1")
+  })
+})
diff --git a/packages/ui/src/components/markdown-stream.ts b/packages/ui/src/components/markdown-stream.ts
index ea35b0c140..4748b0e3a2 100644
--- a/packages/ui/src/components/markdown-stream.ts
+++ b/packages/ui/src/components/markdown-stream.ts
@@ -26,6 +26,28 @@ function heal(text: string) {
   return remend(text, { linkMode: "text-only" })
 }
 
+// marked-katex only tokenizes $$…$$ display math in two shapes: all on one line
+// (its inline rule's body class [^\\\n] forbids newlines) or with the $$ alone
+// on their own lines (its block rule needs ^$$\n … \n$$). LLMs routinely emit a
+// third shape — `label: $$\n…\n$$`, opening mid-line with a multi-line body —
+// which matches NEITHER, so the span falls through to markdown, which then eats
+// the LaTeX backslash-escapes (\; → ;, \! → !, \text → text) and renders a raw,
+// mangled `$$ … $$`. Normalize every complete display-math span onto its own
+// block lines so the block rule always matches. Fenced/inline code is skipped
+// so LaTeX shown as code stays literal; an unclosed trailing `$$` (mid-stream)
+// has no match and is left untouched until its closer arrives.
+export function normalizeDisplayMath(text: string): string {
+  const codePattern = /(```[\s\S]*?```|~~~[\s\S]*?~~~|`[^`\n]*`)/g
+  return text
+    .split(codePattern)
+    .map((part, index) =>
+      index % 2 === 1
+        ? part
+        : part.replace(/\$\$([\s\S]*?)\$\$/g, (_match, body: string) => `\n\n$$\n${body.trim()}\n$$\n\n`),
+    )
+    .join("")
+}
+
 export function stream(text: string, live: boolean) {
   if (!live) return [{ raw: text, src: text, mode: "full" }] satisfies Block[]
   const src = heal(text)
diff --git a/packages/ui/src/components/markdown.css b/packages/ui/src/components/markdown.css
index 26c9efd475..fa98bd1f05 100644
--- a/packages/ui/src/components/markdown.css
+++ b/packages/ui/src/components/markdown.css
@@ -16,26 +16,46 @@
     margin-bottom: 0;
   }
 
-  /* Headings: Same size, distinguished by color and spacing */
+  /* Headings: real hierarchy — larger + heavier than body, space ABOVE the
+     title (binds it to its section), tight below. (amicode patch #20; the
+     upstream same-size-as-body rule made section titles indistinguishable
+     from prose.) */
   h1,
   h2,
   h3,
   h4,
   h5,
   h6 {
-    font-size: 14px;
     color: var(--text-strong);
-    font-weight: var(--font-weight-medium);
-    margin-top: 0px;
-    margin-bottom: 24px;
+    font-weight: 600;
+    margin-top: 24px;
+    margin-bottom: 8px;
     line-height: var(--line-height-large);
   }
 
-  /* Emphasis & Strong: Neutral strong color */
+  h1 {
+    font-size: 18px;
+  }
+
+  h2 {
+    font-size: var(--font-size-large); /* 16px */
+  }
+
+  h3 {
+    font-size: 15px;
+  }
+
+  h4,
+  h5,
+  h6 {
+    font-size: var(--font-size-base); /* 14px — weight alone distinguishes */
+  }
+
+  /* Emphasis & Strong: visibly bolder than the 400-weight body */
   strong,
   b {
     color: var(--text-strong);
-    font-weight: var(--font-weight-medium);
+    font-weight: 600;
   }
 
   /* Paragraphs */
diff --git a/packages/ui/src/components/markdown.tsx b/packages/ui/src/components/markdown.tsx
index e12b661dba..990b8c609e 100644
--- a/packages/ui/src/components/markdown.tsx
+++ b/packages/ui/src/components/markdown.tsx
@@ -5,7 +5,7 @@ import morphdom from "morphdom"
 import { checksum } from "@opencode-ai/core/util/encode"
 import { ComponentProps, createEffect, createResource, createSignal, onCleanup, splitProps } from "solid-js"
 import { isServer } from "solid-js/web"
-import { stream } from "./markdown-stream"
+import { stream, normalizeDisplayMath } from "./markdown-stream"
 
 type Entry = {
   hash: string
@@ -275,7 +275,7 @@ export function Markdown(
             }
           }
 
-          const next = await Promise.resolve(marked.parse(block.src))
+          const next = await Promise.resolve(marked.parse(normalizeDisplayMath(block.src)))
           const safe = sanitize(next)
           if (key && hash) touch(key, { hash, html: safe })
           return safe
diff --git a/packages/ui/src/components/message-part-skill.test.ts b/packages/ui/src/components/message-part-skill.test.ts
new file mode 100644
index 0000000000..2df34518a6
--- /dev/null
+++ b/packages/ui/src/components/message-part-skill.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test"
+import { skillBody } from "./message-part-skill"
+
+// Wrapper shape produced by both skill tool implementations
+// (packages/opencode/src/tool/skill.ts and packages/core/src/tool/skill.ts).
+const OUTPUT = [
+  '<skill_content name="atoms">',
+  "# Skill: atoms",
+  "",
+  "## Rydberg conventions",
+  "",
+  "Use the 3-level model: $|0\\rangle$ dark, $|1\\rangle \\leftrightarrow |r\\rangle$ driven.",
+  "",
+  "Base directory for this skill: file:///home/u/.amico/skills/atoms",
+  "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+  "Note: file list is sampled.",
+  "",
+  "<skill_files>",
+  "<file>/home/u/.amico/skills/atoms/reference/blockade.md</file>",
+  "</skill_files>",
+  "</skill_content>",
+].join("\n")
+
+describe("skillBody", () => {
+  test("returns empty string for undefined or empty output", () => {
+    expect(skillBody(undefined)).toBe("")
+    expect(skillBody("")).toBe("")
+  })
+
+  test("strips the transport wrapper and plumbing, keeps the instructions", () => {
+    const body = skillBody(OUTPUT)
+    expect(body).toContain("## Rydberg conventions")
+    expect(body).toContain("3-level model")
+    expect(body).not.toContain("<skill_content")
+    expect(body).not.toContain("</skill_content>")
+    expect(body).not.toContain("<skill_files>")
+    expect(body).not.toContain("blockade.md")
+    expect(body).not.toContain("Base directory")
+    expect(body).not.toContain("Relative paths")
+    expect(body).not.toContain("file list is sampled")
+  })
+
+  test("drops the '# Skill: name' heading (the chip already shows the name)", () => {
+    expect(skillBody(OUTPUT)).not.toContain("# Skill: atoms")
+  })
+
+  test("keeps content lines that merely mention skill files mid-text", () => {
+    const out = '<skill_content name="x">\nSee the skill_files note above for context.\n</skill_content>'
+    expect(skillBody(out)).toBe("See the skill_files note above for context.")
+  })
+
+  test("passes through plain text without wrapper untouched (trimmed)", () => {
+    expect(skillBody("  just some output  ")).toBe("just some output")
+  })
+})
diff --git a/packages/ui/src/components/message-part-skill.ts b/packages/ui/src/components/message-part-skill.ts
new file mode 100644
index 0000000000..d8a614d3ff
--- /dev/null
+++ b/packages/ui/src/components/message-part-skill.ts
@@ -0,0 +1,21 @@
+/** Extract the human-readable body of a skill tool result: the SKILL.md
+ *  instructions without the <skill_content>/<skill_files> transport wrapper
+ *  and the model-facing plumbing lines (base-directory, relative-path note,
+ *  sampling note, the "# Skill: name" heading the chip already shows). */
+export function skillBody(output: string | undefined): string {
+  if (!output) return ""
+  const withoutFiles = output.replace(/<skill_files>[\s\S]*?<\/skill_files>/g, "")
+  const drop = [
+    /^<skill_content\b[^>]*>$/,
+    /^<\/skill_content>$/,
+    /^# Skill: .*$/,
+    /^Base directory for this skill: .*$/,
+    /^Relative paths in this skill .*$/,
+    /^Note: file list is sampled\.$/,
+  ]
+  return withoutFiles
+    .split("\n")
+    .filter((line) => !drop.some((re) => re.test(line.trim())))
+    .join("\n")
+    .trim()
+}
diff --git a/packages/ui/src/components/message-part.tsx b/packages/ui/src/components/message-part.tsx
index 41320c33be..519529e60a 100644
--- a/packages/ui/src/components/message-part.tsx
+++ b/packages/ui/src/components/message-part.tsx
@@ -1,4 +1,6 @@
 import { AmicoSpinner, AmicoMark } from "../amicode/spinner"
+import { ThinkingLine } from "../amicode/thinking-line"
+import { turnTokens } from "../amicode/thinking"
 import {
   Component,
   createEffect,
@@ -46,6 +48,7 @@ import { ToolErrorCard } from "./tool-error-card"
 import { Checkbox } from "./checkbox"
 import { DiffChanges } from "./diff-changes"
 import { Markdown } from "./markdown"
+import { skillBody } from "./message-part-skill"
 import { ImagePreview } from "./image-preview"
 import { getDirectory as _getDirectory, getFilename } from "@opencode-ai/core/util/path"
 import { checksum } from "@opencode-ai/core/util/encode"
@@ -604,11 +607,17 @@ export function AssistantParts(props: {
 
   const last = createMemo(() => grouped().at(-1)?.key)
 
-  // amicode: does this turn already carry an amicode_* tool card? Those cards
-  // (card.tsx) render their OWN AMICO signature, so a turn-level one would
-  // double up. The turn-level signature exists precisely for the OTHER case —
-  // plain prose replies, which otherwise show no Amico identity at all.
-  const hasAmicodeCard = createMemo(() =>
+  // amicode: tokens generated so far this turn (output + reasoning across the
+  // turn's assistant messages) — feeds the thinking line's live token chip.
+  // Reactive: re-runs as the store updates message.tokens.* while streaming.
+  const turnTokenCount = createMemo(() => turnTokens(props.messages))
+
+  // amicode: is THIS turn in Amico's domain? (does it carry an amicode_* tool
+  // part). The only turn-level domain signal available in the UI — Amico's
+  // presence (the working lane below; the rail waking) keys off it. Plain-prose
+  // turns are the *normal chat*: no Amico chrome in the flow
+  // (spec-20260712-amico-third-actor).
+  const inDomainTurn = createMemo(() =>
     props.messages.some((message) =>
       list(data.store.part?.[message.id], emptyParts).some(
         (p) => p.type === "tool" && /^amicode_/.test((p as ToolPart).tool ?? ""),
@@ -618,17 +627,11 @@ export function AssistantParts(props: {
 
   return (
     <>
-      {/* amicode: the AMICO signature heads assistant turns so the brand
-          identity doesn't vanish in plain chat (it only lived on interview
-          receipt cards before). Suppressed when a turn already has an
-          amicode_* card — that card brings its own signature. Kate's restyle
-          (amc-sig/amc-wordmark) is reused untouched. */}
-      <Show when={grouped().length > 0 && !hasAmicodeCard()}>
-        <span class="amc-sig" data-slot="amicode-turn-signature">
-          <AmicoMark running={props.working && last() === grouped().at(-1)?.key} />
-          <span class="amc-wordmark">AMICO</span>
-        </span>
-      </Show>
+      {/* amicode: identity lives in the entity rail now (Amico's body), NOT a
+          per-turn stamp — plain-prose turns read as the normal chat. On an
+          in-domain turn, Amico's working presence rides in an offset accent
+          lane BELOW the streamed parts (see the lane after </Index>).
+          spec-20260712-amico-third-actor. */}
       <Index each={grouped()}>
         {(entryAccessor) => {
           const entryType = createMemo(() => entryAccessor().type)
@@ -711,6 +714,19 @@ export function AssistantParts(props: {
           )
         }}
       </Index>
+      {/* amicode: Amico's working presence — the offset accent lane. Shown only
+          while an in-domain turn streams (state === "on"), decoupled from any
+          card-suppression: the H-mark pulses + the thinking line runs
+          (cycling shimmer word + live elapsed/tokens). Pops out the moment
+          working flips false. spec-20260712-amico-third-actor. */}
+      <Show when={inDomainTurn() && props.working && last() === grouped().at(-1)?.key}>
+        <div class="amc-lane" data-slot="amico-working">
+          <span class="amc-lane-head">
+            <AmicoMark running />
+          </span>
+          <ThinkingLine tokens={turnTokenCount() || undefined} />
+        </div>
+      </Show>
     </>
   )
 }
@@ -2503,6 +2519,7 @@ ToolRegistry.register({
     const i18n = useI18n()
     const title = createMemo(() => props.input.name || i18n.t("ui.tool.skill"))
     const running = createMemo(() => props.status === "pending" || props.status === "running")
+    const body = createMemo(() => skillBody(props.output))
 
     const titleContent = () => <TextShimmer text={title()} active={running()} />
 
@@ -2516,6 +2533,14 @@ ToolRegistry.register({
       </div>
     )
 
-    return <BasicTool icon="brain" status={props.status} trigger={trigger()} hideDetails />
+    return (
+      <BasicTool icon="brain" status={props.status} trigger={trigger()}>
+        <Show when={body()}>
+          <div data-component="tool-output" data-scrollable>
+            <Markdown text={body()} />
+          </div>
+        </Show>
+      </BasicTool>
+    )
   },
 })
diff --git a/packages/ui/src/components/thinking-line.tsx b/packages/ui/src/components/thinking-line.tsx
new file mode 100644
index 0000000000..9c084383bc
--- /dev/null
+++ b/packages/ui/src/components/thinking-line.tsx
@@ -0,0 +1,4 @@
+// AMICODE: re-export shim so packages/app can import the thinking line through
+// the existing `"./*": "./src/components/*.tsx"` export wildcard without touching
+// packages/ui/package.json. Logic lives in ../amicode/thinking-line.tsx.
+export { ThinkingLine } from "../amicode/thinking-line"
diff --git a/packages/ui/src/context/marked.tsx b/packages/ui/src/context/marked.tsx
index 46f4993bab..d5156f26c9 100644
--- a/packages/ui/src/context/marked.tsx
+++ b/packages/ui/src/context/marked.tsx
@@ -6,6 +6,23 @@ import { bundledLanguages, type BundledLanguage } from "shiki"
 import { createSimpleContext } from "./helper"
 import { getSharedHighlighter, registerCustomTheme, ThemeRegistrationResolved } from "@pierre/diffs"
 
+// KaTeX ships no \Tr, \tr, braket, etc. — they are LaTeX packages (physics /
+// \DeclareMathOperator), not core TeX — so an assistant writing quantum-control
+// math ("\Tr(\rho)", "\ket{0}") produced red "undefined control sequence"
+// errors. Register the operators/notation as macros so chat math renders. This
+// is passed to every KaTeX call in this module (both manual renderToString and
+// the marked-katex extension).
+const KATEX_MACROS: Record<string, string> = {
+  "\\Tr": "\\operatorname{Tr}",
+  "\\tr": "\\operatorname{tr}",
+  "\\rank": "\\operatorname{rank}",
+  "\\diag": "\\operatorname{diag}",
+  "\\ket": "{\\left|#1\\right\\rangle}",
+  "\\bra": "{\\left\\langle#1\\right|}",
+  "\\braket": "{\\left\\langle#1\\right\\rangle}",
+  "\\ketbra": "{\\left|#1\\right\\rangle\\!\\left\\langle#2\\right|}",
+}
+
 registerCustomTheme("OpenCode", () => {
   return Promise.resolve({
     name: "OpenCode",
@@ -386,6 +403,7 @@ function renderMathInText(text: string): string {
       return katex.renderToString(math, {
         displayMode: true,
         throwOnError: false,
+        macros: KATEX_MACROS,
       })
     } catch {
       return `$$${math}$$`
@@ -399,6 +417,7 @@ function renderMathInText(text: string): string {
       return katex.renderToString(math, {
         displayMode: false,
         throwOnError: false,
+        macros: KATEX_MACROS,
       })
     } catch {
       return `$${math}$`
@@ -480,6 +499,7 @@ export const { use: useMarked, provider: MarkedProvider } = createSimpleContext(
       markedKatex({
         throwOnError: false,
         nonStandard: true,
+        macros: KATEX_MACROS,
       }),
       markedShiki({
         async highlight(code, lang) {
diff --git a/packages/ui/src/styles/index.css b/packages/ui/src/styles/index.css
index d5a8d22f55..18e0a98749 100644
--- a/packages/ui/src/styles/index.css
+++ b/packages/ui/src/styles/index.css
@@ -36,6 +36,7 @@
 @import "../components/markdown.css" layer(components);
 @import "../components/message-part.css" layer(components);
 @import "../amicode/amicode.css" layer(components);
+@import "../amicode/amico-presence.css" layer(components);
 @import "../components/message-nav.css" layer(components);
 @import "../components/popover.css" layer(components);
 @import "../components/progress.css" layer(components);
diff --git a/packages/ui/src/v2/components/wordmark-v2.tsx b/packages/ui/src/v2/components/wordmark-v2.tsx
index 28f780122c..8a2d5b0ab1 100644
--- a/packages/ui/src/v2/components/wordmark-v2.tsx
+++ b/packages/ui/src/v2/components/wordmark-v2.tsx
@@ -19,7 +19,7 @@ export function WordmarkV2(props: Pick<ComponentProps<"svg">, "class">) {
           dominant-baseline="central"
           textLength="700"
           lengthAdjust="spacingAndGlyphs"
-          font-family="'Racing Sans One', var(--font-family-mono, ui-monospace, monospace)"
+          font-family="'Aero', 'Racing Sans One', var(--font-family-mono, ui-monospace, monospace)"
           font-weight="400"
           font-size="112"
           fill="currentColor"