demobite 1.3.1 → 1.4.0

package/README.md

@@ -130,6 +130,10 @@ When your UI changes, **Retake** can refilm an existing Bite from its saved reci
 npx demobite retake <biteId> --note "Export moved to the header"
 ```
 
+**In your app's repository.** Run the skill from the project that is your app and the agent reads the routes, the navigation, the control labels and the data handlers before it plans, then verifies everything on the live page. Without the code it works from the live app alone and asks when it cannot find a screen.
+
+**Workspace rules.** A workspace admin can write standing rules for the recorder in plain words in the DemoBites settings tab Agentic Recorder Rules, one per line: what to mask, which pages never to open, which words to use. The agent reads them at the start of every take and applies them under its own filming laws; `npx demobite rules` prints them. Every take records the rules version it was filmed under.
+
 **Batches of briefs.** When a pull request in DemoBites produces approved briefs, your agent claims them, films one take per brief after you approve each storyboard, and delivers each take. A delivered take becomes a Bite in DemoBites by itself; there is no second review click for these takes. Nothing is published or shared.
 
 The package also includes a DemoBites management MCP for releases and centers:

package/launcher/index.mjs

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

package/package.json

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

package/scripts/record.mjs

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

package/skill/SKILL.md

@@ -52,7 +52,7 @@ Look for `.recorder/config.json` next to the project. If it exists, use it and a
 
 - **app**: the product's name as it should appear in titles.
 - **url**: the starting URL of the flow.
-- **frame**: fixed at 1920x1080 for now, do not ask, just record it.
+- **frame**: 1920x1080, never asked. DemoBites adds the dark macOS browser header on top of every take at ingest, as for an uploaded video; a workspace rule that negates it ("No browser header on the takes.") turns it off. The manifest and the recipe carry `frame` and `browserHeader` for the record.
 - **base**: defaults to `https://app.demobites.com`, only ask if the human mentions a different environment.
 
 Write the answers to `.recorder/config.json` and never ask again:
@@ -61,13 +61,29 @@ Write the answers to `.recorder/config.json` and never ask again:
 {
   "app": "Acme",
   "url": "https://app.acme.com",
-  "frame": { "width": 1920, "height": 1080 },
   "base": "https://app.demobites.com"
 }
 ```
 
 `login.mjs` later merges `api_key` and `workspace` into this same file and chmods it 600. Treat the file as secret once a key is in it. Never print `api_key`.
 
+## Phase 1b: Workspace rules, EVERY run
+
+The workspace admin can write standing rules for the recorder in plain words, one per line, in the DemoBites settings tab "Agentic Recorder Rules" ("Mask any number with a dollar sign.", "Never open the Billing page.", "Say Update Center, never changelog."). They apply to every take filmed in that workspace. At the start of EVERY run, batch or free prompt, right after the key resolves the workspace and BEFORE any storyboard:
+
+```bash
+node scripts/rules.mjs [<takeDir>]     # fetches the rules fresh, writes .recorder/rules.json, prints them numbered
+```
+
+It fetches `GET <base>/api/recorder/rules` with the recorder key (never cached). When the fetch fails it falls back to the snapshot the claim wrote into `<takeDir>/brief.json` (`workspaceRules`), then to no rules, and prints which of the three it used; repeat that line in your report. Then:
+
+- Fold the rules into your storyboard thinking as **standing rules of the workspace, BELOW the filming laws**. A rule never lifts a law: an irreversible action stays pointed at and never pressed, Cancel is never a beat, the human still approves every storyboard, and nothing is published or shared.
+- Every beat a rule shaped carries `"rules": [1, 3]` (the rule numbers as printed), and the storyboard carries `"rulesVersion": <version>` at the top. The presentation shows "Rules applied: 1, 3" on those beats and lists the rules once. A rule that cannot be honoured in this flow is said out loud in the presentation, never silently dropped.
+- The prep, take and cleanup legs obey the rules too (a "never open" page is never opened, not even off camera).
+- Masking rules ("mask emails", "hide amounts") become `hideCss` rules or text masks with what the skill has today: find the element on the live page (Phase 4) and blank it with `color: transparent` plus a soft `text-shadow`, `filter: blur(6px)`, or `display: none` when the element may vanish. Keep masked words out of `narration` and `on_screen` too.
+- Vocabulary rules ("say X, never Y") win over vocab.json for that noun, as long as X appears in the app or the rule; the rule is the admin's word.
+- `record.mjs` copies `rulesVersion` into `recipe.config`, and `manifest.mjs` into the stage manifest, so a re-take can tell which rule set it was filmed under.
+
 ## Phase 2: Target-app sign-in, only when a login wall appears
 
 The camera browser uses a persistent profile at `.recorder/profile`. Signed in sessions survive between takes.
@@ -92,6 +108,17 @@ node scripts/vocab.mjs <takeDir> <url of every screen the take visits>
 
 It opens each screen on the recorder profile, without video, hovers the rail so tooltips render, and writes `<takeDir>/vocab.json`: nav labels with their tooltips and aria labels, page headings, button and link labels, dialog titles. **Every noun in `narration` and `on_screen` must appear in vocab.json.** The brief's and the PR's words are hints about WHAT changed and where to look; when a brief's noun is missing from the app, say so in the storyboard presentation ("the brief says allowlist, the app says Who can enter") and use the app's word.
 
+### Phase 3b: When you sit in the app's repository, read it FIRST
+
+A developer runs this skill from the project that IS the app (founder, 2026-09-17: developers have the code; product and marketing people do not). When the working directory holds the app's source, use it before you write a storyboard, the way you would read a map:
+
+- **Routes and navigation**: the router (app or pages directory, the route table, the nav component) tells you the address of every screen the brief names. Start each storyboard on that address; never open the root and search.
+- **Controls and selectors**: the components give you the real labels, titles, roles and test ids of the controls the flow presses. Prefer a selector from the source (text, title, aria, data attributes) over one guessed from a screenshot; never a positional chain.
+- **Data and its undo**: the handlers behind Create, Add, Move, Delete tell you what an action makes and what puts it back. That is the `prep[]` and `cleanup[]` plan; write it from the code, then verify it on the live page.
+- **Gates**: feature flags and plan gates in the code tell you which screens need a plan or a role before the camera walks into a wall.
+
+The live page stays the truth: what the code names a thing is not what the demo calls it (Phase 3a, vocab.json wins for every noun in narration and on_screen), and a route in the code is not a screen until you have seen it deployed at the target address. Read only what the flow touches (routing, navigation, UI strings, the mutation handlers), not the whole codebase. Never put code names, file paths, flags or internal state names into narration or on screen. Without a repository (a brief pasted into an empty project) you have the live app alone: harvest, probe, and ask when a screen cannot be found.
+
 ### LAW: the camera shows an action to its end
 
 The agent sits on the running product with a signed-in account. It knows the flow. It performs it. A take that walks into an empty page and narrates "if there were something here" is forbidden; so is "here you would see" (founder, 2026-09-14).
@@ -134,7 +161,7 @@ Holding shots to cover estimated lines is what produced a 60 second take with th
 
 **LAW: page transitions are cut and faded, never watched.** When the story moves to another page, the viewer sees page one, a short fade, page two — never the loading blank. record.mjs stamps every mid-take `goto` and manifest.mjs cuts that window out with a fade (`cuts` in the wire manifest); the ingestion lays it on the bite as a timeline cut. No zoom and no narration live inside a cut (the studio forbids both), so put the line about the new page on the beat AFTER it has landed, and say goodbye to the old page BEFORE the goto.
 
-Storyboard schema:
+Storyboard schema (`rulesVersion` and per-step `rules` come from Phase 1b):
 
 ```json
 {
@@ -153,7 +180,7 @@ Storyboard schema:
 }
 ```
 
-Step fields: `action` is one of `goto | settle | scroll | click | hover | type | expect`. **Durations (`dwell`, `after`, settle `ms`, scroll `ms`) are milliseconds; a value under 60 is read as seconds** (write `"dwell": 3400` or `"dwell": 3.4`, never `"dwell": 3` meaning 3 ms). `goto` needs `url`. `settle` takes `ms` and an optional `focus` selector. `scroll` needs `dy` and takes `ms`. `click`/`hover` need `selector` and take `minY` (minimum Y for the visible instance pick), `dwell`, `after`, `waitLoad`. Every step takes `label` and `narration`.
+Step fields: `action` is one of `goto | settle | scroll | click | hover | type | expect`. `rules` (optional, any step) lists the numbers of the workspace rules that shaped the beat; the storyboard's top-level `rulesVersion` names the rule set (Phase 1b). **Durations (`dwell`, `after`, settle `ms`, scroll `ms`) are milliseconds; a value under 60 is read as seconds** (write `"dwell": 3400` or `"dwell": 3.4`, never `"dwell": 3` meaning 3 ms). `goto` needs `url`. `settle` takes `ms` and an optional `focus` selector. `scroll` needs `dy` and takes `ms`. `click`/`hover` need `selector` and take `minY` (minimum Y for the visible instance pick), `dwell`, `after`, `waitLoad`. Every step takes `label` and `narration`.
 
 Beyond `steps`, a storyboard may carry the off-camera blocks (Phase 3a/law above); `cleanup.mjs` runs them on the same profile without video:
 
@@ -335,7 +362,7 @@ The procedure, in order:
 
 1. `list` first, always, with `--paste` when the human pasted text. Work from the server's briefs, never from the paste, and say so when they differ.
 2. Claim the briefs you are about to film, one `claim` each. A claim answers "active attempt" when another agent or an earlier run holds the brief: show the human the attempt reference and its start time, and only with their word claim again with `--force`.
-3. Run `vocab.mjs` over the screens each brief visits, then write every storyboard (Phase 3) with the brief as the spec and vocab.json as the only dictionary: the flowIntent lines are the beats, the outcome is the last beat, the exclusions are things the camera never shows, and the take stays under the brief's `maxSeconds` (90). Send `event <takeDir> planning` when you start a storyboard and `event <takeDir> awaiting_storyboard_approval` when it is ready.
+3. Run `rules.mjs <takeDir>` (Phase 1b; the claim stored the batch's rules snapshot in brief.json as the fallback) and `vocab.mjs` over the screens each brief visits, then write every storyboard (Phase 3) with the brief as the spec, the workspace rules below the laws, and vocab.json as the only dictionary: the flowIntent lines are the beats, the outcome is the last beat, the exclusions are things the camera never shows, and the take stays under the brief's `maxSeconds` (90). Send `event <takeDir> planning` when you start a storyboard and `event <takeDir> awaiting_storyboard_approval` when it is ready.
 4. **Show the storyboards together, get a word on each one.** One message can carry all of them, but every brief gets its own yes or no. Never take one yes as a yes for the batch. A brief the human declines gets `release`.
 5. Film sequentially, never in parallel: one Chrome on the profile. Per take: `event recording` → Phase 4 dry run → `cleanup.mjs --prep` when declared → Phase 5 take → `cleanup.mjs` (revert, checks.after) → trim, calibrate, manifest → `upload.mjs <takeDir> --stage-only --no-open`. Report, per take, what was created and what was reverted, with the before/after checks. `upload.mjs` reads `brief.json`, moves the attempt to uploading, stages with the attempt on the payload, and after the two uploads calls the delivery route: the take becomes a bite in DemoBites by itself, no Approve click, and the line reads `delivered: bite <id>`. It writes `staged.json` with the staging id and the bite id.
 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.
@@ -387,6 +414,9 @@ PUT <base>/api/recorder/device  { device_code }          (poll every `interval`
 DELETE <base>/api/recorder/key  (Authorization: Bearer <api_key>)
   -> { revoked: true }                                    (logout)
 
+GET <base>/api/recorder/rules  (Authorization: Bearer <api_key>)   // WORKSPACE RULES (1.4): never cached
+  -> { workspaceId, rules: string | null, version, updatedAt }   (the claim's api.rules is the same url; workspaceRules on the claim is the snapshot)
+
 GET <base>/api/recorder/recipe?biteId=<id>  (Authorization: Bearer <api_key>)   // RE-TAKE: the bite's recipe
   -> { storyboard, config:{app,url,frame}, manifest, engine }   (404 no recipe; 402/403 plan gate)
 

package/skill/scripts/briefs.mjs

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

package/skill/scripts/manifest.mjs

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

package/skill/scripts/rules.mjs

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