demobite 1.3.1 → 1.5.0

package/README.md

@@ -2,7 +2,7 @@
 
 **Ask your coding agent to record your product. Edit the result. Download the MP4.**
 
-Your agent drives a real browser on your machine and records the flow you describe. Connect a free DemoBites account to turn the take into an editable video, with text-to-speech, zooms, captions, and MP4 export included.
+Your agent drives a real browser on your machine, records the flow you describe, and delivers the take into your free DemoBites account as an editable video, with text-to-speech, zooms, captions, and MP4 export included.
 
 **Sign in to your app locally. You do not hand DemoBites your app password or upload your recording browser profile.**
 
@@ -28,7 +28,7 @@ Before installing:
 
 - **Node.js 18 or newer** and npm.
 - **Google Chrome**, recommended. The recorder also supports Playwright's Chromium.
-- A **free DemoBites account** for the Studio workflow below.
+- A **free DemoBites account**. The recorder works only when this project is connected to it.
 
 Run these commands from your project directory:
 
@@ -61,7 +61,7 @@ For Cursor or Codex, make the [recorder instructions](skill/SKILL.md) available
 1. **Describe the flow.** Give your agent the app URL and what you want to demonstrate.
 2. **Approve the storyboard.** Review the steps and estimated length before filming. If your app needs a login, sign in yourself in the recorder's local browser window.
 3. **Let it record.** The agent checks the flow and films it. Recording normally runs in the background.
-4. **Review the raw take.** Open the review link printed in the terminal. Check the footage, then approve it to create a Bite, an editable video project.
+4. **Watch it arrive.** The take is delivered by itself and becomes a Bite, an editable video project. The terminal prints a link to your Demos grid in DemoBites, where the take's card shows it coming in. If your account is out of recording minutes, the take is kept and waits on the same grid until minutes are back.
 5. **Tweak and download.** In the Studio, change a sentence, generate its voice, adjust the zooms or timing, and export your MP4.
 
 The storyboard's narration is a starting point. DemoBites rewrites and fits it to the footage; you can edit the final wording in the Studio.
@@ -103,24 +103,18 @@ The recorder uses a separate, persistent Chrome profile at `.recorder/profile/`.
 | --- | --- |
 | Your app's browser session | Stays in the local recording profile; the standard local workflow does not upload that profile to DemoBites. |
 | DemoBites recorder key | Saved in `.recorder/config.json` and used to authenticate recorder requests to DemoBites. This is separate from your app login. |
-| Footage and recording metadata | Uploaded to DemoBites for review and processing, including the storyboard, narration intent, cursor events, and camera targets. |
+| Footage and recording metadata | Uploaded to DemoBites for processing, including the storyboard, narration intent, cursor events, and camera targets. |
 
 Recording happens locally. Studio processing and editing use DemoBites online. Anything visible or typed into the recorded flow can appear in the footage or recording metadata, so use suitable demo data. Your coding agent's own data handling still follows its provider and your settings.
 
 Keep `.recorder/` and take directories out of version control. To disconnect the recorder, run `npx demobite logout`.
 
-## Local output without a DemoBites account
-
-The repository also contains a [standalone recorder skill](recorder/SKILL.md) and local finishing scripts. These produce a local MP4; optional voiceover uses your own ElevenLabs key.
-
-This is an advanced, manual workflow. The default `npx demobite@latest` command installs the Studio-connected skill, not the standalone skill. The standalone finishing reference contains legacy instructions; use the standalone skill as the entry point rather than treating it as a second ending of the installed Studio skill.
-
 ## A few boundaries
 
 - The agentic recorder films **browser workflows**. It does not record native desktop apps or phone screens.
 - The Studio-connected skill is designed for short demos, usually **30–45 seconds**, with a **90-second maximum per Bite**. Split longer stories into separate videos.
 - Some sites block automated browsers. The workflow may need a human sign-in or verification step, and some sites may refuse recording.
-- Filming does not publish anything. You review the take before creating the Bite; public publishing is a separate action.
+- Filming does not publish anything. You approve the storyboard before anything is filmed; the delivered Bite stays in your workspace, and public publishing is a separate action.
 
 ## Optional: Retake and management
 
@@ -130,7 +124,11 @@ When your UI changes, **Retake** can refilm an existing Bite from its saved reci
 npx demobite retake <biteId> --note "Export moved to the header"
 ```
 
-**Batches of briefs.** When a pull request in DemoBites produces approved briefs, your agent claims them, films one take per brief after you approve each storyboard, and delivers each take. A delivered take becomes a Bite in DemoBites by itself; there is no second review click for these takes. Nothing is published or shared.
+**In your app's repository.** Run the skill from the project that is your app and the agent reads the routes, the navigation, the control labels and the data handlers before it plans, then verifies everything on the live page. Without the code it works from the live app alone and asks when it cannot find a screen.
+
+**Workspace rules.** A workspace admin can write standing rules for the recorder in plain words in the DemoBites settings tab Agentic Recorder Rules, one per line: what to mask, which pages never to open, which words to use. The agent reads them at the start of every take and applies them under its own filming laws; `npx demobite rules` prints them. Every take records the rules version it was filmed under.
+
+**Batches of briefs.** When a pull request in DemoBites produces approved briefs, your agent claims them, films one take per brief after you approve each storyboard, and delivers each take. Like every take, a delivered take becomes a Bite in DemoBites by itself and shows up on your Demos grid. Nothing is published or shared.
 
 The package also includes a DemoBites management MCP for releases and centers:
 
@@ -149,7 +147,6 @@ The default installer also attempts to register that MCP with Claude Code when t
 | `launcher/` | CLI setup, connection commands, and MCP registration. |
 | `skill/` | Studio-connected recorder instructions, login, upload, and Retake. |
 | `scripts/` | Shared browser recording, trimming, and timing calibration. |
-| `recorder/` | Standalone skill and local video finishing tools. |
 
 The same package is published under three names, `demobite`, `agentic-recorder` and `demobites`, always at the same version; `npx agentic-recorder@latest` and `npx demobites@latest` do exactly what `npx demobite@latest` does. Run it again to update the installed skill. For publishing instructions, see [RELEASING.md](RELEASING.md).
 

package/launcher/index.mjs

@@ -158,7 +158,8 @@ if (arg === "retake") {
 
 // Batch of briefs (2026-09-13): `npx demobite briefs list <batchId>` etc. and
 // `npx demobite status <takeDir|stagingId>` hand straight to the skill scripts.
-if (arg === "briefs" || arg === "status") {
+// WORKSPACE RULES (1.4): `npx demobite rules` prints the workspace's standing rules.
+if (arg === "briefs" || arg === "status" || arg === "rules") {
   let cfg = readCfg();
   if (!cfg?.api_key) {
     console.log("\n  Not connected yet — linking this machine to DemoBites first…\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "demobite",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "The DemoBites agentic recorder — you prompt, it films a real browser, and DemoBites turns the take into an editable demo bite.",
   "bin": {
     "demobite": "launcher/index.mjs"

package/scripts/record.mjs

@@ -20,6 +20,38 @@ if (!outArg || !storyArg) {
 }
 
 const STORYBOARD = JSON.parse(fs.readFileSync(storyArg, "utf8"));
+
+// BROWSER HEADER (founder ruling 2026-09-16, final): the recording stays
+// 1920x1080 and DemoBites ADDS the dark macOS header on top at ingest, as it
+// does for an uploaded video; the studio places the taller container inside
+// its 16:9 canvas. The header is on by default; a workspace rule negating it
+// ("No browser header on the takes.", same phrase test as the cloud runner)
+// turns it off, and so does storyboard.browserHeader === false. The manifest
+// and the recipe carry browserHeader for the ingest to read. The cloud runner
+// passes --browser-header=on|off; --viewport=WxH and storyboard.viewport can
+// still change the frame when a lane needs it, never by default.
+const NO_HEADER_RE = /no browser header|without (a |the )?browser header|browser header off/i;
+function resolveDesign() {
+  const flag = process.argv.slice(2).find((a) => a.startsWith("--viewport="));
+  const m = flag && /^--viewport=(\d{3,4})x(\d{3,4})$/.exec(flag);
+  if (m) return { width: Number(m[1]), height: Number(m[2]), why: "--viewport" };
+  const v = STORYBOARD.viewport;
+  if (v && Number.isInteger(v.width) && Number.isInteger(v.height)) return { width: v.width, height: v.height, why: "storyboard.viewport" };
+  return { width: 1920, height: 1080, why: "default" };
+}
+function resolveHeader() {
+  // --browser-header=on|off (the cloud runner passes it) → storyboard.browserHeader → the rule → on.
+  const flag = process.argv.slice(2).find((a) => a.startsWith("--browser-header="));
+  if (flag) { const v = flag.slice("--browser-header=".length).toLowerCase(); if (v === "on" || v === "off") return { on: v === "on", why: "--browser-header" }; console.error(`--browser-header must be on or off (got ${v}); ignoring it`); }
+  if (typeof STORYBOARD.browserHeader === "boolean") return { on: STORYBOARD.browserHeader, why: "storyboard.browserHeader" };
+  let rulesText = "";
+  try { rulesText = JSON.parse(fs.readFileSync(path.resolve(".recorder/rules.json"), "utf8")).text ?? ""; } catch {}
+  if (NO_HEADER_RE.test(rulesText)) return { on: false, why: "workspace rule: no browser header" };
+  return { on: true, why: "default, DemoBites adds the browser header at ingest" };
+}
+const { why: DESIGN_WHY, ...DESIGN } = resolveDesign();
+const { on: BROWSER_HEADER, why: HEADER_WHY } = resolveHeader();
+console.log(`viewport ${DESIGN.width}x${DESIGN.height} (${DESIGN_WHY}); browser header: ${BROWSER_HEADER ? "yes" : "no"} (${HEADER_WHY})`);
 const ACTIONS = new Set(["goto", "settle", "scroll", "click", "hover", "type", "expect"]);
 if (!Array.isArray(STORYBOARD.steps) || STORYBOARD.steps.length === 0) {
   console.error("Storyboard has no steps.");
@@ -51,7 +83,11 @@ try {
   const cfgPath = path.resolve(".recorder/config.json");
   const cfg = fs.existsSync(cfgPath) ? JSON.parse(fs.readFileSync(cfgPath, "utf8")) : {};
   // Only the public shape — NEVER the api_key or workspace.
-  const config = { app: STORYBOARD.app ?? cfg.app ?? null, url: STORYBOARD.url ?? cfg.url ?? null, frame: cfg.frame ?? { width: 1920, height: 1080 }, base: cfg.base ?? "https://app.demobites.com" };
+  // WORKSPACE RULES (1.4): the storyboard names the rules version it was written under
+  // (rules.mjs prints it); the recipe carries it so a re-take can refuse an older rule set.
+  let rulesVersion = Number.isInteger(STORYBOARD.rulesVersion) ? STORYBOARD.rulesVersion : null;
+  if (rulesVersion === null) { try { const r = JSON.parse(fs.readFileSync(path.resolve(".recorder/rules.json"), "utf8")); if (Number.isInteger(r.version)) rulesVersion = r.version; } catch {} }
+  const config = { app: STORYBOARD.app ?? cfg.app ?? null, url: STORYBOARD.url ?? cfg.url ?? null, frame: DESIGN, browserHeader: BROWSER_HEADER, base: cfg.base ?? "https://app.demobites.com", ...(rulesVersion !== null ? { rulesVersion } : {}) };
   fs.writeFileSync(path.join(DIR, "recipe.json"), JSON.stringify({ version: 1, lane: (process.env.CDP_WS_URL || STORYBOARD.cdpWsUrl) ? "cloud" : "skill", engine: ENGINE_VERSION, config }, null, 2));
 } catch (e) { console.error("recipe.json not written:", e.message); }
 fs.mkdirSync(DIR, { recursive: true });
@@ -86,7 +122,6 @@ fs.mkdirSync(DIR, { recursive: true });
 // display-level capture: a separate chapter. The coordinate plumbing below is
 // kept so flipping this constant is the only change when it lands.
 const SUPERSAMPLE = 1;
-const DESIGN = { width: 1920, height: 1080 };
 const VIEW = { width: DESIGN.width * SUPERSAMPLE, height: DESIGN.height * SUPERSAMPLE };
 // Persistent camera-browser profile: the human's signed-in sessions live here.
 // The auth checkpoint (SKILL.md) fills it; record only ever reads it.
@@ -281,6 +316,7 @@ const manifest = {
   title: STORYBOARD.title ?? null,
   url: STORYBOARD.url ?? null,
   frame: DESIGN,
+  browserHeader: BROWSER_HEADER,
   supersample: SUPERSAMPLE,
   started_at: new Date(T0).toISOString(),
   steps: [],

package/skill/SKILL.md

@@ -9,7 +9,7 @@ You are the camera operator, the director, and the editor. You film a real brows
 
 All scripts live in `scripts/` beside this file. They are plain Node ESM. Requirements: Node 18+. `npx demobite` installs Playwright, ffmpeg and ffprobe beside the skill; every script resolves the media tools through `scripts/media-tools.mjs` (a compatible system build first, then the packaged one). Never call `ffmpeg` or `ffprobe` by bare name in a new script. Run every script from the project directory so `.recorder/` lands next to the project.
 
-Follow the phases in order. Never skip the storyboard approval. Never ingest before the human's word — for DemoBites, Approve on the in-app preview page IS the word. For a batch of briefs the word was given twice already, on the batch and on each storyboard: a delivered take becomes a bite by itself (see Batch of briefs).
+Follow the phases in order. Never skip the storyboard approval: the human's yes on the storyboard, in the chat, is the word for the take. After that the take is delivered by itself. It becomes a bite in DemoBites without a second click, and the human watches it come in on their Demos grid (`<base>/demos`). Never send them to a preview page to approve it.
 
 ## Phase 0: Auth gate, ALWAYS FIRST — with the human's word
 
@@ -39,10 +39,13 @@ surprise the human with a browser page):**
      for their word.
 
 Gating first is deliberate: fail before minutes of filming and know the
-target workspace up front. Bite-plan limits are NOT your concern and never
-block you: staging always succeeds, takes wait in the product queue, and the
-plan gate lives on the Approve button in DemoBites. Never mention quota in
-the terminal — if the workspace is full, the product does the talking.
+target workspace up front. Plan limits are NOT your concern and never block
+you: staging always succeeds. When the account has no recording minutes
+left, DemoBites KEEPS the take and it waits on the Demos grid, where a strip
+shows the waiting takes with the upgrade door. `upload.mjs` prints one line
+for that ("Kept. The take is waiting for recording minutes..."); relay it
+as it is. Never add numbers, prices or quota talk of your own, the product
+does the talking.
 To sign out: `node scripts/login.mjs --logout` (revokes the key server-side
 AND strips it locally). "Log me out of DemoBites" means exactly that command.
 
@@ -52,7 +55,7 @@ Look for `.recorder/config.json` next to the project. If it exists, use it and a
 
 - **app**: the product's name as it should appear in titles.
 - **url**: the starting URL of the flow.
-- **frame**: fixed at 1920x1080 for now, do not ask, just record it.
+- **frame**: 1920x1080, never asked. DemoBites adds the dark macOS browser header on top of every take at ingest, as for an uploaded video; a workspace rule that negates it ("No browser header on the takes.") turns it off. The manifest and the recipe carry `frame` and `browserHeader` for the record.
 - **base**: defaults to `https://app.demobites.com`, only ask if the human mentions a different environment.
 
 Write the answers to `.recorder/config.json` and never ask again:
@@ -61,13 +64,29 @@ Write the answers to `.recorder/config.json` and never ask again:
 {
   "app": "Acme",
   "url": "https://app.acme.com",
-  "frame": { "width": 1920, "height": 1080 },
   "base": "https://app.demobites.com"
 }
 ```
 
 `login.mjs` later merges `api_key` and `workspace` into this same file and chmods it 600. Treat the file as secret once a key is in it. Never print `api_key`.
 
+## Phase 1b: Workspace rules, EVERY run
+
+The workspace admin can write standing rules for the recorder in plain words, one per line, in the DemoBites settings tab "Agentic Recorder Rules" ("Mask any number with a dollar sign.", "Never open the Billing page.", "Say Update Center, never changelog."). They apply to every take filmed in that workspace. At the start of EVERY run, batch or free prompt, right after the key resolves the workspace and BEFORE any storyboard:
+
+```bash
+node scripts/rules.mjs [<takeDir>]     # fetches the rules fresh, writes .recorder/rules.json, prints them numbered
+```
+
+It fetches `GET <base>/api/recorder/rules` with the recorder key (never cached). When the fetch fails it falls back to the snapshot the claim wrote into `<takeDir>/brief.json` (`workspaceRules`), then to no rules, and prints which of the three it used; repeat that line in your report. Then:
+
+- Fold the rules into your storyboard thinking as **standing rules of the workspace, BELOW the filming laws**. A rule never lifts a law: an irreversible action stays pointed at and never pressed, Cancel is never a beat, the human still approves every storyboard, and nothing is published or shared.
+- Every beat a rule shaped carries `"rules": [1, 3]` (the rule numbers as printed), and the storyboard carries `"rulesVersion": <version>` at the top. The presentation shows "Rules applied: 1, 3" on those beats and lists the rules once. A rule that cannot be honoured in this flow is said out loud in the presentation, never silently dropped.
+- The prep, take and cleanup legs obey the rules too (a "never open" page is never opened, not even off camera).
+- Masking rules ("mask emails", "hide amounts") become `hideCss` rules or text masks with what the skill has today: find the element on the live page (Phase 4) and blank it with `color: transparent` plus a soft `text-shadow`, `filter: blur(6px)`, or `display: none` when the element may vanish. Keep masked words out of `narration` and `on_screen` too.
+- Vocabulary rules ("say X, never Y") win over vocab.json for that noun, as long as X appears in the app or the rule; the rule is the admin's word.
+- `record.mjs` copies `rulesVersion` into `recipe.config`, and `manifest.mjs` into the stage manifest, so a re-take can tell which rule set it was filmed under.
+
 ## Phase 2: Target-app sign-in, only when a login wall appears
 
 The camera browser uses a persistent profile at `.recorder/profile`. Signed in sessions survive between takes.
@@ -92,6 +111,17 @@ node scripts/vocab.mjs <takeDir> <url of every screen the take visits>
 
 It opens each screen on the recorder profile, without video, hovers the rail so tooltips render, and writes `<takeDir>/vocab.json`: nav labels with their tooltips and aria labels, page headings, button and link labels, dialog titles. **Every noun in `narration` and `on_screen` must appear in vocab.json.** The brief's and the PR's words are hints about WHAT changed and where to look; when a brief's noun is missing from the app, say so in the storyboard presentation ("the brief says allowlist, the app says Who can enter") and use the app's word.
 
+### Phase 3b: When you sit in the app's repository, read it FIRST
+
+A developer runs this skill from the project that IS the app (founder, 2026-09-17: developers have the code; product and marketing people do not). When the working directory holds the app's source, use it before you write a storyboard, the way you would read a map:
+
+- **Routes and navigation**: the router (app or pages directory, the route table, the nav component) tells you the address of every screen the brief names. Start each storyboard on that address; never open the root and search.
+- **Controls and selectors**: the components give you the real labels, titles, roles and test ids of the controls the flow presses. Prefer a selector from the source (text, title, aria, data attributes) over one guessed from a screenshot; never a positional chain.
+- **Data and its undo**: the handlers behind Create, Add, Move, Delete tell you what an action makes and what puts it back. That is the `prep[]` and `cleanup[]` plan; write it from the code, then verify it on the live page.
+- **Gates**: feature flags and plan gates in the code tell you which screens need a plan or a role before the camera walks into a wall.
+
+The live page stays the truth: what the code names a thing is not what the demo calls it (Phase 3a, vocab.json wins for every noun in narration and on_screen), and a route in the code is not a screen until you have seen it deployed at the target address. Read only what the flow touches (routing, navigation, UI strings, the mutation handlers), not the whole codebase. Never put code names, file paths, flags or internal state names into narration or on screen. Without a repository (a brief pasted into an empty project) you have the live app alone: harvest, probe, and ask when a screen cannot be found.
+
 ### LAW: the camera shows an action to its end
 
 The agent sits on the running product with a signed-in account. It knows the flow. It performs it. A take that walks into an empty page and narrates "if there were something here" is forbidden; so is "here you would see" (founder, 2026-09-14).
@@ -134,7 +164,7 @@ Holding shots to cover estimated lines is what produced a 60 second take with th
 
 **LAW: page transitions are cut and faded, never watched.** When the story moves to another page, the viewer sees page one, a short fade, page two — never the loading blank. record.mjs stamps every mid-take `goto` and manifest.mjs cuts that window out with a fade (`cuts` in the wire manifest); the ingestion lays it on the bite as a timeline cut. No zoom and no narration live inside a cut (the studio forbids both), so put the line about the new page on the beat AFTER it has landed, and say goodbye to the old page BEFORE the goto.
 
-Storyboard schema:
+Storyboard schema (`rulesVersion` and per-step `rules` come from Phase 1b):
 
 ```json
 {
@@ -153,7 +183,7 @@ Storyboard schema:
 }
 ```
 
-Step fields: `action` is one of `goto | settle | scroll | click | hover | type | expect`. **Durations (`dwell`, `after`, settle `ms`, scroll `ms`) are milliseconds; a value under 60 is read as seconds** (write `"dwell": 3400` or `"dwell": 3.4`, never `"dwell": 3` meaning 3 ms). `goto` needs `url`. `settle` takes `ms` and an optional `focus` selector. `scroll` needs `dy` and takes `ms`. `click`/`hover` need `selector` and take `minY` (minimum Y for the visible instance pick), `dwell`, `after`, `waitLoad`. Every step takes `label` and `narration`.
+Step fields: `action` is one of `goto | settle | scroll | click | hover | type | expect`. `rules` (optional, any step) lists the numbers of the workspace rules that shaped the beat; the storyboard's top-level `rulesVersion` names the rule set (Phase 1b). **Durations (`dwell`, `after`, settle `ms`, scroll `ms`) are milliseconds; a value under 60 is read as seconds** (write `"dwell": 3400` or `"dwell": 3.4`, never `"dwell": 3` meaning 3 ms). `goto` needs `url`. `settle` takes `ms` and an optional `focus` selector. `scroll` needs `dy` and takes `ms`. `click`/`hover` need `selector` and take `minY` (minimum Y for the visible instance pick), `dwell`, `after`, `waitLoad`. Every step takes `label` and `narration`.
 
 Beyond `steps`, a storyboard may carry the off-camera blocks (Phase 3a/law above); `cleanup.mjs` runs them on the same profile without video:
 
@@ -273,23 +303,23 @@ Send the TRIMMED CLEAN take into DemoBites. The studio owns the look: NO backdro
 node scripts/trim.mjs <takeDir>             # raw.webm -> clean.mp4, trim from record_from ONLY
 node scripts/calibrate.mjs <takeDir>        # anchor-measure the clock against the footage
 node scripts/manifest.mjs <takeDir>         # internal manifest -> manifest.demobites.json (wire schema)
-node scripts/upload.mjs <takeDir>           # STAGE the take + open the in-app preview (refuses an uncleaned take)
+node scripts/upload.mjs <takeDir>           # STAGE + DELIVER the take, open the Demos grid (refuses an uncleaned take)
 ```
 
-**The human word lives in the product now.** `upload.mjs` stages the take (the
-ZIP for ingestion plus a playable MP4 for the player), opens the DemoBites
-preview page in the human's browser, and polls while they decide THERE.
-Approve on that page runs the ingest; Discard deletes the staged take and this
-script reports it so you adjust and refilm. There is no local review.html for
-this ending — the preview page is the review.
+**Every take is delivered by itself** (founder ruling 2026-09-25). `upload.mjs` stages the take (the ZIP for ingestion plus a playable MP4), uploads both, then calls the delivery door. There is no Approve click and no preview page to send the human to: the word was the storyboard yes in the chat. The script opens the human's Demos grid (`<base>/demos`, `--no-open` skips it) and prints one of two lines:
 
-What the human approves on that page is the **picture and the coverage**, never the script. The page deliberately shows no quoted lines and no timestamps, because the ingestion rewrites the narration and refits it to the video. Presenting "this line at 0:05" promises something the system does not deliver. A retake is only for a wrong picture: private data on screen, or a missing step in the flow.
+- **Delivered:** `Delivered. Watch it come in: <base>/demos`. The card for the take shows it ingesting on the grid. Without `--stage-only` the script then waits for the bite to finish and prints the receipt (see the law below).
+- **Kept, waiting for minutes:** `Kept. The take is waiting for recording minutes (back on <date>). Watch it here: <base>/demos`. The account has no recording minutes left. The take is safe on the server and waits on the same grid, next to the upgrade door. Tell the human exactly that, nothing more; do not refilm, do not stage it again.
+
+Any other answer is an error: the script says what failed and `node scripts/status.mjs <takeDir>` tries the delivery again (the server is idempotent). `staged.json` in the take directory records `stagingId`, `dashboardUrl`, `delivered`, `waiting`, `resetsAt` and `biteId` (plus `previewUrl`, kept only for older readers; never give it to the human). Tell the human to watch the Demos grid, never the preview link.
+
+If the take is wrong (private data on screen, a missing step in the flow), say so, adjust and film again; the human removes the unwanted bite in the app.
 
 ### LAW: never hand over a studio link before the bite is ready
 
 `ingest` only STARTS the pipeline. Transcode, rescript, fit, synthesize and finalize all happen after the call returns, so a link printed at that moment leads to a half built bite with grey silent rows, which is exactly what the founder walked into on 2026-08-08.
 
-`upload.mjs` now polls `/api/recorder/status` until the bite reaches `completed` and prints what actually landed. **Read that line before you say anything to the human.** It reports `narrationReady/narrationTotal` segments with real audio behind them, and the camera shot count. If narration is 0, or ready is below total, or shots are 0, say so plainly and investigate. Do not pass on a link with a warning above it as though it were a success.
+After a delivered take, `upload.mjs` polls `/api/recorder/status` until the bite reaches `completed` and prints what actually landed. **Read that line before you say anything to the human.** It reports `narrationReady/narrationTotal` segments with real audio behind them, and the camera shot count. If narration is 0, or ready is below total, or shots are 0, say so plainly and investigate. Do not pass on a link with a warning above it as though it were a success.
 
 ## Phase 7: Re-take (Launch plan and up)
 
@@ -312,10 +342,9 @@ Laws for a re-take:
 - **The narration in the recipe is the ORIGINAL intent.** Do not rewrite it to taste: the server replaces it
   with the bite's current text per step. Only remove lines whose beats you dropped.
 - **Same pacing laws apply** (intro, narrate the path, linger, cut and fade on page transitions).
-- **The human approves in-app.** The preview page says "Re-take of <bite>". Approve replaces the recording in
-  that bite; the previous recording is kept for rollback, never overwritten. A re-take filmed from a brief
-  (a take with an attempt) is delivered instead: the new recording replaces the current one by itself, and
-  the promoted export stays as it is until a version is published.
+- **The re-take is delivered like every take.** The new recording replaces the current one in that bite by
+  itself; the previous recording is kept for rollback, never overwritten, and the promoted export stays as it
+  is until a version is published. The human watches it on the Demos grid.
 
 ## Batch of briefs (GitHub PR → demos)
 
@@ -326,22 +355,22 @@ node scripts/briefs.mjs list <batchId> [--paste bundle.txt]        # the approve
 node scripts/briefs.mjs claim <batchId> <briefId>                   # mints an attempt, creates take-<briefId>-r<revision>/brief.json
 node scripts/briefs.mjs event <takeDir> planning|awaiting_storyboard_approval|recording|uploading|failed|cancelled [--note "..."]
 node scripts/briefs.mjs release <takeDir>                           # give the brief back (cancelled)
-node scripts/upload.mjs <takeDir> --stage-only --no-open            # deliver: the take becomes a bite by itself, do not wait
+node scripts/upload.mjs <takeDir> --stage-only --no-open            # deliver: the take becomes a bite by itself (or waits for minutes), do not wait
 node scripts/status.mjs <takeDir>                                   # later: wait for the bite to finish (retries a failed delivery)
-node scripts/status.mjs --all                                       # one look at every delivered take here
+node scripts/status.mjs --all                                       # one look at every delivered or waiting take here
 ```
 
 The procedure, in order:
 
 1. `list` first, always, with `--paste` when the human pasted text. Work from the server's briefs, never from the paste, and say so when they differ.
 2. Claim the briefs you are about to film, one `claim` each. A claim answers "active attempt" when another agent or an earlier run holds the brief: show the human the attempt reference and its start time, and only with their word claim again with `--force`.
-3. Run `vocab.mjs` over the screens each brief visits, then write every storyboard (Phase 3) with the brief as the spec and vocab.json as the only dictionary: the flowIntent lines are the beats, the outcome is the last beat, the exclusions are things the camera never shows, and the take stays under the brief's `maxSeconds` (90). Send `event <takeDir> planning` when you start a storyboard and `event <takeDir> awaiting_storyboard_approval` when it is ready.
+3. Run `rules.mjs <takeDir>` (Phase 1b; the claim stored the batch's rules snapshot in brief.json as the fallback) and `vocab.mjs` over the screens each brief visits, then write every storyboard (Phase 3) with the brief as the spec, the workspace rules below the laws, and vocab.json as the only dictionary: the flowIntent lines are the beats, the outcome is the last beat, the exclusions are things the camera never shows, and the take stays under the brief's `maxSeconds` (90). Send `event <takeDir> planning` when you start a storyboard and `event <takeDir> awaiting_storyboard_approval` when it is ready.
 4. **Show the storyboards together, get a word on each one.** One message can carry all of them, but every brief gets its own yes or no. Never take one yes as a yes for the batch. A brief the human declines gets `release`.
-5. Film sequentially, never in parallel: one Chrome on the profile. Per take: `event recording` → Phase 4 dry run → `cleanup.mjs --prep` when declared → Phase 5 take → `cleanup.mjs` (revert, checks.after) → trim, calibrate, manifest → `upload.mjs <takeDir> --stage-only --no-open`. Report, per take, what was created and what was reverted, with the before/after checks. `upload.mjs` reads `brief.json`, moves the attempt to uploading, stages with the attempt on the payload, and after the two uploads calls the delivery route: the take becomes a bite in DemoBites by itself, no Approve click, and the line reads `delivered: bite <id>`. It writes `staged.json` with the staging id and the bite id.
+5. Film sequentially, never in parallel: one Chrome on the profile. Per take: `event recording` → Phase 4 dry run → `cleanup.mjs --prep` when declared → Phase 5 take → `cleanup.mjs` (revert, checks.after) → trim, calibrate, manifest → `upload.mjs <takeDir> --stage-only --no-open`. Report, per take, what was created and what was reverted, with the before/after checks. `upload.mjs` reads `brief.json`, moves the attempt to uploading, stages with the attempt on the payload, and after the two uploads calls the delivery route, as for every take: the take becomes a bite in DemoBites by itself, no Approve click, and the line reads `Delivered. Watch it come in: <base>/demos`. With no recording minutes left the line reads `Kept. The take is waiting for recording minutes...`; the take waits on the grid, go on with the next brief. It writes `staged.json` with the staging id, the grid link, and the bite id or the waiting state.
 6. **A failed brief never stops the others.** On a failure send `event <takeDir> failed --note "<what happened>"`, keep the take directory for diagnosis, and continue with the next brief. Report every failure plainly at the end.
-7. When all takes are delivered, tell the human: N takes were delivered and are becoming bites in DemoBites by themselves, with the bite ids. `status.mjs --all` shows where each stands; `status.mjs <takeDir>` waits for one to finish and prints what landed (the Phase 6 receipt law holds: no studio link before the bite is completed). A take the server would not deliver (upload.mjs printed the error) waits in the review queue; `status.mjs <takeDir>` tries the delivery again, and on an older DemoBites waits for the word in the app as before. Deliver each take; never publish, never share, never send invitations.
+7. When all takes are delivered, tell the human: N takes were delivered and are becoming bites in DemoBites by themselves, with the bite ids, and they can watch them come in on the Demos grid (`<base>/demos`). Name any take that is kept, waiting for recording minutes; it waits on the same grid. `status.mjs --all` shows where each stands; `status.mjs <takeDir>` waits for one to finish and prints what landed (the Phase 6 receipt law holds: no studio link before the bite is completed). A take the server would not deliver (upload.mjs printed the error): `status.mjs <takeDir>` tries the delivery again. Deliver each take; never publish, never share, never send invitations.
 
-Resume after an interruption from what is on disk and on the server: a `take-*` directory with `brief.json` is claimed; with `raw.webm` it was filmed; with `clean.mp4` and `manifest.demobites.json` it is ready to stage; with `staged.json` it is delivered or staged (check it with `status.mjs --no-wait`). `list` shows the server's view of every attempt. Never re-claim a brief that already has your own live attempt; never re-stage one that `staged.json` says is delivered or staged unless the human asked for a new take (`upload.mjs --supersede`).
+Resume after an interruption from what is on disk and on the server: a `take-*` directory with `brief.json` is claimed; with `raw.webm` it was filmed; with `clean.mp4` and `manifest.demobites.json` it is ready to stage; with `staged.json` it is delivered, waiting for minutes, or staged (check it with `status.mjs --no-wait`). `list` shows the server's view of every attempt. Never re-claim a brief that already has your own live attempt; never re-stage one that `staged.json` says is delivered, waiting or staged unless the human asked for a new take (`upload.mjs --supersede`).
 
 ## The wire manifest (fixed contract, version 2)
 
@@ -387,6 +416,9 @@ PUT <base>/api/recorder/device  { device_code }          (poll every `interval`
 DELETE <base>/api/recorder/key  (Authorization: Bearer <api_key>)
   -> { revoked: true }                                    (logout)
 
+GET <base>/api/recorder/rules  (Authorization: Bearer <api_key>)   // WORKSPACE RULES (1.4): never cached
+  -> { workspaceId, rules: string | null, version, updatedAt }   (the claim's api.rules is the same url; workspaceRules on the claim is the snapshot)
+
 GET <base>/api/recorder/recipe?biteId=<id>  (Authorization: Bearer <api_key>)   // RE-TAKE: the bite's recipe
   -> { storyboard, config:{app,url,frame}, manifest, engine }   (404 no recipe; 402/403 plan gate)
 
@@ -396,11 +428,13 @@ PUT <base>/api/recorder/stage  (Authorization: Bearer <api_key>)
   -> { stagingId, uploadUrl, previewUploadUrl, videoKey, previewUrl }
 
 GET <base>/api/recorder/stage?id=<stagingId>  (Authorization: Bearer <api_key>)
-  -> { status: 'pending'|'approving'|'approved'|'delivered'|'rejected', biteId, biteUKey, biteStatus, studioUrl }
+  -> { status: 'pending'|'approving'|'approved'|'delivered'|'waiting'|'rejected', biteId, biteUKey, biteStatus, studioUrl, resetsAt? }
 
-PUT <base>/api/recorder/stage/<stagingId>/uploaded  (Authorization: Bearer <api_key>)   // DELIVERY: brief takes only, after both uploads
-  {}   // the url comes from the claim's api.uploaded ("{origin}/api/recorder/stage/{id}/uploaded"); this path is the fallback
-  -> 200 { biteId, videoId } | 202 { biteId, queued:true } | 200 { pending:true } (older server: wait for the word) | 404/409 { error }
+PUT <base>/api/recorder/stage/<stagingId>/uploaded  (Authorization: Bearer <api_key>)   // DELIVERY: EVERY take, after both uploads (1.5)
+  {}   // the url comes from the claim's api.uploaded ("{origin}/api/recorder/stage/{id}/uploaded") when there is one; this path is the fallback
+  -> 202 { delivered:true, biteId, studioUrl, dashboardUrl } (also 200 { biteId, videoId } from older servers)
+   | 403 { kept:true, waiting:'minutes', resetsAt, dashboardUrl:'/demos', stagingId }   (no recording minutes: kept, waits on the grid)
+   | 200 { pending:true } (older server: waits for the word in the app) | 404/409 { error }
   // idempotent: a repeat returns the same bite
 
 GET <base>/api/recorder/status?biteId=<id>  (Authorization: Bearer <api_key>)
@@ -414,7 +448,7 @@ The upload zip contains exactly one file: `clean.mp4` stored as `recording.mp4`.
 
 ## Standing rules
 
-- Anything the human sees (storyboard presentation, review page, questions) uses commas and periods only, no dashes, and real action words. Never orphan a single word on its own line in a heading.
+- Anything the human sees (storyboard presentation, questions, reports) uses commas and periods only, no dashes, and real action words. Never orphan a single word on its own line in a heading.
 - Never touch credentials. Never print the api_key. Config and key files are chmod 600.
-- Never INGEST without the human's explicit word. For the DemoBites ending, staging for the in-app preview is HOW the word is asked — the take becomes a bite only when the human clicks Approve on that page. For a batch of briefs the word was given on the batch and on each storyboard, and delivery ingests by itself. Never publish, never share, never send invitations.
+- Never film without the human's explicit word on the storyboard. That yes, in the chat, is the word for the take: delivery ingests by itself, and the human watches the take on the Demos grid, never on a preview page. For a batch of briefs the word is given on the batch and on each storyboard. Never publish, never share, never send invitations.
 - One take directory per take, keep failed takes for diagnosis, name them `take-<slug>`, `take-<slug>2`, and so on. A take claimed from a brief is `take-<briefId>-r<revision>`.

package/skill/scripts/briefs.mjs

@@ -142,7 +142,9 @@ if (cmd === "claim") {
   const record = {
     batchId, briefId: brief.briefId, revision: brief.revision, contentHash: brief.contentHash, attemptRef: r.json.attemptRef,
     brief: r.json.brief ?? brief, target: r.json.target ?? data.batch?.target ?? null, rules: r.json.rules ?? { maxSeconds: 90 },
-    source: data.batch?.source ?? null, api: r.json.api ?? data.api ?? null, claimedAt: new Date().toISOString(),
+    source: data.batch?.source ?? null, api: r.json.api ?? data.api ?? null,
+    // WORKSPACE RULES (1.4): the claim carries a snapshot { version, text }; rules.mjs fetches fresh and falls back to it.
+    workspaceRules: r.json.workspaceRules ?? data.workspaceRules ?? null, claimedAt: new Date().toISOString(),
   };
   fs.writeFileSync(path.join(dir, "brief.json"), JSON.stringify(record, null, 2) + "\n");
   console.log(`Claimed ${brief.briefId} r${brief.revision} → ${dir}/brief.json (attempt ${r.json.attemptRef}, at most ${record.rules.maxSeconds}s)`);

package/skill/scripts/manifest.mjs

@@ -47,6 +47,8 @@ for (let i = 1; i < args.length; i++) {
 const manPath = path.join(dir, "manifest.json");
 if (!fs.existsSync(manPath)) { console.error(`${manPath} not found. Run record.mjs first.`); process.exit(1); }
 const man = JSON.parse(fs.readFileSync(manPath, "utf8"));
+// The recording's own frame (1920x1080; --viewport can change it).
+const FW = man.frame?.width ?? 1920, FH = man.frame?.height ?? 1080;
 const round2 = (x) => Math.round(x * 100) / 100;
 
 // TIMEBASE — see the law in trim.mjs. Every time in manifest.json is WALL
@@ -233,7 +235,7 @@ if (fs.existsSync(cleanPath)) {
     if (!m) return null;
     const [w, h, x, y] = m.slice(1).map(Number);
     if (!(w > 0 && h > 0)) return null;
-    const changedPx = yavg ? (parseFloat(yavg[1]) / 255) * 1920 * 1080 * SS * SS : 0;
+    const changedPx = yavg ? (parseFloat(yavg[1]) / 255) * FW * FH * SS * SS : 0;
     return { x: x / SS, y: y / SS, w: w / SS, h: h / SS, changedPx: changedPx / (SS * SS) };
   };
   for (const st of steps) {
@@ -256,7 +258,7 @@ if (fs.existsSync(cleanPath)) {
       console.log(`consequence: step ${st.n} change too sparse (${Math.round(change.changedPx)}px over ${Math.round(change.w)}x${Math.round(change.h)}) — ignored as noise`);
       continue;
     }
-    if (change.w * change.h > 1920 * 1080 * 0.85) {
+    if (change.w * change.h > FW * FH * 0.85) {
       // A navigation (the whole page swapped). The tight control shot must
       // NOT linger clamped over the new page — reset to wide, so the camera
       // "zooms back out" at the cut (founder, 2026-08-09: "you never zoomed
@@ -267,7 +269,7 @@ if (fs.existsSync(cleanPath)) {
       const wideStart = round2(st.click.t);
       const wideEnd = round2(Math.min(duration, st.t_end));
       if (wideEnd - wideStart >= 0.6) {
-        camera.push({ t_start: wideStart, t_end: wideEnd, x: 0, y: 0, w: 1920, h: 1080, n: st.n, label: `${st.label || "click"}, new page` });
+        camera.push({ t_start: wideStart, t_end: wideEnd, x: 0, y: 0, w: FW, h: FH, n: st.n, label: `${st.label || "click"}, new page` });
         camera.sort((a, b) => a.t_start - b.t_start);
       }
       console.log(`consequence: step ${st.n} navigation — reset to wide at ${wideStart}s`);
@@ -296,7 +298,7 @@ const mouseEvents = rawEvents
   .filter((e) => e.time >= 0 && e.time <= duration);
 const interactions = mouseEvents.length
   ? {
-      viewport: man.interactions?.viewport ?? { width: 1920, height: 1080 },
+      viewport: man.interactions?.viewport ?? { width: FW, height: FH },
       mouseEvents,
     }
   : null;
@@ -322,11 +324,17 @@ if (cuts.length > 0) {
   camera.push(...clipped.sort((a, b) => a.t_start - b.t_start));
 }
 
+// WORKSPACE RULES (1.4): the stage manifest names the rules version the take was filmed under.
+let rulesVersion = null;
+try { const sb = JSON.parse(fs.readFileSync(path.join(dir, "storyboard.json"), "utf8")); if (Number.isInteger(sb.rulesVersion)) rulesVersion = sb.rulesVersion; } catch {}
 const wire = {
   version: 2,
+  ...(rulesVersion !== null ? { rulesVersion } : {}),
   app: man.app ?? "App",
   title: titleArg ?? man.title ?? `${man.app ?? "App"} demo`,
-  frame: { width: 1920, height: 1080 },
+  frame: { width: FW, height: FH },
+  // BROWSER HEADER (2026-09-16): true by default; DemoBites adds the dark macOS bar on top at ingest. A workspace rule "No browser header" sets it false.
+  ...(typeof man.browserHeader === "boolean" ? { browserHeader: man.browserHeader } : {}),
   duration,
   steps,
   camera,

package/skill/scripts/retake.mjs

@@ -8,8 +8,8 @@
 // Usage: node retake.mjs <biteId> [--note "what changed"] [--take <dir>]
 //
 // Flow: recipe -> storyboard.json -> record -> trim -> calibrate (gate) ->
-// manifest -> upload --retake-of <biteId> (stages; the human approves in-app,
-// where the preview says "Re-take of <bite>").
+// manifest -> upload --retake-of <biteId> (stages and delivers into the bite;
+// the person watches it on the Demos grid).
 //
 // A step that no longer resolves makes record.mjs FAIL LOUDLY at that step.
 // That is the moment for the agent to look at the live page, fix the

package/skill/scripts/rules.mjs

@@ -0,0 +1,60 @@
+// WORKSPACE RULES (1.4, founder law 2026-09-15): standing rules the workspace
+// admin wrote in plain words, one per line, in the "Agentic Recorder Rules"
+// settings tab. Every run reads them FIRST, before any storyboard:
+//
+//   node rules.mjs [<takeDir>]     fetch GET <base>/api/recorder/rules with the recorder key,
+//                                  write .recorder/rules.json, print the rules numbered
+//
+// Fallback order, and the run log says which: fetched fresh → the snapshot in
+// <takeDir>/brief.json (workspaceRules from the claim) → no rules.
+// The rules never lift the filming laws: irreversible actions stay pointed at,
+// never pressed; Cancel is never a beat. Never print the api_key.
+import fs from "node:fs";
+import path from "node:path";
+
+const takeDir = process.argv.slice(2).find((a) => !a.startsWith("--")) ?? null;
+const cfgPath = path.resolve(".recorder", "config.json");
+let cfg = {};
+try { cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8")); } catch {}
+if (!cfg.api_key || !cfg.base) { console.error("No recorder key. Run: node scripts/login.mjs"); process.exit(1); }
+const base = cfg.base.replace(/\/+$/, "");
+
+let snapshot = null;
+let rulesUrl = `${base}/api/recorder/rules`;
+if (takeDir) {
+  try {
+    const b = JSON.parse(fs.readFileSync(path.join(takeDir, "brief.json"), "utf8"));
+    if (b.workspaceRules && typeof b.workspaceRules.text === "string") snapshot = { version: Number(b.workspaceRules.version) || 0, text: b.workspaceRules.text };
+    if (typeof b.api?.rules === "string" && /^https?:\/\//.test(b.api.rules)) rulesUrl = b.api.rules;
+  } catch { /* no brief.json: a free-prompt run */ }
+}
+
+let result = null; // { version, text, source, updatedAt }
+try {
+  const res = await fetch(rulesUrl, { headers: { Authorization: `Bearer ${cfg.api_key}`, "Cache-Control": "no-cache" } });
+  if (res.status === 401) { console.error("The recorder key was refused. Run: node scripts/login.mjs"); process.exit(1); }
+  const json = await res.json().catch(() => null);
+  if (res.ok && json && "version" in json) {
+    result = { version: Number(json.version) || 0, text: typeof json.rules === "string" ? json.rules : "", source: "fetched", updatedAt: json.updatedAt ?? null, workspaceId: json.workspaceId ?? null };
+  } else if (res.status === 404 && !json?.error) {
+    console.error("This DemoBites has no workspace rules route yet (older server).");
+  } else {
+    console.error(`Rules fetch answered ${res.status}${json?.error ? ` ${json.error}` : ""}.`);
+  }
+} catch (e) { console.error(`Rules fetch failed: ${e.message}`); }
+if (!result && snapshot) result = { ...snapshot, source: "snapshot", updatedAt: null, workspaceId: null };
+if (!result) result = { version: 0, text: "", source: "none", updatedAt: null, workspaceId: null };
+
+// One rule per line; a leading bullet or dash the admin typed is not part of the rule.
+const lines = result.text.split(/\r?\n/).map((s) => s.trim().replace(/^[•·\-*]+\s*/, "").trim()).filter(Boolean);
+const out = { ...result, lines, fetchedAt: new Date().toISOString() };
+try { fs.mkdirSync(path.dirname(cfgPath), { recursive: true }); fs.writeFileSync(path.resolve(".recorder", "rules.json"), JSON.stringify(out, null, 2) + "\n"); } catch (e) { console.error(`rules.json not written: ${e.message}`); }
+
+const where = result.source === "fetched" ? "fetched from DemoBites" : result.source === "snapshot" ? "from the batch snapshot in brief.json (the fetch failed)" : "none (the fetch failed and no snapshot)";
+console.log(`Workspace rules: version ${result.version}, ${where}.`);
+if (lines.length === 0) console.log("No standing rules. The filming laws alone apply.");
+else {
+  console.log("Standing rules of the workspace, below the filming laws (they never lift them):");
+  lines.forEach((l, i) => console.log(`  ${i + 1}. ${l}`));
+  console.log(`Record "rulesVersion": ${result.version} in the storyboard and list the rules applied on each beat.`);
+}

package/skill/scripts/stage-wait.mjs

@@ -10,14 +10,43 @@
 // Returns { exitCode, status, biteId, studioUrl } and never throws.
 //
 // DELIVERY (1.3.0, founder ruling 2026-09-14): a take filmed from a brief
-// becomes a bite by itself once its ZIP is uploaded; no Approve click. The
-// server answers status "delivered" from then on, and the wait here is only
-// for the bite to finish. Free-prompt takes still wait for the word.
+// becomes a bite by itself once its ZIP is uploaded; no Approve click.
+// DIRECT DELIVERY (1.5.0, founder ruling 2026-09-25): EVERY take is delivered
+// that way, plain prompt takes too. The person watches it come in on the
+// Demos grid (<base>/demos), never on the preview page. A take the account
+// has no recording minutes for is KEPT by the server (403 { kept: true,
+// waiting: "minutes", resetsAt, dashboardUrl, stagingId }) and waits on the
+// same grid; the stage status reads "waiting" until minutes are back.
+
+/** Where the person watches their takes: the Demos grid. `dashboardUrl` from
+ * the server wins (relative or absolute), else <base>/demos. */
+export function gridUrl(base, dashboardUrl) {
+  try { return new URL(dashboardUrl || "/demos", base + "/").toString(); } catch { return `${base}/demos`; }
+}
+
+/** "October 1, 2026" from an ISO date, or null when there is none. */
+export function formatResetDate(resetsAt) {
+  if (!resetsAt) return null;
+  const d = new Date(resetsAt);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toLocaleDateString("en-US", { month: "long", day: "numeric", year: "numeric", timeZone: "UTC" });
+}
+
+/** The one line a person reads when a take is kept for recording minutes. */
+export function waitingLine(grid, resetsAt) {
+  const when = formatResetDate(resetsAt);
+  return `Kept. The take is waiting for recording minutes${when ? ` (back on ${when})` : ""}. Watch it here: ${grid}`;
+}
 
 /** PUT the delivery route for a staged take. `template` is the claim's
  * api.uploaded ("{origin}/api/recorder/stage/{id}/uploaded", literal {id});
  * the fallback is the same path under the configured base. Idempotent on the
- * server: a repeat returns the same bite. Never throws. */
+ * server: a repeat returns the same bite. Never throws.
+ * Returns one of:
+ *   { delivered: true, biteId, videoId, studioUrl, dashboardUrl, queued }
+ *   { delivered: false, waiting: "minutes", kept: true, resetsAt, dashboardUrl }
+ *   { delivered: false, pending: true }              (older server)
+ *   { delivered: false, error } */
 export async function deliverStaged({ base, apiKey, stagingId, template }) {
   const url = template && template.includes("{id}")
     ? template.replace("{id}", encodeURIComponent(stagingId))
@@ -28,7 +57,17 @@ export async function deliverStaged({ base, apiKey, stagingId, template }) {
   } catch (e) { return { delivered: false, httpStatus: 0, error: `DemoBites unreachable (${e.message})` }; }
   const json = await res.json().catch(() => null);
   if ((res.status === 200 || res.status === 202) && json?.biteId) {
-    return { delivered: true, biteId: json.biteId, videoId: json.videoId ?? null, queued: res.status === 202 || json.queued === true, httpStatus: res.status };
+    return {
+      delivered: true, biteId: json.biteId, videoId: json.videoId ?? null, studioUrl: json.studioUrl ?? null,
+      dashboardUrl: json.dashboardUrl ?? null, queued: res.status === 202 || json.queued === true, httpStatus: res.status,
+    };
+  }
+  // No recording minutes left: the server KEEPS the take; it waits on the grid.
+  if (res.status === 403 && json?.kept === true) {
+    return {
+      delivered: false, kept: true, waiting: json.waiting ?? "minutes", resetsAt: json.resetsAt ?? null,
+      dashboardUrl: json.dashboardUrl ?? null, httpStatus: res.status,
+    };
   }
   // An older server: { pending: true }, or no such route at all (a 404 without an error body).
   if ((res.ok && json?.pending) || (res.status === 404 && !json?.error)) return { delivered: false, pending: true, httpStatus: res.status };
@@ -42,7 +81,7 @@ export async function waitForDecision({ base, apiKey, stagingId, pageUrl, delive
   let completed = false;
   let approvedBiteId = null;
   let finalStudioUrl = null;
-  process.stdout.write(delivered ? "Waiting for the bite to finish" : "Waiting for your word in the browser");
+  process.stdout.write(delivered ? "Waiting for the bite to finish" : "Checking the take in DemoBites");
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, pollMs));
     let res;
@@ -52,6 +91,12 @@ export async function waitForDecision({ base, apiKey, stagingId, pageUrl, delive
     if (!res.ok) { process.stdout.write("."); continue; }
     const st = await res.json().catch(() => null);
     if (!st) { process.stdout.write("."); continue; }
+    if (st.status === "waiting") {
+      // Kept for recording minutes: nothing will finish until they are back.
+      process.stdout.write("\n");
+      console.log(waitingLine(pageUrl, st.resetsAt));
+      return { exitCode: 0, status: "waiting", biteId: null, studioUrl: null };
+    }
     if (st.status === "rejected") {
       process.stdout.write("\n");
       console.error("Discarded in the app. Adjust the storyboard and film again.");
@@ -77,11 +122,11 @@ export async function waitForDecision({ base, apiKey, stagingId, pageUrl, delive
   }
   if (!announced) {
     process.stdout.write("\n");
-    console.error(delivered ? `The server does not show the delivered bite yet. Look again later: ${pageUrl}` : `No decision yet. The preview stays available at:\n  ${pageUrl}`);
+    console.error(delivered ? `The server does not show the delivered bite yet. Watch it here: ${pageUrl}` : `No decision yet. The take stays on your Demos grid:\n  ${pageUrl}`);
     return { exitCode: 1, status: "pending", biteId: null, studioUrl: null };
   }
   if (!completed) {
-    console.error(`${delivered ? "Delivered" : "Approved"}, but the bite did not finish within the wait window. Do not share the link yet — poll /api/recorder/status or reload the preview page.`);
+    console.error(`${delivered ? "Delivered" : "Approved"}, but the bite did not finish within the wait window. Do not share the link yet — watch it on your Demos grid: ${pageUrl}`);
     return { exitCode: 1, status: delivered ? "delivered" : "approved", biteId: approvedBiteId, studioUrl: null };
   }
 

package/skill/scripts/status.mjs

@@ -1,17 +1,18 @@
 // Where a staged take stands, and the wait for its word.
 //
-//   node status.mjs <takeDir>            wait for the decision (or, delivered, for the bite to finish); reads <takeDir>/staged.json
+//   node status.mjs <takeDir>            wait for the delivered bite to finish; reads <takeDir>/staged.json
 //                                        a take whose delivery failed is delivered again here first (idempotent on the server)
 //   node status.mjs <stagingId>          same, by id
-//   node status.mjs <takeDir> --no-wait  one look, no waiting: pending | delivered (+bite status) | approved (+bite status) | rejected
+//   node status.mjs <takeDir> --no-wait  one look, no waiting: delivered (+bite status) | waiting for recording minutes | pending | rejected
 //   node status.mjs --all                one look at every take-*/staged.json under the current directory
 //
-// A batch stages every take with `upload.mjs --stage-only --no-open`, then the
-// agent (or the human, later) comes back here per take. The same law as
-// upload.mjs: no studio link before the bite is completed.
+// A batch delivers every take with `upload.mjs --stage-only --no-open`, then
+// the agent (or the human, later) comes back here per take. The page the
+// person opens is the Demos grid (<base>/demos), never the preview page. The
+// same law as upload.mjs: no studio link before the bite is completed.
 import fs from "node:fs";
 import path from "node:path";
-import { waitForDecision, peekStaged, deliverStaged } from "./stage-wait.mjs";
+import { waitForDecision, peekStaged, deliverStaged, gridUrl, formatResetDate, waitingLine } from "./stage-wait.mjs";
 
 const args = process.argv.slice(2);
 const noWait = args.includes("--no-wait");
@@ -27,6 +28,7 @@ let cfg = {};
 try { cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8")); } catch {}
 if (!cfg.api_key || !cfg.base) { console.error("No recorder key. Run: node scripts/login.mjs"); process.exit(1); }
 const base = cfg.base.replace(/\/+$/, "");
+const defaultGrid = gridUrl(base, null);
 
 function readStaged(dir) {
   const p = path.join(dir, "staged.json");
@@ -39,6 +41,10 @@ function describe(st) {
   if (st.status === "rejected") return "discarded in the app";
   if (st.status === "delivered") return `delivered, bite ${st.biteId ?? "?"} ${st.biteStatus ?? "processing"}`;
   if (st.status === "approved") return `approved, bite ${st.biteId ?? "?"} ${st.biteStatus ?? "processing"}`;
+  if (st.status === "waiting") {
+    const when = formatResetDate(st.resetsAt);
+    return `waiting for recording minutes${when ? ` (back on ${when})` : ""}`;
+  }
   return "waiting for the word in the app";
 }
 
@@ -48,8 +54,9 @@ if (all) {
   for (const d of dirs) {
     const staged = readStaged(d);
     const st = staged?.stagingId ? await peekStaged({ base, apiKey: cfg.api_key, stagingId: staged.stagingId }) : { ok: false, httpStatus: 0 };
-    console.log(`${d.padEnd(40)} ${describe(st)}${staged?.previewUrl ? `\n${"".padEnd(40)} ${staged.previewUrl}` : ""}`);
+    console.log(`${d.padEnd(40)} ${describe(st)}`);
   }
+  console.log(`Watch them here: ${defaultGrid}`);
   process.exit(0);
 }
 
@@ -60,27 +67,36 @@ if (fs.existsSync(target) && fs.statSync(target).isDirectory()) {
   const staged = readStaged(target);
   if (!staged?.stagingId) { console.error(`${target} has no staged.json. Stage it first: node scripts/upload.mjs ${target} --stage-only`); process.exit(1); }
   stagingId = staged.stagingId;
-  pageUrl = staged.previewUrl ?? null;
+  pageUrl = staged.dashboardUrl ?? null;
   delivered = staged.delivered === true;
-  // A brief take whose delivery failed (network, 409) is delivered again here;
-  // the server is idempotent. An older server (pending) is left alone.
-  if (staged.attemptRef && staged.delivered === false && staged.pending !== true) {
+  // A take whose delivery failed (network, 409) is delivered again here; the
+  // server is idempotent. An older server (pending) and a kept take (waiting
+  // for minutes, the server holds it) are left alone.
+  if (staged.delivered === false && staged.pending !== true && !staged.waiting) {
     const d = await deliverStaged({ base, apiKey: cfg.api_key, stagingId, template: staged.api?.uploaded ?? null });
+    const grid = gridUrl(base, d.dashboardUrl ?? staged.dashboardUrl);
+    pageUrl = grid;
+    const write = (patch) => { try { fs.writeFileSync(path.join(target, "staged.json"), JSON.stringify({ ...staged, dashboardUrl: grid, ...patch }, null, 2) + "\n"); } catch {} };
     if (d.delivered) {
       delivered = true;
-      console.log(`delivered: bite ${d.biteId}${d.queued ? " (ingest queued)" : ""}. It becomes a bite in DemoBites by itself.`);
-      try { fs.writeFileSync(path.join(target, "staged.json"), JSON.stringify({ ...staged, delivered: true, biteId: d.biteId, videoId: d.videoId ?? null, queued: d.queued ?? null, deliveryError: null }, null, 2) + "\n"); } catch {}
+      console.log(`Delivered. Watch it come in: ${grid}`);
+      write({ delivered: true, waiting: null, biteId: d.biteId, videoId: d.videoId ?? null, studioUrl: d.studioUrl ?? null, queued: d.queued ?? null, deliveryError: null });
+    } else if (d.waiting) {
+      console.log(waitingLine(grid, d.resetsAt));
+      write({ waiting: d.waiting, resetsAt: d.resetsAt ?? null, deliveryError: null });
+      process.exit(0);
     } else if (d.pending) {
-      try { fs.writeFileSync(path.join(target, "staged.json"), JSON.stringify({ ...staged, pending: true }, null, 2) + "\n"); } catch {}
-      console.log("This DemoBites does not deliver by itself yet; the take waits for the word in the app.");
-    } else console.error(`Not delivered: ${d.error}. The take waits in the review queue.`);
+      write({ pending: true });
+      console.log(`This DemoBites does not deliver by itself yet; the take waits for the word in the app. Watch it here: ${grid}`);
+    } else console.error(`Not delivered: ${d.error}. Try again later with: node scripts/status.mjs ${target}\nYour demos: ${grid}`);
   }
 }
-if (!pageUrl) pageUrl = `${base}/recording-preview/agentic/${encodeURIComponent(stagingId)}`;
+if (!pageUrl) pageUrl = defaultGrid;
 
 if (noWait) {
   const st = await peekStaged({ base, apiKey: cfg.api_key, stagingId });
   console.log(`${stagingId}: ${describe(st)}`);
+  console.log(`Watch it here: ${pageUrl}`);
   if (st.ok && (st.status === "approved" || st.status === "delivered") && st.biteStatus === "completed" && st.studioUrl) console.log(`Studio: ${new URL(st.studioUrl, base).toString()}`);
   process.exit(st.ok ? 0 : 1);
 }

package/skill/scripts/upload.mjs

@@ -1,17 +1,20 @@
 #!/usr/bin/env node
-// DemoBites ending — STAGE the take and hand the word to the product.
+// DemoBites ending — STAGE the take and DELIVER it.
 //
-// The human word lives in the app now (founder, 2026-08-09): this script
-// zips clean.mp4, stages it together with a playable preview MP4, opens the
-// in-app preview page, and POLLS while the human decides there. Approve on
-// that page runs the same ingest as the old machine lane; Discard reports
-// back here so the operator adjusts and refilms. No local review.html for
-// this ending anymore.
+// DIRECT DELIVERY (1.5.0, founder ruling 2026-09-25): this script zips
+// clean.mp4, stages it together with a playable MP4, uploads both, then calls
+// the uploaded door. The take becomes a bite by itself; the person watches it
+// come in on their Demos grid (<base>/demos), never on the preview page. When
+// the account has no recording minutes left the server KEEPS the take and it
+// waits on the same grid, next to the upgrade door.
 //
 // Contracts (fixed, coded verbatim):
 //   PUT  <base>/api/recorder/stage  (Bearer)
 //        { filename, sizeBytes, previewSizeBytes, manifest }
 //     -> { stagingId, uploadUrl, previewUploadUrl, videoKey, previewUrl }
+//   PUT  <base>/api/recorder/stage/<stagingId>/uploaded  (Bearer)   after both uploads, EVERY take
+//     -> 202 { delivered: true, biteId, studioUrl, dashboardUrl }
+//      | 403 { kept: true, waiting: "minutes", resetsAt, dashboardUrl, stagingId }
 //   GET  <base>/api/recorder/stage?id=<stagingId>  (Bearer)
 //     -> { status, biteId, biteUKey, biteStatus, studioUrl }
 //
@@ -31,7 +34,7 @@ if (!dir) {
 }
 // RE-TAKE (2026-09-02): `--retake-of <biteId>` stages this take as a NEW RECORDING
 // of an existing bite instead of a new bite. The server keeps the bite's current
-// narration text, voice, intro/outro and look; the human approves in-app.
+// narration text, voice, intro/outro and look; the take is delivered into it.
 const retakeIdx = process.argv.indexOf("--retake-of");
 const retakeOfBiteId = retakeIdx >= 0 ? Number(process.argv[retakeIdx + 1]) : null;
 if (retakeIdx >= 0 && !(Number.isInteger(retakeOfBiteId) && retakeOfBiteId > 0)) { console.error("--retake-of needs a bite id"); process.exit(2); }
@@ -47,11 +50,9 @@ const retakeNote = noteIdx >= 0 ? String(process.argv[noteIdx + 1] ?? "").trim()
 // opts out. `--stage-only` returns right after the two uploads (the batch
 // waits with status.mjs); `--supersede` replaces a stage already pinned to
 // this attempt (the server refuses a second one otherwise).
-// DELIVERY (1.3.0, founder ruling 2026-09-14): a take with an attempt becomes
-// a bite by itself. After both uploads this script PUTs the delivery route
-// (the claim's api.uploaded, fallback <base>/api/recorder/stage/<id>/uploaded)
-// and prints "delivered: bite <id>". No Approve click, no review queue for
-// brief batches. Free-prompt takes (no attempt) still stage for review.
+// DELIVERY (1.3.0 for brief takes, 1.5.0 for every take): after both uploads
+// this script PUTs the delivery route (the claim's api.uploaded when there is
+// one, fallback <base>/api/recorder/stage/<id>/uploaded). No Approve click.
 const stageOnly = process.argv.includes("--stage-only");
 const supersede = process.argv.includes("--supersede");
 const attemptIdx = process.argv.indexOf("--attempt");
@@ -77,13 +78,18 @@ if (!cfg.api_key || !cfg.base) {
   process.exit(1);
 }
 const base = cfg.base.replace(/\/+$/, "");
-// A delivered take is a bite already; staging it again would make a second one.
+// A delivered take is a bite already, and a kept take waits on the server;
+// staging either again would make a second one.
 try {
   const prev = JSON.parse(fs.readFileSync(path.join(dir, "staged.json"), "utf8"));
   if (prev?.delivered === true && prev.biteId && !supersede) {
     console.error(`${dir} was already delivered as bite ${prev.biteId}. See where it stands: node scripts/status.mjs ${dir}. For a new take of it, stage again with --supersede.`);
     process.exit(1);
   }
+  if (prev?.waiting && !supersede) {
+    console.error(`${dir} is already kept in DemoBites, waiting for recording minutes. See where it stands: node scripts/status.mjs ${dir}. For a new take of it, stage again with --supersede.`);
+    process.exit(1);
+  }
 } catch { /* not staged yet */ }
 
 const cleanPath = path.join(dir, "clean.mp4");
@@ -193,7 +199,7 @@ if (!zipped) {
 fs.rmSync(staging, { recursive: true, force: true });
 const sizeBytes = fs.statSync(zipPath).size;
 console.log(`take.zip ready (${(sizeBytes / 1024 / 1024).toFixed(1)} MB, ${zipped ? "system zip" : "store method"})`);
-if (retakeOfBiteId) console.log(`Staging as a RE-TAKE of bite ${retakeOfBiteId} — the new recording replaces the current one inside that bite ${attempt ? "by itself once delivered" : "once approved"}.`);
+if (retakeOfBiteId) console.log(`Staging as a RE-TAKE of bite ${retakeOfBiteId} — the new recording replaces the current one inside that bite by itself once delivered.`);
 
 // ── stage ──────────────────────────────────────────────────────────────────
 const authHeaders = { Authorization: `Bearer ${cfg.api_key}`, "Content-Type": "application/json" };
@@ -228,7 +234,7 @@ if (!stageRes.ok) {
   if (errBody?.error === "quota_exceeded") {
     // Should not happen anymore — staging is quota-free by design. Neutral
     // fallback if an older server answers this way.
-    console.error(`DemoBites declined the stage. Check ${base}/bites and try again.`);
+    console.error(`DemoBites declined the stage. Check ${base}/demos and try again.`);
     process.exit(1);
   }
   if (errBody?.error === "invalid_attempt") {
@@ -236,14 +242,14 @@ if (!stageRes.ok) {
     process.exit(1);
   }
   if (errBody?.error === "attempt_already_staged") {
-    console.error(`This attempt already has a staged take${errBody.stagingId ? ` (${errBody.stagingId})` : ""}. Review that one, or stage again with --supersede to replace it.`);
+    console.error(`This attempt already has a staged take${errBody.stagingId ? ` (${errBody.stagingId})` : ""}. Keep that one, or stage again with --supersede to replace it.`);
     process.exit(1);
   }
   console.error(`Stage failed: ${stageRes.status} ${errBody ? JSON.stringify(errBody) : ""}`);
   process.exit(1);
 }
 const { stagingId, uploadUrl, previewUploadUrl, previewUrl, queueUrl, pendingCount } = await stageRes.json();
-if (!stagingId || !uploadUrl || !previewUploadUrl || !previewUrl) {
+if (!stagingId || !uploadUrl || !previewUploadUrl) {
   console.error("Stage response missing fields.");
   process.exit(1);
 }
@@ -263,68 +269,59 @@ async function putS3(url, contentType, filePath, label) {
 await putS3(uploadUrl, "application/zip", zipPath, "ZIP");
 await putS3(previewUploadUrl, "video/mp4", cleanPath, "Preview");
 
-// ── delivery (brief batches): the take becomes a bite by itself ────────────
-// Only a take carrying an attempt is delivered. Free-prompt takes never call
-// this route, so their flow is unchanged: staged, then the word in the app.
-let delivery = null;
-if (attempt) {
-  const { deliverStaged } = await import("./stage-wait.mjs");
-  delivery = await deliverStaged({ base, apiKey: cfg.api_key, stagingId, template: uploadedTemplate });
-}
+// ── delivery: EVERY take becomes a bite by itself ─────────────────────────
+const { deliverStaged, waitForDecision, gridUrl, waitingLine } = await import("./stage-wait.mjs");
+const delivery = await deliverStaged({ base, apiKey: cfg.api_key, stagingId, template: uploadedTemplate });
+const grid = gridUrl(base, delivery.dashboardUrl);
 // The staging id used to be printed only; a batch resumes from disk, so it is
 // persisted next to the take (status.mjs reads it, and retries a delivery
-// that failed).
-const pageUrl = new URL(previewUrl, base).toString();
+// that failed). previewUrl stays for older readers; the person's page is
+// dashboardUrl, the Demos grid.
+const previewPage = previewUrl ? new URL(previewUrl, base).toString() : null;
 try {
   fs.writeFileSync(path.join(dir, "staged.json"), JSON.stringify({
-    stagingId, previewUrl: pageUrl, queueUrl: queueUrl ? new URL(queueUrl, base).toString() : null,
+    stagingId, previewUrl: previewPage, dashboardUrl: grid, queueUrl: queueUrl ? new URL(queueUrl, base).toString() : null,
     pendingCount: pendingCount ?? null, attemptRef: attempt?.attemptRef ?? null, briefId: attempt?.briefId ?? null,
-    delivered: delivery ? delivery.delivered : null, biteId: delivery?.biteId ?? null, videoId: delivery?.videoId ?? null,
-    queued: delivery?.queued ?? null, pending: delivery?.pending ?? null, deliveryError: delivery?.error ?? null,
+    delivered: delivery.delivered === true, waiting: delivery.waiting ?? null, resetsAt: delivery.resetsAt ?? null,
+    biteId: delivery.biteId ?? null, videoId: delivery.videoId ?? null, studioUrl: delivery.studioUrl ? new URL(delivery.studioUrl, base).toString() : null,
+    queued: delivery.queued ?? null, pending: delivery.pending ?? null, deliveryError: delivery.error ?? null,
     api: uploadedTemplate ? { uploaded: uploadedTemplate } : null, at: new Date().toISOString(),
   }, null, 2) + "\n");
 } catch (e) { console.error(`staged.json not written: ${e.message}`); }
 
-if (delivery?.delivered) {
-  console.log(`delivered: bite ${delivery.biteId}${delivery.queued ? " (ingest queued)" : ""}. It becomes a bite in DemoBites by itself.\n  ${pageUrl}`);
-  if (stageOnly) { console.log(`Delivered only. Wait for the bite to finish later with: node scripts/status.mjs ${dir}`); process.exit(0); }
-  const { waitForDecision } = await import("./stage-wait.mjs");
-  const outcome = await waitForDecision({ base, apiKey: cfg.api_key, stagingId, pageUrl, delivered: true });
-  process.exit(outcome.exitCode);
-}
-if (delivery && !delivery.pending) {
-  console.error(`Staged, but not delivered: ${delivery.error}. The take waits in the review queue:\n  ${pageUrl}\nTry the delivery again later with: node scripts/status.mjs ${dir}`);
-  process.exit(1);
-}
-if (delivery?.pending) console.log("This DemoBites does not deliver by itself yet; the take waits for the word in the app.");
-
-// ── open the in-app preview — the review happens THERE ─────────────────────
-// Batch etiquette (founder, 2026-08-11): when takes are stacked for a later
-// review sprint, auto-opening a tab per take is spam. `--no-open` (or
-// config.open_preview === false) stages silently — the queue pill and the
-// printed URL carry the message. Default stays open: for a single take the
-// opened page IS the consent moment.
-console.log(`Staged. Review and approve in the browser:\n  ${pageUrl}`);
-if (typeof pendingCount === "number" && pendingCount > 1 && queueUrl) {
-  console.log(`${pendingCount} takes are now waiting for review: ${new URL(queueUrl, base).toString()}`);
-}
+// Single take: the grid opens in the browser, the person watches the card
+// come in there. A batch passes --no-open (or config.open_preview === false)
+// and the printed link carries the message.
 const noOpen = process.argv.includes("--no-open") || cfg.open_preview === false;
-if (!noOpen) {
+function openGrid() {
+  if (noOpen) return;
   try {
     const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-    spawnSync(opener, [pageUrl], { stdio: "ignore" });
-  } catch { /* printing the URL above is the fallback */ }
+    spawnSync(opener, [grid], { stdio: "ignore" });
+  } catch { /* the printed link is the fallback */ }
 }
 
-if (stageOnly) {
-  console.log(`Staged only. Wait for the decision later with: node scripts/status.mjs ${dir}`);
+if (delivery.delivered) {
+  console.log(`Delivered. Watch it come in: ${grid}`);
+  openGrid();
+  if (stageOnly) { console.log(`Wait for the bite to finish later with: node scripts/status.mjs ${dir}`); process.exit(0); }
+  // LAW (founder 2026-08-08): no studio link before the bite is completed.
+  const outcome = await waitForDecision({ base, apiKey: cfg.api_key, stagingId, pageUrl: grid, delivered: true });
+  process.exit(outcome.exitCode);
+}
+if (delivery.waiting) {
+  console.log(waitingLine(grid, delivery.resetsAt));
+  openGrid();
   process.exit(0);
 }
-
-// ── poll while the human decides, then until the bite is READY ─────────────
-// Shared with status.mjs (a batch waits there). The law it enforces: never
-// hand a human a studio link before the bite is finished; Approve only
-// STARTS the pipeline.
-const { waitForDecision } = await import("./stage-wait.mjs");
-const outcome = await waitForDecision({ base, apiKey: cfg.api_key, stagingId, pageUrl });
-process.exit(outcome.exitCode);
+if (delivery.pending) {
+  // An older DemoBites that does not deliver by itself: the take waits for
+  // the word in the app. Still no preview link as the destination.
+  console.log(`Staged. This DemoBites does not deliver by itself yet; the take waits for the word in the app. Watch it here: ${grid}`);
+  openGrid();
+  if (stageOnly) { console.log(`Wait for it later with: node scripts/status.mjs ${dir}`); process.exit(0); }
+  const outcome = await waitForDecision({ base, apiKey: cfg.api_key, stagingId, pageUrl: grid });
+  process.exit(outcome.exitCode);
+}
+console.error(`Staged, but not delivered: ${delivery.error}. Try the delivery again with: node scripts/status.mjs ${dir}\nYour demos: ${grid}`);
+process.exit(1);