demobite 1.4.0 → 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
 
@@ -134,7 +128,7 @@ npx demobite retake <biteId> --note "Export moved to the header"
 
 **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. A delivered take becomes a Bite in DemoBites by itself; there is no second review click for these takes. Nothing is published or shared.
+**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:
 
@@ -153,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "demobite",
-  "version": "1.4.0",
+  "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/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.
 
@@ -300,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)
 
@@ -339,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)
 
@@ -353,9 +355,9 @@ 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:
@@ -364,11 +366,11 @@ The procedure, in order:
 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 `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)
 
@@ -426,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>)
@@ -444,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/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/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);