demobite 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "demobite",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "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/calibrate.mjs

@@ -131,10 +131,20 @@ console.log(`calibrate: map video = ${tb.a} * wall + ${tb.b.toFixed(3)} (${tb.me
 console.log(`calibrate: ${anchors.length} hover anchor${anchors.length === 1 ? "" : "s"} usable`);
 
 let anchored = false;
+// BEACON OUTRANKS ANCHORS (2026-09-02, second prod bite-96 take): the head
+// beacon had measured the cut to +-14 ms, yet ONE hover anchor locked onto a
+// stray pixel change 2.66 s away and dragged the clock with it. When the
+// beacon has spoken (trim stamped beaconDelta from >=3 matched flashes),
+// anchors may only REFINE the clock inside a third of a second; they never
+// re-decide it. Without a beacon the wide sweep stays (the pre-beacon world).
+const beaconAnchored = typeof tb?.beaconDelta === "number";
+const SWEEP_LO = beaconAnchored ? -0.35 : -3.0;
+const SWEEP_HI = beaconAnchored ? 0.35 : 1.0;
+if (beaconAnchored) console.log(`calibrate: beacon-anchored clock — hover anchors may refine by at most ${SWEEP_HI.toFixed(2)}s`);
 if (anchors.length >= 2) {
   const TOL = 0.067; // two frames
   let best = { delta: 0, score: -1, resid: Infinity };
-  for (let d = -3.0; d <= 1.0001; d += 1 / 60) {
+  for (let d = SWEEP_LO; d <= SWEEP_HI + 0.0001; d += 1 / 60) {
     let score = 0, resid = 0, hits = 0;
     for (const a of anchors) {
       const target = a.pred + d;
@@ -171,21 +181,27 @@ if (anchors.length >= 2) {
         console.log(`  anchor ${a.label}: no flip within tolerance at this offset (skipped)`);
       }
     }
-    const rms = Math.sqrt(residuals.reduce((s, r) => s + r * r, 0) / residuals.length);
-    if (rms > 0.08) {
+    if (residuals.length < 2) {
+      // One surviving anchor is an opinion, not a measurement.
+      console.log(`calibrate: only ${residuals.length} anchor survived the lock — clock left ${beaconAnchored ? "on the beacon" : "as stamped"}.`);
+      anchored = beaconAnchored;
+      best.delta = 0;
+    }
+    const rms = residuals.length >= 2 ? Math.sqrt(residuals.reduce((s, r) => s + r * r, 0) / residuals.length) : 0;
+    if (residuals.length >= 2 && rms > 0.08) {
       console.error(`CALIBRATE FAILED: hover-anchor rms ${(rms * 1000).toFixed(0)}ms exceeds 80ms — footage disagrees with itself. Do not upload.`);
       process.exit(1);
     }
-    if (Math.abs(best.delta) > 0.005) {
+    if (residuals.length >= 2 && Math.abs(best.delta) > 0.005) {
       tb.b += best.delta;
       tb.videoRecordFrom = -tb.b;
       tb.method += ` + hover-anchor ${best.delta.toFixed(3)}s (${best.hits} anchors, rms ${(rms * 1000).toFixed(0)}ms)`;
       fs.writeFileSync(manPath, JSON.stringify(man, null, 2));
       console.log(`calibrate: hover anchors moved the clock ${best.delta.toFixed(3)}s — b is now ${tb.b.toFixed(3)} (rms ${(rms * 1000).toFixed(0)}ms)`);
-    } else {
+    } else if (residuals.length >= 2) {
       console.log(`calibrate: hover anchors confirm the stamp as-is (rms ${(rms * 1000).toFixed(0)}ms)`);
     }
-    anchored = true;
+    if (residuals.length >= 2) anchored = true;
   }
 }
 
@@ -221,6 +237,8 @@ if (scenes.length === 0) {
   process.exit(0);
 }
 
+const SWEEP_LO_FB = beaconAnchored ? -0.35 : -4;
+const SWEEP_HI_FB = beaconAnchored ? 0.35 : 1.0;
 if (!anchored) {
   // Old plausible-latency search. Kept ONLY as the no-anchor fallback; its
   // known failure mode (plausible != true, 0.237s off on a real take) is why
@@ -237,7 +255,7 @@ if (!anchored) {
     return total;
   };
   let bestDelta = 0, bestScore = score(0);
-  for (let d = -4; d <= 1.0001; d += 1 / 30) {
+  for (let d = SWEEP_LO_FB; d <= SWEEP_HI_FB + 0.0001; d += 1 / 30) {
     const sc = score(d);
     if (sc < bestScore - 1e-9) { bestScore = sc; bestDelta = d; }
   }
@@ -272,6 +290,15 @@ if (!anchored && (median < -0.15 || median > 0.9)) {
   );
   process.exit(1);
 }
+if (!beaconAnchored && anchored && (median < -0.6 || median > 2.5)) {
+  // INCIDENT 2026-09-02: +4.6 s "latency" on an anchored clock was the head
+  // miscut showing through (the anchors had locked onto the wrong beat).
+  console.error(`VERIFY FAILED: median click latency ${median.toFixed(3)}s on an anchor-measured clock is not an app delay, it is a broken timebase (the cut point or the anchor lock is wrong). Do not upload — film again.`);
+  process.exit(1);
+}
+if (beaconAnchored && (median < -0.6 || median > 2.5)) {
+  console.log(`WARNING: median click latency ${median.toFixed(3)}s on a beacon-measured clock — the clock is trusted, so the app genuinely answered late. The footage shows the wait; judge whether the beat reads as slow.`);
+}
 if (anchored && (median < -0.15 || median > 0.9)) {
   console.log(`note: median click latency ${median.toFixed(3)}s is unusual, but the clock is anchor-measured — likely a genuinely slow app response. Judge the take on duration and feel.`);
 }

package/scripts/record.mjs

@@ -40,7 +40,7 @@ const DIR = path.resolve(outArg);
 // RE-TAKE (founder 2026-09-02): the storyboard IS the bite's DNA. Keep a verbatim
 // copy in the take dir so upload.mjs can stage it as the recording recipe —
 // selectors, urls, typed text, hideCss — the wire manifest alone cannot re-film.
-const ENGINE_VERSION = "1.0.7";
+const ENGINE_VERSION = "1.0.9";
 fs.mkdirSync(DIR, { recursive: true });
 // The copy is the RECIPE, not the transport: cdpWsUrl / storageStatePath are
 // per-take plumbing stamped by the cloud runner (a CDP url carries a session
@@ -615,6 +615,7 @@ async function smoothScroll(dy, ms = 1400, within = null) {
   }), [dy, ms, within]);
 }
 
+const BEACON_GAPS_MS = [300, 450, 600, 750, 900, 1050];
 // ── Head beacon ────────────────────────────────────────────────────────────
 // The identity law (video = wall - record_from) assumes raw.webm's t=0 lines
 // up with T0. That anchoring is otherwise UNMEASURED: on a cold remote-CDP
@@ -634,22 +635,26 @@ try {
     // stamp error at half a CDP round trip — inside one frame co-located.
     return { color, wall: (before + after) / 2 };
   };
-  // Wait for the screencast to actually be ROLLING (first frames on disk):
-  // over a remote CDP link the recorder starts late, and a flash before the
-  // first frame is invisible (mode A smoke, 2026-09-02).
-  const rollDeadline = Date.now() + 5000;
-  while (Date.now() < rollDeadline) {
-    const rolling = fs.readdirSync(DIR).some((f) => f.endsWith(".webm") && fs.statSync(path.join(DIR, f)).size > 4096);
-    if (rolling) break;
-    await page.waitForTimeout(100);
-  }
+  // GAP-CODED PATTERN (2026-09-02, after the prod bite-96 miscut): nothing
+  // inside this process can see whether the screencast is rolling yet (the
+  // video file does not grow while recording), and under load the first
+  // frame can land seconds after the page exists. So the beacon no longer
+  // relies on being seen from its first flash: seven flashes with strictly
+  // increasing gaps form a signature trim.mjs recognises from ANY three
+  // consecutive flashes it finds. A screencast that started late still
+  // yields the anchor; one that missed every flash stops the take in trim.
   await page.evaluate(() => { document.documentElement.style.background = "#ffffff"; });
-  await page.waitForTimeout(600); // let the white state reach the recording
+  await page.waitForTimeout(1500); // let the page exist and the white state settle
   const flips = [];
-  flips.push(await flip("#ff00ff")); // onset 1: white -> magenta
-  await page.waitForTimeout(400);
-  flips.push(await flip("#ffffff")); // onset 2: magenta -> white
-  await page.waitForTimeout(400);
+  let color = "#ff00ff";
+  for (const gapMs of BEACON_GAPS_MS) {
+    flips.push(await flip(color));
+    color = color === "#ff00ff" ? "#ffffff" : "#ff00ff";
+    await page.waitForTimeout(gapMs);
+  }
+  flips.push(await flip(color)); // final onset closes the last gap
+  if (color === "#ff00ff") { await page.waitForTimeout(250); flips.push(await flip("#ffffff")); }
+  await page.waitForTimeout(300);
   manifest.beacon = { flips };
   process.stdout.write(`beacon: flips at ${flips.map((f) => f.wall.toFixed(3)).join("s, ")}s (wall)\n`);
 } catch (e) {

package/scripts/trim.mjs

@@ -56,32 +56,57 @@ const r0 = man.record_from ?? 0;
 // Shift the cut by it so clean.mp4 truly begins at the record_from moment.
 let beaconDelta = 0;
 let beaconMethod = "";
-if ((man.beacon?.flips?.length ?? 0) >= 2) {
+if ((man.beacon?.flips?.length ?? 0) >= 3) {
   const flips = man.beacon.flips;
   // The flashes are the first big whole-frame changes in the head. Search a
   // window generous enough for seconds of anchor error in either direction.
-  const searchEnd = Math.min(Math.max(r0, flips[flips.length - 1].wall) + 8, 40);
+  const searchEnd = Math.min(Math.max(r0, flips[flips.length - 1].wall) + 10, 45);
   const res = spawnSync("ffmpeg", [
     "-loglevel", "info", "-t", String(searchEnd), "-i", raw,
     "-vf", "select='gt(scene,0.3)',showinfo", "-f", "null", "-",
   ], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
   const onsets = [...`${res.stderr ?? ""}`.matchAll(/pts_time:([0-9.]+)/g)]
     .map((m) => parseFloat(m[1]));
-  if (onsets.length >= 2) {
-    // Pair the first two onsets to the two flips, in order. Anything the page
-    // paints later (the goto) lands after onset 2 and never enters the pair.
-    const d1 = flips[0].wall - onsets[0];
-    const d2 = flips[1].wall - onsets[1];
-    const spread = Math.abs(d1 - d2);
-    if (spread <= 0.15) {
-      beaconDelta = (d1 + d2) / 2;
-      beaconMethod = ` + head-beacon anchor ${beaconDelta >= 0 ? "+" : ""}${beaconDelta.toFixed(3)}s (2 flips, spread ${(spread * 1000).toFixed(0)}ms)`;
-      console.log(`beacon: anchor error ${beaconDelta >= 0 ? "+" : ""}${beaconDelta.toFixed(3)}s measured (flip spread ${(spread * 1000).toFixed(0)}ms) — cut corrected`);
-    } else {
-      console.log(`beacon: flip deltas disagree (${(spread * 1000).toFixed(0)}ms spread) — ignoring beacon, cut stays as stamped`);
+  // Align the KNOWN flash gaps against the DETECTED onset gaps: slide every
+  // flip index against every onset index and count consecutive gap matches
+  // (tolerance 70 ms). Three flashes in a row (two matching gaps) identify
+  // the pattern unambiguously because the gaps strictly increase; the
+  // alignment with the most matches wins. Missing leading flashes (a
+  // screencast that started late) cost nothing but the pairs they would
+  // have added.
+  const TOL = 0.07;
+  let best = null;
+  for (let i = 0; i < flips.length - 2; i++) {
+    for (let j = 0; j < onsets.length - 2; j++) {
+      let k = 0;
+      while (i + k + 1 < flips.length && j + k + 1 < onsets.length) {
+        const gf = flips[i + k + 1].wall - flips[i + k].wall;
+        const go = onsets[j + k + 1] - onsets[j + k];
+        if (Math.abs(gf - go) > TOL) break;
+        k++;
+      }
+      if (k >= 2 && (!best || k > best.k)) best = { i, j, k };
+    }
+  }
+  if (best) {
+    const deltas = [];
+    for (let m = 0; m <= best.k; m++) deltas.push(flips[best.i + m].wall - onsets[best.j + m]);
+    const spread = Math.max(...deltas) - Math.min(...deltas);
+    beaconDelta = deltas.reduce((a, b) => a + b, 0) / deltas.length;
+    const missed = best.i;
+    beaconMethod = ` + head-beacon anchor ${beaconDelta >= 0 ? "+" : ""}${beaconDelta.toFixed(3)}s (${deltas.length} flashes matched, ${missed} missed, spread ${(spread * 1000).toFixed(0)}ms)`;
+    console.log(`beacon: anchor error ${beaconDelta >= 0 ? "+" : ""}${beaconDelta.toFixed(3)}s measured from ${deltas.length} flashes (${missed} before the first frame, spread ${(spread * 1000).toFixed(0)}ms) — cut corrected`);
+    if (spread > 0.15) {
+      console.error(`BEACON FAILED: matched flashes disagree by ${(spread * 1000).toFixed(0)}ms. The cut point cannot be trusted — do not upload, film again.`);
+      process.exit(3);
     }
   } else {
-    console.log("beacon: flashes not found in the raw head — cut stays as stamped");
+    // INCIDENT 2026-09-02: a missed beacon staged a take whose head was cut
+    // seconds late (screencast started after the flashes). The stamped cut
+    // is only right when the screencast began at wall 0, which nothing
+    // guarantees — so a recorded-but-unfound beacon is a hard stop.
+    console.error(`BEACON FAILED: no run of the flash pattern found in the raw head (${onsets.length} onsets seen). The startup lead is unmeasured and the cut point cannot be trusted. Do not upload — film again (a busy machine delays the screencast; let builds finish first).`);
+    process.exit(3);
   }
 }
 

package/skill/scripts/retake.mjs

@@ -72,5 +72,5 @@ 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); }
 r = run("manifest.mjs", [takeDir]); if (r.status !== 0) process.exit(r.status ?? 1);
-r = run("upload.mjs", [takeDir, "--retake-of", String(biteId)]);
+r = run("upload.mjs", [takeDir, "--retake-of", String(biteId), ...(note ? ["--note", note] : [])]);
 process.exit(r.status ?? 0);

package/skill/scripts/upload.mjs

@@ -35,6 +35,11 @@ if (!dir) {
 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); }
+// `--note "<what changed>"` (device lane, founder 2026-09-02): the human's note
+// rides in recipe.config.retake_note so the in-app preview and the recording
+// 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) : "";
 const cfgPath = path.resolve(".recorder", "config.json");
 let cfg = {};
 try { cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8")); } catch {}
@@ -57,6 +62,7 @@ try {
     const rc = fs.existsSync(rcPath) ? JSON.parse(fs.readFileSync(rcPath, "utf8")) : {};
     recipe = { version: 1, lane: rc.lane ?? "skill", engine: rc.engine ?? null, storyboard: JSON.parse(fs.readFileSync(sbPath, "utf8")), config: rc.config ?? {} };
     if (recipe.config && "api_key" in recipe.config) delete recipe.config.api_key;
+    if (retakeNote) recipe.config = { ...(recipe.config ?? {}), retake_note: retakeNote };
   }
 } catch (e) { console.error("recipe skipped:", e.message); }
 if (!fs.existsSync(cleanPath)) { console.error(`${cleanPath} not found. Run: node scripts/trim.mjs ${dir}`); process.exit(1); }