---
{
  "n": 69,
  "title": "The live demo's three scenarios",
  "abstract": "",
  "refs": [
    "plan:23",
    "message:13310",
    "todo:2227",
    "doc:70"
  ],
  "seen": [
    "agent",
    "user"
  ],
  "data": {
    "written": true,
    "environment": "main",
    "revisions": 1,
    "open_until": 1790874416.890356,
    "status": "final"
  },
  "created": 1790872616.78971,
  "updated": 1790892417.829234,
  "deleted": 0.0,
  "completed": 1790892417.8286662,
  "outcome": "superseded by doc 70",
  "type": "doc"
}
---
Scenario 1 already shows: plan and to-dos, auto mode, work tracking, activity line, a question with options, a fact, a report, a closing summary.
Rules for both scripts: every project is invented, every file is local, no keys, no accounts, no real
names. The agent runs on Claude; helper jobs are small enough to finish in a few minutes. Recorder
presses Enter on message N only after the agent has gone idle for message N-1 (a helper's report may
land later; wait for it, it belongs to the step).
---

## Scenario 2 - HELPERS: "Pebble Pantry"
**Project:** Pebble Pantry, a small Python command-line tool that scales a recipe for any number of
guests and converts cups to grams.
**Recorder setup**
- Fresh git repo on branch `main`, 4 files: `pantry/scale.py` (scales amounts, rounds badly on purpose),
  `pantry/units.py` (cups, spoons, grams for flour, sugar, butter), `README.md` (two lines), `recipes/pancakes.json`.
  One passing test file `tests/test_scale.py` (3 tests). Journal installed, one environment.
- Agent: Claude (main), model sonnet. Work mode: **hands-on** at the start (message 5 switches it).
  Auto mode: **off** (the user approves the plan, then watches helpers).
- Codex installed and signed in on the recording machine; helper 1 = Codex, helper 2 = Claude (haiku).
  Journal setting for the work-mode switch is done through the status-bar chip, not by a message.
- Viewer open on Home at desktop width; record at least one full-screen shot of the Orchestrator layout.
**Messages**
1. "Pebble Pantry scales recipes badly: 2.5 guests gives 3 eggs and 0.33333 cups. Plan the fix, and
   tell me which parts could go to helpers."
   - Agent files a plan: phase 1 "Round amounts sensibly" (code), phase 2 "Cover units with tests" (a
     bounded job), phase 3 "Write usage in the README" (a bounded job). It says which two suit helpers.
   - Shows: plan card with phases, to-dos on the list, row links in text (to-do numbers become links),
     a plan awaiting approval with the Approve button.
2. "Approve the plan. Send the unit tests to Codex in its own worktree, and the README to a Claude
   helper. You take the rounding."
   - Agent runs `journal helper dispatch` twice (Codex with `--worktree`; Claude without, README only),
     each with a name from the naming law and an explicit model. It starts to-do 1 and writes
     `scale.py` meanwhile. A short Explore subagent is sent to find every place amounts are rounded.
   - Shows: helpers chip in the status bar with a count of 2, helper dropdown (name, provider, state,
     buttons pinned at the top), each helper's to-do on its own list with its environment hidden
     from the main lists, the activity line saying what the main agent is doing, subagent errand
     appearing and finishing (Explore, named model, concrete job: the journal's law).
3. "While they work: what is each of them doing right now?"
   - Agent answers from the helper list and the work rows without interrupting anyone, and
     uses `journal work await` on the helpers only after saying so.
   - Shows: the chat answering while helpers are out, the "waiting on" state of an await, the
     helper dropdown with live status, a message from the agent that carries buttons ("Show Codex's diff" /
     "Leave it").
4. "Tell Codex to also cover grams for butter."
   - Agent sends `journal helper say` with the follow-up to the Codex helper.
   - Shows: a follow-up message to a helper, the helper's to-do getting a new line in its log.
5. (Before sending: switch the status-bar chip from hands-on to **Orchestrator**.) "From now on you
   only plan and review. Helper two is going off track, stop it."
   - Agent acknowledges the new mode (it is told when the mode changes) and asks the Stop confirm
     for helper 2 (the user presses Stop in the dropdown, a confirm dialog appears, user confirms).
     The agent is told the helper was stopped and files a to-do to redo the README.
   - Shows: Orchestrator layout (agent bar names the mode, helpers beside the main agent),
     Stop with its confirm, the agent being told, a to-do filed from a stop.
6. "Send the README to a fresh helper, a Claude one, and carry on."
   - New Claude helper (own environment, no worktree); finishes in seconds.
   - Shows: a second helper arriving, a report from a Claude helper returning to the chat as a
     message from it, report card (what it wrote, which file), helper finish packing its environment away.
7. (Codex reports back.) "Bring the Codex work into main."
   - The Codex report lands in the chat. Agent asks the helper to rebase, runs `journal worktree take`
     (its commits are cherry-picked into main), reviews the diff in a short report, runs the check
     "the suite passes" through the commit gate, which commits with `Journal: todos done <n>` and so
     closes the row. Then `journal helper finish`.
   - Shows: worktree commits taken into main, commit mark in the chat (hash, branch, subject),
     the gate result, to-do closed from a commit, a check row going green, helpers chip back to 0.
8. "Did the helpers' work and yours fit together? Review it as an orchestrator."
   - Agent (orchestrator) dispatches a reviewer subagent (opus, named job: "judge whether the
     rounding and the unit tests agree"), waits on it, and writes a report with one finding.
   - Shows: subagent errand with a model and a concrete job, report in the rail, a suggestion
     filed for a small fix ("Round grams to whole numbers") with Accept / Decline.
9. "Accept that, do it yourself, then summarise what the helpers and you did."
   - Small fix by the main agent (allowed as a small fix), summary message listing who did what,
     the family tree of agents mentioned in prose.
   - Shows: suggestion accepted becomes a to-do citing it, closing summary, all rows done,
     plan finished.
---

## Scenario 3 - PHONE: "Hedgerow"
**Project:** Hedgerow, a one-page website that tells a small allotment club which plants need
water this week.
**Recorder setup**
- Fresh git repo: `index.html`, `plants.json` (12 plants, each with a water-every number),
  `style.css`, one open to-do ("Dark mode") and one fact already set ("Club meets on Saturdays").
- Agent: Claude (sonnet). Work mode: hands-on. Auto mode: off until message 4.
- Recording is of the **phone app** at 390 x 844 (iPhone-size browser window loading the phone page,
  paired with the code from the viewer's phone button; the code is shown once on screen, ten
  minutes, then discarded). One helper (Codex) available for message 8.
- Network control: the recorder has a switch to put the phone page offline (browser
  offline mode) and back, used in message 5. Never let the recorder post to the viewer API.
**Messages** (all typed on the phone)
1. "Hi. What is open on Hedgerow today?"
   - Agent reads the list and replies with the one open to-do and the fact it holds.
   - Shows: pairing code scan result (the first screen once connected), chat on the phone, reply
     bubble with a chip naming the row (to-do) it speaks of, row link opening the to-do on the phone.
2. (Tap the status chip) then: "Pause for a minute, I'm checking something." Then tap Continue.
   - The agent sheet opens: state, Pause, Stop, work mode (hands-on / orchestrator / solo), auto
     mode switch, context and usage figures, helpers list (empty). User pauses the agent, the
     activity line shows paused, user resumes it. Sheet is closed with a swipe down.
   - Shows: agent sheet, pause and resume, state line, usage and context numbers.
3. "Add a dry-spell banner that shows when no plant needs water for three days. Ask me where it should go."
   - Agent asks a question with options (Top of the page / Under the title / Bottom), with tap
     buttons. User taps "Under the title". Brief hold, then the answer is saved and the agent carries on.
   - Shows: question answered with a tap, the held answer (a few seconds to take it back), the
     activity line on a narrow screen spanning the field's width, to-do opened from the chat.
4. (Open the sheet; switch auto mode on, work mode stays hands-on) "Do the banner and the dark mode to-do. I'll
   leave the phone."
   - Agent works through two to-dos, declares work before each write, logs work, finishes both
     and commits through the gate. The agents-at-work chip shows one agent; the user taps it and the
     sheet lists it with its current work row.
   - Shows: auto mode, activity line, agents-at-work chip and sheet, commit mark, to-dos closing.
5. (Recorder switches the phone offline.) Type two messages: "Remember: no watering on rain days." and
   "Also show the date the page was last changed." Then switch back online.
   - While offline, both bubbles show as waiting (clock icon) and the field keeps them. When
     online, they are sent in order; agent turns the first into a fact and the second into a to-do.
   - Shows: messages queued offline, sent on return, a fact from "Remember:", a to-do filed from a
     message, receipts on the bubbles.
6. "Send Codex to check the page is readable at 320 px wide, its own worktree."
   - Codex helper is dispatched; the sheet's helpers list now lists it, the status chip changes;
     user opens the helper's to-do on the phone. A short Explore subagent runs a quick errand.
   - Shows: helpers on the phone sheet, subagents, a to-do on the helper's own list.
7. (Helper reports.) Open the report from the chat bubble: "What did Codex find?"
   - The report lands as a card in the chat; the user taps it and reads it full screen, then taps back.
     Agent summarises in two lines and offers buttons: "Fix both" / "Fix later".
   - Shows: report opened on the phone, message buttons, plan or report card on a small screen.
8. Tap "Fix both". Then: "Write a plan for the autumn version: seed list, frost warnings, club photos."
   - Agent does the small fixes and takes the helper's commits into main. Writes a plan with
     three phases and a checkpoint; user taps Approve on the plan card on the phone.
   - Shows: message button running a command, worktree take, plan approval on the phone, Stop is not
     tapped here (scenario 2 has it).
9. "Share the plan with Wren from the club" (a made-up person: no address, only a link).
   - Agent creates a share link for the plan (a tunler link that opens only it) and pins it over
     the chat. User taps the pinned link; the shared plan opens on its own page.
   - Shows: sharing, pinned link, a closing summary the user reads in the chat. Recorder shows
     the phone's home-screen app icon and the journal switcher (list of journals on the computer)
     in a last cut, not a message.
---

## Coverage table (scenarios 1, 2, 3)
| Capability | Shown in |
|---|---|
| Chat thread, replies, receipts, reactions | 1, 2, 3 |
| Plans with phases, approval, checkpoint | 1, 2 (msg 1, 9), 3 (msg 8) |
| To-dos, work rows, declare work before writes | 1, 2, 3 |
| Activity line, thinking | 1, 2, 3 |
| Auto mode | 1; 3 (msg 4) |
| Questions with options; held answer | 1; 3 (msg 3) |
| Facts ("remember:") | 1; 3 (msg 5) |
| Reports; the update/summary report | 1, 2, 3 |
| Closing summary | 1, 2 (msg 9) |
| Helpers (Codex and Claude), helper dropdown | 2; 3 (msg 6) |
| Helper worktrees and `worktree take` | 2 (msg 7); 3 (msg 8) |
| Stop with confirm | 2 (msg 5) |
| Work modes: hands-on, orchestrator | 2 (msg 5); 3 sheet |
| Subagents with model and job (journal laws) | 2 (msg 2, 8); 3 (msg 6) |
| Waiting on helpers (await) | 2 (msg 3) |
| Message buttons | 2 (msg 3); 3 (msg 7, 8) |
| Suggestions accepted or declined | 2 (msg 8, 9) |
| Checks and commit gate; close from commits | 2 (msg 7); 3 (msg 4) |
| Row links, commit marks, status bar | 1, 2, 3 |
| Phone: chat, agent sheet, pause, stop, offline queue | 3 |
| Phone: questions, reports, plan approval by tap | 3 |
| Phone: agents-at-work chip and sheet | 3 (msg 4) |
| Sharing, pinned links | 3 (msg 9) |
| Put-off work caught; Kanban lanes; family tree | gap: see below |

## Gaps (shown by none of the three)
Worth adding, cheap, inside an existing run:
- **Memory checkpoint** (writes held at a context mark; the agent picks fact, rule or nothing): needs a
  long session. Fake with a low context-mark setting in scenario 1; worth it, it is the journal's
  signature move.
- **Rules** (a project-wide ruling that binds every environment): add to scenario 2 msg 9, "rule: helpers
  never touch tests/". Worth it.
- **Reminders** ("remind me every Friday to review water levels") : add to scenario 3 msg 5. Worth it.
- **Kanban lanes** and **boards/tickets**: a board run is a whole scenario of its own (tickets in
  worktrees, plan review, merge). Worth a 4th scenario, "Board", if the demo wants the Orchestrator at full scale.
- **Put-off work caught** ("I'll do that later" with no to-do): happens by itself if the agent drifts;
  cannot be scripted reliably. Skip, or let it show if it occurs.
- **File feed (diff cards)** and **terminal**: a setting, not a message; switch on in scenario 1 and
  mention it on the Settings page. Cheap.
Not worth adding: collections, dumps, templates, sequences, triggers, plugins, Chrome extension,
critique rounds, pull requests, hosting, auto-update. Each needs its own project setup, and they
read better as short written notes on the demo page than as recordings.