demobite 1.0.9 → 1.2.0

package/skill/scripts/status.mjs

@@ -0,0 +1,72 @@
+// Where a staged take stands, and the wait for its word.
+//
+//   node status.mjs <takeDir>            wait for the decision, then for the bite to finish (reads <takeDir>/staged.json)
+//   node status.mjs <stagingId>          same, by id
+//   node status.mjs <takeDir> --no-wait  one look, no waiting: pending | approved (+bite status) | 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.
+import fs from "node:fs";
+import path from "node:path";
+import { waitForDecision, peekStaged } from "./stage-wait.mjs";
+
+const args = process.argv.slice(2);
+const noWait = args.includes("--no-wait");
+const all = args.includes("--all");
+const target = args.find((a) => !a.startsWith("--"));
+if (!target && !all) {
+  console.error("Usage: node status.mjs <takeDir|stagingId> [--no-wait]   |   node status.mjs --all");
+  process.exit(2);
+}
+
+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(/\/+$/, "");
+
+function readStaged(dir) {
+  const p = path.join(dir, "staged.json");
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function describe(st) {
+  if (!st.ok) return `unreachable (${st.httpStatus})`;
+  if (st.status === "rejected") return "discarded in the app";
+  if (st.status === "approved") return `approved, bite ${st.biteId ?? "?"} ${st.biteStatus ?? "processing"}`;
+  return "waiting for the word in the app";
+}
+
+if (all) {
+  const dirs = fs.readdirSync(".").filter((d) => d.startsWith("take-") && fs.existsSync(path.join(d, "staged.json")));
+  if (dirs.length === 0) { console.log("No staged takes here."); process.exit(0); }
+  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}` : ""}`);
+  }
+  process.exit(0);
+}
+
+let stagingId = target;
+let pageUrl = 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;
+}
+if (!pageUrl) pageUrl = `${base}/recording-preview/agentic/${encodeURIComponent(stagingId)}`;
+
+if (noWait) {
+  const st = await peekStaged({ base, apiKey: cfg.api_key, stagingId });
+  console.log(`${stagingId}: ${describe(st)}`);
+  if (st.ok && st.status === "approved" && 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 });
+process.exit(outcome.exitCode);

package/skill/scripts/upload.mjs

@@ -40,6 +40,28 @@ if (retakeIdx >= 0 && !(Number.isInteger(retakeOfBiteId) && retakeOfBiteId > 0))
 // history show why this version was filmed. Never a secret, never required.
 const noteIdx = process.argv.indexOf("--note");
 const retakeNote = noteIdx >= 0 ? String(process.argv[noteIdx + 1] ?? "").trim().slice(0, 600) : "";
+// BATCH OF BRIEFS (2026-09-13): a take claimed from a brief carries its attempt
+// (briefId, revision, contentHash, attemptRef) so provenance rides into the
+// staged take and the bite. Read from <takeDir>/brief.json (written by
+// briefs.mjs claim) unless --attempt <file> points elsewhere or --no-attempt
+// 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).
+const stageOnly = process.argv.includes("--stage-only");
+const supersede = process.argv.includes("--supersede");
+const attemptIdx = process.argv.indexOf("--attempt");
+const attemptPath = process.argv.includes("--no-attempt")
+  ? null
+  : attemptIdx >= 0 ? String(process.argv[attemptIdx + 1] ?? "") : path.join(dir, "brief.json");
+let attempt = null;
+if (attemptPath && fs.existsSync(attemptPath)) {
+  try {
+    const b = JSON.parse(fs.readFileSync(attemptPath, "utf8"));
+    if (b.briefId && b.revision !== undefined && b.contentHash && b.attemptRef) {
+      attempt = { briefId: String(b.briefId), revision: b.revision, contentHash: String(b.contentHash), attemptRef: String(b.attemptRef) };
+    } else console.error(`${attemptPath} is missing briefId/revision/contentHash/attemptRef; staging without an attempt`);
+  } catch (e) { console.error(`${attemptPath} unreadable (${e.message}); staging without an attempt`); }
+} else if (attemptIdx >= 0) { console.error(`--attempt ${attemptPath} not found`); process.exit(2); }
 const cfgPath = path.resolve(".recorder", "config.json");
 let cfg = {};
 try { cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8")); } catch {}
@@ -65,6 +87,22 @@ try {
     if (retakeNote) recipe.config = { ...(recipe.config ?? {}), retake_note: retakeNote };
   }
 } catch (e) { console.error("recipe skipped:", e.message); }
+// LAW (founder 2026-09-14): a take that created anything returns the workspace
+// to its initial state before it is staged. The storyboard declares cleanup[];
+// cleanup.mjs writes cleanup.json with the checks. No passing cleanup.json,
+// no stage. --allow-uncleaned overrides, and says so out loud.
+try {
+  const sbp = path.join(dir, "storyboard.json");
+  const sb = fs.existsSync(sbp) ? JSON.parse(fs.readFileSync(sbp, "utf8")) : {};
+  if (Array.isArray(sb.cleanup) && sb.cleanup.length > 0) {
+    const cp = path.join(dir, "cleanup.json");
+    const rep = fs.existsSync(cp) ? JSON.parse(fs.readFileSync(cp, "utf8")) : null;
+    if (!rep || rep.ok !== true) {
+      if (process.argv.includes("--allow-uncleaned")) console.error("WARNING: staging a take whose cleanup did not run or did not pass (--allow-uncleaned). The workspace may still carry what the take created.");
+      else { console.error(`This take declares cleanup[] but ${rep ? "cleanup.json says NOT ok" : "cleanup.json is missing"}. Run: node scripts/cleanup.mjs ${dir}  (then stage again)`); process.exit(1); }
+    }
+  }
+} catch (e) { console.error(`cleanup check skipped: ${e.message}`); }
 if (!fs.existsSync(cleanPath)) { console.error(`${cleanPath} not found. Run: node scripts/trim.mjs ${dir}`); process.exit(1); }
 if (!fs.existsSync(wirePath)) { console.error(`${wirePath} not found. Run: node scripts/manifest.mjs ${dir}`); process.exit(1); }
 const manifest = JSON.parse(fs.readFileSync(wirePath, "utf8"));
@@ -144,13 +182,23 @@ if (retakeOfBiteId) console.log(`Staging as a RE-TAKE of bite ${retakeOfBiteId}
 
 // ── stage ──────────────────────────────────────────────────────────────────
 const authHeaders = { Authorization: `Bearer ${cfg.api_key}`, "Content-Type": "application/json" };
+if (attempt) {
+  // The attempt moves to "uploading" before the stage call; a 409 here means
+  // the server already sees it at or past that state, which is fine.
+  try {
+    const ev = await fetch(`${base}/api/recorder/briefs/attempts/${encodeURIComponent(attempt.attemptRef)}`, {
+      method: "PUT", headers: authHeaders, body: JSON.stringify({ event: "uploading" }),
+    });
+    if (!ev.ok && ev.status !== 409) console.error(`attempt event "uploading" → ${ev.status} (continuing)`);
+  } catch (e) { console.error(`attempt event "uploading" failed: ${e.message} (continuing)`); }
+}
 const previewSizeBytes = fs.statSync(cleanPath).size;
 let stageRes;
 try {
   stageRes = await fetch(`${base}/api/recorder/stage`, {
     method: "PUT",
     headers: authHeaders,
-    body: JSON.stringify({ filename: "take.zip", sizeBytes, previewSizeBytes, manifest, ...(recipe ? { recipe } : {}), ...(retakeOfBiteId ? { retakeOfBiteId } : {}) }),
+    body: JSON.stringify({ filename: "take.zip", sizeBytes, previewSizeBytes, manifest, ...(recipe ? { recipe } : {}), ...(retakeOfBiteId ? { retakeOfBiteId } : {}), ...(attempt ? { attempt } : {}), ...(attempt && supersede ? { supersede: true } : {}) }),
   });
 } catch (e) {
   console.error(`Could not reach ${base}: ${e.message}`);
@@ -168,6 +216,14 @@ if (!stageRes.ok) {
     console.error(`DemoBites declined the stage. Check ${base}/bites and try again.`);
     process.exit(1);
   }
+  if (errBody?.error === "invalid_attempt") {
+    console.error(`DemoBites refused the attempt on this take: ${errBody.message ?? "invalid_attempt"}. Re-claim the brief (node scripts/briefs.mjs claim …) and stage again.`);
+    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.`);
+    process.exit(1);
+  }
   console.error(`Stage failed: ${stageRes.status} ${errBody ? JSON.stringify(errBody) : ""}`);
   process.exit(1);
 }
@@ -191,6 +247,14 @@ async function putS3(url, contentType, filePath, label) {
 }
 await putS3(uploadUrl, "application/zip", zipPath, "ZIP");
 await putS3(previewUploadUrl, "video/mp4", cleanPath, "Preview");
+// 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).
+try {
+  fs.writeFileSync(path.join(dir, "staged.json"), JSON.stringify({
+    stagingId, previewUrl: new URL(previewUrl, base).toString(), queueUrl: queueUrl ? new URL(queueUrl, base).toString() : null,
+    pendingCount: pendingCount ?? null, attemptRef: attempt?.attemptRef ?? null, briefId: attempt?.briefId ?? null, at: new Date().toISOString(),
+  }, null, 2) + "\n");
+} catch (e) { console.error(`staged.json not written: ${e.message}`); }
 
 // ── open the in-app preview — the review happens THERE ─────────────────────
 // Batch etiquette (founder, 2026-08-11): when takes are stacked for a later
@@ -211,83 +275,15 @@ if (!noOpen) {
   } catch { /* printing the URL above is the fallback */ }
 }
 
-// ── poll while the human decides, then until the bite is READY ─────────────
-// LAW (founder 2026-08-08): never hand a human a studio link before the bite
-// is finished. Approve only STARTS the pipeline.
-const POLL_MS = 4000;
-const DECISION_TIMEOUT_MS = 30 * 60 * 1000;
-const deadline = Date.now() + DECISION_TIMEOUT_MS;
-let announced = false;
-let completed = false;
-let approvedBiteId = null;
-let finalStudioUrl = null;
-process.stdout.write("Waiting for your word in the browser");
-while (Date.now() < deadline) {
-  await new Promise((r) => setTimeout(r, POLL_MS));
-  let res;
-  try {
-    res = await fetch(`${base}/api/recorder/stage?id=${stagingId}`, {
-      headers: { Authorization: `Bearer ${cfg.api_key}` },
-    });
-  } catch { process.stdout.write("."); continue; }
-  if (!res.ok) { process.stdout.write("."); continue; }
-  const st = await res.json().catch(() => null);
-  if (!st) { process.stdout.write("."); continue; }
-  if (st.status === "rejected") {
-    process.stdout.write("\n");
-    console.error("Discarded in the app. Adjust the storyboard and film again.");
-    process.exit(1);
-  }
-  if (st.status === "approved") {
-    if (!announced) {
-      process.stdout.write("\n");
-      console.log(`Approved — bite ${st.biteId} is being created`);
-      announced = true;
-      approvedBiteId = st.biteId;
-      finalStudioUrl = st.studioUrl ? new URL(st.studioUrl, base).toString() : null;
-      process.stdout.write("Waiting for the bite to finish");
-    }
-    if (st.biteStatus === "completed") {
-      completed = true;
-      process.stdout.write("\n");
-      break;
-    }
-    if (st.biteStatus === "failed") {
-      process.stdout.write("\n");
-      console.error("The pipeline FAILED for this bite. Do not hand over any link — investigate.");
-      process.exit(1);
-    }
-  }
-  process.stdout.write(".");
-}
-if (!announced) {
-  process.stdout.write("\n");
-  console.error(`No decision yet. The preview stays available at:\n  ${pageUrl}`);
-  process.exit(1);
-}
-// LAW: the studio link exists ONLY behind a confirmed 'completed'. A deadline
-// expiry after approval is NOT completion (review finding: the fallthrough
-// here once printed the link for an unfinished bite).
-if (!completed) {
-  console.error("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.");
-  process.exit(1);
+if (stageOnly) {
+  console.log(`Staged only. Wait for the decision later with: node scripts/status.mjs ${dir}`);
+  process.exit(0);
 }
 
-// ── final receipt via the status endpoint (same gate as before) ────────────
-let last = null;
-try {
-  const res = await fetch(`${base}/api/recorder/status?biteId=${approvedBiteId}`, {
-    headers: { Authorization: `Bearer ${cfg.api_key}` },
-  });
-  if (res.ok) last = await res.json().catch(() => null);
-} catch { /* summary is best-effort; readiness was confirmed above */ }
-if (last && last.status === "completed") {
-  console.log(
-    `Ready: "${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.");
-}
-if (finalStudioUrl) console.log(`Studio: ${finalStudioUrl}`);
+// ── 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);

package/skill/scripts/vocab.mjs

@@ -0,0 +1,88 @@
+// Harvest the product's CURRENT vocabulary from the running app (Phase 3a).
+//
+//   node vocab.mjs <takeDir> <url> [<url> ...] [--headless=false]
+//
+// Opens each URL headless on the recorder profile (signed in, no video) and
+// writes <takeDir>/vocab.json: for every screen, the nav labels (visible text,
+// aria-label, title, tooltips), the page headings, the button and link labels,
+// and the titles of any open dialogs. The storyboard's narration and
+// on_screen lines may only use nouns that appear here. The brief's and the
+// PR's words are hints about WHAT changed, never the words the demo speaks
+// (founder, 2026-09-14: a take said "Release Readiness" while the app said
+// "Assignments").
+//
+// Prints a short inventory so the agent can read it in chat before writing.
+import fs from "node:fs";
+import path from "node:path";
+import { chromium } from "playwright";
+
+const args = process.argv.slice(2);
+const dir = args[0];
+const urls = args.slice(1).filter((a) => /^https?:\/\//.test(a));
+if (!dir || urls.length === 0) {
+  console.error("Usage: node vocab.mjs <takeDir> <url> [<url> ...]");
+  process.exit(2);
+}
+fs.mkdirSync(dir, { recursive: true });
+const profileDir = path.resolve(".recorder", "profile");
+const headless = !args.includes("--headless=false");
+
+const ctx = await chromium.launchPersistentContext(profileDir, { channel: "chrome", headless, viewport: { width: 1920, height: 1080 } }).catch(async () =>
+  chromium.launchPersistentContext(profileDir, { headless, viewport: { width: 1920, height: 1080 } }),
+);
+const page = await ctx.newPage();
+
+const harvest = () => {
+  const clean = (s) => (s || "").replace(/\s+/g, " ").trim();
+  const vis = (el) => { const r = el.getBoundingClientRect(); return r.width > 0 && r.height > 0 && getComputedStyle(el).visibility !== "hidden"; };
+  const labelOf = (el) => clean(el.getAttribute("aria-label") || el.getAttribute("title") || el.getAttribute("data-tooltip") || el.innerText);
+  const uniq = (xs) => [...new Set(xs.filter(Boolean))];
+  const inRail = (el) => el.getBoundingClientRect().x < 90;
+  const nav = uniq([...document.querySelectorAll("nav a, nav button, aside a, aside button, [role='navigation'] a, header a, header button")].filter(vis).map((el) => {
+    const label = labelOf(el);
+    const href = el.getAttribute("href") || "";
+    // Tooltips often live on a sibling/parent: look at the closest element that carries one.
+    const tip = clean(el.closest("[title],[aria-label],[data-tooltip]")?.getAttribute("title") || el.closest("[data-tooltip]")?.getAttribute("data-tooltip") || "");
+    return (label || tip) ? `${label || tip}${href ? ` (${href})` : ""}${inRail(el) ? " [rail]" : ""}` : "";
+  }));
+  const headings = uniq([...document.querySelectorAll("h1, h2, h3")].filter(vis).map((el) => clean(el.innerText)).filter((t) => t.length < 90));
+  // Editors keep their controls in header bars and side panels, so nothing is
+  // excluded by landmark; only the left rail (x < 90) is reported separately.
+  const buttons = uniq([...document.querySelectorAll("button, [role='button'], a[href], [role='tab'], [role='menuitem']")].filter(vis).filter((el) => !inRail(el)).map(labelOf).filter((t) => t && t.length < 60));
+  const fields = uniq([...document.querySelectorAll("input, textarea, [contenteditable='true']")].filter(vis).map((el) => clean(el.getAttribute("aria-label") || el.getAttribute("placeholder") || el.closest("label")?.innerText || "")).filter((t) => t && t.length < 60));
+  const dialogs = uniq([...document.querySelectorAll("[role='dialog'], [role='alertdialog']")].map((d) => clean(d.querySelector("h1,h2,h3,[id*='title']")?.innerText || d.getAttribute("aria-label") || "")));
+  const tooltips = uniq([...document.querySelectorAll("[role='tooltip']")].map((el) => clean(el.innerText)));
+  return { title: document.title, nav, headings, buttons, fields, dialogs, tooltips };
+};
+
+const screens = [];
+for (const url of urls) {
+  await page.goto(url, { waitUntil: "networkidle", timeout: 60000 }).catch(() => page.goto(url, { waitUntil: "load", timeout: 60000 }).catch((e) => console.error(`${url}: ${e.message}`)));
+  // Entitlement-gated nav items paint late; give the app a moment, then hover
+  // every rail link (the icons carry their names as tooltips, not as text) so
+  // the tooltip portals render into the DOM.
+  await page.waitForTimeout(5000);
+  const rail = page.locator("a[href^='/']");
+  const n = Math.min(await rail.count(), 40);
+  const tips = new Set();
+  for (let i = 0; i < n; i++) {
+    const el = rail.nth(i);
+    const box = await el.boundingBox().catch(() => null);
+    if (!box || box.x > 90 || box.width > 80) continue;
+    await el.hover().catch(() => {});
+    await page.waitForTimeout(700);
+    const texts = await page.locator("[role='tooltip'], [data-slot='tooltip-content'], [data-slot='tooltip-popup']").allInnerTexts().catch(() => []);
+    for (const t of texts) if (t.trim()) tips.add(`${t.trim()} (${(await el.getAttribute("href")) || "?"})`);
+  }
+  await page.mouse.move(600, 600);
+  const h = await page.evaluate(harvest);
+  h.railTooltips = [...tips];
+  h.url = page.url();
+  screens.push(h);
+  console.log(`\n${h.url}\n  title: ${h.title}\n  headings: ${h.headings.join(" · ")}\n  rail tooltips: ${h.railTooltips.join(" · ") || "(none rendered)"}\n  nav: ${h.nav.slice(0, 20).join(" · ")}\n  buttons/links: ${h.buttons.slice(0, 60).join(" · ")}${h.fields.length ? `\n  fields: ${h.fields.join(" · ")}` : ""}${h.dialogs.filter(Boolean).length ? `\n  dialogs: ${h.dialogs.filter(Boolean).join(" · ")}` : ""}`);
+}
+await ctx.close();
+
+const out = { harvestedAt: new Date().toISOString(), screens };
+fs.writeFileSync(path.join(dir, "vocab.json"), JSON.stringify(out, null, 2) + "\n");
+console.log(`\nvocab.json written (${screens.length} screen${screens.length === 1 ? "" : "s"}). Narration may use only these nouns.`);