⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

grill-with-ui

jasonku09@jasonku09⭐ 330 stars· last commit 24d ago· 4 open issues

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".

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐ 330 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

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

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.

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 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.

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:

AgentUser-level folderProject-level folderStart 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: "; 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: "
Any other agent that reads SKILL.mdits skills foldersay "grill with ui: "

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 for startup, harness fallback, and turn-boundary requirements.
  • Optionally a subagent tool, for Visualize. See 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 i

// HOW IT'S BUILT

// FILES

48 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md37 KB199e34d5a904truncatedupstream ↗

    Showing the inlined prefix. The rest is in the upstream file.

    ---
    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
  • README.md16 KB424933694cc8upstream ↗
    # 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.
    
  • .github/dependabot.yml163 Bfecd44dba998upstream ↗
    version: 2
    updates:
      - package-ecosystem: github-actions
        directory: /
        schedule:
          interval: weekly
        groups:
          actions:
            patterns: ["*"]
    
  • .github/workflows/ci.yml506 B768daf901960upstream ↗
    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
    
  • .github/workflows/e2e.yml532 B7059a4a8712aupstream ↗
    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
    
  • .github/workflows/static.yml803 B89515b6ab870upstream ↗
    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
    
  • .gitignore10 Be43b0f988953upstream ↗
    .DS_Store
    
  • .no-mistakes.yaml639 B17ce0e381593upstream ↗
    # 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]
    
  • design/index.html1.8 KB2150d58064cdupstream ↗
    <!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>
    
  • design/mockups-codex/a-inbox.html42 KB0606dfe3f673upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups-codex/a-inbox.png111 KB07026423577bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups-codex/b-scroll.html42 KB0121890257ffupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups-codex/b-scroll.png120 KBfe75203baacaupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups-codex/c-tree.html42 KB4b8e9c6a1907upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups-codex/c-tree.png158 KB82b33097d283upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups-codex/PROMPT.md3.3 KBdc14df98f820upstream ↗
    # 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.
    
  • design/mockups/a-inbox-clean-staged.png129 KBccfb1e5158c5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups/a-inbox-clean.html28 KBca99e196f55cupstream ↗
    <!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,[email protected],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>
    
  • design/mockups/a-inbox-clean.png135 KB07dc413b8048upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups/a-inbox-clean.template.html14 KB47ef0c6ec594upstream ↗
    <!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,[email protected],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>
    
  • design/mockups/a-inbox.html30 KBc1858063367cupstream ↗
    <!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>
    
  • design/mockups/a-inbox.png535 KBc651b8a1f077upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups/a-inbox.template.html15 KBc97b7e5516a3upstream ↗
    <!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>
    
  • design/mockups/b-scroll.html30 KB695e0b76e4edupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups/b-scroll.png186 KB6269ed7f489cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups/b-scroll.template.html16 KBd43396adf6b1upstream ↗
    <!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>
    
  • design/mockups/c-tree.html32 KBc89345170b03upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups/c-tree.png258 KBe0d1a08efa8aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups/c-tree.template.html18 KB2511a9fe7158upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/mockups/data.js14 KB7cc27aad2f09upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • design/record-demo.mjs21 KB8002d9247476upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/demo.gif627 KBe42629d55f38upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/design.md11 KBba682199dbcbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/importance-and-ratings-design.md25 KB16f2129b9fa5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/importance-and-ratings-visual.html31 KBdaf56fe5b9cbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/visualize-design.md8.8 KB7bc90e289732upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • LICENSE1.0 KB40e58caad406upstream ↗
    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.
    
  • markdown.mjs2.0 KB5bfc43c5f4b1upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • page.html70 KB0e9f22cea15cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • server.mjs45 KB53f870b247a2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/listener.e2e.mjs6.5 KB1381e1643086upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/manual-visual.e2e.mjs9.2 KBfd2494523e20upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/markdown.test.mjs3.4 KB004cba4490ebupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/page-markdown-parity.test.mjs3.3 KBb2f7e398aca0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/page.e2e.mjs78 KB2394817a6936upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/server.test.mjs80 KBc80c1ce88521upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/subagent-toggle.e2e.mjs7.0 KB2aafcd366267upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • visual-brief.md4.2 KB09523ca39699upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/jasonku09-grill-with-ui.md

// REPO STATS

330 stars
4 open issues
Last commit: 24d ago