demobites 1.4.0 → 1.7.0

package/skill/scripts/retake.mjs

@@ -5,16 +5,28 @@
 // is fetched from DemoBites; the server keeps the bite's CURRENT narration
 // text, voice, intro/outro and look, and refits camera, cuts and audio.
 //
-// Usage: node retake.mjs <biteId> [--note "what changed"] [--take <dir>]
+// Usage: node retake.mjs <biteId> [--note "what changed"] [--take <dir>] [--fresh]
 //
-// 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>").
+//   --take <dir>   film into an existing take dir. Its storyboard.json is the
+//                  SOURCE OF TRUTH and is never overwritten: fix a selector in
+//                  it and run again with --take, the fix stays. The recipe is
+//                  written only when the file is absent.
+//   --fresh        with --take: discard the dir's storyboard.json and write
+//                  the bite's recipe again.
+//
+// Flow (the same legs, the same scripts, as a normal take — see batch.mjs):
+// recipe -> storyboard.json -> cleanup.mjs --prep (when the storyboard
+// declares prep[] / checks.before[]) -> record -> cleanup.mjs (when it
+// declares cleanup[] / checks.after[]) -> trim -> calibrate (gate) ->
+// manifest -> upload --retake-of <biteId> (stages and delivers into the bite;
+// the person watches it on the Demos grid). upload.mjs refuses a take whose
+// storyboard declares cleanup[] until cleanup.json passes, so the cleanup leg
+// is not optional here.
 //
 // 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
 // storyboard (or drop the beat AND its line, and tell the human what is gone),
-// and run again. Nothing is staged until every step resolves.
+// and run again with --take. Nothing is staged until every step resolves.
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -22,19 +34,34 @@ import { spawnSync } from "node:child_process";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const args = process.argv.slice(2);
+const USAGE = 'Usage: node retake.mjs <biteId> [--note "what changed"] [--take <dir>] [--fresh]';
+if (args.includes("--help") || args.includes("-h")) { console.log(USAGE); process.exit(0); }
 const biteId = Number(args[0]);
 if (!Number.isInteger(biteId) || biteId <= 0) {
-  console.error('Usage: node retake.mjs <biteId> [--note "what changed"] [--take <dir>]');
+  console.error(USAGE);
   process.exit(2);
 }
 const opt = (name) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined; };
 const note = opt("--note") ?? "";
+const fresh = args.includes("--fresh");
 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(/\/+$/, "");
 
+// Where the scripts are: installed, every script sits beside this file; in the
+// package repository record/trim/calibrate live in ../../scripts (batch.mjs
+// resolves the same two layouts).
+function scriptPath(name) {
+  for (const dir of [here, path.resolve(here, "..", "..", "scripts")]) {
+    const p = path.join(dir, name);
+    if (fs.existsSync(p)) return p;
+  }
+  console.error(`${name} not found beside ${here}. Run \`npx demobite\` to refresh the skill.`);
+  process.exit(1);
+}
+
 // 1. The recipe — the bite's DNA.
 const res = await fetch(`${base}/api/recorder/recipe?biteId=${biteId}`, { headers: { Authorization: `Bearer ${cfg.api_key}` } });
 if (res.status === 404) {
@@ -48,26 +75,57 @@ if (res.status === 402 || res.status === 403) {
 }
 if (!res.ok) { console.error(`Could not fetch the recipe (${res.status}).`); process.exit(1); }
 const recipe = await res.json();
-const storyboard = recipe.storyboard;
-if (!storyboard?.steps?.length) { console.error("The recipe has no storyboard steps."); process.exit(1); }
+if (!recipe.storyboard?.steps?.length) { console.error("The recipe has no storyboard steps."); process.exit(1); }
 
-// 2. Take dir + files.
+// 2. Take dir + files. With --take, an existing storyboard.json in the dir is
+// the source of truth (the "fix a selector, run again" loop); the recipe is
+// written only when the file is absent, or when --fresh asks for it.
 let takeDir = opt("--take");
 if (!takeDir) { let n = 1; while (fs.existsSync(`take-retake-${biteId}${n > 1 ? n : ""}`)) n++; takeDir = `take-retake-${biteId}${n > 1 ? n : ""}`; }
 fs.mkdirSync(takeDir, { recursive: true });
 const sbPath = path.join(takeDir, "storyboard.json");
-fs.writeFileSync(sbPath, JSON.stringify(storyboard, null, 2));
+let storyboard;
+if (fs.existsSync(sbPath) && !fresh) {
+  try { storyboard = JSON.parse(fs.readFileSync(sbPath, "utf8")); } catch (e) { console.error(`${sbPath} is not valid JSON (${e.message}). Fix it, or start over with --fresh.`); process.exit(1); }
+  if (!storyboard?.steps?.length) { console.error(`${sbPath} has no steps. Fix it, or start over with --fresh.`); process.exit(1); }
+  console.log(`Using the storyboard already in ${sbPath} (kept as is; --fresh replaces it from the recipe).`);
+} else {
+  storyboard = recipe.storyboard;
+  fs.writeFileSync(sbPath, JSON.stringify(storyboard, null, 2));
+  if (fresh) console.log(`${sbPath} replaced from the recipe (--fresh).`);
+}
 fs.writeFileSync(path.join(takeDir, "retake.json"), JSON.stringify({ biteId, note, engine: recipe.engine ?? null, fetchedAt: new Date().toISOString() }, null, 2));
-console.log(`Re-take of bite ${biteId} — ${storyboard.steps.length} steps from the recipe${recipe.engine ? ` (filmed by ${recipe.engine})` : ""}.`);
+console.log(`Re-take of bite ${biteId} — ${storyboard.steps.length} steps${recipe.engine ? ` (filmed by ${recipe.engine})` : ""}.`);
 if (note) console.log(`Note from the human: ${note}`);
+const hasPrep = (storyboard.prep?.length ?? 0) > 0 || (storyboard.checks?.before?.length ?? 0) > 0;
+const hasCleanup = (storyboard.cleanup?.length ?? 0) > 0 || (storyboard.checks?.after?.length ?? 0) > 0;
 
-// 3. Film -> trim -> calibrate (gate) -> manifest -> stage.
-const run = (script, extra) => spawnSync("node", [path.join(here, script), ...extra], { stdio: "inherit", cwd: process.cwd() });
-let r = run("record.mjs", [takeDir, sbPath]);
+// 3. Prep (off camera) -> film -> cleanup (off camera) -> trim -> calibrate
+// (gate) -> manifest -> stage. The same child scripts a normal take runs.
+const run = (script, extra) => spawnSync("node", [scriptPath(script), ...extra], { stdio: "inherit", cwd: process.cwd() });
+const again = `node scripts/retake.mjs ${biteId} --take ${takeDir}${note ? ` --note ${JSON.stringify(note)}` : ""}`;
+let r;
+if (hasPrep) {
+  console.log("Prep, off camera (storyboard.prep[] then checks.before[])...");
+  r = run("cleanup.mjs", [takeDir, "--prep"]);
+  if (r.status !== 0) {
+    console.error(`\nPrep did not pass (see ${path.join(takeDir, "prep.json")}). Nothing was filmed. Fix prep[] / checks.before[] in ${sbPath}, then run:\n  ${again}`);
+    process.exit(r.status ?? 1);
+  }
+}
+r = run("record.mjs", [takeDir, sbPath]);
 if (r.status !== 0) {
-  console.error(`\nThe take stopped at a step that no longer resolves. Look at the live page, fix the storyboard in ${sbPath}\n(or drop the beat and its line, and tell the human what is gone), then run:\n  node scripts/retake.mjs ${biteId} --take ${takeDir}${note ? ` --note ${JSON.stringify(note)}` : ""}`);
+  console.error(`\nThe take stopped at a step that no longer resolves. Look at the live page, fix the storyboard in ${sbPath}\n(or drop the beat and its line, and tell the human what is gone), then run:\n  ${again}`);
   process.exit(r.status ?? 1);
 }
+if (hasCleanup) {
+  console.log("Cleanup, off camera (storyboard.cleanup[] then checks.after[])...");
+  r = run("cleanup.mjs", [takeDir]);
+  if (r.status !== 0) {
+    console.error(`\nCleanup did not pass (see ${path.join(takeDir, "cleanup.json")}); the workspace may still carry what the take created, and upload.mjs will not stage it until cleanup.json says ok.\nFix cleanup[] / checks.after[] in ${sbPath} if a step no longer resolves, then, without filming again:\n  node scripts/cleanup.mjs ${takeDir}\n  node scripts/trim.mjs ${takeDir} && node scripts/calibrate.mjs ${takeDir} && node scripts/manifest.mjs ${takeDir}\n  node scripts/upload.mjs ${takeDir} --retake-of ${biteId}${note ? ` --note ${JSON.stringify(note)}` : ""}`);
+    process.exit(4);
+  }
+}
 r = run("trim.mjs", [takeDir]); if (r.status !== 0) process.exit(r.status ?? 1);
 r = run("calibrate.mjs", [takeDir]);
 if (r.status !== 0) { console.error("Calibration failed — do not stage this take. Investigate record_from / anchors and film again."); process.exit(3); }

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 };
   }
 
@@ -104,6 +149,125 @@ export async function waitForDecision({ base, apiKey, stagingId, pageUrl, delive
   return { exitCode: 0, status: "completed", biteId: approvedBiteId, studioUrl: finalStudioUrl };
 }
 
+// ── RE-TAKE: wait for the NEW version, not the bite ────────────────────────
+// A re-take (`upload.mjs --retake-of <biteId>`) lands INSIDE a bite that is
+// already `completed`: the server ingests the new recording as a new
+// uploaded_videos row + a 'processing' recipe row, and finalize's atomic swap
+// repoints the bite and flips that row to 'live'. The bite's status never
+// leaves `completed`, so waitForDecision returned on its first poll and
+// printed the PREVIOUS version's receipt (bite 1110 read 45.1s where the new
+// take was 44.6s, 2026-09-27). The marker that moves exactly at the swap and
+// that a recorder key can read is the LIVE recipe (GET /api/recorder/recipe):
+// after the swap its manifest is the one this take staged. The ingest
+// rewrites only steps[].narration.text (the bite's current lines), so the
+// manifest's duration and step windows survive verbatim and identify THIS
+// take. When the status route ever reports the bite's video id
+// (`videoId`), it is compared to the delivery's videoId first.
+
+/** What a staged manifest leaves on the live recipe: duration + step windows. */
+export function manifestFingerprint(manifest) {
+  if (!manifest || typeof manifest !== "object") return null;
+  const steps = Array.isArray(manifest.steps) ? manifest.steps : [];
+  if (!Number.isFinite(Number(manifest.duration)) && steps.length === 0) return null;
+  return JSON.stringify({
+    d: manifest.duration ?? null,
+    s: steps.map((s, i) => [s?.n ?? i + 1, s?.t_start ?? null, s?.t_end ?? null]),
+  });
+}
+
+/** The live recipe's fingerprint as the server sees it now, or null when it cannot be read. */
+export async function readLiveRecipeFingerprint({ base, apiKey, biteId }) {
+  try {
+    const res = await fetch(`${base}/api/recorder/recipe?biteId=${encodeURIComponent(biteId)}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+    if (!res.ok) return null;
+    const recipe = await res.json().catch(() => null);
+    return manifestFingerprint(recipe?.manifest);
+  } catch { return null; }
+}
+
+/** GET /api/recorder/status for a bite, or null when it cannot be read. */
+export async function readBiteStatus({ base, apiKey, biteId }) {
+  try {
+    const res = await fetch(`${base}/api/recorder/status?biteId=${encodeURIComponent(biteId)}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+    if (!res.ok) return null;
+    return await res.json().catch(() => null);
+  } catch { return null; }
+}
+
+/** The numbers the receipt prints; two equal reads in a row mean the post-swap manifest application has settled. */
+function receiptKey(st) {
+  return st ? JSON.stringify([st.status, st.durationSec ?? null, st.zooms ?? null, st.narrationTotal ?? null, st.narrationReady ?? null, st.title ?? null]) : null;
+}
+
+/** Wait until the re-take is the bite's live recording, then print ITS receipt.
+ *  `manifest` is the staged wire manifest, `before` the live fingerprint read
+ *  BEFORE staging (null when unknown), `videoId` the delivery's new video id.
+ *  Returns { exitCode, status, biteId, studioUrl } and never throws. */
+export async function waitForRetake({ base, apiKey, biteId, videoId = null, manifest = null, before = null, pageUrl, studioUrl = null, timeoutMs = 30 * 60 * 1000, pollMs = 4000, settleMs = 30 * 1000 }) {
+  const ours = manifestFingerprint(manifest);
+  if (ours && before && ours === before) {
+    console.error("Note: the bite's live recording already carries this take's manifest; the receipt below may describe it rather than a newer version.");
+  }
+  const deadline = Date.now() + timeoutMs;
+  let landed = false;
+  let how = null;
+  process.stdout.write(`Waiting for the new recording to land in bite ${biteId}`);
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, pollMs));
+    const st = await readBiteStatus({ base, apiKey, biteId });
+    if (st?.status === "failed") {
+      process.stdout.write("\n");
+      console.error(`The pipeline FAILED while re-taking bite ${biteId}. The bite keeps its previous recording. Do not hand over any link — investigate.`);
+      return { exitCode: 1, status: "failed", biteId, studioUrl: null };
+    }
+    // 1. The server names the bite's video: exact.
+    if (videoId && st && Number.isFinite(Number(st.videoId))) {
+      if (Number(st.videoId) === Number(videoId)) { landed = true; how = "video"; break; }
+      process.stdout.write("."); continue;
+    }
+    // 2. The live recipe carries this take's manifest: exact. Or it moved
+    //    away from what was live before staging: this take, or a newer one.
+    const fp = await readLiveRecipeFingerprint({ base, apiKey, biteId });
+    if (fp && ours && fp === ours) { landed = true; how = "recipe"; break; }
+    if (fp && before && fp !== before) { landed = true; how = "moved"; break; }
+    process.stdout.write(".");
+  }
+  process.stdout.write("\n");
+  if (!landed) {
+    console.error(`The new recording has not landed in bite ${biteId} within the wait window; the bite still plays its previous version. No receipt for the new one yet — watch it on your Demos grid: ${pageUrl}\n(wait again later with: node scripts/status.mjs <takeDir>)`);
+    return { exitCode: 1, status: "delivered", biteId, studioUrl: null };
+  }
+  console.log(`New recording landed in bite ${biteId}${how === "moved" ? " (the live recording changed after staging)" : ""}.`);
+
+  // The swap is followed by the manifest application (camera shots, narration
+  // rows) on the new version; read until the numbers hold still.
+  let last = await readBiteStatus({ base, apiKey, biteId });
+  const settleDeadline = Date.now() + settleMs;
+  let prevKey = receiptKey(last);
+  while (Date.now() < settleDeadline) {
+    await new Promise((r) => setTimeout(r, Math.min(pollMs, 3000)));
+    const st = await readBiteStatus({ base, apiKey, biteId });
+    const key = receiptKey(st);
+    if (st && key === prevKey && st.status === "completed" && (st.narrationTotal ?? 0) === (st.narrationReady ?? 0)) { last = st; break; }
+    if (st) { last = st; prevKey = key; }
+  }
+  if (last && last.status === "completed") {
+    console.log(
+      `Ready (new recording): "${last.title}" — ${last.durationSec ? last.durationSec.toFixed(1) + "s, " : ""}` +
+      `${last.narrationReady}/${last.narrationTotal} narration segments with audio, ${last.zooms} camera shots`,
+    );
+    if (last.narrationTotal === 0) console.error("WARNING: no narration segments landed. The voice will be silent.");
+    else if (last.narrationReady < last.narrationTotal) console.error(`WARNING: ${last.narrationTotal - last.narrationReady} segment(s) have no audio behind them.`);
+    if (last.zooms === 0) console.error("WARNING: no camera shots landed.");
+  } else {
+    console.error(`The new recording landed but the status door did not answer with a completed bite${last?.status ? ` (${last.status})` : ""}. Watch it here: ${pageUrl}`);
+    return { exitCode: 1, status: last?.status ?? "unknown", biteId, studioUrl: null };
+  }
+  const finalStudioUrl = studioUrl ? new URL(studioUrl, base).toString() : null;
+  if (finalStudioUrl) console.log(`Studio: ${finalStudioUrl}`);
+  return { exitCode: 0, status: "completed", biteId, studioUrl: finalStudioUrl };
+}
+
 /** One look, no waiting: the staged take's current status as the server sees it. */
 export async function peekStaged({ base, apiKey, stagingId }) {
   const res = await fetch(`${base}/api/recorder/stage?id=${encodeURIComponent(stagingId)}`, { headers: { Authorization: `Bearer ${apiKey}` } });

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, waitForRetake, 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,42 +54,62 @@ 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);
 }
 
 let stagingId = target;
 let pageUrl = null;
 let delivered = false;
+// A re-take (staged with --retake-of) waits for its NEW version, not the bite,
+// which is completed already; upload.mjs left the baseline in staged.json.
+let retake = null;
 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) {
+  if (Number.isInteger(staged.retakeOfBiteId) && staged.retakeOfBiteId > 0) {
+    let manifest = null;
+    try { manifest = JSON.parse(fs.readFileSync(path.join(target, "manifest.demobites.json"), "utf8")); } catch {}
+    retake = { biteId: staged.retakeOfBiteId, before: staged.retakeBefore ?? null, videoId: staged.videoId ?? null, studioUrl: staged.studioUrl ?? null, manifest };
+  }
+  // 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);
 }
 
-const outcome = await waitForDecision({ base, apiKey: cfg.api_key, stagingId, pageUrl, delivered });
+const outcome = retake && delivered
+  ? await waitForRetake({ base, apiKey: cfg.api_key, biteId: retake.biteId, videoId: retake.videoId, manifest: retake.manifest, before: retake.before, pageUrl, studioUrl: retake.studioUrl })
+  : await waitForDecision({ base, apiKey: cfg.api_key, stagingId, pageUrl, delivered });
 process.exit(outcome.exitCode);