# grill-with-ui

Adopt this skill: https://proskills.md/skills/other/jasonku09-grill-with-ui

Page: https://proskills.md/skills/other/jasonku09-grill-with-ui
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 37734
sha: 199e34d5a904ee59d4a8f2961bc7c415c7414c94
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/SKILL.md
truncated: true

````text
---
name: grill-with-ui
description: Run a grilling interview on a local browser page instead of the terminal. Every question is laid out with its recommendation, answerable in any order, with a per-question discussion thread and one "Send to Agent" button. Use when the user says "grill with ui", invokes /grill-with-ui with a topic, or says "/grill-with-ui resume".
---

# grill-with-ui

`$SKILL` below means this skill's base directory (the folder holding this file). Everything is
plain Node with no install step: `node $SKILL/server.mjs <command>`.

Two files carry a grill. `state.json` is **yours alone**: questions, recommendations, thread
replies, statuses, agent status. `events.jsonl` is **the page's alone**: one line per Send.
Nobody writes the other's file. The page polls `state.json`; how you receive events depends
on the listening mode below.
A third file, `visual.html`, is also yours (see [Visualize](#visualize) for drawing).

## Listening mode and turn boundaries

Choose the mode from the tools actually available, not the agent's model name:

- **Persistent Monitor:** if the harness delivers its events to the agent even after a turn
  ends, publish the update and end the turn; the next event wakes you.
- **Wait mode (no persistent Monitor):** a running page server or background shell process
  does **not** wake a finished agent turn. Keep the turn active and return to the foreground
  `wait` loop after opening the page, handling every send, and every draw completion or
  failure. A tool returning a process/session ID is not an event subscription: resume that
  process with the harness's polling tool. Do not send a final response merely because a
  question round or visual is ready. A timeout means wait again, not end the interview.

Throughout this skill, **return to listening** means the appropriate action above. In wait
mode stop only after Finish and any final visual export are complete, the user explicitly
pauses/stops the interview, or a tool failure prevents continuing. If you must stop, say that
the listener is inactive and that browser submissions will be queued until resume; never
claim you are still listening. On resume, drain `pending` as Resume step 3 describes before
waiting for new events.

**You change `state.json` only through `patch`** (next section), never with a file-write or
edit tool. A whole-file write puts the entire state into this conversation on every turn, and
the state grows with the grill: after twenty sends one rewrite is about 60 KB, some 15k
tokens, paid again on every send. A patch carries only what changed. Below, "set" and
"append" mean a key in a patch, and `null` is how a key is deleted.

## Patching state.json

```sh
node $SKILL/server.mjs patch --session <session> <<'GRILL_PATCH'
{ …only what changed… }
GRILL_PATCH
```

The delimiter is quoted, so the shell expands nothing inside it. (`--file <path>` reads the
patch from a file instead, for harnesses where heredocs are awkward.) It merges the patch,
validates the result, and swaps the file in atomically, so the page sees one consistent
update per patch. It works whether or not `serve` is running. It prints one line,
`{"ok":true,"questions":12,"open":3,"handled":14,"bytes":41233}`, never the state. A bad
patch exits non-zero with a one-line error and leaves the file untouched: fix the patch and
run it again.

The patch is shaped like `state.json` (schema at the end):

- `null` deletes a key, at any level: `"answer": null`, `"drawing": null`, `"visual": null`.
- `agent` and `visual` merge one level: keys you give replace those keys; the rest stay.
- `questions` is keyed by `id`. A known id merges one level: each field you give replaces
  that field whole (`rec`, `answer`, `options`, `deps`, `explore`). An unknown id is a new
  question, appended; it needs `round`, `title`, and `rec` (give `body` and `options` too);
  `status: "open"`, `deps: []`, `options: []`, `thread: []`, `durable: false`, and
  `updated: false` are filled in (`level` is not: give it). An unknown id without `title` is
  an error, not a new question (ids are case-sensitive: `q7`, never `Q7`).
- `thread` (on a question and on `visual`) and `visual.queued` append: list only the new
  messages or bullets.
- `terms` is keyed by `term`: a known term is replaced whole, a new one appended.
- Every other key (`note`, `intent`, `finished`, `doc`, …) is replaced whole.

**Never write the current time; the server stamps every time you leave out**: `agent.since`
whenever you give `agent.status`, `at` on each appended message, `explore.at`, `visual.at`
when `version` changes, `visual.drawing.since`, and `finished.at`. A time you give always
wins; give one only when copying it from a send line (a user's thread message takes the
send's `at`).

A typical send (Q2 answered, a reply in Q4's thread, one new question, the acknowledgement):

```sh
node $SKILL/server.mjs patch --session <session> <<'GRILL_PATCH'
{
  "agent": { "status": "waiting", "handled": 5 },
  "questions": [
    { "id": "q2", "status": "answered", "answer": { "kind": "option", "option": "B" }, "updated": false },
    { "id": "q4", "thread": [
      { "who": "user", "text": "Why not keep staged answers in localStorage?", "at": "2026-09-18T21:39:58Z" },
      { "who": "agent", "text": "localStorage is per browser profile, so a second browser or a cleared profile loses them. The session folder survives both, at the cost of one more file." } ] },
    { "id": "q7", "round": 4, "deps": ["q2"], "title": "Who owns the retry budget?",
      "body": "With the server-side queue settled in Q2, retries need an owner.",
      "level": "check", "levelReason": "high stakes, clear answer",
      "options": [ { "k": "A", "text": "Each queue row counts its own retries",
                     "ratings": { "ux": "good", "correct": "good", "risk": "mixed", "cost": "good" } },
                   { "k": "B", "text": "One counter per device",
                     "ratings": { "ux": "mixed", "correct": "poor", "risk": "poor", "cost": "good" } } ],
      "rec": { "option": "A", "why": "A row owning its count needs no join, and one bad device cannot starve the rest. Its weakest axis is risk: there is no global cap." } }
  ]
}
GRILL_PATCH
```

## Start (`/grill-with-ui <topic>`, `$grill-with-ui <topic>`, or "grill with ui: <topic>")

1. From the project directory run
   `node $SKILL/server.mjs new --topic "<topic>" --intent "<why this grill exists, 1-2 sentences>" --doc "<doc path>"`.
   The doc path defaults to `docs/<slug-of-topic>-design.md` under the project root (create the
   folder later if needed). Pass `--intent` with the user's goal in their words (1-2 sentences),
   taken from the topic message that started this grill. The topic is the title; the intent
   is the why. Omit it only when the topic arrived as a bare phrase with no goal attached.
   The page shows it under the topic so several open
   grills stay distinguishable. It prints one JSON line; keep `session` (the session folder).
2. Patch round 1 in (`new` already wrote the skeleton): one to three independent questions,
   each with lettered options, a level, ratings, one recommendation, and a one-paragraph why
   (see Interview method), plus any `terms`, `axes` if the default four do not fit the topic,
   and `"agent": { "status": "waiting" }`.
3. Open a **persistent Monitor** (`persistent: true`) whose command is
   `node $SKILL/server.mjs serve --session <session> --open`, description `grill page: <topic>`.
   No Monitor tool in your harness (Codex, Gemini CLI, Cursor, Copilot, others)? Use
   "Wait mode" at the end of this file for this step and for every wait after it.
   `--open` opens the page in the user's browser once the server is listening. Pass it
   only here, on Start: on Resume a tab the user still has open reconnects by itself, and
   a second tab would only duplicate it. It is best effort: with no usable opener (a
   headless or remote machine) the server says so on stderr and kee
````

## File: README.md
size: 16034
sha: 424933694cc8b2e29aac48faf389d4fa77f071f2
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/README.md

````text
# grill-with-ui

A skill for coding agents that moves a "grilling" design interview out of the terminal and
onto a local browser page. The agent asks its questions as cards, each with lettered options
and a highlighted recommendation. You answer them in any order, defer or reopen them, discuss
any single one in its own thread without losing the rest of the session, and press one
button, **Send to Agent**, to ship everything you staged as a single turn. At the end the
agent writes an exhaustive design doc for the topic.

![A grill in progress: the recommended option accepted on one question, a question asked in
another one's discussion thread, both shipped with one Send, the agent's reply and next round
of questions arriving, a pros and cons table from Explore deeper, a prototype of the design
from Visualize, and that prototype redrawn after one note of feedback](docs/demo.gif)

Above: a recommendation accepted on Q3 and a question asked on Q4 go to the agent as one Send,
and its reply opens the next round. Then one click on **Explore deeper** lays out the pros and
cons of Q6's options, **Visualize** draws the design so far as a prototype, and one note in its
feedback thread redraws it as v2 with the change asked for. Recorded against a real session by
[`design/record-demo.mjs`](design/record-demo.mjs).

Under the hood it is small on purpose: one Node script and one HTML file, no dependencies,
no build step. The agent owns `state.json` and changes it only through
`node server.mjs patch`, sending just what changed as a small JSON patch that the script
merges, validates, and writes atomically; a whole-file rewrite would put the entire state
(60 KB by the end of a long grill) into the agent's context on every turn. The page appends
one line per Send to `events.jsonl`; the server that serves the page is also the process
whose output a persistent Monitor delivers to the agent. In wait mode the agent must keep
its foreground listener active; a page server alone cannot wake an ended agent turn.
Submissions made while the agent is not listening remain queued for resume.

## Install

The skill is a plain [Agent Skills](https://agentskills.io) folder (`SKILL.md` plus one
script and one page), so it installs the same way everywhere: put this folder where your
agent looks for skills, under the name `grill-with-ui`. A symlink keeps `git pull` as the
update path; copying the folder works too. Node 20 or newer is the only requirement.

```sh
git clone https://github.com/jasonku09/grill-with-ui ~/Projects/grill-with-ui
ln -s ~/Projects/grill-with-ui ~/.claude/skills/grill-with-ui   # Claude Code (Cursor reads it too)
ln -s ~/Projects/grill-with-ui ~/.agents/skills/grill-with-ui   # Codex, Gemini CLI, Cursor, Copilot
```

Where each agent looks, and how to start a grill once it is there:

| Agent | User-level folder | Project-level folder | Start a grill |
|---|---|---|---|
| Claude Code | `~/.claude/skills/` | `.claude/skills/` | `/grill-with-ui <topic>` |
| Codex (CLI, IDE) | `~/.agents/skills/` | `.agents/skills/` | `$grill-with-ui <topic>` |
| Gemini CLI | `~/.gemini/skills/` or `~/.agents/skills/` | `.gemini/skills/` or `.agents/skills/` | say "grill with ui: <topic>"; accept the activation prompt |
| Cursor | `~/.cursor/skills/` or `~/.agents/skills/` (also `~/.claude/skills/`) | `.cursor/skills/` or `.agents/skills/` | `/grill-with-ui <topic>` in Agent chat |
| GitHub Copilot (CLI, VS Code, JetBrains) | `~/.copilot/skills/` or `~/.agents/skills/` | `.github/skills/`, `.claude/skills/`, or `.agents/skills/` | say "grill with ui: <topic>" |
| Any other agent that reads `SKILL.md` | its skills folder | | say "grill with ui: <topic>" |

Paths are from each product's documentation as of September 2026; `/skills` (Codex,
Gemini CLI) or the agent's skill picker will show whether the install landed. The skill's
description names the phrase "grill with ui", so plain language works on every agent.

What the agent needs at run time:

- **A shell tool and Node 20+.** Claude Code is woken per Send by its persistent Monitor
  tool. Agents without one use **wait mode**: `serve --detach` starts the page server,
  and a foreground `wait` loop receives sends. Follow [Wait mode](SKILL.md#wait-mode-agents-without-a-monitor-tool)
  for startup, harness fallback, and turn-boundary requirements.
- **Optionally a subagent tool**, for Visualize. See [Use](#use) for the drawing modes;
  without a subagent tool, the agent draws inline.

## Use

In any project:

```
/grill-with-ui <topic you want grilled>
```

The agent opens the page in your browser and prints its URL too, in case no browser
could be opened (a headless or remote machine). Answer by clicking an option (the recommended one is
outlined) or writing free text. A card marked "Pick one or more" takes any number of
options, and each click toggles one. Start a discussion in the right-hand panel; use **Defer** and **Reopen** on a card when
you want to. Staged actions and typed drafts survive a reload. **Send N to Agent** (⌘↩)
ships staged actions together with text left in any question's discussion or the visual
feedback box, including questions you navigated away from. These notes count toward the
Send total and can enable Send on their own; sending clears their boxes. A free-text answer
is sent only once staged (**Stage text**, or ⌘↩ in its box): until then it stays in its box,
does not count toward Send, and the footer names the question in a warning. If sending fails, carried notes remain
staged and removable. **Explore deeper** next to a question's title goes to
the agent the moment you click it, and the pros and cons table for that question's options
appears in the discussion panel when the agent is done. The agent answers
threads, writes the tables, records your answers, and adds the next round of questions to
the page.

New questions say how much attention they deserve: an **importance level** (Skim, Check, Decide
carefully, or Your call) with a one-line reason; **Levels** in the header explains them. The
question list puts Decide carefully and Your call first within each round and labels only
those two. Under each option a row of chips rates it on user experience, technical
correctness, risk, and cost (green good, yellow mixed, red poor), so the trade-offs read at
a glance; the agent swaps in its own axes at the start only when those clearly do not fit
the topic. Unrated axes and axes that do not apply show no chip. A Your-call question is
taste, so it shows the agent's **My lean** and no chips. Older questions without a level
show no pill; **Levels** is hidden when no question has a level. Rounds without levels
keep their original order; otherwise, unlevelled questions sort with Check, ties use
natural question-id order, and the default open-question selection follows that order.

**Visualize** in the header asks the agent for one picture of the design so far: an
interactive HTML prototype when the topic is a UI, an architecture or flow diagram
otherwise. When the topic is a change to an existing app, the prototype is drawn inside the
real page it changes, with the app's own look. It appears in place of the question list and
card, with its own feedback thread on the right. Undecided parts are drawn from the
recommendations and marked "assumed"; feedback you add there ships with your next Send and
redraws it; a note that contradicts an answered question reopens that question rather than
silently changing your answer. Ordinary answers and question discussions do not regenerate
the visual or delay the next round. When decisions change what it shows, it is marked
**Out of date**; click **Regenerate** to include the latest decisions. Each requested redraw
has a version number and a one-line change note. **Use subagent** is checked by default:
the agent briefs a subagent so hundreds of lines of markup stay out of the interview's
context. The draw runs in the background, so Send keeps working and the interview goes
on while it is drawn; the header says
Visualizing… (or the strip says regenerating…) until the new version lands. Once the
grilling is done, untick **Use subagent** beside Visualize: the agent then draws inline in
its own turn, which is faster, at the cost of the markup landing in its context and Send
waiting until the draw is done. The choice is remembered per grill across reloads and
is read when the request is sent, including for staged feedback. It applies to Visualize,
Regenerate, feedback, and Finish reconciliation when a visual exists.
The checkbox hides when the grill is finished. Finish reconciles and copies the final
visual next to the design doc as
`docs/<topic>-visual.html`.

**Finish grill** sends at once (after an inline confirm), including the same pending items
as Send; the agent writes the design doc to the path shown in the header (default
`docs/<topic>-design.md` in your project) and stops.

To pick up an unfinished grill, in the same project:

```
/grill-with-ui resume
```

If the agent crashed or was closed, sends you made in the meantime are replayed on resume,
and the page tab you still have open reconnects on its own. Resume does not open a second
tab; if you closed yours, open the URL the agent prints.

An unfinished, reachable page shows **No agent is listening · sends will queue until it
resumes** with a hollow amber dot when listener information confirms inactivity and the
agent is not marked as working. A send then reads **Sent #N · queued until an agent listens**.
The warning is hidden when listener information is unavailable; its absence alone does not
guarantee that an agent is listening.

## Files

Session state lives outside your repo, so there is nothing to gitignore:

```
~/.grill-with-ui/
  ui.json        global UI prefs shared by every grill (theme)
  sessions/<project-key>/<YYYYMMDD-HHMMSS>/
    state.json     written only by the agent, through `patch` (questions, recommendations, threads, status)
    events.jsonl   appended only by the page, one line per Send
    server.json    url, port and pid of the running server
    listener.json  heartbeat written by a running `wait`
    serve.log      server output from `serve --detach`
    visual.html    the prototype or diagram, served at /visual
```

`<project-key>` is the git common root of the project with slashes turned into dashes, so
every worktree of a repo sees the same sessions; outside git it is the working directory.

In this repo: `server.mjs` (the server and CLI), `page.html` (the page), `SKILL.md` (the
prompt the agent follows), `test/`, and `design/` + `docs/design.md` (how it was designed).
`design/record-demo.mjs` re-records the GIF above by driving the real page; it needs
Playwright and `ffmpeg`.

## Server commands

```
node server.mjs new      --topic T [--doc P]                  create a session, print its folder
node server.mjs serve    --session DIR [--port N] [--host ADDR | --lan] [--open | --open-command P] [--detach]
                                                          serve the page; print one line per Send
                                                          (--detach: in the background, output in serve.log)
node server.mjs sessions [--all]                               list this project's sessions
node server.mjs pending  --session DIR                         print sends past agent.handled
node server.mjs wait     --session DIR [--after N] [--timeout S]  block until the next send (exit 3 on timeout)
node server.mjs url      --session DIR [--timeout S] [--all]   print the running server's url (--all adds the LAN URL)
node server.mjs patch    --session DIR [--file P]              apply a JSON patch (stdin or P) to state.json
```

Loopback is the default. Pass `--lan` when you answer from a second machine on the
same network: the server listens on the LAN interface and `url` prints the LAN address
next to localhost. Without `--lan` no LAN socket opens and no LAN URL prints, so a grill
never reaches beyond its own machine by accident. LAN mode mints a random per-serve
token and puts it in the LAN URL (`http://<ip>:<port>/?t=<token>`); every request from a
non-loopback address needs it, including `/`, `/state`, `/visual`, `/events`, and `/send`,
while loopback requests work exactly as before. Treat the LAN URL like a password: anyone
with it can read the session and send to the agent, so share it only with the answering
machine. The token is fresh on every serve.

`--open` opens the live page in a browser once the server is listening. The skill passes it
when it starts a grill, not on resume (your open tab reconnects) and not with `--lan` (you
answer from the other machine). It is best effort: without a usable opener a one-line note
goes to stderr, the server keeps running, and stdout carries the same ready-then-sends
lines as ever. `--open-command P` runs `P` with the URL as its argument instead of the OS
opener.

`--detach` runs the same server in the background with its output in `serve.log`, prints
its ready line (with `lanUrl` under `--lan`) once it listens, and exits. Every other flag
goes to the background server, so `--open` opens the page once, from it. A server already
running for the session is reported with `"already": true` instead of doubled, and opens
nothing.

`patch` merges by the rules in `SKILL.md` ("Patching state.json"). A bad patch exits
non-zero and leaves the file untouched; a good one prints one short summary line, never the
state.

By default `serve` listens on 127.0.0.1. Every route requires a Host header matching
`127.0.0.1:<port>`, `localhost:<port>` or `[::1]:<port>` (case-insensitive), or the host of
a URL the server printed (the LAN URL, or the `--host` address); other values receive 403.
The IPv6 spelling is accepted as a header, but the server does not listen on `::1`. This
prevents a web page that points its hostname at your machine (DNS rebinding) from reading
the session. In LAN mode a request from a non-loopback address that carries a valid token
may use any Host, so the page also works opened as `http://<name>.local:<port>/?t=<token>`;
a loopback request never gets that pass. The port is required: avoid `--port 80`, since
browsers omit that default port from Host and are refused. Local clients such as curl
remain trusted: POSTs without an Origin header are allowed after the Host check.

`/visual` is sent with `Content-Security-Policy: sandbox allow-scripts`: its scripts run
with an opaque origin, even when opened in a separate tab. They cannot read the grill's
session responses or submit an accepted Send. This sandbox does not disable networking;
the [visual brief](visual-brief.md#the-file) defines the artifact's offline requirements.
POST bodies over 1 MB on `/send` and `/theme` are refused with 413.

`GRILL_HOME` overrides `~/.grill-with-ui`.

## Tests

```sh
node --test test/server.test.mjs
PLAYWRIGHT_PKG=/path/to/node_modules/@playwright/test/index.mjs node test/page.e2e.mjs
PLAYWRIGHT_PKG=/path/to/node_modules/@playwright/test/index.mjs node test/manual-visual.e2e.mjs
PLAYWRIGHT_PKG=/path/to/node_modules/@playwright/test/index.mjs node test/subagent-toggle.e2e.mjs
PLAYWRIGHT_PKG=/path/to/node_modules/@playwright/test/index.mjs node test/listener.e2e.mjs
```

The page check needs Playwright with Chromium; point `PLAYWRIGHT_PKG` at an existing install
or run it with `@playwright/test` installed next to the repo. It starts a real server on a
throwaway session and drives the page end to end (staging, reload, send, working state,
server restart, finished state).
The manual-visual check covers explicit regeneration and sandbox isolation both in the
iframe and in a separate tab. The focused toggle check covers both drawing modes, the
choice at Send time, and per-grill persistence. The listener check starts a `serve --detach`
server and a real `wait`, and covers the page's "No agent is listening" status appearing,
clearing, and returning. Set `GRILL_EVIDENCE_DIR` to save screenshots and send evidence
from these browser checks.
````

## File: .github/dependabot.yml
size: 163
sha: fecd44dba998b27601192785ffaab42caf404fba
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/.github/dependabot.yml

```text
version: 2
updates:
  - package-ecosystem: github-actions
    directory: /
    schedule:
      interval: weekly
    groups:
      actions:
        patterns: ["*"]
```

## File: .github/workflows/ci.yml
size: 506
sha: 768daf9019605598661ea9b74116cd52bb2c04b6
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/.github/workflows/ci.yml

```text
name: CI

on:
  push:
    branches: [main]
  pull_request:

permissions:
  contents: read

jobs:
  unit:
    name: unit (node ${{ matrix.node }})
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        node: [20, 22, 24]
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v6
        with:
          node-version: ${{ matrix.node }}
      - run: node --check server.mjs
      - run: node --check markdown.mjs
      - run: node --test test/*.test.mjs
```

## File: .github/workflows/e2e.yml
size: 532
sha: 7059a4a8712abf5b44129eaac5b60cbce0f81b99
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/.github/workflows/e2e.yml

```text
name: E2E

on:
  push:
    branches: [main]
  pull_request:
  workflow_dispatch:

permissions:
  contents: read

jobs:
  page:
    runs-on: ubuntu-latest
    timeout-minutes: 15
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v6
        with:
          node-version: 22
      - run: npm install --no-save @playwright/test@1
      - run: npx playwright install --with-deps chromium
      - run: node test/page.e2e.mjs
      - run: node test/manual-visual.e2e.mjs
      - run: node test/listener.e2e.mjs
```

## File: .github/workflows/static.yml
size: 803
sha: 89515b6ab870c160cc4bbaef4d2e1f489cd83bf0
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/.github/workflows/static.yml

```text
name: Static checks

on:
  push:
    branches: [main]
  pull_request:

permissions:
  contents: read

jobs:
  static:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v6
        with:
          node-version: 22
      - name: Syntax-check every script
        run: |
          for f in server.mjs markdown.mjs test/*.mjs design/record-demo.mjs; do
            node --check "$f"
          done
      - name: Page stays dependency-free (no external fetches)
        run: |
          if grep -En "src=[\"']http|href=[\"']http|fonts\.googleapis|fetch\s*\(\s*[\"']https?://|url\(\s*[\"']?https?://|@import" page.html; then
            echo "page.html must not fetch external resources (system fonts only, works offline)"
            exit 1
          fi
```

## File: .gitignore
size: 10
sha: e43b0f988953ae3a84b00331d0ccf5f7d51cb3cf
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/.gitignore

```text
.DS_Store
```

## File: .no-mistakes.yaml
size: 639
sha: 17ce0e381593b9dd4be0e64f0132efd4155122df
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/.no-mistakes.yaml

```text
# no-mistakes per-repo config — gates a branch through
# review → test → document → lint → push → PR → CI in a disposable worktree,
# then opens a clean PR.  Docs: https://kunchenguid.github.io/no-mistakes/
#
# `agent` executes on the daemon host, so no-mistakes reads it ONLY from the
# default branch (`main`) — it takes effect once committed to main, never from a
# pushed feature branch.

# Ordered fallback: pipeline steps (review/fix/document/lint) run on Codex and
# fall back to Claude Code if Codex is unavailable. The Codex model itself is
# pinned in the daemon's global config, not here.
agent: [codex, claude]
```

## File: design/index.html
size: 1805
sha: 2150d58064cdd9158f2d6d5b0a5cd6634a578008
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/index.html

```text
<!doctype html><meta charset="utf-8"><title>grill-with-ui mockups</title>
<style>body{font-family:system-ui;max-width:900px;margin:50px auto;line-height:1.6;padding:0 20px}h2{margin-top:36px;font-size:16px;color:#555;text-transform:uppercase;letter-spacing:.08em}.row{display:grid;grid-template-columns:1fr 1fr;gap:12px}a{display:block;padding:14px 18px;border:1px solid #ccc;border-radius:8px;text-decoration:none;color:#111}a:hover{background:#f4f4f4}small{display:block;color:#666}</style>
<h1>grill-with-ui mockups</h1>
<p>Left column: Claude (Fable 5.1) with the frontend-design skill. Right column: Codex (gpt-6-astra) from the functional brief only, no design guidance.</p>
<h2>A2 · Inbox, clean — three columns, discussion in the right third</h2>
<div class="row"><a href="mockups/a-inbox-clean.html">Claude, revised from A<small>flat paper, two fonts, thread panel on the right</small></a><span></span></div>
<h2>A · Inbox — list left, detail right, sticky send bar</h2>
<div class="row"><a href="mockups/a-inbox.html">Claude + frontend-design<small>warm paper, serif headings</small></a><a href="mockups-codex/a-inbox.html">Codex gpt-6-astra<small>warm ivory, forest green</small></a></div>
<h2>B · Scroll — single column by round, outline rail</h2>
<div class="row"><a href="mockups/b-scroll.html">Claude + frontend-design<small>dark control room, progress strip</small></a><a href="mockups-codex/b-scroll.html">Codex gpt-6-astra<small>serif headings, terracotta accents</small></a></div>
<h2>C · Tree + focus — dependency tree, focused card, thread drawer</h2>
<div class="row"><a href="mockups/c-tree.html">Claude + frontend-design<small>navy blueprint, gold recommendation</small></a><a href="mockups-codex/c-tree.html">Codex gpt-6-astra<small>dark slate, mint</small></a></div>
```

## File: design/mockups-codex/a-inbox.html
size: 43163
sha: 0606dfe3f6737561d4e7e601beb6110b65dde6b3
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/a-inbox.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/a-inbox.html

## File: design/mockups-codex/a-inbox.png
size: 113890
sha: 07026423577b112303c76ba8426fa0f51e9a8138
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/a-inbox.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/a-inbox.png

## File: design/mockups-codex/b-scroll.html
size: 43167
sha: 0121890257ff0bc85372234d0eda335939fd8084
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/b-scroll.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/b-scroll.html

## File: design/mockups-codex/b-scroll.png
size: 122621
sha: fe75203baaca377ec72db669ac3700f504969e0a
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/b-scroll.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/b-scroll.png

## File: design/mockups-codex/c-tree.html
size: 43246
sha: 4b8e9c6a19078bb4035de5a501e6c407a04e287e
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/c-tree.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/c-tree.html

## File: design/mockups-codex/c-tree.png
size: 161634
sha: 82b33097d283911bf57410122d981630da76aff7
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/c-tree.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/c-tree.png

## File: design/mockups-codex/PROMPT.md
size: 3334
sha: dc14df98f82089912c0e153ceaacf787e5a19123
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups-codex/PROMPT.md

```text
# Task: build three static HTML mockups of a "grill session" page

You are working in the repo at the current directory (`grill-with-ui`). Read
`docs/design.md` first for what the product is. Then build three mockup variations of
the page and write them to `design/mockups-codex/` with exactly these names:

- `a-inbox.html`  — inbox layout: a question list on the left (grouped by round), one
  detail card on the right, a sticky bottom bar with the staged count and a Send to Agent
  button.
- `b-scroll.html` — single-column scroll: all question cards in one vertical flow grouped
  by round, an outline rail for jumping between questions, threads expanding inline under
  each card.
- `c-tree.html`   — dependency tree + focus: the design tree (built from each question's
  `deps`) on the left, one focused question card in the middle, and a thread drawer on the
  right.

Do NOT modify anything under `design/mockups/` (an existing set of mockups you must not
read or copy from). Do NOT commit.

## Sample data

Use the data in `design/mockups/data.js` verbatim (it defines a `SESSION` object). You may
read that one file. Inline its contents into each HTML file inside a `<script>` tag so
every file is fully self-contained (no external script tags, no build step, no
frameworks, no dependencies). Vanilla HTML, CSS and JavaScript only.

## Every variation must show, per question

- id, title, body, round number, and links to the questions it depends on (`deps`)
- the lettered options, with the recommended option (`rec.option`) visibly highlighted and
  the rationale (`rec.why`) shown near it
- status (open / answered / deferred), and for answered questions what was chosen, with a
  visible marker when the chosen option differs from the recommendation
- a "durable" marker when `durable` is true and a "recommendation updated" marker when
  `updated` is true
- ways to respond: click an option, a one-click "Accept <rec>" button, and a free-text
  answer box
- a per-question discussion thread showing existing `thread` messages (who + text) and a
  box to add a new message

## Interaction model (page-local state, mocked)

Nothing goes to the agent until the user presses one "Send to Agent" button. Actions the
user takes (option picked, accept clicked, free text staged, thread message added) are
"staged": shown as staged on the page and counted in the Send button label, e.g.
"Send 3 to Agent". Send is disabled when nothing is staged. Pressing Send clears the staged
set, shows a brief confirmation, and flips a visible "agent working / agent waiting"
indicator for a couple of seconds. Also show a "Finish grill" button (no behavior needed)
and the target doc path from `SESSION.doc`.

Focus/select the current open question (`q15`) on load.

## Verification

- Every file must parse and run without console errors. At minimum, run a syntax check of
  each file's scripts with node. If Playwright is available at
  `~/Projects/altitude/apps/web/node_modules/@playwright/test` you may use it from that
  directory to load each file, click one option and add one thread message, and confirm
  the Send button enables with a count; otherwise say you could not run a browser check.
- Finish with a short summary: for each file, the layout and the visual choices you made,
  plus anything you could not verify.
```

## File: design/mockups/a-inbox-clean-staged.png
size: 131778
sha: ccfb1e5158c502ce98ff030c5e77dc1ca07854a4
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox-clean-staged.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox-clean-staged.png

## File: design/mockups/a-inbox-clean.html
size: 28696
sha: ca99e196f55cd77025c361fb76175ab4e46c8b39
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox-clean.html

```text
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>grill · grill-with-ui skill · Inbox (clean)</title>
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link href="https://fonts.googleapis.com/css2?family=Fraunces:opsz,wght@9..144,400;9..144,500&family=IBM+Plex+Sans:wght@400;500;600&display=swap" rel="stylesheet" />
<style>
  :root {
    --bg: #f7f4ee; --panel: #ffffff; --ink: #1f1c18; --ink-2: #625b51; --ink-3: #9a9285;
    --rule: #e6e0d4; --accent: #9a3a26; --ok: #3d6b4a; --stage: #b8791f; --stage-soft: #f8ecd2;
    --serif: "Fraunces", Georgia, serif; --sans: "IBM Plex Sans", system-ui, sans-serif;
  }
  * { box-sizing: border-box; }
  html, body { height: 100%; margin: 0; }
  body {
    font-family: var(--sans); font-size: 15px; line-height: 1.5; color: var(--ink); background: var(--bg);
    display: grid; grid-template-rows: auto 1fr auto; grid-template-columns: 260px minmax(0, 1fr) 33vw; height: 100vh;
  }

  header { grid-column: 1 / -1; display: flex; align-items: center; gap: 14px; padding: 14px 24px; border-bottom: 1px solid var(--rule); background: var(--panel); }
  header h1 { font-family: var(--serif); font-weight: 500; font-size: 20px; margin: 0; }
  header .path { color: var(--ink-3); font-size: 13px; }
  header .status { margin-left: auto; display: flex; align-items: center; gap: 8px; font-size: 13px; color: var(--ink-2); }
  .dot { width: 8px; height: 8px; border-radius: 50%; background: var(--ok); }
  .dot.working { background: var(--stage); animation: pulse 1.2s ease-in-out infinite; }
  @keyframes pulse { 50% { opacity: .3; } }

  nav { border-right: 1px solid var(--rule); overflow-y: auto; padding: 10px 0 24px; }
  nav .round { padding: 16px 20px 6px; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; color: var(--ink-3); display: flex; justify-content: space-between; }
  nav .round.current { color: var(--accent); }
  .item { display: grid; grid-template-columns: 30px 1fr auto; gap: 8px; align-items: baseline; padding: 8px 20px; cursor: pointer; }
  .item:hover { background: #efebe3; }
  .item.selected { background: var(--panel); box-shadow: inset 3px 0 0 var(--accent); }
  .item .id { font-size: 12px; color: var(--ink-3); }
  .item .t { font-size: 14px; }
  .item .mark { font-size: 11px; color: var(--ink-3); }
  .mark.answered { color: var(--ok); }
  .mark.open { color: var(--accent); }
  .mark.staged { color: var(--stage); font-weight: 600; }
  .item.updated .t::after { content: "updated"; font-size: 10px; color: var(--stage); margin-left: 6px; letter-spacing: .06em; text-transform: uppercase; }

  main { overflow-y: auto; padding: 36px 44px 60px; background: var(--panel); }
  .card { max-width: 680px; }
  .crumb { font-size: 12px; color: var(--ink-3); display: flex; gap: 12px; }
  .crumb a { color: var(--accent); text-decoration: none; }
  .card h2 { font-family: var(--serif); font-weight: 500; font-size: 30px; line-height: 1.15; margin: 8px 0 12px; }
  .card .body { font-size: 15px; color: var(--ink-2); max-width: 62ch; margin: 0; }
  .opts { list-style: none; padding: 0; margin: 24px 0 0; display: grid; gap: 8px; }
  .opt { display: grid; grid-template-columns: 28px 1fr; gap: 12px; align-items: start; padding: 12px 14px; border: 1px solid var(--rule); border-radius: 8px; background: var(--panel); cursor: pointer; }
  .opt:hover { border-color: var(--ink-3); }
  .opt .k { font-family: var(--serif); font-size: 18px; line-height: 1.2; color: var(--ink-3); }
  .opt.rec { border-color: var(--accent); }
  .opt.rec .k { color: var(--accent); }
  .opt .tag { font-size: 11px; letter-spacing: .06em; text-transform: uppercase; color: var(--accent); margin-bottom: 2px; }
  .opt.chosen { border-color: var(--ok); box-shadow: 0 0 0 1px var(--ok); }
  .opt.staged { border-color: var(--stage); box-shadow: 0 0 0 1px var(--stage); background: var(--stage-soft); }
  .why { margin: 14px 0 0; font-size: 14px; color: var(--ink-2); }
  .why b { color: var(--accent); font-weight: 600; }
  .answered-line { margin-top: 18px; font-size: 14px; color: var(--ok); }
  .answered-line .against { color: var(--accent); margin-left: 6px; }
  .answer-row { display: flex; gap: 8px; margin-top: 20px; align-items: flex-start; }
  textarea { width: 100%; min-height: 60px; font: inherit; font-size: 14px; padding: 10px 12px; border: 1px solid var(--rule); border-radius: 8px; background: var(--panel); resize: vertical; color: var(--ink); }
  textarea:focus { outline: none; border-color: var(--ink-3); }
  button { font-family: var(--sans); font-weight: 500; font-size: 14px; padding: 9px 14px; border-radius: 8px; border: 1px solid var(--rule); background: var(--panel); color: var(--ink); cursor: pointer; white-space: nowrap; }
  button:hover { border-color: var(--ink-3); }
  button.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
  button.primary:hover { border-color: var(--accent); }
  button.primary:disabled { background: var(--ink-3); border-color: var(--ink-3); cursor: default; }

  aside { border-left: 1px solid var(--rule); display: grid; grid-template-rows: auto 1fr auto; min-height: 0; }
  aside .head { padding: 20px 22px 12px; }
  aside .head h3 { margin: 0; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; color: var(--ink-3); font-weight: 600; }
  aside .head .sub { font-family: var(--serif); font-size: 16px; margin-top: 4px; }
  aside .head .count { font-size: 12px; color: var(--ink-3); margin-left: 8px; font-family: var(--sans); }
  aside .msgs { overflow-y: auto; padding: 0 22px 12px; }
  .msg { padding: 12px 0; border-top: 1px solid var(--rule); }
  .msg .who { font-size: 11px; letter-spacing: .06em; text-transform: uppercase; color: var(--ink-3); margin-bottom: 4px; }
  .msg.user .who { color: var(--stage); }
  .msg.agent .who { color: var(--accent); }
  .msg.staged { background: var(--stage-soft); margin: 8px -10px 0; padding: 10px; border-radius: 6px; border-top: 0; }
  .msg .text { font-size: 14px; }
  .empty { padding: 12px 0; font-size: 13px; color: var(--ink-3); border-top: 1px solid var(--rule); }
  aside .compose { padding: 12px 22px 18px; border-top: 1px solid var(--rule); display: grid; gap: 8px; }
  aside .compose button { justify-self: end; }

  footer { grid-column: 1 / -1; display: flex; align-items: center; gap: 14px; padding: 12px 24px; border-top: 1px solid var(--rule); background: var(--panel); }
  footer .staged-list { font-size: 13px; color: var(--ink-2); flex: 1; }
  footer .staged-list b { color: var(--stage); }
  footer .hint { font-size: 12px; color: var(--ink-3); }
  .toast { position: fixed; right: 24px; bottom: 72px; padding: 10px 14px; background: var(--ink); color: #fff; font-size: 13px; border-radius: 6px; opacity: 0; transform: translateY(6px); transition: .25s; }
  .toast.show { opacity: 1; transform: none; }
</style>
</head>
<body>
<header>
  <h1>grill-with-ui skill</h1>
  <span class="path" id="doc-path"></span>
  <span class="status"><span class="dot" id="agent-dot"></span><span id="agent-status">Agent waiting for you · since 22:41</span></span>
</header>
<nav id="nav"></nav>
<main id="main"></main>
<aside id="aside"></aside>
<footer>
  <span class="staged-list" id="staged-list">Nothing staged. Pick an option, accept a recommendation, or write in the discussion.</span>
  <span class="hint">⌘↩ send</span>
  <button id="finish">Finish grill</button>
  <button class="primary" id="send" disabled>Send to Agent</button>
</footer>
<div class="toast" id="toast"></div>
<script>
// Sample data: the real grill-with-ui design session of 2026-09-06, lightly compressed.
const SESSION = {
  topic: "grill-with-ui skill",
  project: "~/Projects/grill-with-ui",
  doc: "docs/design.md",
  agent: { status: "waiting", since: "22:41" },
  terms: [
    { term: "Round", def: "One agent turn's worth of new questions: the current frontier.", avoid: ["batch", "wave"] },
    { term: "Frontier", def: "Questions whose prerequisites are all settled and can be asked now.", avoid: ["queue", "next up"] },
    { term: "Send", def: "One press of Send to Agent: every staged action shipped as a single event.", avoid: ["submit", "reply"] },
    { term: "Durable decision", def: "Hard to reverse, surprising without context, a real trade-off. Goes under Locked decisions.", avoid: ["ADR", "big decision"] },
  ],
  rounds: [
    { n: 1, ids: ["q1"] }, { n: 2, ids: ["q2"] }, { n: 3, ids: ["q3", "q4"] },
    { n: 4, ids: ["q5", "q6", "q7"] }, { n: 5, ids: ["q8", "q9"] }, { n: 6, ids: ["q10", "q11"] },
    { n: 7, ids: ["q12", "q13", "q14"] }, { n: 8, ids: ["q15", "q16", "q17"] },
  ],
  questions: {
    q1: { id: "q1", round: 1, title: "UI surface", deps: [],
      body: "What is the UI surface, and how does it talk to the running session? This is the root decision; state format, threads and resume all hang off it.",
      options: [
        { k: "A", text: "Local browser app. A tiny bundled server serves a page and reads/writes one state file per session. Terminal stays a parallel input." },
        { k: "B", text: "Read-only side panel. Claude re-renders an HTML summary each turn; you still answer in the terminal by number." },
        { k: "C", text: "MCP app panel. Only if Claude Code renders it. Heavier to build and install." },
        { k: "D", text: "Terminal TUI. Doesn't solve scrollback. Listed to rule out." },
      ],
      rec: { option: "A", why: "Works in any terminal today, nothing to install, and the file protocol is agent-neutral so a Codex version is packaging, not a rewrite." },
      status: "answered", answer: { kind: "accept", option: "A", text: "A is exactly what I was thinking" }, durable: true, thread: [] },
    q2: { id: "q2", round: 2, title: "Transport", deps: ["q1"],
      body: "How does a browser answer reach the running Claude session? Docs check: Monitor wakes an idle session; a background shell exiting does not; Channels need a launch flag.",
      options: [
        { k: "A", text: "Persistent Monitor on the server's WebSocket. Every browser action is one event and one Claude turn." },
        { k: "B", text: "Claude Code Channels. Officially blessed, but needs a startup flag and a plugin." },
        { k: "C", text: "Manual nudge: answer in the browser, type 'go' in the terminal." },
      ],
      rec: { option: "A", why: "No startup flags, works from inside the skill. Live test fired while idle: verified." },
      status: "answered", answer: { kind: "text", text: "Simpler: the web app writes to a local JSON and the agent has a file-change watcher on it." },
      durable: true,
      thread: [
        { who: "agent", text: "Yes, and simpler than what I proposed. Refinement: two files, not one. state.json written only by the agent; events.jsonl appended only by the web app, watched with plain tail -F." },
      ] },
    q3: { id: "q3", round: 3, title: "Questions per turn", deps: ["q2"],
      body: "When Claude replies to a batch, how many new questions does it post on top of the thread replies?",
      options: [
        { k: "A", text: "Exactly one new primary question per turn. Keeps 'resolve dependencies one by one'." },
        { k: "B", text: "Up to a few new questions when they're independent. Fewer round trips; recommendations can go stale." },
      ],
      rec: { option: "A", why: "You already batch on your side; keeping Claude to one at a time is what makes recommendations trustworthy." },
      status: "answered", answer: { kind: "option", option: "B", text: "" }, durable: false, thread: [] },
    q4: { id: "q4", round: 3, title: "Thread context", deps: ["q1"],
      body: "What does 'chat more about a question without losing context' mean mechanically?",
      options: [
        { k: "A", text: "One Claude session; threads are labeled messages. Nothing is separate under the hood." },
        { k: "B", text: "A subagent per thread, seeded with a summary. Isolation, but loses exactly the context you want." },
      ],
      rec: { option: "A", why: "The thing you're missing is navigation, not isolation. The page provides that." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: true, thread: [] },
    q5: { id: "q5", round: 4, title: "Question card shape", deps: ["q4"],
      body: "What does a question look like on the page, and how do you answer it? This fixes the state schema.",
      options: [
        { k: "A", text: "Structured card: title, body, lettered options, a recommendation pointing at one, a rationale. Answer by option, Accept, or free text. Thread box separate." },
        { k: "B", text: "Free text everywhere. Simpler schema, no one-click accept." },
      ],
      rec: { option: "A", why: "Grilling already produces lettered options and a named recommendation, so structure costs nothing." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q6: { id: "q6", round: 4, title: "Terminal role", deps: ["q1"],
      body: "What does the terminal do while a grill runs in the page?",
      options: [
        { k: "A", text: "One-line status per turn, plus the URL. Terminal typing still works and is recorded into state." },
        { k: "B", text: "Terminal goes silent. Launch only." },
        { k: "C", text: "Terminal mirrors the full text. Defeats the purpose." },
      ],
      rec: { option: "A", why: "Same scrollback cost as silence, and it gives you the 'Claude is waiting' signal where you're already looking." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q7: { id: "q7", round: 4, title: "Server lifecycle", deps: ["q2"],
      body: "Who starts and stops the local server, and how do we guarantee it dies? Orphaned processes have bitten this machine before.",
      options: [
        { k: "A", text: "The server is the monitor. It lives exactly as long as the monitor: killed at session end or on Finish. Nothing to orphan." },
        { k: "B", text: "Server in the background, separate tail watcher. Needs its own shutdown story; every option is a way to leak." },
      ],
      rec: { option: "A", why: "Same file-based design, with writer and watcher collapsed into one process the harness already manages." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: true, thread: [] },
    q8: { id: "q8", round: 5, title: "Finish + deliverable", deps: ["q5"],
      body: "How does a grill end, and what's the deliverable? Past grills all ended as design docs.",
      options: [
        { k: "A", text: "Explicit Finish button; Claude writes a markdown decisions doc from state. Doc path asked once at start." },
        { k: "B", text: "No explicit end; the state file is the record." },
      ],
      rec: { option: "A", why: "Writing from a structured state file is more faithful than writing from a long transcript." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false,
      thread: [
        { who: "user", text: "Can you also look up Matt Pocock's grill-with-docs skill to see what we can borrow for the docs part, and compare it to the docs we already generate?" },
        { who: "agent", text: "Fetched it. It's one line: run grilling + domain-modeling. The docs part writes a repo-wide CONTEXT.md glossary and sparse ADRs gated on hard-to-reverse, surprising, real trade-off. Your docs are the opposite shape: one exhaustive topic doc builders consume as the spec. Turned into Q9." },
      ] },
    q9: { id: "q9", round: 5, title: "What Finish writes", deps: ["q8"],
      body: "Your exhaustive topic doc, Matt's sparse ADRs and glossary, or both?",
      options: [
        { k: "A", text: "Your design doc, with two borrows: a per-decision durable flag (Locked vs Routine sections) and a Terms section with Avoid lists." },
        { k: "B", text: "Your design doc plus ADRs in docs/adr and a root CONTEXT.md. Two places to keep in sync." },
        { k: "C", text: "Matt's files only. Rejected: builders need the exhaustive doc." },
      ],
      rec: { option: "A", why: "The durable flag and the terms section fix two real problems; repo-wide files can be an opt-in flag later." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: true, thread: [] },
    q10: { id: "q10", round: 6, title: "State location + resume", deps: ["q7"],
      body: "Where does session state live, and how does resume work? Several worktrees per project here.",
      options: [
        { k: "A", text: "Per-session folder under home, keyed by git common root (working directory when not in git). Resume lists unfinished sessions for the project." },
        { k: "B", text: "Inside the repo, gitignored. Lives in one worktree; ws reset wipes it." },
      ],
      rec: { option: "A", why: "Worktree independence decides it here; for adopters it also means zero repo changes." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: true,
      thread: [
        { who: "user", text: "Hm, what would be easier for other people to adopt?" },
        { who: "agent", text: "Outside the repo, by a wider margin: zero repo changes, one mental model, works outside git, resume is discoverable anyway. Only loss: sessions don't travel with a clone, which is a non-goal." },
      ] },
    q11: { id: "q11", round: 6, title: "Stack", deps: ["q10"],
      body: "What is the server and page built with? Must run the moment the skill is installed.",
      options: [
        { k: "A", text: "Plain Node, no dependencies, no build step. One server script, one self-contained HTML page." },
        { k: "B", text: "Bun. Nicer API, not on most machines." },
        { k: "C", text: "React with a build step." },
      ],
      rec: { option: "A", why: "Claude Code requires Node, so every adopter has it. Polish comes from CSS, not the framework." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q12: { id: "q12", round: 7, title: "Relation to grilling skills", deps: ["q9"],
      body: "How does grill-with-ui relate to the grilling and grill-me skills you already have?",
      options: [
        { k: "A", text: "Self-contained new skill with its own interview prompt (frontier-per-round) plus the page protocol. Developed in its own repo, symlinked in." },
        { k: "B", text: "Composition, Matt-style: invoke grilling plus a protocol skill. Two skills fighting over output format." },
        { k: "C", text: "A flag on grill-me." },
      ],
      rec: { option: "A", why: "One folder, one prompt, nothing to depend on. Publishable later without extraction." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q13: { id: "q13", round: 7, title: "Agent neutrality", deps: ["q11"],
      body: "Claude Code only, or agent-neutral from the start? Codex has no Monitor; Bedrock/Vertex Claude Code lacks it too.",
      options: [
        { k: "A", text: "Add a blocking wait mode to the server now: blocks in the foreground until the next Send, prints it, exits. About twenty lines." },
        { k: "B", text: "Claude Code only for v1." },
      ],
      rec: { option: "A", why: "Cheap, also the fallback for Claude Code without Monitor, keeps the no-lock-in promise." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q14: { id: "q14", round: 7, title: "Build order", deps: ["q13"],
      body: "What gets built first? One assumption is unverified: the harness labels monitor events 'not user input'; the skill prompt says Send events are your answers.",
      options: [
        { k: "A", text: "Spike the wake-up path first: minimal server, one-textarea page, stub prompt with only the event rule. One real round." },
        { k: "B", text: "Build everything, then test end to end." },
      ],
      rec: { option: "A", why: "The only piece that can't be reasoned out from what we already know." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q15: { id: "q15", round: 8, title: "Page visual direction", deps: ["q11"],
      body: "Three mockups are on the table. Which layout carries forward into the spike page?",
      options: [
        { k: "A", text: "Inbox: question list on the left, one detail card on the right, sticky send bar." },
        { k: "B", text: "Scroll: single column of cards grouped by round, outline rail for jumping." },
        { k: "C", text: "Tree + focus: dependency tree on the left, one focused card, thread drawer." },
      ],
      rec: { option: "A", why: "Best fit for 'go back to an earlier question' and it keeps the current question in view while you read history." },
      status: "open", answer: null, durable: false, thread: [] },
    q16: { id: "q16", round: 8, title: "Doc template sections", deps: ["q9"],
      body: "Section order for the generated design doc: Terms, Why, Locked decisions, Routine choices, Deferred, Follow-ups?",
      options: [
        { k: "A", text: "That order, with the header carrying the locked-decision count and the date." },
        { k: "B", text: "Decisions first, Terms at the end as an appendix." },
      ],
      rec: { option: "A", why: "Terms first is what makes cold re-entry work; the header count is your existing convention." },
      status: "open", answer: null, durable: false, updated: true, thread: [] },
    q17: { id: "q17", round: 8, title: "Keyboard shortcuts", deps: ["q15"],
      body: "j/k to move between questions, a/b/c to pick an option, enter to stage, cmd+enter to send?",
      options: [
        { k: "A", text: "Yes, all of them, shown in a footer hint." },
        { k: "B", text: "Defer to after the spike." },
      ],
      rec: { option: "B", why: "Zero cost to add later; not on the critical path." },
      status: "deferred", answer: null, durable: false, thread: [] },
  },
};

</script>
<script>
const S = SESSION; const staged = {}; // qid -> {answer?, thread?:[]}
let selected = "q15";
document.getElementById("doc-path").textContent = S.doc;
const stagedCount = () => Object.values(staged).reduce((n, s) => n + (s.answer ? 1 : 0) + (s.thread ? s.thread.length : 0), 0);
function renderNav() {
  const nav = document.getElementById("nav"); nav.innerHTML = "";
  for (const r of S.rounds) {
    const isCur = r.n === S.rounds.length;
    const h = document.createElement("div"); h.className = "round" + (isCur ? " current" : "");
    h.innerHTML = `<span>Round ${r.n}${isCur ? " · current" : ""}</span><span>${r.ids.length}</span>`; nav.appendChild(h);
    for (const id of r.ids) {
      const q = S.questions[id]; const st = staged[id];
      const el = document.createElement("div");
      el.className = "item" + (id === selected ? " selected" : "") + (q.updated ? " updated" : "");
      const mark = st ? `<span class="mark staged">staged</span>` : `<span class="mark ${q.status}">${q.status === "answered" ? (q.answer.option || "text") : q.status}</span>`;
      el.innerHTML = `<span class="id">${id.toUpperCase()}</span><span class="t">${q.title}</span>${mark}`;
      el.onclick = () => { selected = id; render(); };
      nav.appendChild(el);
    }
  }
}
function renderMain() {
  const q = S.questions[selected]; const st = staged[selected] || {};
  const deps = q.deps.length ? `<span>after ${q.deps.map(d => `<a href="#" data-go="${d}">${d.toUpperCase()}</a>`).join(", ")}</span>` : `<span>root</span>`;
  const opts = q.options.map(o => {
    const isRec = q.rec.option === o.k; const chosen = q.answer && q.answer.option === o.k; const isStaged = st.answer && st.answer.option === o.k;
    return `<li class="opt ${isRec ? "rec" : ""} ${chosen ? "chosen" : ""} ${isStaged ? "staged" : ""}" data-opt="${o.k}"><span class="k">${o.k}</span><span>${isRec ? `<div class="tag">Recommended</div>` : ""}${o.text}</span></li>`;
  }).join("");
  let answerBlock = "";
  if (q.status === "answered") {
    const against = q.answer.option && q.answer.option !== q.rec.option ? `<span class="against">against rec ${q.rec.option}</span>` : "";
    answerBlock = `<div class="answered-line">Answered: ${q.answer.kind === "accept" ? `accepted recommendation <b>${q.answer.option}</b>` : q.answer.option ? `chose <b>${q.answer.option}</b>` : ""}${q.answer.text ? ` “${q.answer.text}”` : ""}${against}</div>`;
  }
  document.getElementById("main").innerHTML = `
    <article class="card">
      <div class="crumb"><span>${q.id.toUpperCase()} · round ${q.round}</span>${deps}${q.durable ? `<span>durable</span>` : ""}</div>
      <h2>${q.title}</h2>
      <p class="body">${q.body}</p>
      <ul class="opts">${opts}</ul>
      <p class="why"><b>Why ${q.rec.option}.</b> ${q.rec.why}</p>
      ${answerBlock}
      <div class="answer-row">
        <textarea id="free" placeholder="${q.status === "answered" ? "Change your answer, or add nuance…" : "Free-text answer, if none of the options fit…"}">${st.answer && st.answer.text || ""}</textarea>
        <button id="accept">Accept ${q.rec.option}</button>
        <button id="stage-text">Stage text</button>
      </div>
    </article>`;
  document.querySelectorAll("[data-go]").forEach(a => a.onclick = e => { e.preventDefault(); selected = a.dataset.go; render(); });
  document.querySelectorAll(".opt").forEach(o => o.onclick = () => stage(q.id, { answer: { kind: "option", option: o.dataset.opt } }));
  document.getElementById("accept").onclick = () => stage(q.id, { answer: { kind: "accept", option: q.rec.option } });
  document.getElementById("stage-text").onclick = () => { const t = document.getElementById("free").value.trim(); if (t) stage(q.id, { answer: { kind: "text", text: t } }); };
}
function renderAside() {
  const q = S.questions[selected]; const st = staged[selected] || {};
  const msgs = q.thread.map(m => `<div class="msg ${m.who}"><div class="who">${m.who}</div><div class="text">${m.text}</div></div>`).join("") +
    (st.thread || []).map(t => `<div class="msg user staged"><div class="who">you · staged</div><div class="text">${t}</div></div>`).join("");
  document.getElementById("aside").innerHTML = `
    <div class="head"><h3>Discussion</h3><div class="sub">${q.id.toUpperCase()} · ${q.title}<span class="count">${q.thread.length} message${q.thread.length === 1 ? "" : "s"}</span></div></div>
    <div class="msgs">${msgs || `<div class="empty">Nothing yet. Ask anything about this question; the agent answers here on the next send.</div>`}</div>
    <div class="compose"><textarea id="thread-in" placeholder="Dig deeper on ${q.id.toUpperCase()}…"></textarea><button id="stage-thread">Add to discussion</button></div>`;
  document.getElementById("stage-thread").onclick = () => { const t = document.getElementById("thread-in").value.trim(); if (t) { staged[q.id] = staged[q.id] || {}; (staged[q.id].thread = staged[q.id].thread || []).push(t); render(); } };
}
function stage(id, patch) { staged[id] = Object.assign(staged[id] || {}, patch); render(); }
function renderFooter() {
  const n = stagedCount(); const send = document.getElementById("send"); send.disabled = n === 0;
  const parts = Object.entries(staged).map(([id, s]) => `${id.toUpperCase()}${s.answer ? ` ${s.answer.option ? "→ " + s.answer.option : "→ text"}` : ""}${s.thread ? ` +${s.thread.length} msg` : ""}`);
  document.getElementById("staged-list").innerHTML = n ? `<b>${n} staged</b> · ${parts.join(" · ")}` : "Nothing staged. Pick an option, accept a recommendation, or write in the discussion.";
  send.textContent = n ? `Send ${n} to Agent` : "Send to Agent";
}
function render() { renderNav(); renderMain(); renderAside(); renderFooter(); const sel = document.querySelector(".item.selected"); if (sel) sel.scrollIntoView({ block: "nearest" }); }
document.getElementById("send").onclick = () => {
  const n = stagedCount(); for (const k in staged) delete staged[k];
  const dot = document.getElementById("agent-dot"), s = document.getElementById("agent-status"), t = document.getElementById("toast");
  dot.classList.add("working"); s.textContent = "Agent working on your batch…"; t.textContent = `Sent ${n} action${n > 1 ? "s" : ""} as one event`; t.classList.add("show");
  render(); setTimeout(() => { t.classList.remove("show"); }, 1800);
  setTimeout(() => { dot.classList.remove("working"); s.textContent = "Agent waiting for you · just now"; }, 2600);
};
document.addEventListener("keydown", e => { if ((e.metaKey || e.ctrlKey) && e.key === "Enter") document.getElementById("send").click(); });
render();
</script>
</body>
</html>
```

## File: design/mockups/a-inbox-clean.png
size: 138447
sha: 07dc413b80481d766d9f2d11289ca30530364284
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox-clean.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox-clean.png

## File: design/mockups/a-inbox-clean.template.html
size: 14272
sha: 47ef0c6ec5940262d77d494e1aa04b156af20f9b
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox-clean.template.html

```text
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>grill · grill-with-ui skill · Inbox (clean)</title>
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link href="https://fonts.googleapis.com/css2?family=Fraunces:opsz,wght@9..144,400;9..144,500&family=IBM+Plex+Sans:wght@400;500;600&display=swap" rel="stylesheet" />
<style>
  :root {
    --bg: #f7f4ee; --panel: #ffffff; --ink: #1f1c18; --ink-2: #625b51; --ink-3: #9a9285;
    --rule: #e6e0d4; --accent: #9a3a26; --ok: #3d6b4a; --stage: #b8791f; --stage-soft: #f8ecd2;
    --serif: "Fraunces", Georgia, serif; --sans: "IBM Plex Sans", system-ui, sans-serif;
  }
  * { box-sizing: border-box; }
  html, body { height: 100%; margin: 0; }
  body {
    font-family: var(--sans); font-size: 15px; line-height: 1.5; color: var(--ink); background: var(--bg);
    display: grid; grid-template-rows: auto 1fr auto; grid-template-columns: 260px minmax(0, 1fr) 33vw; height: 100vh;
  }

  header { grid-column: 1 / -1; display: flex; align-items: center; gap: 14px; padding: 14px 24px; border-bottom: 1px solid var(--rule); background: var(--panel); }
  header h1 { font-family: var(--serif); font-weight: 500; font-size: 20px; margin: 0; }
  header .path { color: var(--ink-3); font-size: 13px; }
  header .status { margin-left: auto; display: flex; align-items: center; gap: 8px; font-size: 13px; color: var(--ink-2); }
  .dot { width: 8px; height: 8px; border-radius: 50%; background: var(--ok); }
  .dot.working { background: var(--stage); animation: pulse 1.2s ease-in-out infinite; }
  @keyframes pulse { 50% { opacity: .3; } }

  nav { border-right: 1px solid var(--rule); overflow-y: auto; padding: 10px 0 24px; }
  nav .round { padding: 16px 20px 6px; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; color: var(--ink-3); display: flex; justify-content: space-between; }
  nav .round.current { color: var(--accent); }
  .item { display: grid; grid-template-columns: 30px 1fr auto; gap: 8px; align-items: baseline; padding: 8px 20px; cursor: pointer; }
  .item:hover { background: #efebe3; }
  .item.selected { background: var(--panel); box-shadow: inset 3px 0 0 var(--accent); }
  .item .id { font-size: 12px; color: var(--ink-3); }
  .item .t { font-size: 14px; }
  .item .mark { font-size: 11px; color: var(--ink-3); }
  .mark.answered { color: var(--ok); }
  .mark.open { color: var(--accent); }
  .mark.staged { color: var(--stage); font-weight: 600; }
  .item.updated .t::after { content: "updated"; font-size: 10px; color: var(--stage); margin-left: 6px; letter-spacing: .06em; text-transform: uppercase; }

  main { overflow-y: auto; padding: 36px 44px 60px; background: var(--panel); }
  .card { max-width: 680px; }
  .crumb { font-size: 12px; color: var(--ink-3); display: flex; gap: 12px; }
  .crumb a { color: var(--accent); text-decoration: none; }
  .card h2 { font-family: var(--serif); font-weight: 500; font-size: 30px; line-height: 1.15; margin: 8px 0 12px; }
  .card .body { font-size: 15px; color: var(--ink-2); max-width: 62ch; margin: 0; }
  .opts { list-style: none; padding: 0; margin: 24px 0 0; display: grid; gap: 8px; }
  .opt { display: grid; grid-template-columns: 28px 1fr; gap: 12px; align-items: start; padding: 12px 14px; border: 1px solid var(--rule); border-radius: 8px; background: var(--panel); cursor: pointer; }
  .opt:hover { border-color: var(--ink-3); }
  .opt .k { font-family: var(--serif); font-size: 18px; line-height: 1.2; color: var(--ink-3); }
  .opt.rec { border-color: var(--accent); }
  .opt.rec .k { color: var(--accent); }
  .opt .tag { font-size: 11px; letter-spacing: .06em; text-transform: uppercase; color: var(--accent); margin-bottom: 2px; }
  .opt.chosen { border-color: var(--ok); box-shadow: 0 0 0 1px var(--ok); }
  .opt.staged { border-color: var(--stage); box-shadow: 0 0 0 1px var(--stage); background: var(--stage-soft); }
  .why { margin: 14px 0 0; font-size: 14px; color: var(--ink-2); }
  .why b { color: var(--accent); font-weight: 600; }
  .answered-line { margin-top: 18px; font-size: 14px; color: var(--ok); }
  .answered-line .against { color: var(--accent); margin-left: 6px; }
  .answer-row { display: flex; gap: 8px; margin-top: 20px; align-items: flex-start; }
  textarea { width: 100%; min-height: 60px; font: inherit; font-size: 14px; padding: 10px 12px; border: 1px solid var(--rule); border-radius: 8px; background: var(--panel); resize: vertical; color: var(--ink); }
  textarea:focus { outline: none; border-color: var(--ink-3); }
  button { font-family: var(--sans); font-weight: 500; font-size: 14px; padding: 9px 14px; border-radius: 8px; border: 1px solid var(--rule); background: var(--panel); color: var(--ink); cursor: pointer; white-space: nowrap; }
  button:hover { border-color: var(--ink-3); }
  button.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
  button.primary:hover { border-color: var(--accent); }
  button.primary:disabled { background: var(--ink-3); border-color: var(--ink-3); cursor: default; }

  aside { border-left: 1px solid var(--rule); display: grid; grid-template-rows: auto 1fr auto; min-height: 0; }
  aside .head { padding: 20px 22px 12px; }
  aside .head h3 { margin: 0; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; color: var(--ink-3); font-weight: 600; }
  aside .head .sub { font-family: var(--serif); font-size: 16px; margin-top: 4px; }
  aside .head .count { font-size: 12px; color: var(--ink-3); margin-left: 8px; font-family: var(--sans); }
  aside .msgs { overflow-y: auto; padding: 0 22px 12px; }
  .msg { padding: 12px 0; border-top: 1px solid var(--rule); }
  .msg .who { font-size: 11px; letter-spacing: .06em; text-transform: uppercase; color: var(--ink-3); margin-bottom: 4px; }
  .msg.user .who { color: var(--stage); }
  .msg.agent .who { color: var(--accent); }
  .msg.staged { background: var(--stage-soft); margin: 8px -10px 0; padding: 10px; border-radius: 6px; border-top: 0; }
  .msg .text { font-size: 14px; }
  .empty { padding: 12px 0; font-size: 13px; color: var(--ink-3); border-top: 1px solid var(--rule); }
  aside .compose { padding: 12px 22px 18px; border-top: 1px solid var(--rule); display: grid; gap: 8px; }
  aside .compose button { justify-self: end; }

  footer { grid-column: 1 / -1; display: flex; align-items: center; gap: 14px; padding: 12px 24px; border-top: 1px solid var(--rule); background: var(--panel); }
  footer .staged-list { font-size: 13px; color: var(--ink-2); flex: 1; }
  footer .staged-list b { color: var(--stage); }
  footer .hint { font-size: 12px; color: var(--ink-3); }
  .toast { position: fixed; right: 24px; bottom: 72px; padding: 10px 14px; background: var(--ink); color: #fff; font-size: 13px; border-radius: 6px; opacity: 0; transform: translateY(6px); transition: .25s; }
  .toast.show { opacity: 1; transform: none; }
</style>
</head>
<body>
<header>
  <h1>grill-with-ui skill</h1>
  <span class="path" id="doc-path"></span>
  <span class="status"><span class="dot" id="agent-dot"></span><span id="agent-status">Agent waiting for you · since 22:41</span></span>
</header>
<nav id="nav"></nav>
<main id="main"></main>
<aside id="aside"></aside>
<footer>
  <span class="staged-list" id="staged-list">Nothing staged. Pick an option, accept a recommendation, or write in the discussion.</span>
  <span class="hint">⌘↩ send</span>
  <button id="finish">Finish grill</button>
  <button class="primary" id="send" disabled>Send to Agent</button>
</footer>
<div class="toast" id="toast"></div>
<script>
/*__DATA__*/
</script>
<script>
const S = SESSION; const staged = {}; // qid -> {answer?, thread?:[]}
let selected = "q15";
document.getElementById("doc-path").textContent = S.doc;
const stagedCount = () => Object.values(staged).reduce((n, s) => n + (s.answer ? 1 : 0) + (s.thread ? s.thread.length : 0), 0);
function renderNav() {
  const nav = document.getElementById("nav"); nav.innerHTML = "";
  for (const r of S.rounds) {
    const isCur = r.n === S.rounds.length;
    const h = document.createElement("div"); h.className = "round" + (isCur ? " current" : "");
    h.innerHTML = `<span>Round ${r.n}${isCur ? " · current" : ""}</span><span>${r.ids.length}</span>`; nav.appendChild(h);
    for (const id of r.ids) {
      const q = S.questions[id]; const st = staged[id];
      const el = document.createElement("div");
      el.className = "item" + (id === selected ? " selected" : "") + (q.updated ? " updated" : "");
      const mark = st ? `<span class="mark staged">staged</span>` : `<span class="mark ${q.status}">${q.status === "answered" ? (q.answer.option || "text") : q.status}</span>`;
      el.innerHTML = `<span class="id">${id.toUpperCase()}</span><span class="t">${q.title}</span>${mark}`;
      el.onclick = () => { selected = id; render(); };
      nav.appendChild(el);
    }
  }
}
function renderMain() {
  const q = S.questions[selected]; const st = staged[selected] || {};
  const deps = q.deps.length ? `<span>after ${q.deps.map(d => `<a href="#" data-go="${d}">${d.toUpperCase()}</a>`).join(", ")}</span>` : `<span>root</span>`;
  const opts = q.options.map(o => {
    const isRec = q.rec.option === o.k; const chosen = q.answer && q.answer.option === o.k; const isStaged = st.answer && st.answer.option === o.k;
    return `<li class="opt ${isRec ? "rec" : ""} ${chosen ? "chosen" : ""} ${isStaged ? "staged" : ""}" data-opt="${o.k}"><span class="k">${o.k}</span><span>${isRec ? `<div class="tag">Recommended</div>` : ""}${o.text}</span></li>`;
  }).join("");
  let answerBlock = "";
  if (q.status === "answered") {
    const against = q.answer.option && q.answer.option !== q.rec.option ? `<span class="against">against rec ${q.rec.option}</span>` : "";
    answerBlock = `<div class="answered-line">Answered: ${q.answer.kind === "accept" ? `accepted recommendation <b>${q.answer.option}</b>` : q.answer.option ? `chose <b>${q.answer.option}</b>` : ""}${q.answer.text ? ` “${q.answer.text}”` : ""}${against}</div>`;
  }
  document.getElementById("main").innerHTML = `
    <article class="card">
      <div class="crumb"><span>${q.id.toUpperCase()} · round ${q.round}</span>${deps}${q.durable ? `<span>durable</span>` : ""}</div>
      <h2>${q.title}</h2>
      <p class="body">${q.body}</p>
      <ul class="opts">${opts}</ul>
      <p class="why"><b>Why ${q.rec.option}.</b> ${q.rec.why}</p>
      ${answerBlock}
      <div class="answer-row">
        <textarea id="free" placeholder="${q.status === "answered" ? "Change your answer, or add nuance…" : "Free-text answer, if none of the options fit…"}">${st.answer && st.answer.text || ""}</textarea>
        <button id="accept">Accept ${q.rec.option}</button>
        <button id="stage-text">Stage text</button>
      </div>
    </article>`;
  document.querySelectorAll("[data-go]").forEach(a => a.onclick = e => { e.preventDefault(); selected = a.dataset.go; render(); });
  document.querySelectorAll(".opt").forEach(o => o.onclick = () => stage(q.id, { answer: { kind: "option", option: o.dataset.opt } }));
  document.getElementById("accept").onclick = () => stage(q.id, { answer: { kind: "accept", option: q.rec.option } });
  document.getElementById("stage-text").onclick = () => { const t = document.getElementById("free").value.trim(); if (t) stage(q.id, { answer: { kind: "text", text: t } }); };
}
function renderAside() {
  const q = S.questions[selected]; const st = staged[selected] || {};
  const msgs = q.thread.map(m => `<div class="msg ${m.who}"><div class="who">${m.who}</div><div class="text">${m.text}</div></div>`).join("") +
    (st.thread || []).map(t => `<div class="msg user staged"><div class="who">you · staged</div><div class="text">${t}</div></div>`).join("");
  document.getElementById("aside").innerHTML = `
    <div class="head"><h3>Discussion</h3><div class="sub">${q.id.toUpperCase()} · ${q.title}<span class="count">${q.thread.length} message${q.thread.length === 1 ? "" : "s"}</span></div></div>
    <div class="msgs">${msgs || `<div class="empty">Nothing yet. Ask anything about this question; the agent answers here on the next send.</div>`}</div>
    <div class="compose"><textarea id="thread-in" placeholder="Dig deeper on ${q.id.toUpperCase()}…"></textarea><button id="stage-thread">Add to discussion</button></div>`;
  document.getElementById("stage-thread").onclick = () => { const t = document.getElementById("thread-in").value.trim(); if (t) { staged[q.id] = staged[q.id] || {}; (staged[q.id].thread = staged[q.id].thread || []).push(t); render(); } };
}
function stage(id, patch) { staged[id] = Object.assign(staged[id] || {}, patch); render(); }
function renderFooter() {
  const n = stagedCount(); const send = document.getElementById("send"); send.disabled = n === 0;
  const parts = Object.entries(staged).map(([id, s]) => `${id.toUpperCase()}${s.answer ? ` ${s.answer.option ? "→ " + s.answer.option : "→ text"}` : ""}${s.thread ? ` +${s.thread.length} msg` : ""}`);
  document.getElementById("staged-list").innerHTML = n ? `<b>${n} staged</b> · ${parts.join(" · ")}` : "Nothing staged. Pick an option, accept a recommendation, or write in the discussion.";
  send.textContent = n ? `Send ${n} to Agent` : "Send to Agent";
}
function render() { renderNav(); renderMain(); renderAside(); renderFooter(); const sel = document.querySelector(".item.selected"); if (sel) sel.scrollIntoView({ block: "nearest" }); }
document.getElementById("send").onclick = () => {
  const n = stagedCount(); for (const k in staged) delete staged[k];
  const dot = document.getElementById("agent-dot"), s = document.getElementById("agent-status"), t = document.getElementById("toast");
  dot.classList.add("working"); s.textContent = "Agent working on your batch…"; t.textContent = `Sent ${n} action${n > 1 ? "s" : ""} as one event`; t.classList.add("show");
  render(); setTimeout(() => { t.classList.remove("show"); }, 1800);
  setTimeout(() => { dot.classList.remove("working"); s.textContent = "Agent waiting for you · just now"; }, 2600);
};
document.addEventListener("keydown", e => { if ((e.metaKey || e.ctrlKey) && e.key === "Enter") document.getElementById("send").click(); });
render();
</script>
</body>
</html>
```

## File: design/mockups/a-inbox.html
size: 30212
sha: c1858063367c831376ddabf8b8d804faaec29182
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox.html

```text
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>grill · grill-with-ui skill · Inbox</title>
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link href="https://fonts.googleapis.com/css2?family=Fraunces:ital,opsz,wght@0,9..144,300..700;1,9..144,300..700&family=IBM+Plex+Sans:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap" rel="stylesheet" />
<style>
  :root {
    --paper: #f5efe4; --paper-2: #ece4d5; --ink: #1c1915; --ink-2: #5b544a; --ink-3: #8f8778;
    --rule: #d8cfbd; --ox: #8c2f1f; --ox-soft: #f3dcd5; --moss: #3f6b4a; --moss-soft: #dbe7db;
    --gold: #b7791f; --gold-soft: #f6e7c6; --current: #fffdf7;
    --serif: "Fraunces", Georgia, serif; --sans: "IBM Plex Sans", system-ui, sans-serif; --mono: "IBM Plex Mono", ui-monospace, monospace;
  }
  * { box-sizing: border-box; }
  html, body { height: 100%; margin: 0; }
  body {
    font-family: var(--sans); color: var(--ink); background: var(--paper);
    background-image: radial-gradient(1200px 600px at 10% -10%, #fbf7ee 0%, transparent 60%), url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='160' height='160'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='.9' numOctaves='2' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='.035'/%3E%3C/svg%3E");
    display: grid; grid-template-rows: auto 1fr auto; grid-template-columns: 340px 1fr; height: 100vh;
    font-size: 15px; line-height: 1.5;
  }
  header { grid-column: 1 / -1; display: flex; align-items: baseline; gap: 18px; padding: 16px 28px 12px; border-bottom: 1px solid var(--rule); }
  header .kicker { font-family: var(--mono); font-size: 12px; letter-spacing: .08em; text-transform: uppercase; color: var(--ink-3); }
  header h1 { font-family: var(--serif); font-weight: 400; font-size: 26px; margin: 0; font-variation-settings: "opsz" 40; }
  header h1 em { font-style: italic; color: var(--ox); }
  header .status { margin-left: auto; display: flex; align-items: center; gap: 8px; font-family: var(--mono); font-size: 12px; color: var(--ink-2); }
  .dot { width: 9px; height: 9px; border-radius: 50%; background: var(--moss); box-shadow: 0 0 0 3px var(--moss-soft); }
  .dot.working { background: var(--gold); box-shadow: 0 0 0 3px var(--gold-soft); animation: pulse 1.2s ease-in-out infinite; }
  @keyframes pulse { 50% { box-shadow: 0 0 0 6px transparent; } }

  nav { border-right: 1px solid var(--rule); overflow-y: auto; padding: 8px 0 24px; }
  nav .round { padding: 14px 20px 6px 28px; font-family: var(--mono); font-size: 11px; letter-spacing: .1em; text-transform: uppercase; color: var(--ink-3); display: flex; justify-content: space-between; }
  nav .round.current { color: var(--ox); }
  .item { display: grid; grid-template-columns: 34px 1fr auto; gap: 10px; align-items: baseline; padding: 9px 20px 9px 28px; cursor: pointer; border-left: 3px solid transparent; }
  .item:hover { background: var(--paper-2); }
  .item.selected { background: var(--current); border-left-color: var(--ox); }
  .item .id { font-family: var(--mono); font-size: 12px; color: var(--ink-3); }
  .item .t { font-family: var(--serif); font-size: 16px; font-variation-settings: "opsz" 20; }
  .item .t small { display: block; font-family: var(--sans); font-size: 12px; color: var(--ink-2); margin-top: 2px; }
  .item .mark { font-family: var(--mono); font-size: 11px; padding: 1px 7px; border-radius: 999px; white-space: nowrap; }
  .mark.answered { color: var(--moss); background: var(--moss-soft); }
  .mark.open { color: var(--ox); background: var(--ox-soft); }
  .mark.deferred { color: var(--ink-2); background: var(--paper-2); }
  .mark.staged { color: #fff; background: var(--gold); }
  .item.updated .t::after { content: "updated"; font-family: var(--mono); font-size: 10px; color: var(--gold); margin-left: 8px; letter-spacing: .08em; text-transform: uppercase; }

  main { overflow-y: auto; padding: 32px 48px 120px; }
  .card { max-width: 760px; animation: rise .35s ease-out both; }
  @keyframes rise { from { opacity: 0; transform: translateY(6px); } }
  .crumb { font-family: var(--mono); font-size: 12px; color: var(--ink-3); display: flex; gap: 14px; }
  .crumb .deps a { color: var(--ox); text-decoration: none; border-bottom: 1px dotted var(--ox); }
  .card h2 { font-family: var(--serif); font-weight: 400; font-size: 34px; line-height: 1.1; margin: 10px 0 14px; font-variation-settings: "opsz" 72; }
  .card .body { font-size: 16px; color: var(--ink); max-width: 64ch; }
  .opts { list-style: none; padding: 0; margin: 22px 0 0; display: grid; gap: 8px; }
  .opt { display: grid; grid-template-columns: 40px 1fr; gap: 12px; align-items: start; padding: 12px 14px; border: 1px solid var(--rule); border-radius: 8px; background: #fbf8f1; cursor: pointer; transition: transform .12s, border-color .12s; }
  .opt:hover { transform: translateX(2px); border-color: var(--ink-3); }
  .opt .k { font-family: var(--serif); font-size: 22px; line-height: 1; color: var(--ink-2); font-variation-settings: "opsz" 40; }
  .opt.rec { border-color: var(--ox); background: linear-gradient(90deg, var(--ox-soft), #fbf8f1 40%); }
  .opt.rec .k { color: var(--ox); }
  .opt.rec .tag { font-family: var(--mono); font-size: 10px; letter-spacing: .12em; text-transform: uppercase; color: var(--ox); margin-bottom: 4px; }
  .opt.chosen { outline: 2px solid var(--moss); border-color: var(--moss); }
  .opt.staged { outline: 2px solid var(--gold); border-color: var(--gold); }
  .why { margin: 14px 0 0; padding: 12px 16px; border-left: 3px solid var(--ox); font-family: var(--serif); font-style: italic; font-size: 16px; color: var(--ink-2); background: rgba(140,47,31,.04); }
  .why b { font-style: normal; font-family: var(--mono); font-size: 11px; letter-spacing: .12em; text-transform: uppercase; color: var(--ox); display: block; margin-bottom: 4px; }
  .answer-row { display: flex; gap: 10px; margin-top: 18px; align-items: flex-start; }
  textarea { width: 100%; min-height: 64px; font: inherit; font-size: 15px; padding: 10px 12px; border: 1px solid var(--rule); border-radius: 8px; background: #fffdf8; resize: vertical; color: var(--ink); }
  textarea:focus { outline: 2px solid var(--gold); border-color: transparent; }
  button { font-family: var(--sans); font-weight: 600; font-size: 14px; padding: 10px 16px; border-radius: 8px; border: 1px solid var(--ink); background: transparent; color: var(--ink); cursor: pointer; white-space: nowrap; }
  button.primary { background: var(--ox); border-color: var(--ox); color: #fff; }
  button.primary:disabled { background: var(--ink-3); border-color: var(--ink-3); cursor: default; }
  button.ghost { border-color: var(--rule); color: var(--ink-2); }
  .answered-box { margin-top: 20px; padding: 14px 16px; border-radius: 8px; background: var(--moss-soft); color: var(--moss); display: grid; grid-template-columns: auto 1fr; gap: 14px; align-items: baseline; }
  .answered-box .lbl { font-family: var(--mono); font-size: 11px; letter-spacing: .12em; text-transform: uppercase; }
  .answered-box .against { font-family: var(--mono); font-size: 11px; color: var(--ox); margin-left: 8px; }
  .thread { margin-top: 36px; border-top: 1px solid var(--rule); padding-top: 18px; }
  .thread h3 { font-family: var(--mono); font-size: 11px; letter-spacing: .12em; text-transform: uppercase; color: var(--ink-3); margin: 0 0 12px; font-weight: 500; }
  .msg { display: grid; grid-template-columns: 64px 1fr; gap: 12px; padding: 10px 0; border-bottom: 1px dashed var(--rule); }
  .msg .who { font-family: var(--mono); font-size: 11px; text-transform: uppercase; letter-spacing: .1em; color: var(--ink-3); padding-top: 3px; }
  .msg.user .who { color: var(--gold); }
  .msg.agent .who { color: var(--ox); }
  .msg.staged { background: var(--gold-soft); margin: 0 -10px; padding: 10px; border-radius: 6px; }

  footer { grid-column: 1 / -1; position: sticky; bottom: 0; display: flex; align-items: center; gap: 18px; padding: 12px 28px; border-top: 1px solid var(--rule); background: rgba(245,239,228,.92); backdrop-filter: blur(6px); }
  footer .staged-list { font-family: var(--mono); font-size: 12px; color: var(--ink-2); flex: 1; }
  footer .staged-list b { color: var(--gold); }
  footer .hint { font-family: var(--mono); font-size: 11px; color: var(--ink-3); }
  .toast { position: fixed; right: 28px; bottom: 76px; padding: 10px 14px; background: var(--ink); color: var(--paper); font-family: var(--mono); font-size: 12px; border-radius: 6px; opacity: 0; transform: translateY(6px); transition: .25s; }
  .toast.show { opacity: 1; transform: none; }
</style>
</head>
<body>
<header>
  <span class="kicker">grill session</span>
  <h1>grill-with-ui <em>skill</em></h1>
  <span class="kicker" id="doc-path"></span>
  <span class="status"><span class="dot" id="agent-dot"></span><span id="agent-status">agent waiting for you · since 22:41</span></span>
</header>
<nav id="nav"></nav>
<main id="main"></main>
<footer>
  <span class="staged-list" id="staged-list">Nothing staged. Pick an option, accept a recommendation, or write in a thread.</span>
  <span class="hint">⌘↩ send</span>
  <button class="ghost" id="finish">Finish grill</button>
  <button class="primary" id="send" disabled>Send to Agent</button>
</footer>
<div class="toast" id="toast"></div>
<script>
// Sample data: the real grill-with-ui design session of 2026-09-06, lightly compressed.
const SESSION = {
  topic: "grill-with-ui skill",
  project: "~/Projects/grill-with-ui",
  doc: "docs/design.md",
  agent: { status: "waiting", since: "22:41" },
  terms: [
    { term: "Round", def: "One agent turn's worth of new questions: the current frontier.", avoid: ["batch", "wave"] },
    { term: "Frontier", def: "Questions whose prerequisites are all settled and can be asked now.", avoid: ["queue", "next up"] },
    { term: "Send", def: "One press of Send to Agent: every staged action shipped as a single event.", avoid: ["submit", "reply"] },
    { term: "Durable decision", def: "Hard to reverse, surprising without context, a real trade-off. Goes under Locked decisions.", avoid: ["ADR", "big decision"] },
  ],
  rounds: [
    { n: 1, ids: ["q1"] }, { n: 2, ids: ["q2"] }, { n: 3, ids: ["q3", "q4"] },
    { n: 4, ids: ["q5", "q6", "q7"] }, { n: 5, ids: ["q8", "q9"] }, { n: 6, ids: ["q10", "q11"] },
    { n: 7, ids: ["q12", "q13", "q14"] }, { n: 8, ids: ["q15", "q16", "q17"] },
  ],
  questions: {
    q1: { id: "q1", round: 1, title: "UI surface", deps: [],
      body: "What is the UI surface, and how does it talk to the running session? This is the root decision; state format, threads and resume all hang off it.",
      options: [
        { k: "A", text: "Local browser app. A tiny bundled server serves a page and reads/writes one state file per session. Terminal stays a parallel input." },
        { k: "B", text: "Read-only side panel. Claude re-renders an HTML summary each turn; you still answer in the terminal by number." },
        { k: "C", text: "MCP app panel. Only if Claude Code renders it. Heavier to build and install." },
        { k: "D", text: "Terminal TUI. Doesn't solve scrollback. Listed to rule out." },
      ],
      rec: { option: "A", why: "Works in any terminal today, nothing to install, and the file protocol is agent-neutral so a Codex version is packaging, not a rewrite." },
      status: "answered", answer: { kind: "accept", option: "A", text: "A is exactly what I was thinking" }, durable: true, thread: [] },
    q2: { id: "q2", round: 2, title: "Transport", deps: ["q1"],
      body: "How does a browser answer reach the running Claude session? Docs check: Monitor wakes an idle session; a background shell exiting does not; Channels need a launch flag.",
      options: [
        { k: "A", text: "Persistent Monitor on the server's WebSocket. Every browser action is one event and one Claude turn." },
        { k: "B", text: "Claude Code Channels. Officially blessed, but needs a startup flag and a plugin." },
        { k: "C", text: "Manual nudge: answer in the browser, type 'go' in the terminal." },
      ],
      rec: { option: "A", why: "No startup flags, works from inside the skill. Live test fired while idle: verified." },
      status: "answered", answer: { kind: "text", text: "Simpler: the web app writes to a local JSON and the agent has a file-change watcher on it." },
      durable: true,
      thread: [
        { who: "agent", text: "Yes, and simpler than what I proposed. Refinement: two files, not one. state.json written only by the agent; events.jsonl appended only by the web app, watched with plain tail -F." },
      ] },
    q3: { id: "q3", round: 3, title: "Questions per turn", deps: ["q2"],
      body: "When Claude replies to a batch, how many new questions does it post on top of the thread replies?",
      options: [
        { k: "A", text: "Exactly one new primary question per turn. Keeps 'resolve dependencies one by one'." },
        { k: "B", text: "Up to a few new questions when they're independent. Fewer round trips; recommendations can go stale." },
      ],
      rec: { option: "A", why: "You already batch on your side; keeping Claude to one at a time is what makes recommendations trustworthy." },
      status: "answered", answer: { kind: "option", option: "B", text: "" }, durable: false, thread: [] },
    q4: { id: "q4", round: 3, title: "Thread context", deps: ["q1"],
      body: "What does 'chat more about a question without losing context' mean mechanically?",
      options: [
        { k: "A", text: "One Claude session; threads are labeled messages. Nothing is separate under the hood." },
        { k: "B", text: "A subagent per thread, seeded with a summary. Isolation, but loses exactly the context you want." },
      ],
      rec: { option: "A", why: "The thing you're missing is navigation, not isolation. The page provides that." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: true, thread: [] },
    q5: { id: "q5", round: 4, title: "Question card shape", deps: ["q4"],
      body: "What does a question look like on the page, and how do you answer it? This fixes the state schema.",
      options: [
        { k: "A", text: "Structured card: title, body, lettered options, a recommendation pointing at one, a rationale. Answer by option, Accept, or free text. Thread box separate." },
        { k: "B", text: "Free text everywhere. Simpler schema, no one-click accept." },
      ],
      rec: { option: "A", why: "Grilling already produces lettered options and a named recommendation, so structure costs nothing." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q6: { id: "q6", round: 4, title: "Terminal role", deps: ["q1"],
      body: "What does the terminal do while a grill runs in the page?",
      options: [
        { k: "A", text: "One-line status per turn, plus the URL. Terminal typing still works and is recorded into state." },
        { k: "B", text: "Terminal goes silent. Launch only." },
        { k: "C", text: "Terminal mirrors the full text. Defeats the purpose." },
      ],
      rec: { option: "A", why: "Same scrollback cost as silence, and it gives you the 'Claude is waiting' signal where you're already looking." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q7: { id: "q7", round: 4, title: "Server lifecycle", deps: ["q2"],
      body: "Who starts and stops the local server, and how do we guarantee it dies? Orphaned processes have bitten this machine before.",
      options: [
        { k: "A", text: "The server is the monitor. It lives exactly as long as the monitor: killed at session end or on Finish. Nothing to orphan." },
        { k: "B", text: "Server in the background, separate tail watcher. Needs its own shutdown story; every option is a way to leak." },
      ],
      rec: { option: "A", why: "Same file-based design, with writer and watcher collapsed into one process the harness already manages." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: true, thread: [] },
    q8: { id: "q8", round: 5, title: "Finish + deliverable", deps: ["q5"],
      body: "How does a grill end, and what's the deliverable? Past grills all ended as design docs.",
      options: [
        { k: "A", text: "Explicit Finish button; Claude writes a markdown decisions doc from state. Doc path asked once at start." },
        { k: "B", text: "No explicit end; the state file is the record." },
      ],
      rec: { option: "A", why: "Writing from a structured state file is more faithful than writing from a long transcript." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false,
      thread: [
        { who: "user", text: "Can you also look up Matt Pocock's grill-with-docs skill to see what we can borrow for the docs part, and compare it to the docs we already generate?" },
        { who: "agent", text: "Fetched it. It's one line: run grilling + domain-modeling. The docs part writes a repo-wide CONTEXT.md glossary and sparse ADRs gated on hard-to-reverse, surprising, real trade-off. Your docs are the opposite shape: one exhaustive topic doc builders consume as the spec. Turned into Q9." },
      ] },
    q9: { id: "q9", round: 5, title: "What Finish writes", deps: ["q8"],
      body: "Your exhaustive topic doc, Matt's sparse ADRs and glossary, or both?",
      options: [
        { k: "A", text: "Your design doc, with two borrows: a per-decision durable flag (Locked vs Routine sections) and a Terms section with Avoid lists." },
        { k: "B", text: "Your design doc plus ADRs in docs/adr and a root CONTEXT.md. Two places to keep in sync." },
        { k: "C", text: "Matt's files only. Rejected: builders need the exhaustive doc." },
      ],
      rec: { option: "A", why: "The durable flag and the terms section fix two real problems; repo-wide files can be an opt-in flag later." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: true, thread: [] },
    q10: { id: "q10", round: 6, title: "State location + resume", deps: ["q7"],
      body: "Where does session state live, and how does resume work? Several worktrees per project here.",
      options: [
        { k: "A", text: "Per-session folder under home, keyed by git common root (working directory when not in git). Resume lists unfinished sessions for the project." },
        { k: "B", text: "Inside the repo, gitignored. Lives in one worktree; ws reset wipes it." },
      ],
      rec: { option: "A", why: "Worktree independence decides it here; for adopters it also means zero repo changes." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: true,
      thread: [
        { who: "user", text: "Hm, what would be easier for other people to adopt?" },
        { who: "agent", text: "Outside the repo, by a wider margin: zero repo changes, one mental model, works outside git, resume is discoverable anyway. Only loss: sessions don't travel with a clone, which is a non-goal." },
      ] },
    q11: { id: "q11", round: 6, title: "Stack", deps: ["q10"],
      body: "What is the server and page built with? Must run the moment the skill is installed.",
      options: [
        { k: "A", text: "Plain Node, no dependencies, no build step. One server script, one self-contained HTML page." },
        { k: "B", text: "Bun. Nicer API, not on most machines." },
        { k: "C", text: "React with a build step." },
      ],
      rec: { option: "A", why: "Claude Code requires Node, so every adopter has it. Polish comes from CSS, not the framework." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q12: { id: "q12", round: 7, title: "Relation to grilling skills", deps: ["q9"],
      body: "How does grill-with-ui relate to the grilling and grill-me skills you already have?",
      options: [
        { k: "A", text: "Self-contained new skill with its own interview prompt (frontier-per-round) plus the page protocol. Developed in its own repo, symlinked in." },
        { k: "B", text: "Composition, Matt-style: invoke grilling plus a protocol skill. Two skills fighting over output format." },
        { k: "C", text: "A flag on grill-me." },
      ],
      rec: { option: "A", why: "One folder, one prompt, nothing to depend on. Publishable later without extraction." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q13: { id: "q13", round: 7, title: "Agent neutrality", deps: ["q11"],
      body: "Claude Code only, or agent-neutral from the start? Codex has no Monitor; Bedrock/Vertex Claude Code lacks it too.",
      options: [
        { k: "A", text: "Add a blocking wait mode to the server now: blocks in the foreground until the next Send, prints it, exits. About twenty lines." },
        { k: "B", text: "Claude Code only for v1." },
      ],
      rec: { option: "A", why: "Cheap, also the fallback for Claude Code without Monitor, keeps the no-lock-in promise." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q14: { id: "q14", round: 7, title: "Build order", deps: ["q13"],
      body: "What gets built first? One assumption is unverified: the harness labels monitor events 'not user input'; the skill prompt says Send events are your answers.",
      options: [
        { k: "A", text: "Spike the wake-up path first: minimal server, one-textarea page, stub prompt with only the event rule. One real round." },
        { k: "B", text: "Build everything, then test end to end." },
      ],
      rec: { option: "A", why: "The only piece that can't be reasoned out from what we already know." },
      status: "answered", answer: { kind: "accept", option: "A" }, durable: false, thread: [] },
    q15: { id: "q15", round: 8, title: "Page visual direction", deps: ["q11"],
      body: "Three mockups are on the table. Which layout carries forward into the spike page?",
      options: [
        { k: "A", text: "Inbox: question list on the left, one detail card on the right, sticky send bar." },
        { k: "B", text: "Scroll: single column of cards grouped by round, outline rail for jumping." },
        { k: "C", text: "Tree + focus: dependency tree on the left, one focused card, thread drawer." },
      ],
      rec: { option: "A", why: "Best fit for 'go back to an earlier question' and it keeps the current question in view while you read history." },
      status: "open", answer: null, durable: false, thread: [] },
    q16: { id: "q16", round: 8, title: "Doc template sections", deps: ["q9"],
      body: "Section order for the generated design doc: Terms, Why, Locked decisions, Routine choices, Deferred, Follow-ups?",
      options: [
        { k: "A", text: "That order, with the header carrying the locked-decision count and the date." },
        { k: "B", text: "Decisions first, Terms at the end as an appendix." },
      ],
      rec: { option: "A", why: "Terms first is what makes cold re-entry work; the header count is your existing convention." },
      status: "open", answer: null, durable: false, updated: true, thread: [] },
    q17: { id: "q17", round: 8, title: "Keyboard shortcuts", deps: ["q15"],
      body: "j/k to move between questions, a/b/c to pick an option, enter to stage, cmd+enter to send?",
      options: [
        { k: "A", text: "Yes, all of them, shown in a footer hint." },
        { k: "B", text: "Defer to after the spike." },
      ],
      rec: { option: "B", why: "Zero cost to add later; not on the critical path." },
      status: "deferred", answer: null, durable: false, thread: [] },
  },
};

</script>
<script>
const S = SESSION; const staged = {}; // qid -> {answer?, thread?:[]}
let selected = "q15";
document.getElementById("doc-path").textContent = "→ " + S.doc;
const stagedCount = () => Object.values(staged).reduce((n, s) => n + (s.answer ? 1 : 0) + (s.thread ? s.thread.length : 0), 0);
function renderNav() {
  const nav = document.getElementById("nav"); nav.innerHTML = "";
  for (const r of S.rounds) {
    const isCur = r.n === S.rounds.length;
    const h = document.createElement("div"); h.className = "round" + (isCur ? " current" : "");
    h.innerHTML = `<span>Round ${r.n}${isCur ? " · current" : ""}</span><span>${r.ids.length}</span>`; nav.appendChild(h);
    for (const id of r.ids) {
      const q = S.questions[id]; const st = staged[id];
      const el = document.createElement("div");
      el.className = "item" + (id === selected ? " selected" : "") + (q.updated ? " updated" : "");
      const mark = st ? `<span class="mark staged">staged</span>` : `<span class="mark ${q.status}">${q.status === "answered" ? (q.answer.option || "text") : q.status}</span>`;
      el.innerHTML = `<span class="id">${id.toUpperCase()}</span><span class="t">${q.title}<small>${q.body.slice(0, 54)}…</small></span>${mark}`;
      el.onclick = () => { selected = id; render(); };
      nav.appendChild(el);
    }
  }
}
function renderMain() {
  const q = S.questions[selected]; const st = staged[selected] || {};
  const deps = q.deps.length ? `<span class="deps">after ${q.deps.map(d => `<a href="#" data-go="${d}">${d.toUpperCase()}</a>`).join(", ")}</span>` : `<span>root</span>`;
  const opts = q.options.map(o => {
    const isRec = q.rec.option === o.k; const chosen = q.answer && q.answer.option === o.k; const isStaged = st.answer && st.answer.option === o.k;
    return `<li class="opt ${isRec ? "rec" : ""} ${chosen ? "chosen" : ""} ${isStaged ? "staged" : ""}" data-opt="${o.k}"><span class="k">${o.k}</span><span>${isRec ? `<div class="tag">Recommended</div>` : ""}${o.text}</span></li>`;
  }).join("");
  let answerBlock = "";
  if (q.status === "answered") {
    const against = q.answer.option && q.answer.option !== q.rec.option ? `<span class="against">against rec ${q.rec.option}</span>` : "";
    answerBlock = `<div class="answered-box"><span class="lbl">Answered${against}</span><span>${q.answer.kind === "accept" ? `Accepted recommendation <b>${q.answer.option}</b>. ` : q.answer.option ? `Chose <b>${q.answer.option}</b>. ` : ""}${q.answer.text ? `“${q.answer.text}”` : ""}</span></div>`;
  }
  const thread = q.thread.map(m => `<div class="msg ${m.who}"><span class="who">${m.who}</span><span>${m.text}</span></div>`).join("") +
    (st.thread || []).map(t => `<div class="msg user staged"><span class="who">you · staged</span><span>${t}</span></div>`).join("");
  document.getElementById("main").innerHTML = `
    <article class="card" key="${q.id}">
      <div class="crumb"><span>${q.id.toUpperCase()} · round ${q.round}</span>${deps}${q.durable ? `<span>durable</span>` : ""}</div>
      <h2>${q.title}</h2>
      <p class="body">${q.body}</p>
      <ul class="opts">${opts}</ul>
      <div class="why"><b>Why ${q.rec.option}</b>${q.rec.why}</div>
      ${answerBlock}
      <div class="answer-row">
        <textarea id="free" placeholder="${q.status === "answered" ? "Change your answer, or add nuance…" : "Free-text answer, if none of the options fit…"}">${st.answer && st.answer.text || ""}</textarea>
        <button id="accept">Accept ${q.rec.option}</button>
        <button class="ghost" id="stage-text">Stage text</button>
      </div>
      <section class="thread">
        <h3>Discussion on ${q.id.toUpperCase()} · ${q.thread.length} messages</h3>
        ${thread}
        <div class="answer-row"><textarea id="thread-in" placeholder="Dig deeper on this question without leaving the session…"></textarea><button class="ghost" id="stage-thread">Add to thread</button></div>
      </section>
    </article>`;
  document.querySelectorAll("[data-go]").forEach(a => a.onclick = e => { e.preventDefault(); selected = a.dataset.go; render(); });
  document.querySelectorAll(".opt").forEach(o => o.onclick = () => stage(q.id, { answer: { kind: "option", option: o.dataset.opt } }));
  document.getElementById("accept").onclick = () => stage(q.id, { answer: { kind: "accept", option: q.rec.option } });
  document.getElementById("stage-text").onclick = () => { const t = document.getElementById("free").value.trim(); if (t) stage(q.id, { answer: { kind: "text", text: t } }); };
  document.getElementById("stage-thread").onclick = () => { const t = document.getElementById("thread-in").value.trim(); if (t) { staged[q.id] = staged[q.id] || {}; (staged[q.id].thread = staged[q.id].thread || []).push(t); render(); } };
}
function stage(id, patch) { staged[id] = Object.assign(staged[id] || {}, patch); render(); }
function renderFooter() {
  const n = stagedCount(); const send = document.getElementById("send"); send.disabled = n === 0;
  const parts = Object.entries(staged).map(([id, s]) => `${id.toUpperCase()}${s.answer ? ` ${s.answer.option ? "→ " + s.answer.option : "→ text"}` : ""}${s.thread ? ` +${s.thread.length} msg` : ""}`);
  document.getElementById("staged-list").innerHTML = n ? `<b>${n} staged</b> · ${parts.join(" · ")}` : "Nothing staged. Pick an option, accept a recommendation, or write in a thread.";
  send.textContent = n ? `Send ${n} to Agent` : "Send to Agent";
}
function render() { renderNav(); renderMain(); renderFooter(); }
document.getElementById("send").onclick = () => {
  const n = stagedCount(); for (const k in staged) delete staged[k];
  const dot = document.getElementById("agent-dot"), s = document.getElementById("agent-status"), t = document.getElementById("toast");
  dot.classList.add("working"); s.textContent = "agent working on your batch…"; t.textContent = `Sent ${n} action${n > 1 ? "s" : ""} as one event`; t.classList.add("show");
  render(); setTimeout(() => { t.classList.remove("show"); }, 1800);
  setTimeout(() => { dot.classList.remove("working"); s.textContent = "agent waiting for you · just now"; }, 2600);
};
document.addEventListener("keydown", e => { if ((e.metaKey || e.ctrlKey) && e.key === "Enter") document.getElementById("send").click(); });
render();
</script>
</body>
</html>
```

## File: design/mockups/a-inbox.png
size: 548272
sha: c651b8a1f077f8866d52b82312c30ff78bb76df9
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox.png

## File: design/mockups/a-inbox.template.html
size: 15788
sha: c97b7e5516a32bf5db5c91923c1a1c0b886a84df
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/a-inbox.template.html

```text
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>grill · grill-with-ui skill · Inbox</title>
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link href="https://fonts.googleapis.com/css2?family=Fraunces:ital,opsz,wght@0,9..144,300..700;1,9..144,300..700&family=IBM+Plex+Sans:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap" rel="stylesheet" />
<style>
  :root {
    --paper: #f5efe4; --paper-2: #ece4d5; --ink: #1c1915; --ink-2: #5b544a; --ink-3: #8f8778;
    --rule: #d8cfbd; --ox: #8c2f1f; --ox-soft: #f3dcd5; --moss: #3f6b4a; --moss-soft: #dbe7db;
    --gold: #b7791f; --gold-soft: #f6e7c6; --current: #fffdf7;
    --serif: "Fraunces", Georgia, serif; --sans: "IBM Plex Sans", system-ui, sans-serif; --mono: "IBM Plex Mono", ui-monospace, monospace;
  }
  * { box-sizing: border-box; }
  html, body { height: 100%; margin: 0; }
  body {
    font-family: var(--sans); color: var(--ink); background: var(--paper);
    background-image: radial-gradient(1200px 600px at 10% -10%, #fbf7ee 0%, transparent 60%), url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='160' height='160'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='.9' numOctaves='2' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='.035'/%3E%3C/svg%3E");
    display: grid; grid-template-rows: auto 1fr auto; grid-template-columns: 340px 1fr; height: 100vh;
    font-size: 15px; line-height: 1.5;
  }
  header { grid-column: 1 / -1; display: flex; align-items: baseline; gap: 18px; padding: 16px 28px 12px; border-bottom: 1px solid var(--rule); }
  header .kicker { font-family: var(--mono); font-size: 12px; letter-spacing: .08em; text-transform: uppercase; color: var(--ink-3); }
  header h1 { font-family: var(--serif); font-weight: 400; font-size: 26px; margin: 0; font-variation-settings: "opsz" 40; }
  header h1 em { font-style: italic; color: var(--ox); }
  header .status { margin-left: auto; display: flex; align-items: center; gap: 8px; font-family: var(--mono); font-size: 12px; color: var(--ink-2); }
  .dot { width: 9px; height: 9px; border-radius: 50%; background: var(--moss); box-shadow: 0 0 0 3px var(--moss-soft); }
  .dot.working { background: var(--gold); box-shadow: 0 0 0 3px var(--gold-soft); animation: pulse 1.2s ease-in-out infinite; }
  @keyframes pulse { 50% { box-shadow: 0 0 0 6px transparent; } }

  nav { border-right: 1px solid var(--rule); overflow-y: auto; padding: 8px 0 24px; }
  nav .round { padding: 14px 20px 6px 28px; font-family: var(--mono); font-size: 11px; letter-spacing: .1em; text-transform: uppercase; color: var(--ink-3); display: flex; justify-content: space-between; }
  nav .round.current { color: var(--ox); }
  .item { display: grid; grid-template-columns: 34px 1fr auto; gap: 10px; align-items: baseline; padding: 9px 20px 9px 28px; cursor: pointer; border-left: 3px solid transparent; }
  .item:hover { background: var(--paper-2); }
  .item.selected { background: var(--current); border-left-color: var(--ox); }
  .item .id { font-family: var(--mono); font-size: 12px; color: var(--ink-3); }
  .item .t { font-family: var(--serif); font-size: 16px; font-variation-settings: "opsz" 20; }
  .item .t small { display: block; font-family: var(--sans); font-size: 12px; color: var(--ink-2); margin-top: 2px; }
  .item .mark { font-family: var(--mono); font-size: 11px; padding: 1px 7px; border-radius: 999px; white-space: nowrap; }
  .mark.answered { color: var(--moss); background: var(--moss-soft); }
  .mark.open { color: var(--ox); background: var(--ox-soft); }
  .mark.deferred { color: var(--ink-2); background: var(--paper-2); }
  .mark.staged { color: #fff; background: var(--gold); }
  .item.updated .t::after { content: "updated"; font-family: var(--mono); font-size: 10px; color: var(--gold); margin-left: 8px; letter-spacing: .08em; text-transform: uppercase; }

  main { overflow-y: auto; padding: 32px 48px 120px; }
  .card { max-width: 760px; animation: rise .35s ease-out both; }
  @keyframes rise { from { opacity: 0; transform: translateY(6px); } }
  .crumb { font-family: var(--mono); font-size: 12px; color: var(--ink-3); display: flex; gap: 14px; }
  .crumb .deps a { color: var(--ox); text-decoration: none; border-bottom: 1px dotted var(--ox); }
  .card h2 { font-family: var(--serif); font-weight: 400; font-size: 34px; line-height: 1.1; margin: 10px 0 14px; font-variation-settings: "opsz" 72; }
  .card .body { font-size: 16px; color: var(--ink); max-width: 64ch; }
  .opts { list-style: none; padding: 0; margin: 22px 0 0; display: grid; gap: 8px; }
  .opt { display: grid; grid-template-columns: 40px 1fr; gap: 12px; align-items: start; padding: 12px 14px; border: 1px solid var(--rule); border-radius: 8px; background: #fbf8f1; cursor: pointer; transition: transform .12s, border-color .12s; }
  .opt:hover { transform: translateX(2px); border-color: var(--ink-3); }
  .opt .k { font-family: var(--serif); font-size: 22px; line-height: 1; color: var(--ink-2); font-variation-settings: "opsz" 40; }
  .opt.rec { border-color: var(--ox); background: linear-gradient(90deg, var(--ox-soft), #fbf8f1 40%); }
  .opt.rec .k { color: var(--ox); }
  .opt.rec .tag { font-family: var(--mono); font-size: 10px; letter-spacing: .12em; text-transform: uppercase; color: var(--ox); margin-bottom: 4px; }
  .opt.chosen { outline: 2px solid var(--moss); border-color: var(--moss); }
  .opt.staged { outline: 2px solid var(--gold); border-color: var(--gold); }
  .why { margin: 14px 0 0; padding: 12px 16px; border-left: 3px solid var(--ox); font-family: var(--serif); font-style: italic; font-size: 16px; color: var(--ink-2); background: rgba(140,47,31,.04); }
  .why b { font-style: normal; font-family: var(--mono); font-size: 11px; letter-spacing: .12em; text-transform: uppercase; color: var(--ox); display: block; margin-bottom: 4px; }
  .answer-row { display: flex; gap: 10px; margin-top: 18px; align-items: flex-start; }
  textarea { width: 100%; min-height: 64px; font: inherit; font-size: 15px; padding: 10px 12px; border: 1px solid var(--rule); border-radius: 8px; background: #fffdf8; resize: vertical; color: var(--ink); }
  textarea:focus { outline: 2px solid var(--gold); border-color: transparent; }
  button { font-family: var(--sans); font-weight: 600; font-size: 14px; padding: 10px 16px; border-radius: 8px; border: 1px solid var(--ink); background: transparent; color: var(--ink); cursor: pointer; white-space: nowrap; }
  button.primary { background: var(--ox); border-color: var(--ox); color: #fff; }
  button.primary:disabled { background: var(--ink-3); border-color: var(--ink-3); cursor: default; }
  button.ghost { border-color: var(--rule); color: var(--ink-2); }
  .answered-box { margin-top: 20px; padding: 14px 16px; border-radius: 8px; background: var(--moss-soft); color: var(--moss); display: grid; grid-template-columns: auto 1fr; gap: 14px; align-items: baseline; }
  .answered-box .lbl { font-family: var(--mono); font-size: 11px; letter-spacing: .12em; text-transform: uppercase; }
  .answered-box .against { font-family: var(--mono); font-size: 11px; color: var(--ox); margin-left: 8px; }
  .thread { margin-top: 36px; border-top: 1px solid var(--rule); padding-top: 18px; }
  .thread h3 { font-family: var(--mono); font-size: 11px; letter-spacing: .12em; text-transform: uppercase; color: var(--ink-3); margin: 0 0 12px; font-weight: 500; }
  .msg { display: grid; grid-template-columns: 64px 1fr; gap: 12px; padding: 10px 0; border-bottom: 1px dashed var(--rule); }
  .msg .who { font-family: var(--mono); font-size: 11px; text-transform: uppercase; letter-spacing: .1em; color: var(--ink-3); padding-top: 3px; }
  .msg.user .who { color: var(--gold); }
  .msg.agent .who { color: var(--ox); }
  .msg.staged { background: var(--gold-soft); margin: 0 -10px; padding: 10px; border-radius: 6px; }

  footer { grid-column: 1 / -1; position: sticky; bottom: 0; display: flex; align-items: center; gap: 18px; padding: 12px 28px; border-top: 1px solid var(--rule); background: rgba(245,239,228,.92); backdrop-filter: blur(6px); }
  footer .staged-list { font-family: var(--mono); font-size: 12px; color: var(--ink-2); flex: 1; }
  footer .staged-list b { color: var(--gold); }
  footer .hint { font-family: var(--mono); font-size: 11px; color: var(--ink-3); }
  .toast { position: fixed; right: 28px; bottom: 76px; padding: 10px 14px; background: var(--ink); color: var(--paper); font-family: var(--mono); font-size: 12px; border-radius: 6px; opacity: 0; transform: translateY(6px); transition: .25s; }
  .toast.show { opacity: 1; transform: none; }
</style>
</head>
<body>
<header>
  <span class="kicker">grill session</span>
  <h1>grill-with-ui <em>skill</em></h1>
  <span class="kicker" id="doc-path"></span>
  <span class="status"><span class="dot" id="agent-dot"></span><span id="agent-status">agent waiting for you · since 22:41</span></span>
</header>
<nav id="nav"></nav>
<main id="main"></main>
<footer>
  <span class="staged-list" id="staged-list">Nothing staged. Pick an option, accept a recommendation, or write in a thread.</span>
  <span class="hint">⌘↩ send</span>
  <button class="ghost" id="finish">Finish grill</button>
  <button class="primary" id="send" disabled>Send to Agent</button>
</footer>
<div class="toast" id="toast"></div>
<script>
/*__DATA__*/
</script>
<script>
const S = SESSION; const staged = {}; // qid -> {answer?, thread?:[]}
let selected = "q15";
document.getElementById("doc-path").textContent = "→ " + S.doc;
const stagedCount = () => Object.values(staged).reduce((n, s) => n + (s.answer ? 1 : 0) + (s.thread ? s.thread.length : 0), 0);
function renderNav() {
  const nav = document.getElementById("nav"); nav.innerHTML = "";
  for (const r of S.rounds) {
    const isCur = r.n === S.rounds.length;
    const h = document.createElement("div"); h.className = "round" + (isCur ? " current" : "");
    h.innerHTML = `<span>Round ${r.n}${isCur ? " · current" : ""}</span><span>${r.ids.length}</span>`; nav.appendChild(h);
    for (const id of r.ids) {
      const q = S.questions[id]; const st = staged[id];
      const el = document.createElement("div");
      el.className = "item" + (id === selected ? " selected" : "") + (q.updated ? " updated" : "");
      const mark = st ? `<span class="mark staged">staged</span>` : `<span class="mark ${q.status}">${q.status === "answered" ? (q.answer.option || "text") : q.status}</span>`;
      el.innerHTML = `<span class="id">${id.toUpperCase()}</span><span class="t">${q.title}<small>${q.body.slice(0, 54)}…</small></span>${mark}`;
      el.onclick = () => { selected = id; render(); };
      nav.appendChild(el);
    }
  }
}
function renderMain() {
  const q = S.questions[selected]; const st = staged[selected] || {};
  const deps = q.deps.length ? `<span class="deps">after ${q.deps.map(d => `<a href="#" data-go="${d}">${d.toUpperCase()}</a>`).join(", ")}</span>` : `<span>root</span>`;
  const opts = q.options.map(o => {
    const isRec = q.rec.option === o.k; const chosen = q.answer && q.answer.option === o.k; const isStaged = st.answer && st.answer.option === o.k;
    return `<li class="opt ${isRec ? "rec" : ""} ${chosen ? "chosen" : ""} ${isStaged ? "staged" : ""}" data-opt="${o.k}"><span class="k">${o.k}</span><span>${isRec ? `<div class="tag">Recommended</div>` : ""}${o.text}</span></li>`;
  }).join("");
  let answerBlock = "";
  if (q.status === "answered") {
    const against = q.answer.option && q.answer.option !== q.rec.option ? `<span class="against">against rec ${q.rec.option}</span>` : "";
    answerBlock = `<div class="answered-box"><span class="lbl">Answered${against}</span><span>${q.answer.kind === "accept" ? `Accepted recommendation <b>${q.answer.option}</b>. ` : q.answer.option ? `Chose <b>${q.answer.option}</b>. ` : ""}${q.answer.text ? `“${q.answer.text}”` : ""}</span></div>`;
  }
  const thread = q.thread.map(m => `<div class="msg ${m.who}"><span class="who">${m.who}</span><span>${m.text}</span></div>`).join("") +
    (st.thread || []).map(t => `<div class="msg user staged"><span class="who">you · staged</span><span>${t}</span></div>`).join("");
  document.getElementById("main").innerHTML = `
    <article class="card" key="${q.id}">
      <div class="crumb"><span>${q.id.toUpperCase()} · round ${q.round}</span>${deps}${q.durable ? `<span>durable</span>` : ""}</div>
      <h2>${q.title}</h2>
      <p class="body">${q.body}</p>
      <ul class="opts">${opts}</ul>
      <div class="why"><b>Why ${q.rec.option}</b>${q.rec.why}</div>
      ${answerBlock}
      <div class="answer-row">
        <textarea id="free" placeholder="${q.status === "answered" ? "Change your answer, or add nuance…" : "Free-text answer, if none of the options fit…"}">${st.answer && st.answer.text || ""}</textarea>
        <button id="accept">Accept ${q.rec.option}</button>
        <button class="ghost" id="stage-text">Stage text</button>
      </div>
      <section class="thread">
        <h3>Discussion on ${q.id.toUpperCase()} · ${q.thread.length} messages</h3>
        ${thread}
        <div class="answer-row"><textarea id="thread-in" placeholder="Dig deeper on this question without leaving the session…"></textarea><button class="ghost" id="stage-thread">Add to thread</button></div>
      </section>
    </article>`;
  document.querySelectorAll("[data-go]").forEach(a => a.onclick = e => { e.preventDefault(); selected = a.dataset.go; render(); });
  document.querySelectorAll(".opt").forEach(o => o.onclick = () => stage(q.id, { answer: { kind: "option", option: o.dataset.opt } }));
  document.getElementById("accept").onclick = () => stage(q.id, { answer: { kind: "accept", option: q.rec.option } });
  document.getElementById("stage-text").onclick = () => { const t = document.getElementById("free").value.trim(); if (t) stage(q.id, { answer: { kind: "text", text: t } }); };
  document.getElementById("stage-thread").onclick = () => { const t = document.getElementById("thread-in").value.trim(); if (t) { staged[q.id] = staged[q.id] || {}; (staged[q.id].thread = staged[q.id].thread || []).push(t); render(); } };
}
function stage(id, patch) { staged[id] = Object.assign(staged[id] || {}, patch); render(); }
function renderFooter() {
  const n = stagedCount(); const send = document.getElementById("send"); send.disabled = n === 0;
  const parts = Object.entries(staged).map(([id, s]) => `${id.toUpperCase()}${s.answer ? ` ${s.answer.option ? "→ " + s.answer.option : "→ text"}` : ""}${s.thread ? ` +${s.thread.length} msg` : ""}`);
  document.getElementById("staged-list").innerHTML = n ? `<b>${n} staged</b> · ${parts.join(" · ")}` : "Nothing staged. Pick an option, accept a recommendation, or write in a thread.";
  send.textContent = n ? `Send ${n} to Agent` : "Send to Agent";
}
function render() { renderNav(); renderMain(); renderFooter(); }
document.getElementById("send").onclick = () => {
  const n = stagedCount(); for (const k in staged) delete staged[k];
  const dot = document.getElementById("agent-dot"), s = document.getElementById("agent-status"), t = document.getElementById("toast");
  dot.classList.add("working"); s.textContent = "agent working on your batch…"; t.textContent = `Sent ${n} action${n > 1 ? "s" : ""} as one event`; t.classList.add("show");
  render(); setTimeout(() => { t.classList.remove("show"); }, 1800);
  setTimeout(() => { dot.classList.remove("working"); s.textContent = "agent waiting for you · just now"; }, 2600);
};
document.addEventListener("keydown", e => { if ((e.metaKey || e.ctrlKey) && e.key === "Enter") document.getElementById("send").click(); });
render();
</script>
</body>
</html>
```

## File: design/mockups/b-scroll.html
size: 31043
sha: 695e0b76e4ede2761eaedfe170e9c849abd5a449
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/b-scroll.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/b-scroll.html

## File: design/mockups/b-scroll.png
size: 190775
sha: 6269ed7f489c5ed5d58e128e2ae9c088363ffb65
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/b-scroll.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/b-scroll.png

## File: design/mockups/b-scroll.template.html
size: 16619
sha: d43396adf6b1f9eb4fe933f67d0dd472fdfba24b
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/b-scroll.template.html

```text
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>grill · grill-with-ui skill · Scroll</title>
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link href="https://fonts.googleapis.com/css2?family=Sora:wght@400;500;600&family=JetBrains+Mono:wght@400;500;700&display=swap" rel="stylesheet" />
<style>
  :root {
    --bg: #0d1117; --bg-2: #131a23; --bg-3: #1a2330; --line: #24303f; --fg: #e7ecf3; --fg-2: #9aa7b8; --fg-3: #5f6c7d;
    --amber: #ffb454; --amber-dim: rgba(255,180,84,.14); --cyan: #63d4f5; --cyan-dim: rgba(99,212,245,.12); --green: #7bd88f; --green-dim: rgba(123,216,143,.12); --red: #ff7b72;
    --sans: "Sora", system-ui, sans-serif; --mono: "JetBrains Mono", ui-monospace, monospace;
  }
  * { box-sizing: border-box; }
  html, body { margin: 0; height: 100%; }
  body { font-family: var(--sans); background: var(--bg); color: var(--fg); font-size: 14.5px; line-height: 1.55;
    background-image: linear-gradient(var(--line) 1px, transparent 1px), linear-gradient(90deg, var(--line) 1px, transparent 1px); background-size: 48px 48px; background-position: -1px -1px; }
  body::before { content: ""; position: fixed; inset: 0; background: radial-gradient(900px 500px at 70% -10%, rgba(99,212,245,.10), transparent 60%), radial-gradient(700px 400px at 0% 100%, rgba(255,180,84,.08), transparent 60%); pointer-events: none; }
  .top { position: sticky; top: 0; z-index: 5; display: grid; grid-template-columns: 1fr auto auto; gap: 16px; align-items: center; padding: 12px 24px; background: rgba(13,17,23,.85); backdrop-filter: blur(8px); border-bottom: 1px solid var(--line); }
  .top .title { display: flex; align-items: baseline; gap: 14px; }
  .top .title h1 { margin: 0; font-size: 16px; font-weight: 600; letter-spacing: -.01em; }
  .top .title .path { font-family: var(--mono); font-size: 12px; color: var(--fg-3); }
  .progress { display: flex; gap: 3px; align-items: center; }
  .progress i { width: 14px; height: 6px; border-radius: 2px; background: var(--bg-3); }
  .progress i.answered { background: var(--green); } .progress i.open { background: var(--amber); } .progress i.staged { background: var(--cyan); } .progress i.deferred { background: var(--fg-3); }
  .progress span { font-family: var(--mono); font-size: 11px; color: var(--fg-2); margin-left: 8px; }
  .agent { font-family: var(--mono); font-size: 12px; color: var(--fg-2); display: flex; gap: 8px; align-items: center; }
  .agent b { color: var(--green); font-weight: 500; } .agent b.working { color: var(--amber); }
  .agent b::before { content: "●"; margin-right: 6px; }
  .layout { display: grid; grid-template-columns: 1fr 72px; max-width: 1180px; margin: 0 auto; padding: 28px 24px 140px; gap: 24px; }
  .rail { position: sticky; top: 76px; align-self: start; display: flex; flex-direction: column; gap: 6px; }
  .rail a { font-family: var(--mono); font-size: 11px; color: var(--fg-3); text-decoration: none; padding: 3px 8px; border-left: 2px solid var(--line); transition: .15s; }
  .rail a:hover, .rail a.active { color: var(--fg); border-left-color: var(--cyan); }
  .rail a.open { color: var(--amber); } .rail a.staged { color: var(--cyan); }
  .rail .r { font-family: var(--mono); font-size: 10px; color: var(--fg-3); margin-top: 8px; letter-spacing: .1em; }
  .round-h { display: flex; align-items: center; gap: 12px; margin: 30px 0 14px; font-family: var(--mono); font-size: 11px; letter-spacing: .14em; text-transform: uppercase; color: var(--fg-3); }
  .round-h::after { content: ""; flex: 1; height: 1px; background: var(--line); }
  .round-h.current { color: var(--amber); }
  .card { background: var(--bg-2); border: 1px solid var(--line); border-radius: 10px; padding: 18px 22px 16px; margin-bottom: 14px; scroll-margin-top: 90px; transition: border-color .2s; position: relative; }
  .card.open { border-color: rgba(255,180,84,.45); box-shadow: 0 0 0 1px rgba(255,180,84,.15), 0 20px 60px -30px rgba(255,180,84,.35); }
  .card.staged { border-color: rgba(99,212,245,.55); }
  .card.answered { opacity: .82; } .card.answered:hover { opacity: 1; }
  .card.deferred { border-style: dashed; opacity: .6; }
  .head { display: flex; align-items: baseline; gap: 12px; }
  .head .id { font-family: var(--mono); font-size: 12px; color: var(--cyan); font-weight: 700; }
  .head h2 { margin: 0; font-size: 18px; font-weight: 600; letter-spacing: -.01em; }
  .head .deps { font-family: var(--mono); font-size: 11px; color: var(--fg-3); margin-left: auto; }
  .head .deps a { color: var(--fg-2); text-decoration: none; } .head .deps a:hover { color: var(--cyan); }
  .pill { font-family: var(--mono); font-size: 10px; letter-spacing: .1em; text-transform: uppercase; padding: 2px 8px; border-radius: 4px; }
  .pill.open { background: var(--amber-dim); color: var(--amber); } .pill.answered { background: var(--green-dim); color: var(--green); } .pill.deferred { background: var(--bg-3); color: var(--fg-2); } .pill.staged { background: var(--cyan-dim); color: var(--cyan); } .pill.updated { background: var(--amber-dim); color: var(--amber); }
  .body { color: var(--fg-2); margin: 8px 0 0; max-width: 78ch; }
  .card.answered .body, .card.answered .opts, .card.answered .why { display: none; }
  .card.answered.expanded .body, .card.answered.expanded .opts, .card.answered.expanded .why { display: block; }
  .opts { list-style: none; padding: 0; margin: 14px 0 0; display: grid; gap: 6px; }
  .opt { display: grid; grid-template-columns: 26px 1fr; gap: 10px; padding: 9px 12px; border-radius: 7px; background: var(--bg-3); border: 1px solid transparent; cursor: pointer; transition: .12s; }
  .opt:hover { border-color: var(--fg-3); }
  .opt .k { font-family: var(--mono); font-weight: 700; color: var(--fg-2); }
  .opt.rec { border-color: rgba(255,180,84,.5); background: linear-gradient(90deg, var(--amber-dim), var(--bg-3) 50%); } .opt.rec .k { color: var(--amber); }
  .opt.rec .tag { font-family: var(--mono); font-size: 10px; letter-spacing: .12em; text-transform: uppercase; color: var(--amber); margin-right: 8px; }
  .opt.chosen { border-color: var(--green); } .opt.stg { border-color: var(--cyan); background: var(--cyan-dim); }
  .why { margin: 10px 0 0; font-size: 13.5px; color: var(--fg-2); padding-left: 12px; border-left: 2px solid var(--amber); }
  .why b { color: var(--amber); font-family: var(--mono); font-size: 11px; font-weight: 500; letter-spacing: .1em; text-transform: uppercase; margin-right: 8px; }
  .ans { margin-top: 12px; display: flex; gap: 10px; align-items: baseline; font-size: 14px; }
  .ans .lbl { font-family: var(--mono); font-size: 11px; color: var(--green); letter-spacing: .1em; text-transform: uppercase; }
  .ans .against { font-family: var(--mono); font-size: 11px; color: var(--red); }
  .row { display: flex; gap: 8px; margin-top: 12px; align-items: flex-start; }
  textarea { flex: 1; min-height: 44px; font: inherit; font-size: 14px; color: var(--fg); background: var(--bg); border: 1px solid var(--line); border-radius: 7px; padding: 9px 11px; resize: vertical; }
  textarea:focus { outline: none; border-color: var(--cyan); }
  button { font-family: var(--mono); font-size: 12px; font-weight: 500; padding: 9px 12px; border-radius: 7px; border: 1px solid var(--line); background: var(--bg-3); color: var(--fg); cursor: pointer; white-space: nowrap; }
  button:hover { border-color: var(--fg-3); }
  button.accept { border-color: var(--amber); color: var(--amber); }
  button.primary { background: var(--cyan); color: #06222b; border-color: var(--cyan); font-weight: 700; }
  button.primary:disabled { background: var(--bg-3); color: var(--fg-3); border-color: var(--line); cursor: default; }
  details { margin-top: 12px; border-top: 1px dashed var(--line); padding-top: 8px; }
  summary { cursor: pointer; font-family: var(--mono); font-size: 11px; color: var(--fg-3); letter-spacing: .1em; text-transform: uppercase; list-style: none; display: flex; gap: 8px; align-items: center; }
  summary::before { content: "▸"; color: var(--fg-3); } details[open] summary::before { content: "▾"; }
  summary .n { color: var(--cyan); }
  .msg { display: grid; grid-template-columns: 56px 1fr; gap: 10px; padding: 8px 0; font-size: 13.5px; }
  .msg .who { font-family: var(--mono); font-size: 10px; letter-spacing: .1em; text-transform: uppercase; color: var(--fg-3); padding-top: 3px; }
  .msg.agent .who { color: var(--amber); } .msg.user .who { color: var(--cyan); }
  .msg.stg { background: var(--cyan-dim); border-radius: 6px; padding: 8px; }
  .toggle { position: absolute; top: 16px; right: 16px; font-family: var(--mono); font-size: 11px; color: var(--fg-3); cursor: pointer; }
  .card.answered .toggle::after { content: "expand"; } .card.answered.expanded .toggle::after { content: "collapse"; }
  .bar { position: fixed; left: 0; right: 0; bottom: 0; z-index: 5; display: flex; align-items: center; gap: 14px; padding: 12px 24px; background: rgba(13,17,23,.9); backdrop-filter: blur(8px); border-top: 1px solid var(--line); }
  .bar .list { flex: 1; font-family: var(--mono); font-size: 12px; color: var(--fg-2); }
  .bar .list b { color: var(--cyan); }
  .bar .hint { font-family: var(--mono); font-size: 11px; color: var(--fg-3); }
  .toast { position: fixed; right: 24px; bottom: 72px; padding: 9px 12px; background: var(--cyan); color: #06222b; font-family: var(--mono); font-size: 12px; font-weight: 700; border-radius: 6px; opacity: 0; transition: .25s; transform: translateY(6px); }
  .toast.show { opacity: 1; transform: none; }
</style>
</head>
<body>
<div class="top">
  <div class="title"><h1>grill: grill-with-ui skill</h1><span class="path" id="doc-path"></span></div>
  <div class="progress" id="progress"></div>
  <div class="agent" id="agent"><b>waiting for you</b><span>since 22:41</span></div>
</div>
<div class="layout">
  <div id="feed"></div>
  <div class="rail" id="rail"></div>
</div>
<div class="bar">
  <span class="list" id="staged-list">Nothing staged.</span>
  <span class="hint">j/k jump · ⌘↩ send</span>
  <button id="finish">Finish grill</button>
  <button class="primary" id="send" disabled>Send to Agent</button>
</div>
<div class="toast" id="toast"></div>
<script>
/*__DATA__*/
</script>
<script>
const S = SESSION; const staged = {}; const expanded = new Set();
document.getElementById("doc-path").textContent = "→ " + S.doc;
const count = () => Object.values(staged).reduce((n, s) => n + (s.answer ? 1 : 0) + (s.thread ? s.thread.length : 0), 0);
const stateOf = id => staged[id] ? "staged" : S.questions[id].status;
function renderTop() {
  document.getElementById("progress").innerHTML = Object.keys(S.questions).map(id => `<i class="${stateOf(id)}" title="${id}"></i>`).join("") +
    `<span>${Object.values(S.questions).filter(q => q.status === "answered").length}/${Object.keys(S.questions).length} settled</span>`;
}
function renderRail() {
  document.getElementById("rail").innerHTML = S.rounds.map(r => `<span class="r">R${r.n}</span>` + r.ids.map(id => `<a href="#${id}" class="${stateOf(id)}">${id.toUpperCase()}</a>`).join("")).join("");
}
function card(q) {
  const st = staged[q.id] || {}; const cls = staged[q.id] ? "staged" : q.status;
  const opts = q.options.map(o => `<li class="opt ${q.rec.option === o.k ? "rec" : ""} ${q.answer && q.answer.option === o.k ? "chosen" : ""} ${st.answer && st.answer.option === o.k ? "stg" : ""}" data-q="${q.id}" data-opt="${o.k}"><span class="k">${o.k}</span><span>${q.rec.option === o.k ? `<span class="tag">rec</span>` : ""}${o.text}</span></li>`).join("");
  const ans = q.status === "answered" ? `<div class="ans"><span class="lbl">answered</span><span>${q.answer.kind === "accept" ? `accepted <b>${q.answer.option}</b>` : q.answer.option ? `chose <b>${q.answer.option}</b>` : ""}${q.answer.text ? ` “${q.answer.text}”` : ""}</span>${q.answer.option && q.answer.option !== q.rec.option ? `<span class="against">against rec ${q.rec.option}</span>` : ""}</div>` : "";
  const thread = q.thread.map(m => `<div class="msg ${m.who}"><span class="who">${m.who}</span><span>${m.text}</span></div>`).join("") + (st.thread || []).map(t => `<div class="msg user stg"><span class="who">you · staged</span><span>${t}</span></div>`).join("");
  const stagedPill = staged[q.id] ? `<span class="pill staged">staged</span>` : `<span class="pill ${q.status}">${q.status}</span>`;
  return `<article class="card ${cls} ${expanded.has(q.id) ? "expanded" : ""}" id="${q.id}">
    <div class="head"><span class="id">${q.id.toUpperCase()}</span><h2>${q.title}</h2>${stagedPill}${q.updated ? `<span class="pill updated">rec updated</span>` : ""}<span class="deps">${q.deps.length ? "after " + q.deps.map(d => `<a href="#${d}">${d.toUpperCase()}</a>`).join(" ") : "root"}</span></div>
    ${q.status === "answered" ? `<span class="toggle" data-toggle="${q.id}"></span>` : ""}
    <p class="body">${q.body}</p>
    <ul class="opts">${opts}</ul>
    <div class="why"><b>why ${q.rec.option}</b>${q.rec.why}</div>
    ${ans}
    ${q.status !== "answered" || expanded.has(q.id) ? `<div class="row"><textarea data-free="${q.id}" placeholder="Free-text answer…">${st.answer && st.answer.text || ""}</textarea><button class="accept" data-accept="${q.id}">accept ${q.rec.option}</button><button data-stagetext="${q.id}">stage text</button></div>` : ""}
    <details ${q.thread.length || st.thread ? "open" : ""}><summary>thread <span class="n">${q.thread.length + (st.thread || []).length}</span></summary>${thread}
      <div class="row"><textarea data-thread="${q.id}" placeholder="Dig deeper on ${q.id.toUpperCase()}…"></textarea><button data-stagethread="${q.id}">add to thread</button></div></details>
  </article>`;
}
function renderFeed() {
  document.getElementById("feed").innerHTML = S.rounds.map(r => `<div class="round-h ${r.n === S.rounds.length ? "current" : ""}"><span>Round ${r.n}${r.n === S.rounds.length ? " · current frontier" : ""}</span></div>` + r.ids.map(id => card(S.questions[id])).join("")).join("");
  document.querySelectorAll("[data-toggle]").forEach(t => t.onclick = () => { const id = t.dataset.toggle; expanded.has(id) ? expanded.delete(id) : expanded.add(id); render(); });
  document.querySelectorAll(".opt").forEach(o => o.onclick = () => stage(o.dataset.q, { answer: { kind: "option", option: o.dataset.opt } }));
  document.querySelectorAll("[data-accept]").forEach(b => b.onclick = () => stage(b.dataset.accept, { answer: { kind: "accept", option: S.questions[b.dataset.accept].rec.option } }));
  document.querySelectorAll("[data-stagetext]").forEach(b => b.onclick = () => { const t = document.querySelector(`[data-free="${b.dataset.stagetext}"]`).value.trim(); if (t) stage(b.dataset.stagetext, { answer: { kind: "text", text: t } }); });
  document.querySelectorAll("[data-stagethread]").forEach(b => b.onclick = () => { const id = b.dataset.stagethread; const t = document.querySelector(`[data-thread="${id}"]`).value.trim(); if (t) { staged[id] = staged[id] || {}; (staged[id].thread = staged[id].thread || []).push(t); render(); } });
}
function stage(id, patch) { staged[id] = Object.assign(staged[id] || {}, patch); render(); }
function renderBar() {
  const n = count(); const send = document.getElementById("send"); send.disabled = !n; send.textContent = n ? `send ${n} to agent` : "Send to Agent";
  document.getElementById("staged-list").innerHTML = n ? `<b>${n} staged</b> · ` + Object.entries(staged).map(([id, s]) => `${id.toUpperCase()}${s.answer ? " → " + (s.answer.option || "text") : ""}${s.thread ? ` +${s.thread.length}` : ""}`).join(" · ") : "Nothing staged. Everything you do here stays local until you send.";
}
function render() { const y = window.scrollY; renderTop(); renderRail(); renderFeed(); renderBar(); window.scrollTo(0, y); }
document.getElementById("send").onclick = () => {
  const n = count(); for (const k in staged) delete staged[k]; const a = document.getElementById("agent"), t = document.getElementById("toast");
  a.innerHTML = `<b class="working">working on your batch</b>`; t.textContent = `sent ${n} action${n > 1 ? "s" : ""} as one event`; t.classList.add("show"); render();
  setTimeout(() => t.classList.remove("show"), 1800); setTimeout(() => { a.innerHTML = `<b>waiting for you</b><span>just now</span>`; }, 2600);
};
document.addEventListener("keydown", e => { if ((e.metaKey || e.ctrlKey) && e.key === "Enter") document.getElementById("send").click(); });
render(); setTimeout(() => document.getElementById("q15").scrollIntoView({ block: "center" }), 50);
</script>
</body>
</html>
```

## File: design/mockups/c-tree.html
size: 32674
sha: c89345170b036b4993f939d6a5ed110691ee92cb
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/c-tree.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/c-tree.html

## File: design/mockups/c-tree.png
size: 264647
sha: e0d1a08efa8a9974d1a21be362f01fa3be0d6a86
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/c-tree.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/c-tree.png

## File: design/mockups/c-tree.template.html
size: 18250
sha: 2511a9fe7158d3e5743f81dd3ecb0ca07ae31d93
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/c-tree.template.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/c-tree.template.html

## File: design/mockups/data.js
size: 14436
sha: 7cc27aad2f09ed4141e5544317d8ffd201ed6c7f
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/data.js

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/mockups/data.js

## File: design/record-demo.mjs
size: 21533
sha: 8002d92474768f333bbfae4c4be7080fa16821b9
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/record-demo.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/design/record-demo.mjs

## File: docs/demo.gif
size: 641740
sha: e42629d55f3821d647eceadd383edd099f07dfc4
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/demo.gif

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/demo.gif

## File: docs/design.md
size: 11061
sha: ba682199dbcb587d677ebf6128ebf40e739fb3fd
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/design.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/design.md

## File: docs/importance-and-ratings-design.md
size: 25129
sha: 16f2129b9fa5d8aac3817aca0a90f027969d17c9
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/importance-and-ratings-design.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/importance-and-ratings-design.md

## File: docs/importance-and-ratings-visual.html
size: 31792
sha: daf56fe5b9cbc81163f9384121113fd11da7bd42
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/importance-and-ratings-visual.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/importance-and-ratings-visual.html

## File: docs/visualize-design.md
size: 9007
sha: 7bc90e2897323c424819a69eaec1053f56e71b50
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/visualize-design.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/docs/visualize-design.md

## File: LICENSE
size: 1065
sha: 40e58caad406cbf998628883dece5e767ee6b4b7
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/LICENSE

```text
MIT License

Copyright (c) 2026 Jason Ku

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

## File: markdown.mjs
size: 2079
sha: 5bfc43c5f4b16f43e559d3a5d052d3e0b12aa875
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/markdown.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/markdown.mjs

## File: page.html
size: 71631
sha: 0e9f22cea15c463a3ade42c36172860ee264b26d
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/page.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/page.html

## File: server.mjs
size: 45723
sha: 53f870b247a2a55286288bbdd347fb7a3d8f260c
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/server.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/server.mjs

## File: test/listener.e2e.mjs
size: 6642
sha: 1381e16430867a4b223410dc7dc6418699f4fd25
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/listener.e2e.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/listener.e2e.mjs

## File: test/manual-visual.e2e.mjs
size: 9397
sha: fd2494523e208f1c0ac283cf242246f61814b68f
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/manual-visual.e2e.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/manual-visual.e2e.mjs

## File: test/markdown.test.mjs
size: 3461
sha: 004cba4490ebb2c5e95efdd0d3f5d31e81da4c1f
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/markdown.test.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/markdown.test.mjs

## File: test/page-markdown-parity.test.mjs
size: 3385
sha: b2f7e398aca0d822c37e76d32e80904199d18809
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/page-markdown-parity.test.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/page-markdown-parity.test.mjs

## File: test/page.e2e.mjs
size: 79656
sha: 2394817a69360943d4caececd102b07b8a5a5adc
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/page.e2e.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/page.e2e.mjs

## File: test/server.test.mjs
size: 81517
sha: c80c1ce885215703716d00a3a888309b1cd01b32
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/server.test.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/server.test.mjs

## File: test/subagent-toggle.e2e.mjs
size: 7145
sha: 2aafcd366267ccc2e05061d1190ae467e0c98870
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/subagent-toggle.e2e.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/test/subagent-toggle.e2e.mjs

## File: visual-brief.md
size: 4349
sha: 09523ca39699fee7877ccdf585457b6a44c272d7
upstream: https://github.com/jasonku09/grill-with-ui/blob/HEAD/visual-brief.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/jasonku09/grill-with-ui/blob/HEAD/visual-brief.md
