diff --git a/README.md b/README.md
index 54d4531..5dc77aa 100644
--- a/README.md
+++ b/README.md
@@ -111,7 +111,11 @@ The local database dashboard (Supabase Studio) is at http://127.0.0.1:57323. Bef
 
 ### Replayed real answers
 
-`npm run dev:replay` shows the interface with the real model's answers, for free and without a token. It replays answers the measurement recorded on gpt-oss-120b ([`replays.json`](src/server/ai/replays.json)), each reply whole, after the time the real model took. The intro's button, the grocery delivery suggestion and the other measured requests replay; any other message gets the scripted fake's answer, at the same pace. Searches and saves still run on your machine, so the search lines show local passages, while the words come from the recording. The header says "Replaying recorded answers". To refresh the copy after a new measurement, run `npm run replays:copy -- --from docs/records/measurements/<name>` where the records are.
+`npm run dev:replay` shows the interface with the real model's answers, for free and without a token. It replays answers the measurement recorded on gpt-oss-120b ([`replays.json`](src/server/ai/replays.json)), each reply whole, after the time the real model took. The intro's button, the grocery delivery suggestion and the other measured requests replay; any other message gets the scripted fake's answer, at the same pace. Searches and saves still run on your machine, so the search lines show local passages, while the words come from the recording. The header says "Replaying recorded answers".
+
+A **scenario tour** in the corner of the page walks through every state the chat and the PRD can show, which recorded answers alone never reach: rich text and tables, folded and refused searches, a section with every kind of statement, a long wait to stop, each kind of failure and, last, the used-up daily allowance. Each step says what to watch for; "Play next" sends it. The scripted answers run through the same chat code, so their searches, saves and quote checks are real.
+
+To refresh the copy after a new measurement, run `npm run replays:copy -- --from docs/records/measurements/<name>` where the records are.
 
 ### The real chat model on your machine
 
diff --git a/docs/plan.md b/docs/plan.md
index 7bd6bc2..5696bdf 100644
--- a/docs/plan.md
+++ b/docs/plan.md
@@ -20,12 +20,12 @@
 
 ### Build lane
 - **Where:** its own worktree per piece, on a branch from an up-to-date `main`. If the session isn't in a worktree yet (`git worktree list` shows its folder as the main checkout, not under `.claude/worktrees/`), it creates one before touching anything, and never checks out a branch in the main folder, where the measurement lane works. Claude Code's worktree option puts it under `.claude/worktrees/`; run `npm ci` there first. A worktree made with `git worktree add` gets no `.env.local`: run `npm run env:local` there, or the end-to-end tests find no interviews. Its browser check uses `app-build` in `.claude/launch.json` (port 3200), never `app` or `app-real`, which are the measurement lane's on port 3000. It never runs `measure`, `measure:fake` or `dev:real`, never edits the measurement lane's files above, and changes code in `src/server` only where its piece needs it, never what the model receives (listed above); its pull request says which `src/server` files it changed and why.
-- **Doing:** slice 23, the README rewritten for reviewers, is done on `docs/readme-for-reviewers` (`.claude/worktrees/readme`), from `main` at 6e1dae5 (slice 22's merge), waiting for the owner's push and merge. It opens on the demo's story (the owner's wish, 2026-10-21: a story, not terms such as "citation check" before the reader knows what the app does), then what's worth a look, the status and how it works; running it, the commands and the database follow, and the deploy steps fold into two collapsed sections. The facts were checked against the code at 6e1dae5; "How it works" keeps its heading (`tests/unit/readme.test.ts`), and so does "The real chat model on your machine" (`src/lib/env-guard.ts`). Prettier passed on it; nothing else ran, since only documents changed.
+- **Doing:** slice 24, the scenario tour, is done on `feat/scenario-tour` (`.claude/worktrees/slice-22-replay`), from `main` at e4bd98e (slice 23's merge), waiting for the owner's look, push and merge. The owner asked for it on 2026-10-21, after finding that the replay never shows a table, among others, and chose all four groups of states, played in one sequence from a menu in the replay. Local checks on 2026-10-21: `verify` (527 unit tests) and `test:e2e` (69, of which 1 new in `tests/e2e/replay.spec.ts`) passed in one full run each. All 17 steps were played from the panel with `npm run dev:replay` at `REPLAY_SPEED=4` from the worktree on port 3200, read through the page's text (the Browser pane was hidden, so no screenshots): the tables, the rich text, the folded and refused searches, the section of every kind (8 of 13 quotes confirmed, as scripted), the refused save, Stop during the long wait, each failure with "Try again", the busy message and the quota notice. "Breaking off partway" first lost its words, fixed before the commit. Not seen: Jump to latest during the long answer, and the wide table's sideways scroll, which a hidden pane doesn't measure. It adds `src/server/ai/scenarios.ts` and `src/lib/scenarios.ts` and changes `src/server/ai/replay-chat-model.ts`, all for `dev:replay` only; nothing the real model receives changes, so the measurement lane needn't wait for it, though its comparison will list those files as code.
 - **Next:**
   1. A short GIF near the README's top, from `npm run dev:replay`, once the owner has looked at the replay themselves (asked 2026-10-21). The screen recording for launch stays (`docs/decisions.md`, 2026-10-17).
   2. Slice 8, the rate limit, once 9d is done and the owner has decided its legal basis and size (*Deferred*).
 - **Unverified:** on staging, a reload keeping the PRD and the downloaded file (local Chromium only); a stop ending the answer on Cloudflare too, where the call in flight may still be finished and counted; the quota message against Cloudflare's real refusal (the tests replay its reply of 2026-10-20) and whether its per-minute 429 carries a retry header; a source name's pop-over, "Your decision, not from the interviews." under a claim of the visitor's, the table fix and the intro screen; Safari and Firefox (only Chromium ran; without anchor positioning the pop-over is a centred box, by design, and without `field-sizing`, before Safari 26.2 and Firefox 152, the message box keeps its three lines; the moving band, whose fallback is the still grey line; the PRD's highlight and rolling count; Jump to latest; the folded line's slide, which falls back to showing at once; the words' fade; the copy button, its label and the clipboard; Inter and its resized fallback, which needs Arial installed, so Linux and Android show the system's font until Inter arrives; a table's cells keeping their 144px and its box's sideways scroll; the Thinking line's band). On staging, a real reply's table, and the Thinking line through the real model's waits with the times it shows (the fake model's are about 0s). On staging, a reply that arrives whole fading in as one, and a section's copy over HTTPS pasted into another app. Expect the Security Advisor's lint 0028 on `search_passages` on staging; it's intended (`supabase/AGENTS.md`). Production waits for launch and its Cloudflare token.
-- **Waiting on the owner:** pushing `docs/readme-for-reviewers`, its pull request and the merge; a look at `npm run dev:replay` before the GIF; whether `next dev` may keep adding its block to `AGENTS.md` (KI-8); the GitHub description and topics whenever they like.
+- **Waiting on the owner:** a look at `npm run dev:replay` and its tour, then pushing `feat/scenario-tour`, its pull request and the merge; the GIF after that; whether `next dev` may keep adding its block to `AGENTS.md` (KI-8); the GitHub description and topics whenever they like.
 
 ### Shared rules
 - One branch per piece, from an up-to-date `main`; the owner pushes it, opens the pull request and merges it (`AGENTS.md`, Branches). After the other lane's merge, rebase an unpushed branch onto `main`, and merge `main` into a pushed one; never rewrite a pushed branch.
@@ -121,4 +121,12 @@
 
 ### 22 · Replayed real answers, to look at the interface here · risk: normal · status: done (6e1dae5)
 
-### 23 · The README, for reviewers · risk: normal · status: done (on `docs/readme-for-reviewers`; its id on `main` goes here after the merge)
+### 23 · The README, for reviewers · risk: normal · status: done (e4bd98e)
+
+### 24 · A tour of every state the chat and the PRD can show · risk: normal · status: done (on `feat/scenario-tour`; its id on `main` goes here after the merge)
+- **Goal:** the owner and the build lane can see, step by step, every state the chat and the PRD can show, at the real model's pace, for free and without the token: the replay shows only what the model happened to do in its recorded runs, and never a table (the owner, 2026-10-21).
+- **Acceptance:**
+  - With `npm run dev:replay`, a small "Scenario tour" panel lists the steps in order, with what to watch for in each, which were played, and "Play next"; any step can be played on its own. It never shows in a build for staging or production, nor with `npm run dev`.
+  - Each step sends its own words as the visitor's message, and its answer is scripted like a recording: each model call's parts, whole, after a set wait. The searches, the saves and the check run here for real, on the local database and the fake embedder, as with the replay.
+  - The steps, in order: two real recorded answers (the first section, the grocery delivery claim); rich text (bold, code, lists, and marks the chat strips); tables (wide, line breaks in cells, empty cells, a row longer than the header); searches folding into one line with text between runs and a long query cut short; a refused search and a step that doesn't exist; one section with every kind of statement (confirmed, many sources, an unverified quote, the interviewer's question quoted, the wrong passage cited, an unknown source, citing nothing, the visitor's decision); a save refused for its form, then saved; Open Questions; a long answer for Jump to latest; a long wait for Stop; failing before the first word and partway, each once so "Try again" works; an answer cut off at its output limit; an answer with no words; the busy message; and last, the used-up allocation, which lasts until a reload.
+  - Unit tests: the scripted quotes meant to pass match the interviews and those meant to fail don't, a failure fails once, and the panel's next step and what it sends; an end-to-end check that the tables step's words, sent to the replay's server, show a table (that server runs a build, which never carries the panel). Nothing the real model receives changes; the pull request names the `src/server` and `src/lib` files it adds.
diff --git a/src/features/AGENTS.md b/src/features/AGENTS.md
index 83a325a..bd7c9df 100644
--- a/src/features/AGENTS.md
+++ b/src/features/AGENTS.md
@@ -37,6 +37,10 @@
 - **Its label** (`.copy-tip` in `src/app/globals.css`) is CSS, `aria-hidden`: shown on `.copy-button:hover` after 0.4s, closed by `data-pressed` from the press until the pointer leaves, held open by `data-open` to say "Couldn't copy".
 - **After a copy** the name is "Copied" or "Couldn't copy" for `COPY_OUTCOME_MS`, and an `aria-live="polite"` span says it once, since screen readers don't reliably announce a focused button's new name. Not `role="status"`: the chat's status line is the page's one. `navigator.clipboard.writeText` rejects when refused (MDN, read 2026-10-21 through Context7), and a page that isn't a secure context has no `navigator.clipboard`; both read "Couldn't copy". The desktop app's Browser pane refuses the clipboard while it's hidden, so a successful copy is seen only in the end-to-end tests there (found 2026-10-21).
 
+## The scenario tour (`workspace/scenario-tour.tsx`, slice 24)
+- **Only with `npm run dev:replay`:** `Workspace` renders it when `NEXT_PUBLIC_CHAT_REPLAY` was "1" at compile time, as the header's "Replaying recorded answers", so no build for staging or production has it, and neither does the end-to-end tests' replay server, which runs that build. It's a `fixed` `<aside>` over the page's corner, beside the intro or the workspace, never in their layout, so the layout tests measure nothing new.
+- **What it sends:** a step's words, through `playScenario`, which leaves the intro as its button does and clears a pending check-in. A step counts as played once its words are among the visitor's messages (`playedScenarios` in `src/lib/scenarios.ts`), so the tour survives a reload and "Start over" begins it again; "Play next" offers the step after the furthest one played. Both are disabled while an answer is on its way.
+
 ## The intro (`workspace/intro.tsx`, `workspace/disclosure.ts`)
 - **What shows when:** the intro until the visitor leaves it or the conversation holds messages (`conversationStarted`, which holds for a restored conversation too); the suggestion to try to break it once a section is saved, until the visitor has sent it (`breakItSuggestion`). Its button and the suggestion import their words from `src/lib/suggestions.ts`, never a copy: the measurement sends the same words, and changing them means a new baseline.
 - **A failed first request:** `useChat`'s `onFinish` runs after every answer, once the error status is set, with `isError` and the messages from the chat's own state (ai 7.0.143, `makeRequestImpl` in `node_modules/ai/dist/index.js`, read 2026-10-19; the AI SDK's `useChat` reference through Context7). `afterAnswer` brings the intro back only when the intro's request failed before a section was saved, and clears the error, so the chat never opens on the old one. The server can send an error after a save (a reply cut off at its output limit, or the provider failing on the last call); then the section stays, with the chat's "Try again". Don't decide this in `onError`: it runs before the status is set, and the rendered `messages` can lag behind the chat's state. A ref marks the intro's request, so a later failure stays in the chat.
diff --git a/src/features/workspace/scenario-tour.tsx b/src/features/workspace/scenario-tour.tsx
new file mode 100644
index 0000000..1991d5c
--- /dev/null
+++ b/src/features/workspace/scenario-tour.tsx
@@ -0,0 +1,117 @@
+"use client";
+
+import { useId, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { nextScenario, playedScenarios, SCENARIOS } from "@/lib/scenarios";
+import { cn } from "@/lib/utils";
+
+/**
+ * The scenario tour's panel (docs/plan.md, slice 24), shown only with `npm
+ * run dev:replay`: the steps in order, what to watch for in the next one, and
+ * "Play next", which sends its words as the visitor's message. A step counts
+ * as played once its words are in the conversation, so the tour picks up
+ * where it was after a reload. Any step can be played on its own from the
+ * list. It sits over the page's corner, never in its layout.
+ */
+export function ScenarioTour({
+  sent,
+  working,
+  onPlay,
+}: {
+  /** The visitor's messages so far. */
+  sent: readonly string[];
+  working: boolean;
+  onPlay: (words: string) => void;
+}) {
+  const [open, setOpen] = useState(true);
+  const [listOpen, setListOpen] = useState(false);
+  const panelId = useId();
+  const listId = useId();
+  const played = playedScenarios(sent);
+  const next = nextScenario(played);
+  const step = next === undefined ? undefined : SCENARIOS[next];
+  const count = SCENARIOS.length;
+
+  return (
+    <aside
+      aria-label="Scenario tour"
+      className="fixed right-4 bottom-4 z-50 w-80 max-w-[calc(100vw-2rem)] rounded-(--radius-control) border border-border-strong bg-background text-sm shadow-lg"
+    >
+      <button
+        type="button"
+        aria-expanded={open}
+        aria-controls={panelId}
+        onClick={() => setOpen((value) => !value)}
+        className="flex w-full items-center justify-between gap-3 px-4 py-2.5 text-left font-medium"
+      >
+        <span>Scenario tour</span>
+        <span className="text-muted-foreground tabular-nums">
+          {played.size} of {count} played
+        </span>
+      </button>
+      <div id={panelId} hidden={!open} className="space-y-3 px-4 pb-4">
+        {step === undefined ? (
+          <p className="text-muted-foreground">
+            The tour is done. Reload the page, then “Start over” begins it
+            again.
+          </p>
+        ) : (
+          <div className="space-y-1.5">
+            <p className="text-muted-foreground tabular-nums">
+              Step {(next ?? 0) + 1} of {count}
+            </p>
+            <p className="font-medium">{step.title}</p>
+            <p className="text-muted-foreground">{step.watch}</p>
+          </div>
+        )}
+        <div className="flex items-center gap-4">
+          {step !== undefined && (
+            <Button
+              disabled={working}
+              onClick={() => onPlay(step.words)}
+              className="h-8 px-3"
+            >
+              Play next
+            </Button>
+          )}
+          <Button
+            variant="quiet"
+            aria-expanded={listOpen}
+            aria-controls={listId}
+            onClick={() => setListOpen((value) => !value)}
+            className="h-auto px-0"
+          >
+            All steps
+          </Button>
+        </div>
+        <ol
+          id={listId}
+          hidden={!listOpen}
+          className="max-h-64 space-y-0.5 overflow-y-auto"
+        >
+          {SCENARIOS.map((scenario, index) => (
+            <li key={scenario.id}>
+              <button
+                type="button"
+                disabled={working}
+                onClick={() => onPlay(scenario.words)}
+                className={cn(
+                  "flex w-full gap-2 rounded-(--radius-control) px-2 py-1 text-left hover:bg-foreground/10 disabled:opacity-50",
+                  index === next && "bg-foreground/10",
+                )}
+              >
+                <span className="w-5 shrink-0 text-muted-foreground tabular-nums">
+                  {index + 1}
+                </span>
+                <span className="flex-1">{scenario.title}</span>
+                {played.has(scenario.id) && (
+                  <span className="text-muted-foreground">played</span>
+                )}
+              </button>
+            </li>
+          ))}
+        </ol>
+      </div>
+    </aside>
+  );
+}
diff --git a/src/features/workspace/workspace.tsx b/src/features/workspace/workspace.tsx
index ca74e0c..46f7a55 100644
--- a/src/features/workspace/workspace.tsx
+++ b/src/features/workspace/workspace.tsx
@@ -31,9 +31,14 @@ import {
 import { FIRST_SECTION_REQUEST } from "@/lib/suggestions";
 import { breakItSuggestion, conversationStarted } from "./disclosure";
 import { Intro, INTRO_TITLE_ID } from "./intro";
+import { ScenarioTour } from "./scenario-tour";
 import { keepConversation, restoreConversation } from "./stored-conversation";
 import { finishedOnly, unfinishedStep } from "./stopped-answer";
 
+// `npm run dev:replay` sets it, and with it the scenario tour shows (slice 24).
+// Inlined when Next.js compiles, so no build for staging or production has it.
+const REPLAY = process.env.NEXT_PUBLIC_CHAT_REPLAY === "1";
+
 /** The chat's requests, with each wait for the model's reply timed. */
 class TimedTransport extends DefaultChatTransport<ChatMessage> {
   override async sendMessages(
@@ -268,6 +273,25 @@ function RestoredWorkspace() {
     focusNext.current = "intro";
   }
 
+  /** A step of the scenario tour, sent from the intro or the chat. */
+  function playScenario(words: string) {
+    if (working) return;
+    setDiscarded(false);
+    setIntroFailed(false);
+    setLeftIntro(true);
+    setCheckIn(undefined);
+    if (onIntro) focusNext.current = "workspace";
+    send(words);
+  }
+
+  const tour = REPLAY && (
+    <ScenarioTour
+      sent={[...visitorMessages.values()]}
+      working={working}
+      onPlay={playScenario}
+    />
+  );
+
   function confirmSection() {
     if (latest === undefined || next === undefined || working) return;
     setCheckIn({ section: next, fromMessage: messages.length });
@@ -290,67 +314,73 @@ function RestoredWorkspace() {
 
   if (onIntro) {
     return (
-      <Intro
-        failed={introFailed}
-        discarded={discarded}
-        quotaUsedUp={quotaUsedUp}
-        onDraft={draftFirstSection}
-        onAsk={askOwnQuestion}
-      />
+      <>
+        <Intro
+          failed={introFailed}
+          discarded={discarded}
+          quotaUsedUp={quotaUsedUp}
+          onDraft={draftFirstSection}
+          onAsk={askOwnQuestion}
+        />
+        {tour}
+      </>
     );
   }
 
   // On a laptop the chat keeps a steady width, 400 to 520px, and the PRD
   // takes the rest of the page (docs/decisions.md, Design, 2026-10-20).
   return (
-    <div
-      data-workspace
-      className="flex flex-col gap-10 lg:grid lg:h-full lg:min-h-0 lg:grid-cols-[clamp(25rem,38%,32.5rem)_minmax(0,1fr)] lg:gap-8"
-    >
-      <h1 id={WORKSPACE_TITLE_ID} tabIndex={-1} className="sr-only">
-        The chat and your PRD
-      </h1>
-      <div className="flex flex-col lg:min-h-0">
-        <Chat
-          messages={messages}
-          status={failed ? "error" : status}
-          error={error}
-          quotaUsedUp={quotaUsedUp}
-          suggestion={suggestion}
-          draft={draft}
-          onDraftChange={setDraft}
-          onSend={(text) => {
-            setCheckIn(undefined);
-            send(text);
-          }}
-          onStop={stopAnswer}
-          stopped={stopped}
-          onRetry={retry}
-          onSeeSection={seeSection}
-        />
-      </div>
-      <div className="flex flex-col lg:min-h-0">
-        <PrdDocument
-          sections={sections}
-          latest={latest}
-          drafting={drafting}
-          visitorMessages={visitorMessages}
-          onStartOver={startOver}
-          checkIn={
-            // The check-in sends a message too, so it goes with the message box.
-            next === undefined || quotaUsedUp
-              ? undefined
-              : {
-                  next: checkInOpen ? checkIn.section : next,
-                  drafting: checkInOpen && working,
-                  failed: checkInOpen && status === "error",
-                  disabled: working,
-                  onConfirm: confirmSection,
-                }
-          }
-        />
+    <>
+      <div
+        data-workspace
+        className="flex flex-col gap-10 lg:grid lg:h-full lg:min-h-0 lg:grid-cols-[clamp(25rem,38%,32.5rem)_minmax(0,1fr)] lg:gap-8"
+      >
+        <h1 id={WORKSPACE_TITLE_ID} tabIndex={-1} className="sr-only">
+          The chat and your PRD
+        </h1>
+        <div className="flex flex-col lg:min-h-0">
+          <Chat
+            messages={messages}
+            status={failed ? "error" : status}
+            error={error}
+            quotaUsedUp={quotaUsedUp}
+            suggestion={suggestion}
+            draft={draft}
+            onDraftChange={setDraft}
+            onSend={(text) => {
+              setCheckIn(undefined);
+              send(text);
+            }}
+            onStop={stopAnswer}
+            stopped={stopped}
+            onRetry={retry}
+            onSeeSection={seeSection}
+          />
+        </div>
+        <div className="flex flex-col lg:min-h-0">
+          <PrdDocument
+            sections={sections}
+            latest={latest}
+            drafting={drafting}
+            visitorMessages={visitorMessages}
+            onStartOver={startOver}
+            checkIn={
+              // The check-in sends a message too, so it goes with the message box.
+              next === undefined || quotaUsedUp
+                ? undefined
+                : {
+                    next: checkInOpen ? checkIn.section : next,
+                    drafting: checkInOpen && working,
+                    failed: checkInOpen && status === "error",
+                    disabled: working,
+                    onConfirm: confirmSection,
+                  }
+            }
+          />
+        </div>
       </div>
-    </div>
+      {tour}
+    </>
   );
 }
 
diff --git a/src/lib/scenarios.ts b/src/lib/scenarios.ts
new file mode 100644
index 0000000..b6d4b80
--- /dev/null
+++ b/src/lib/scenarios.ts
@@ -0,0 +1,146 @@
+import {
+  FIRST_SECTION_REQUEST,
+  GROCERY_DELIVERY_SUGGESTION,
+} from "./suggestions.ts";
+
+// The scenario tour of `npm run dev:replay` (docs/plan.md, slice 24): every
+// state the chat and the PRD can show, one step at a time. Each step sends its
+// words as the visitor's message; the replay answers the first two with real
+// recordings and the rest with scripted answers (src/server/ai/scenarios.ts),
+// so the panel (src/features/workspace/scenario-tour.tsx) and the server
+// share this list. Nothing here reaches the model or a deployment.
+
+export type Scenario = {
+  /** Letters, digits and dashes: it names the script too. */
+  id: string;
+  title: string;
+  /** What the step sends as the visitor's message. */
+  words: string;
+  /** What to look at while it plays. */
+  watch: string;
+};
+
+/** A scripted step's message: its title, marked as a scenario. */
+function scripted(id: string, title: string, watch: string): Scenario {
+  return { id, title, words: `Scenario: ${title}`, watch };
+}
+
+export const SCENARIOS: readonly Scenario[] = [
+  {
+    id: "first-section",
+    title: "A real answer: the first section",
+    words: FIRST_SECTION_REQUEST,
+    watch:
+      "A recorded gpt-oss answer at its real pace: Thinking, the searches folding into one line, the save and its check, then the reply fading in.",
+  },
+  {
+    id: "break-it",
+    title: "A real answer: the grocery delivery claim",
+    words: GROCERY_DELIVERY_SUGGESTION,
+    watch:
+      "How the recorded model answered a claim no interview makes. Each play takes the next of its recordings.",
+  },
+  scripted(
+    "rich-text",
+    "Rich text",
+    "Bold, inline code, a bulleted and a numbered list. The headings, italics, links, quotes, rules and strikethrough the model writes lose their marks; other HTML shows as typed.",
+  ),
+  scripted(
+    "tables",
+    "Tables",
+    "A small table; a wide one that scrolls sideways inside the message, reachable with Tab; one with line breaks in cells, empty cells and a row longer than its header.",
+  ),
+  scripted(
+    "searches",
+    "Searches in a row",
+    "Two searches fold into “Used 2 searches”, which opens; text between searches starts a new line; a long question is cut off with an ellipsis.",
+  ),
+  scripted(
+    "failed-steps",
+    "A refused search and an impossible step",
+    "A question over 500 characters is refused with its reason, a call to a tool the chat doesn't have shows as a step that didn't work, then a search works.",
+  ),
+  scripted(
+    "every-statement",
+    "Every kind of statement",
+    "One saved section with confirmed quotes, many sources, an unverified quote, the interviewer's question quoted, the wrong passage cited, an unknown source, a statement citing nothing and your own decision. Click the names.",
+  ),
+  scripted(
+    "refused-save",
+    "A save refused, then saved",
+    "The first save names a section the PRD doesn't have, so it isn't saved and shows as failed; the second try saves Goals / Objectives.",
+  ),
+  scripted(
+    "open-questions",
+    "Open Questions",
+    "The last section, where a statement needs no source and none is flagged, saved out of order: it takes its place at the end of the PRD.",
+  ),
+  scripted(
+    "long-answer",
+    "A long answer",
+    "Scroll up in the chat while it thinks: when the long reply arrives, Jump to latest appears.",
+  ),
+  scripted(
+    "long-wait",
+    "A long wait",
+    "Thinking for 30 seconds. Press Stop to end it: the question then reads as stopped.",
+  ),
+  scripted(
+    "fail-before",
+    "Failing before the first word",
+    "The answer fails before anything arrives. Try again works: it fails once per server start.",
+  ),
+  scripted(
+    "fail-partway",
+    "Breaking off partway",
+    "The reply breaks off after its first words and stays marked unfinished. Try again works: it fails once per server start.",
+  ),
+  scripted(
+    "cut-off",
+    "Cut off at the output limit",
+    "Text that stops mid-sentence at the model's output limit, marked unfinished.",
+  ),
+  scripted(
+    "no-words",
+    "An answer with no words",
+    "The model thinks, then writes nothing: the chat says so, with Try again.",
+  ),
+  scripted(
+    "busy",
+    "The demo is busy",
+    "Cloudflare's per-minute limit after the retries: the busy message with Try again, which works the second time.",
+  ),
+  scripted(
+    "quota",
+    "The day's allocation used up",
+    "Last, since it lasts until a reload: the message box gives way to the notice with the reset time. Reload the page to go on.",
+  ),
+];
+
+/** The words as the replay compares them: case and spacing don't count. */
+export function sameWords(a: string, b: string): boolean {
+  const normal = (text: string) =>
+    text.normalize("NFC").toLowerCase().replace(/\s+/g, " ").trim();
+  return normal(a) === normal(b);
+}
+
+/** The steps whose words the visitor has sent, by id. */
+export function playedScenarios(sent: readonly string[]): Set<string> {
+  return new Set(
+    SCENARIOS.filter((scenario) =>
+      sent.some((words) => sameWords(words, scenario.words)),
+    ).map((scenario) => scenario.id),
+  );
+}
+
+/**
+ * The step after the furthest one played, or the first; undefined once the
+ * last was played. Playing a step out of order moves the tour on from there.
+ */
+export function nextScenario(played: ReadonlySet<string>): number | undefined {
+  const furthest = SCENARIOS.findLastIndex((scenario) =>
+    played.has(scenario.id),
+  );
+  const next = furthest + 1;
+  return next < SCENARIOS.length ? next : undefined;
+}
diff --git a/src/server/AGENTS.md b/src/server/AGENTS.md
index ea93eeb..8625a58 100644
--- a/src/server/AGENTS.md
+++ b/src/server/AGENTS.md
@@ -33,6 +33,7 @@ Versions: `ai` 7.0.143, `@ai-sdk/openai-compatible` 3.0.71 and `@ai-sdk/react` 4
 - **Picking:** the first call of an answer compares the visitor's latest message with the recordings' words (NFC, lowercase, spaces collapsed) and gives that request's recordings out in turn, per server process (`picks`). Later calls find the recording by the answer's replayed tool call ids and play the next recorded call, so a search or save that ran here differently doesn't change what's replayed. An answer that began on the fallback stays on it; one whose recording has no calls left goes on with it.
 - **Pacing:** each recorded reply arrives whole after its `durationMs` divided by `REPLAY_SPEED` (1 by default; the end-to-end tests use 100), as `simulateStreamingMiddleware` delivers Cloudflare's. A stop during the wait rejects with the signal's reason. Any other message gets the scripted fake with no delay between parts, after a recorded duration picked by the prompt's length.
 - **What it can't show:** the searches return local passages, while the replayed words were written about staging's; a save's check runs here on the recorded statements. The check-in ("… looks right. Please draft …") has no recording, so it gets the fallback. The tools' budget and the prompt are today's, so a recording made under another setup may call a tool the chat no longer offers, and the SDK refuses it as it would the real model's.
+- **The scenario tour** (slice 24, `ai/scenarios.ts`; the steps and their words in `src/lib/scenarios.ts`, which the browser's panel shares): scripted answers written as recordings (`S-<step>`, recorded "scripted"), which the replay gives out by their words like any other, after their own waits, never the real ones'. Their searches, saves and the check run here for real, so each scripted citation says whether the check should confirm it (`passes`, dropped before the model's tool input) and `tests/unit/scenarios.test.ts` holds them to the interviews. A scripted call may fail instead (`fails`): "before" and "busy" throw a non-retryable `APICallError` (503, and 429, which `describeError` words as `DEMO_BUSY`), "partway" streams the reply's first eight words one read at a time and then errors (a stream's `error()` drops what waits in its queue, so enqueuing them all first lost the words: found 2026-10-21), and "quota" throws `QuotaExceededError`. The first three fail once per server process (`failed`), so "Try again" works; the quota fails every time, as Cloudflare's would. Not retryable, so the SDK's own retries never play a failing call again.
 - **Never in a deployment:** `loadReplays` reads the file at run time from `process.cwd()` with `turbopackIgnore`, so builds neither trace the project for it nor carry it (the build's own warning, 2026-10-21), and `NEXT_PUBLIC_CHAT_REPLAY` is inlined only where it was set when Next.js compiled (Next.js, *Environment variables*, read 2026-10-21 through Context7).
 
 ## The system prompt (`prompts/system-prompt.ts`)
diff --git a/src/server/ai/replay-chat-model.ts b/src/server/ai/replay-chat-model.ts
index f81b0ab..51177ff 100644
--- a/src/server/ai/replay-chat-model.ts
+++ b/src/server/ai/replay-chat-model.ts
@@ -1,18 +1,24 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { APICallError } from "ai";
 import type {
   ChatModel,
   ChatModelCall,
   ChatModelStreamPart,
 } from "./chat-model.ts";
+import { QuotaExceededError } from "./cloudflare.ts";
 import { createFakeChatModel, lastVisitorMessage } from "./fake-chat-model.ts";
 import {
   normalizedWords,
   recordingOfCallId,
   REPLAYS_FILE,
-  type Recording,
   type Replays,
 } from "./replays.ts";
+import {
+  scenarioRecordings,
+  type ScriptedCall,
+  type ScriptedRecording,
+} from "./scenarios.ts";
 
 // The chat model of `npm run dev:replay` (docs/plan.md, slice 22): the real
 // model's recorded answers, replayed here for free and without the token. A
@@ -22,36 +28,50 @@ import {
 // searches and saves it calls still run here, on the local database and the
 // fake embedder. Any other message gets the scripted fake's answer, also
 // whole and after a wait the recordings show, so the interface keeps the
-// real model's rhythm.
+// real model's rhythm. The scenario tour's steps (scenarios.ts, slice 24) are
+// played the same way, and their calls may also fail on purpose.
 
 export const REPLAY_CHAT_MODEL = "replayed-recordings";
 
 /** The recordings already given out in this server process, by words. */
 const pickedInThisProcess = new Map<string, number>();
 
+/** The scripted failures that already happened in this server process. */
+const failedInThisProcess = new Set<string>();
+
+/** How many words of a reply arrive before a "partway" failure. */
+const WORDS_BEFORE_BREAK = 8;
+
 export type ReplayChatModelOptions = {
   replays: Replays;
+  /** The tour's scripted steps, played like recordings. */
+  scenarios?: ScriptedRecording[];
   /** How many times faster than recorded: 1 replays the real waits. */
   speed?: number;
   /** How many of each request's recordings were given out. Tests pass their own. */
   picks?: Map<string, number>;
+  /** The scripted failures already shown. Tests pass their own. */
+  failed?: Set<string>;
   /** The model for messages nothing was recorded for. */
   fallback?: ChatModel;
 };
 
 export function createReplayChatModel({
   replays,
+  scenarios = scenarioRecordings(),
   speed = 1,
   picks = pickedInThisProcess,
+  failed = failedInThisProcess,
   fallback = createFakeChatModel({ chunkDelayInMs: 0 }),
 }: ReplayChatModelOptions): ChatModel {
-  const { recordings } = replays;
-  const durations = recordings.flatMap((recording) =>
+  // The real waits only: the scripted ones are set by hand.
+  const durations = replays.recordings.flatMap((recording) =>
     recording.calls.map((call) => call.durationMs),
   );
+  const recordings: ScriptedRecording[] = [...replays.recordings, ...scenarios];
 
   /** The recording this call continues, or the next one for its words. */
-  function recordingFor(call: ChatModelCall): Recording | undefined {
+  function recordingFor(call: ChatModelCall): ScriptedRecording | undefined {
     const answerSoFar = sinceLastVisitorMessage(call);
     const replayed = answerSoFar
       .flatMap((message) =>
@@ -94,8 +114,14 @@ export function createReplayChatModel({
       const index = callsSoFar(call);
       const recorded = recording?.calls[index];
 
-      if (recorded) {
+      if (recording && recorded) {
         await wait(recorded.durationMs / speed, call.abortSignal);
+        const failure = `${recording.id}:${index}`;
+        if (recorded.fails === "quota" || !failed.has(failure)) {
+          if (recorded.fails !== undefined) failed.add(failure);
+          const broken = failOnPurpose(recorded);
+          if (broken) return { stream: broken };
+        }
         return { stream: wholeReply(recorded.parts) };
       }
 
@@ -145,6 +171,79 @@ function wait(ms: number, signal: AbortSignal | undefined): Promise<void> {
   });
 }
 
+/**
+ * A scripted call's failure: thrown, as the provider's would be, or a stream
+ * that breaks after the reply's first words. Undefined when it doesn't fail.
+ * Not retryable, so the AI SDK's retries don't play the call again.
+ */
+function failOnPurpose(
+  call: ScriptedCall,
+): ReadableStream<ChatModelStreamPart> | undefined {
+  switch (call.fails) {
+    case undefined:
+      return undefined;
+    case "quota":
+      throw new QuotaExceededError(4006);
+    case "busy":
+      throw new APICallError({
+        message: "The scripted per-minute limit, after the retries.",
+        url: "replay://chat",
+        requestBodyValues: {},
+        statusCode: 429,
+        isRetryable: false,
+      });
+    case "before":
+      throw new APICallError({
+        message: "The scripted provider failed on purpose.",
+        url: "replay://chat",
+        requestBodyValues: {},
+        statusCode: 503,
+        isRetryable: false,
+      });
+    case "partway":
+      return brokenReply(call.parts);
+  }
+}
+
+/** The reply up to its first words, then a dropped connection. */
+function brokenReply(
+  parts: ChatModelStreamPart[],
+): ReadableStream<ChatModelStreamPart> {
+  const firstText = parts.findIndex((part) => part.type === "text-delta");
+  const before = parts.slice(0, Math.max(firstText, 0));
+  const text = parts[firstText];
+  const words =
+    text?.type === "text-delta"
+      ? [
+          {
+            ...text,
+            delta: (text.delta.match(/\S+\s*/g) ?? [])
+              .slice(0, WORDS_BEFORE_BREAK)
+              .join(""),
+          },
+        ]
+      : [];
+  const arrived = [...before, ...words];
+  let index = 0;
+  // One part per read, as the fake model's stream: an error drops whatever
+  // waits in a stream's queue, so the words must be read before it.
+  return new ReadableStream(
+    {
+      pull(controller) {
+        const part = arrived[index++];
+        if (part === undefined) {
+          controller.error(
+            new Error("The scripted connection dropped on purpose."),
+          );
+        } else {
+          controller.enqueue(structuredClone(part));
+        }
+      },
+    },
+    { highWaterMark: 0 },
+  );
+}
+
 /** The whole reply at once, as Cloudflare's arrives. */
 function wholeReply(
   parts: ChatModelStreamPart[],
diff --git a/src/server/ai/scenarios.ts b/src/server/ai/scenarios.ts
new file mode 100644
index 0000000..f60d474
--- /dev/null
+++ b/src/server/ai/scenarios.ts
@@ -0,0 +1,580 @@
+import { SCENARIOS } from "../../lib/scenarios.ts";
+import type { ChatModelStreamPart } from "./chat-model.ts";
+import { replayCallId, type ReplayedCall, type Recording } from "./replays.ts";
+
+// The scripted answers of the scenario tour (docs/plan.md, slice 24; the steps
+// are in src/lib/scenarios.ts). Each is written like a recording, so the
+// replay (replay-chat-model.ts) plays it like one: each model call's parts,
+// whole, after its wait. The searches, saves and the quote check they call run
+// for real, so a quote below is confirmed only if the interview says it.
+// `passes` says which way each is meant to go, for the tests; it never leaves
+// this file. A call can also fail on purpose (`fails`).
+
+/** How a scripted call fails, instead of replying. */
+export type ScriptedFailure =
+  /** Before its reply, as a provider error. Once per server process. */
+  | "before"
+  /** After its first words, as a dropped connection. Once per process. */
+  | "partway"
+  /** As Cloudflare's per-minute limit after the retries. Once per process. */
+  | "busy"
+  /** As the day's allocation used up. Every time, as Cloudflare would. */
+  | "quota";
+
+export type ScriptedCall = ReplayedCall & { fails?: ScriptedFailure };
+
+export type ScriptedRecording = Recording & { calls: ScriptedCall[] };
+
+/** A citation as scripted: `passes` is what the check should find. */
+export type ScriptedCitation = {
+  source: string;
+  quote: string;
+  passes: boolean;
+};
+
+export type ScriptedStatement = {
+  text: string;
+  citations: ScriptedCitation[];
+};
+
+export type ScriptedSection = {
+  section: string;
+  statements: ScriptedStatement[];
+};
+
+type ToolCall =
+  | { tool: "searchNotes"; query: string }
+  | { tool: "saveSection"; draft: ScriptedSection }
+  | { tool: string; input: Record<string, unknown> };
+
+/** One model call as written below: what it says and what it calls. */
+type Step = {
+  waitMs: number;
+  /** Reasoning, which stays on the server, as gpt-oss's does. */
+  thinks?: string;
+  says?: string;
+  calls?: ToolCall[];
+  /** How the reply ends; a call with tools ends in "tool-calls". */
+  ends?: "stop" | "length";
+  fails?: ScriptedFailure;
+};
+
+const SCRIPTS: Record<string, Step[]> = {
+  "rich-text": [
+    {
+      waitMs: 3200,
+      thinks: "Show every mark the chat reads, and the ones it strips.",
+      says: [
+        "## A heading the chat strips",
+        "",
+        "Here is **bold text**, some `inline code` such as `saveSection`, and an *italic* word whose marks go.",
+        "",
+        "What the households agree on:",
+        "- A **shared** list everyone can see",
+        "- Ticking items off while you shop",
+        "- Adding an item in a few seconds",
+        "",
+        "What to build first, in order:",
+        "1. The shared list",
+        "2. Ticking off, seen by everyone at once",
+        "3. Notifications, once the open question about them is settled",
+        "",
+        "> A quoted line, whose mark is stripped.",
+        "",
+        "A [link to the interviews](/transcripts) shows as its words, and a rule follows.",
+        "",
+        "---",
+        "",
+        "~~Struck-through~~ words show without their marks, and <b>other HTML</b> shows as typed.",
+      ].join("\n"),
+    },
+  ],
+
+  tables: [
+    {
+      waitMs: 4100,
+      thinks: "Three tables: small, wide, and awkward.",
+      says: [
+        "A small table:",
+        "",
+        "| Household | Notifications |",
+        "| --- | --- |",
+        "| Henk | Every item |",
+        "| Daan | None: he looks before he shops |",
+        "",
+        "A wide one, which scrolls sideways inside the message:",
+        "",
+        "| Household | Who shops | How often | Lists today | Notifications | Shares with | Wants most |",
+        "|---|---|---|---|---|---|---|",
+        "| Maya | Maya and Tom | Three or four times a week | Chat messages | Every item | Tom | Ticks that show at once |",
+        "| Daan | Daan | Saturday, plus top-ups | Paper on the fridge | None | Esther and the older two | The list in his route's order |",
+        "| Sofia | Whoever is near | Often | The house chat | None | Four housemates | Claiming an item |",
+        "",
+        "Line breaks in cells, empty cells, an unnamed column and a row longer than its header:",
+        "",
+        "| Item | Notes | |",
+        "| :--- | :---: | ---: |",
+        "| Coffee | Ria's brand only<br>Henk, henk-5 | |",
+        "| Rice | | Bought twice |",
+        "| Nappies | **Lena** and `lena-5`<br/>her mother too | Once | and one cell too many |",
+        "| | | |",
+      ].join("\n"),
+    },
+  ],
+
+  searches: [
+    { waitMs: 2400, calls: [search("notifications for every item")] },
+    { waitMs: 3100, calls: [search("buying the same thing twice")] },
+    {
+      waitMs: 4200,
+      says: "Two angles so far. One more, worded the long way round:",
+      calls: [
+        search(
+          "how the households who share a list today would want to hear about items that someone else added while they are away from home, at work or already standing in the shop, and whether they would rather look at the list themselves",
+        ),
+      ],
+    },
+    {
+      waitMs: 6500,
+      says: "Three searches: the first two folded into one line, then a line of its own after my words, cut off where it runs long. Henk and Maya want to hear about every item; Daan and Sofia uninstalled apps that did exactly that.",
+    },
+  ],
+
+  "failed-steps": [
+    {
+      waitMs: 2900,
+      calls: [
+        search(
+          Array.from(
+            { length: 5 },
+            () =>
+              "what the six households say about notifications, shared lists, ticking items off and buying things twice,",
+          ).join(" "),
+        ),
+      ],
+    },
+    {
+      waitMs: 2600,
+      calls: [
+        {
+          tool: "browseWeb",
+          input: { url: "https://example.com/grocery-apps" },
+        },
+      ],
+    },
+    { waitMs: 2200, calls: [search("coffee brand")] },
+    {
+      waitMs: 5200,
+      says: "My first question was too long for the search, and the chat has no web browser, so those two steps didn't work. The third search did: Henk needs the right brand of coffee for Ria.",
+    },
+  ],
+
+  "every-statement": [
+    { waitMs: 2600, calls: [search("notifications and buying twice")] },
+    {
+      waitMs: 9800,
+      calls: [
+        {
+          tool: "saveSection",
+          draft: {
+            section: "User Stories / Use Cases",
+            statements: [
+              {
+                text: "As Henk, I want a ping for every item Ineke adds, so I know to buy it.",
+                citations: [
+                  passage(
+                    "henk-4",
+                    "I'd like my phone to ping me every time she puts something on the list",
+                  ),
+                ],
+              },
+              {
+                text: "As anyone who shops for a household, I want to see who is getting what, so we stop buying things twice.",
+                citations: [
+                  passage("maya-2", "We buy things twice"),
+                  passage(
+                    "lena-5",
+                    "My mother and I once both bought a big pack of nappies",
+                  ),
+                  passage(
+                    "sofia-1",
+                    "three people buy toilet paper on the same day",
+                  ),
+                  passage(
+                    "daan-2",
+                    "someone has to go back to the shop for one thing",
+                  ),
+                ],
+              },
+              {
+                text: "As Henk, I want large text and a dark mode.",
+                citations: [
+                  unverified("henk-3", "Big letters and a dark mode, please."),
+                ],
+              },
+              {
+                text: "As Maya, I want the list to work the way we planned it together.",
+                citations: [
+                  unverified(
+                    "maya-3",
+                    "If you had a shared list, how would you want it to work?",
+                  ),
+                ],
+              },
+              {
+                text: "As Ravi, I want my regular items to appear without typing them.",
+                citations: [
+                  unverified(
+                    "ravi-6",
+                    "I'd like to mark those as regulars and have them show up without typing them",
+                  ),
+                ],
+              },
+              {
+                text: "As a household, we want the app to be free.",
+                citations: [
+                  unverified("notes-7", "Every household wants it free"),
+                ],
+              },
+              {
+                text: "As a shopper, I want the list to work offline in the shop.",
+                citations: [],
+              },
+              {
+                text: "As the product manager, I want this section to show every kind of statement the PRD can hold.",
+                citations: [chat("every kind of statement")],
+              },
+              {
+                text: "As a parent sharing care across two homes, I want one list for my child's things that both homes and my mother can see, while my own shopping stays private, and housemates want the same split between what is shared and what is theirs alone, so a long statement like this one wraps across several lines before its sources.",
+                citations: [
+                  passage(
+                    "lena-2",
+                    "one list for Milo's things that the three of us share",
+                  ),
+                  passage("sofia-4", "My own shopping is my business"),
+                  unverified("sofia-4", "I want my own food hidden"),
+                ],
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      waitMs: 4800,
+      says: "I saved User Stories / Use Cases with one statement of every kind: confirmed quotes, an unverified quote, the interviewer's question quoted as an answer, the wrong passage cited, a source that doesn't exist, a statement that cites nothing, and one backed only by your message. Click a name in the PRD to see its quote in the full answer.",
+    },
+  ],
+
+  "refused-save": [
+    { waitMs: 2300, calls: [search("what success looks like")] },
+    {
+      waitMs: 7400,
+      calls: [
+        {
+          tool: "saveSection",
+          draft: {
+            section: "Goals",
+            statements: [
+              {
+                text: "Stop buying the same thing twice.",
+                citations: [
+                  passage("maya-7", "A month without buying anything twice"),
+                ],
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      waitMs: 6100,
+      calls: [
+        {
+          tool: "saveSection",
+          draft: {
+            section: "Goals / Objectives",
+            statements: [
+              {
+                text: "Households stop buying the same thing twice.",
+                citations: [
+                  passage("maya-7", "A month without buying anything twice"),
+                ],
+              },
+              {
+                text: "Planning the week's shopping takes twenty minutes instead of an hour.",
+                citations: [
+                  passage(
+                    "ravi-7",
+                    "If Sunday planning took twenty minutes instead of an hour",
+                  ),
+                ],
+              },
+              {
+                text: "Henk comes home with the right coffee, without Ineke phoning him in the shop.",
+                citations: [
+                  passage(
+                    "henk-7",
+                    "That Ineke stops having to phone me in the shop",
+                  ),
+                  passage(
+                    "henk-7",
+                    "And that I come home with the right coffee",
+                  ),
+                ],
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      waitMs: 4400,
+      says: "Goals / Objectives is saved, on the second try: the first named a section the PRD doesn't have, so the check never read it.",
+    },
+  ],
+
+  "open-questions": [
+    { waitMs: 2500, calls: [search("notifications and accounts")] },
+    {
+      waitMs: 8200,
+      calls: [
+        {
+          tool: "saveSection",
+          draft: {
+            section: "Open Questions / Future Considerations",
+            statements: [
+              {
+                text: "Open question: notify on every item, or only when someone is about to shop? Henk and Maya want every item; Daan and Sofia uninstalled apps that did that.",
+                citations: [
+                  passage("henk-4", "Every single item, yes"),
+                  passage(
+                    "maya-3",
+                    "I want a notification for every item someone adds",
+                  ),
+                  passage("daan-5", "I uninstalled it after two days"),
+                  passage(
+                    "sofia-5",
+                    "If an app notifies me every time someone adds something, I uninstall it",
+                  ),
+                ],
+              },
+              {
+                text: "Open question: should the list open from a link, without an account?",
+                citations: [
+                  passage(
+                    "sofia-7",
+                    "He'd use it if it opened in the browser from a link, without making an account",
+                  ),
+                ],
+              },
+              {
+                text: "Future consideration: settling up shared costs between housemates.",
+                citations: [
+                  passage(
+                    "sofia-3",
+                    "If the list remembered who bought what, it would save a lot of arguing",
+                  ),
+                ],
+              },
+              {
+                text: "Open question: what should the app cost?",
+                citations: [],
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      waitMs: 3900,
+      says: "I saved Open Questions / Future Considerations. Its last question cites nothing, which this section allows, so nothing is flagged under it.",
+    },
+  ],
+
+  "long-answer": [
+    {
+      waitMs: 9000,
+      thinks: "Write at length, so the chat has to scroll.",
+      says: Array.from(
+        { length: 12 },
+        (_, index) =>
+          `Paragraph ${index + 1} of 12. Maya and Tom message each other all day and rebuild the list in the shop; Henk wants a ping for every item Ineke adds, while Daan and Sofia uninstalled apps that did exactly that. Ravi plans six dinners on Sunday and copies every ingredient by hand, Lena keeps Milo's things apart across two homes, and Sofia's house would rather claim an item than race for it.`,
+      ).join("\n\n"),
+    },
+  ],
+
+  "long-wait": [
+    {
+      waitMs: 30_000,
+      thinks: "Take a long time on purpose.",
+      says: "That took thirty seconds on purpose: long enough to watch the Thinking line, or to press Stop.",
+    },
+  ],
+
+  "fail-before": [
+    {
+      waitMs: 2500,
+      fails: "before",
+      says: "This time it worked: the failure before the first word happens once per server start.",
+    },
+  ],
+
+  "fail-partway": [
+    {
+      waitMs: 3000,
+      fails: "partway",
+      says: "This reply breaks off after its first few words the first time it plays, as a dropped connection would, and arrives whole when you try again.",
+    },
+  ],
+
+  "cut-off": [
+    {
+      waitMs: 7000,
+      thinks: "Write until the output limit stops me.",
+      says: "The households agree on a shared list, ticked off as they shop, but they disagree about notifications: Henk and Maya want one for every item, while Daan and Sofia",
+      ends: "length",
+    },
+  ],
+
+  "no-words": [
+    {
+      waitMs: 5000,
+      thinks: "Think, then write nothing at all.",
+    },
+  ],
+
+  busy: [
+    {
+      waitMs: 6000,
+      fails: "busy",
+      says: "Cloudflare answered this time: the busy message comes once per server start.",
+    },
+  ],
+
+  quota: [{ waitMs: 1500, fails: "quota" }],
+};
+
+function search(query: string): ToolCall {
+  return { tool: "searchNotes", query };
+}
+
+function passage(source: string, quote: string): ScriptedCitation {
+  return { source, quote, passes: true };
+}
+
+function unverified(source: string, quote: string): ScriptedCitation {
+  return { source, quote, passes: false };
+}
+
+/** A quote of the visitor's own message, which the check confirms. */
+function chat(quote: string): ScriptedCitation {
+  return { source: "chat", quote, passes: true };
+}
+
+/** Every section a script saves, for the tests. */
+export function scriptedSections(): {
+  scenario: string;
+  section: ScriptedSection;
+}[] {
+  return Object.entries(SCRIPTS).flatMap(([scenario, steps]) =>
+    steps.flatMap((step) =>
+      (step.calls ?? []).flatMap((call) =>
+        "draft" in call ? [{ scenario, section: call.draft }] : [],
+      ),
+    ),
+  );
+}
+
+/** The scripted steps of the tour, as recordings the replay plays. */
+export function scenarioRecordings(): ScriptedRecording[] {
+  return SCENARIOS.flatMap((scenario) => {
+    const steps = SCRIPTS[scenario.id];
+    if (steps === undefined) return [];
+    const id = `S-${scenario.id}`;
+    return [
+      {
+        id,
+        recordedOn: "scripted",
+        words: scenario.words,
+        calls: steps.map((step, index) => toCall(step, id, index + 1)),
+      },
+    ];
+  });
+}
+
+/** The ids of the steps that have a script. */
+export function scriptedScenarioIds(): string[] {
+  return Object.keys(SCRIPTS);
+}
+
+function toCall(step: Step, recording: string, call: number): ScriptedCall {
+  const parts: ChatModelStreamPart[] = [{ type: "stream-start", warnings: [] }];
+  if (step.thinks !== undefined) {
+    parts.push(
+      { type: "reasoning-start", id: "0" },
+      { type: "reasoning-delta", id: "0", delta: step.thinks },
+      { type: "reasoning-end", id: "0" },
+    );
+  }
+  if (step.says !== undefined) {
+    parts.push(
+      { type: "text-start", id: "1" },
+      { type: "text-delta", id: "1", delta: step.says },
+      { type: "text-end", id: "1" },
+    );
+  }
+  const calls = step.calls ?? [];
+  calls.forEach((toolCall, index) => {
+    parts.push({
+      type: "tool-call",
+      toolCallId: replayCallId(recording, call, index),
+      toolName: toolCall.tool,
+      input: JSON.stringify(toolInput(toolCall)),
+    });
+  });
+  const written = (step.thinks ?? "") + (step.says ?? "");
+  parts.push({
+    type: "finish",
+    finishReason:
+      calls.length > 0
+        ? { unified: "tool-calls", raw: "tool_calls" }
+        : { unified: step.ends ?? "stop", raw: step.ends ?? "stop" },
+    usage: {
+      inputTokens: {
+        total: 2000,
+        noCache: 2000,
+        cacheRead: 0,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: Math.ceil(written.length / 4) + 40,
+        text: Math.ceil((step.says ?? "").length / 4),
+        reasoning: Math.ceil((step.thinks ?? "").length / 4) + 40,
+      },
+    },
+  });
+  return {
+    durationMs: step.waitMs,
+    parts,
+    ...(step.fails === undefined ? {} : { fails: step.fails }),
+  };
+}
+
+/** What the model sends a tool: `passes` stays here. */
+function toolInput(call: ToolCall): Record<string, unknown> {
+  if ("query" in call) return { query: call.query };
+  if ("draft" in call) {
+    return {
+      section: call.draft.section,
+      statements: call.draft.statements.map((statement) => ({
+        text: statement.text,
+        citations: statement.citations.map(({ source, quote }) => ({
+          source,
+          quote,
+        })),
+      })),
+    };
+  }
+  return call.input;
+}
diff --git a/tests/AGENTS.md b/tests/AGENTS.md
index c889580..81c626d 100644
--- a/tests/AGENTS.md
+++ b/tests/AGENTS.md
@@ -15,7 +15,7 @@ Every feature gets a test in each layer it touches. A bug fix starts with a test
 - **Fakes sit only at external boundaries.** That means the AI provider: the fake embedder (`src/server/ai/fake-embedder.ts`) and the fake chat model (`src/server/ai/fake-chat-model.ts`). The database is real in integration tests, never mocked.
 - **The fake embedder counts shared words,** without stemming or synonyms ("notification" and "notifications" are different words to it). A search test's question uses the words of the passages it expects; search by meaning can only be checked on staging.
 - **The fake chat model follows a script:** it searches with the visitor's whole message, then quotes the closest passage. A message with "draft" or "section" in it makes it save a section instead, the one the message names last (so the check-in, "Introduction / Overview looks right. Please draft Goals / Objectives.", drafts Goals / Objectives), or the first when it names none: one statement per closest passage (up to three) quoting the first sentence of its answer, and one quoting the message's first sentence, then a reply saying what the check found. `FAKE_SEARCH_AGAIN` makes it search again with the same words while the search is on offer (three times), so the chat folds its searches. `FAKE_FLAWED_SECTION` in the message adds three flaws for the check to catch: a quote from the researcher's question, another passage's words under the first passage's id, and a statement that cites nothing. A message containing `FAKE_FAILURES.beforeAnswering` or `FAKE_FAILURES.partway` makes it fail once, so a retry succeeds. Its memory of failed messages lasts as long as the server, so an end-to-end test adds `testInfo.testId` to its message. Unit tests pass their own `failedMessages` and `chunkDelayInMs: 0`.
-- **The replayed answers** (`src/server/ai/replay-chat-model.ts`) run only on the second server of `playwright.config.ts`, port 3101, started after the first on its build with `AI_CHAT_PROVIDER=replay` and `REPLAY_SPEED=100`; only `tests/e2e/replay.spec.ts` goes there, and every other test stays on the scripted fake. That server gives each request's recordings out in turn, so a test there expects the first recording only once per run. Unit tests pass the replay their own `picks` and use fake timers for its waits.
+- **The replayed answers** (`src/server/ai/replay-chat-model.ts`) run only on the second server of `playwright.config.ts`, port 3101, started after the first on its build with `AI_CHAT_PROVIDER=replay` and `REPLAY_SPEED=100`; only `tests/e2e/replay.spec.ts` goes there, and every other test stays on the scripted fake. That server gives each request's recordings out in turn, so a test there expects the first recording only once per run. Unit tests pass the replay their own `picks` and use fake timers for its waits. The scenario tour's steps (slice 24) answer there too, by their words; their scripted failures happen once per server process, so a test there that wants one sees it only once per run, and unit tests pass their own `failed`.
 - **Next.js renders its own empty `role="alert"`** (the route announcer) on every page. Scope alert lookups to the part of the page under test.
 - **`server-only`:** Vitest maps it to an empty module (`vitest.config.ts`), so tests can import server code.
 
diff --git a/tests/e2e/replay.spec.ts b/tests/e2e/replay.spec.ts
index 64ce9ff..d916985 100644
--- a/tests/e2e/replay.spec.ts
+++ b/tests/e2e/replay.spec.ts
@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { expect, test } from "@playwright/test";
+import { SCENARIOS } from "@/lib/scenarios";
 import { REPLAYS_FILE, type Replays } from "@/server/ai/replays";
 import { expectNoAccessibilityViolations } from "./accessibility";
 
@@ -44,3 +45,36 @@ test("the intro's button replays a real answer with its recorded words", async (
   await expect(conversation).not.toContainText("This is the local fake model");
   await expectNoAccessibilityViolations(page);
 });
+
+// The scenario tour's steps (slice 24) answer on the same server. Its panel
+// shows only with `npm run dev:replay`, whose compile sets the flag, never in
+// this build, so the test sends a step's words itself.
+test("the tour's tables step shows its tables in the chat", async ({
+  page,
+}) => {
+  await page.goto(REPLAY_URL);
+  await page
+    .getByRole("button", { name: "Or ask your own question first" })
+    .click();
+  await expect(
+    page.getByRole("complementary", { name: "Scenario tour" }),
+  ).toHaveCount(0);
+  await page
+    .getByRole("textbox", { name: "Your message" })
+    .fill(scenarioWords("tables"));
+  await page.getByRole("button", { name: "Send" }).click();
+
+  const conversation = page.getByRole("list", { name: "Conversation" });
+  await expect(conversation.getByRole("table")).toHaveCount(3);
+  await expect(
+    conversation.getByRole("columnheader", { name: "Wants most" }),
+  ).toBeVisible();
+  await expect(conversation).not.toContainText("| Household |");
+  await expectNoAccessibilityViolations(page);
+});
+
+function scenarioWords(id: string): string {
+  const step = SCENARIOS.find((scenario) => scenario.id === id);
+  if (!step) throw new Error(`No scenario "${id}".`);
+  return step.words;
+}
diff --git a/tests/unit/scenario-tour.test.tsx b/tests/unit/scenario-tour.test.tsx
new file mode 100644
index 0000000..31f6ef2
--- /dev/null
+++ b/tests/unit/scenario-tour.test.tsx
@@ -0,0 +1,72 @@
+import { fireEvent, render, screen, within } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { ScenarioTour } from "@/features/workspace/scenario-tour";
+import { SCENARIOS } from "@/lib/scenarios";
+
+// The scenario tour's panel (slice 24): what it offers next and what it sends.
+
+function tour(sent: string[] = [], working = false) {
+  const onPlay = vi.fn();
+  render(<ScenarioTour sent={sent} working={working} onPlay={onPlay} />);
+  return {
+    onPlay,
+    panel: screen.getByRole("complementary", { name: "Scenario tour" }),
+  };
+}
+
+describe("the scenario tour", () => {
+  it("offers the first step, with what to watch for, and sends its words", () => {
+    const { onPlay, panel } = tour();
+    const [first] = SCENARIOS;
+
+    expect(
+      within(panel).getByText(`Step 1 of ${SCENARIOS.length}`),
+    ).toBeTruthy();
+    expect(within(panel).getByText(first?.watch ?? "")).toBeTruthy();
+    fireEvent.click(within(panel).getByRole("button", { name: "Play next" }));
+    expect(onPlay).toHaveBeenCalledWith(first?.words);
+  });
+
+  it("goes on after the steps already in the conversation", () => {
+    const tables = SCENARIOS.findIndex((step) => step.id === "tables");
+    const { onPlay, panel } = tour([
+      "scenario: tables",
+      "A question of the visitor's own",
+    ]);
+
+    expect(
+      within(panel).getByText(`1 of ${SCENARIOS.length} played`),
+    ).toBeTruthy();
+    fireEvent.click(within(panel).getByRole("button", { name: "Play next" }));
+    expect(onPlay).toHaveBeenCalledWith(SCENARIOS[tables + 1]?.words);
+  });
+
+  it("plays any step from its list", () => {
+    const { onPlay, panel } = tour();
+    const list = within(panel).getByRole("button", { name: "All steps" });
+    expect(list.getAttribute("aria-expanded")).toBe("false");
+    fireEvent.click(list);
+    expect(list.getAttribute("aria-expanded")).toBe("true");
+
+    fireEvent.click(within(panel).getByRole("button", { name: /Tables/ }));
+    expect(onPlay).toHaveBeenCalledWith("Scenario: Tables");
+  });
+
+  it("sends nothing while an answer is on its way", () => {
+    const { onPlay, panel } = tour([], true);
+    const next = within(panel).getByRole("button", { name: "Play next" });
+
+    expect((next as HTMLButtonElement).disabled).toBe(true);
+    fireEvent.click(next);
+    expect(onPlay).not.toHaveBeenCalled();
+  });
+
+  it("says when the tour is done", () => {
+    const { panel } = tour(SCENARIOS.map((step) => step.words));
+
+    expect(
+      within(panel).queryByRole("button", { name: "Play next" }),
+    ).toBeNull();
+    expect(within(panel).getByText(/The tour is done/)).toBeTruthy();
+  });
+});
diff --git a/tests/unit/scenarios.test.ts b/tests/unit/scenarios.test.ts
new file mode 100644
index 0000000..afc8350
--- /dev/null
+++ b/tests/unit/scenarios.test.ts
@@ -0,0 +1,274 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { APICallError } from "ai";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  nextScenario,
+  playedScenarios,
+  sameWords,
+  SCENARIOS,
+} from "@/lib/scenarios";
+import type {
+  ChatModelCall,
+  ChatModelStreamPart,
+} from "@/server/ai/chat-model";
+import { QuotaExceededError } from "@/server/ai/cloudflare";
+import { createReplayChatModel } from "@/server/ai/replay-chat-model";
+import {
+  normalizedWords,
+  recordingOfCallId,
+  REPLAYS_FILE,
+  type Replays,
+} from "@/server/ai/replays";
+import {
+  scenarioRecordings,
+  scriptedScenarioIds,
+  scriptedSections,
+} from "@/server/ai/scenarios";
+import { quoteIsIn } from "@/server/citations";
+import { parseInterview } from "@/server/notes/parse-interview";
+
+// The scenario tour of `npm run dev:replay` (docs/plan.md, slice 24): its
+// steps, its scripted answers and their failures.
+
+type Prompt = ChatModelCall["prompt"];
+
+const copied = JSON.parse(readFileSync(REPLAYS_FILE, "utf8")) as Replays;
+
+/** Every interview answer, by passage id, such as henk-4. */
+const answers = new Map<string, string>(
+  readdirSync("notes")
+    .filter((file) => file.endsWith(".md"))
+    .flatMap((file) => {
+      const interview = parseInterview(
+        file,
+        readFileSync(join("notes", file), "utf8"),
+      );
+      return interview.passages.map(
+        (passage) =>
+          [`${interview.slug}-${passage.position}`, passage.answer] as const,
+      );
+    }),
+);
+
+function scenario(id: string) {
+  const found = SCENARIOS.find((step) => step.id === id);
+  if (!found) throw new Error(`No scenario "${id}".`);
+  return found;
+}
+
+describe("the tour's steps", () => {
+  it("each have a script or real recordings, and every script a step", () => {
+    const scripted = new Set(scriptedScenarioIds());
+    for (const step of SCENARIOS) {
+      const recorded = copied.recordings.some(
+        (recording) =>
+          normalizedWords(recording.words) === normalizedWords(step.words),
+      );
+      expect(scripted.has(step.id) || recorded, step.id).toBe(true);
+    }
+    expect(
+      [...scripted].filter((id) => !SCENARIOS.some((s) => s.id === id)),
+    ).toEqual([]);
+  });
+
+  it("send words of their own, and end on the used-up allocation", () => {
+    const words = SCENARIOS.map((step) => normalizedWords(step.words));
+    expect(new Set(words).size).toBe(SCENARIOS.length);
+    expect(SCENARIOS.at(-1)?.id).toBe("quota");
+  });
+
+  it("count as played once their words were sent, in any case and spacing", () => {
+    const played = playedScenarios([
+      "  scenario:   TABLES ",
+      "Something else entirely",
+    ]);
+    expect([...played]).toEqual(["tables"]);
+    expect(sameWords("Scenario: Tables", "scenario:  tables")).toBe(true);
+  });
+
+  it("go on after the furthest step played, and end after the last", () => {
+    expect(nextScenario(new Set())).toBe(0);
+    const tables = SCENARIOS.findIndex((step) => step.id === "tables");
+    expect(nextScenario(new Set(["tables", "first-section"]))).toBe(tables + 1);
+    expect(nextScenario(new Set(["quota"]))).toBeUndefined();
+  });
+});
+
+describe("the scripted answers", () => {
+  it("name their own recording in every tool call's id", () => {
+    for (const recording of scenarioRecordings()) {
+      for (const call of recording.calls) {
+        for (const part of call.parts) {
+          if (part.type !== "tool-call") continue;
+          expect(recordingOfCallId(part.toolCallId)).toBe(recording.id);
+          expect(() => JSON.parse(part.input) as unknown).not.toThrow();
+        }
+      }
+    }
+  });
+
+  it("quote the interviews word for word where the check should confirm, and miss where it shouldn't", () => {
+    const sections = scriptedSections();
+    expect(sections.length).toBeGreaterThan(0);
+    for (const { scenario: id, section } of sections) {
+      const visitor = scenario(id).words;
+      for (const statement of section.statements) {
+        for (const citation of statement.citations) {
+          const source =
+            citation.source === "chat" ? visitor : answers.get(citation.source);
+          const found =
+            source !== undefined && quoteIsIn(citation.quote, source);
+          expect(found, `${id}: ${citation.source} “${citation.quote}”`).toBe(
+            citation.passes,
+          );
+        }
+      }
+    }
+  });
+
+  it("hold every kind of statement in one section", () => {
+    const [every] = scriptedSections().filter(
+      ({ scenario: id }) => id === "every-statement",
+    );
+    const statements = every?.section.statements ?? [];
+    const citations = statements.flatMap((statement) => statement.citations);
+
+    expect(citations.some((citation) => citation.passes)).toBe(true);
+    expect(citations.some((citation) => !citation.passes)).toBe(true);
+    // An unknown source, nothing cited, the visitor's own words, many sources.
+    expect(
+      citations.some(
+        (citation) =>
+          !answers.has(citation.source) && citation.source !== "chat",
+      ),
+    ).toBe(true);
+    expect(
+      statements.some((statement) => statement.citations.length === 0),
+    ).toBe(true);
+    expect(citations.some((citation) => citation.source === "chat")).toBe(true);
+    expect(
+      Math.max(...statements.map((statement) => statement.citations.length)),
+    ).toBeGreaterThanOrEqual(4);
+  });
+});
+
+describe("the replay of a scripted step", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  function model(failed = new Set<string>()) {
+    return createReplayChatModel({
+      replays: { format: 1, measurement: "none", recordings: [] },
+      picks: new Map(),
+      failed,
+    });
+  }
+
+  function asks(id: string): Prompt {
+    return [
+      { role: "user", content: [{ type: "text", text: scenario(id).words }] },
+    ];
+  }
+
+  /** The call's outcome once every wait has passed. */
+  async function outcome(
+    replay: ReturnType<typeof model>,
+    prompt: Prompt,
+  ): Promise<{ parts: ChatModelStreamPart[]; error?: unknown }> {
+    const pending = Promise.resolve(replay.doStream({ prompt, tools: [] }));
+    pending.catch(() => undefined);
+    await vi.runAllTimersAsync();
+    let result;
+    try {
+      result = await pending;
+    } catch (error) {
+      return { parts: [], error };
+    }
+    const parts: ChatModelStreamPart[] = [];
+    try {
+      for await (const part of result.stream) parts.push(part);
+    } catch (error) {
+      return { parts, error };
+    }
+    return { parts };
+  }
+
+  function words(parts: ChatModelStreamPart[]): string {
+    return parts
+      .flatMap((part) => (part.type === "text-delta" ? [part.delta] : []))
+      .join("");
+  }
+
+  it("plays a table after its set wait", async () => {
+    const replay = model();
+    const pending = replay.doStream({ prompt: asks("tables"), tools: [] });
+    let arrived = false;
+    void pending.then(() => (arrived = true));
+    await vi.advanceTimersByTimeAsync(4000);
+    expect(arrived).toBe(false);
+    await vi.advanceTimersByTimeAsync(200);
+    expect(arrived).toBe(true);
+
+    const parts: ChatModelStreamPart[] = [];
+    for await (const part of (await pending).stream) parts.push(part);
+    expect(words(parts)).toContain("| Household | Notifications |");
+  });
+
+  it("fails before its reply once, then replies", async () => {
+    const replay = model();
+    const first = await outcome(replay, asks("fail-before"));
+    expect(APICallError.isInstance(first.error)).toBe(true);
+
+    const second = await outcome(replay, asks("fail-before"));
+    expect(second.error).toBeUndefined();
+    expect(words(second.parts)).toContain("This time it worked");
+  });
+
+  it("breaks off after its first words once, then replies whole", async () => {
+    const replay = model();
+    const first = await outcome(replay, asks("fail-partway"));
+    expect(first.error).toBeInstanceOf(Error);
+    expect(words(first.parts).trim().split(/\s+/)).toHaveLength(8);
+
+    const second = await outcome(replay, asks("fail-partway"));
+    expect(second.error).toBeUndefined();
+    expect(words(second.parts)).toMatch(/when you try again\.$/);
+  });
+
+  it("is busy once, as a per-minute refusal no retry got past", async () => {
+    const replay = model();
+    const { error } = await outcome(replay, asks("busy"));
+    expect(APICallError.isInstance(error) && error.statusCode).toBe(429);
+    expect(APICallError.isInstance(error) && error.isRetryable).toBe(false);
+
+    expect((await outcome(replay, asks("busy"))).error).toBeUndefined();
+  });
+
+  it("finds the allocation used up every time", async () => {
+    const replay = model();
+    for (let asked = 0; asked < 2; asked++) {
+      const { error } = await outcome(replay, asks("quota"));
+      expect(error).toBeInstanceOf(QuotaExceededError);
+    }
+  });
+
+  it("ends a cut-off answer at the output limit, and a wordless one with none", async () => {
+    const cut = await outcome(model(), asks("cut-off"));
+    expect(cut.parts.at(-1)).toMatchObject({
+      type: "finish",
+      finishReason: { unified: "length" },
+    });
+
+    const none = await outcome(model(), asks("no-words"));
+    expect(words(none.parts)).toBe("");
+    expect(none.parts.at(-1)).toMatchObject({
+      type: "finish",
+      finishReason: { unified: "stop" },
+    });
+  });
+});