wicked-garden 12.40.0 → 12.42.0

package/.claude-plugin/marketplace.json

@@ -1 +1 @@
-{"name": "wicked-garden", "owner": {"name": "Mike Parcewski"}, "plugins": [{"name": "wicked-garden", "source": "./", "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, real multi-model second opinions. Don't fight the harness; fill its gaps. The gate needs wicked-vault (a self-contained infra peer, installed directly) and re-derives through garden's built-in engine; estate/bus are opt-in layers (wicked-testing and wicked-brain are retired \u2014 QE ships in-catalog as the qe domain, memory lives in wicked-estate).", "version": "12.40.0"}], "version": "12.40.0"}
+{"name": "wicked-garden", "owner": {"name": "Mike Parcewski"}, "plugins": [{"name": "wicked-garden", "source": "./", "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, real multi-model second opinions. Don't fight the harness; fill its gaps. The gate needs wicked-vault (a self-contained infra peer, installed directly) and re-derives through garden's built-in engine; estate/bus are opt-in layers (wicked-testing and wicked-brain are retired \u2014 QE ships in-catalog as the qe domain, memory lives in wicked-estate).", "version": "12.42.0"}], "version": "12.42.0"}

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.40.0",
+  "version": "12.42.0",
   "description": "Your coding agent's harness already plans and swarms; Wicked Garden is the curated toolkit for what it can't do alone. Proof, not claims \u2014 gates re-derive 'done' through the internal loom engine (fail-closed, independently attested via wicked-vault), so a self-asserted pass can't lie its way green. Relationships grep can't see \u2014 the wicked-estate code graph + injected bus/dispatch/capability/archetype edges power blast-radius & lineage. Plus deterministic multi-file refactor (wicked-patch), cross-session memory + knowledge (the mem domain over wicked-estate), real multi-model second opinions (jam:council), portable expertise as on-demand skill-refs, and evidence-gated testing (the in-catalog qe domain). It reads the shape of your work to apply the right rigor \u2014 steering, not a pipeline \u2014 then gets out of the way. The compiler stamps a self-contained evidence gate into any repo that runs with no wicked-garden installed. Don't fight the harness; fill its gaps. The evidence gate requires wicked-vault, a self-contained infra peer wicked-garden installs directly; wicked-bus is an opt-in layer \u2014 install what you'll use, the toolkit works without the rest.",
   "wicked_vault_version": "^0.5.0",
   "wicked_ledger_version": "^0.4.0",

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [12.42.0] — 2026-10-03
+
+### Changed
+- **Demo recorder: encodes while it records; no frame file touches disk.** Before, `scripts/demo/stage.mjs` wrote every changed screencast frame as a JPEG (q95, 1920x1080: ~8 MB/s, about 5 GB per 10-minute take) and `postprocess.mjs` encoded them afterwards from an ffconcat list. Now a 30 fps ticker hands the newest screencast picture to an ffmpeg child over stdin (`-f image2pipe`), which writes the take's master `segments/<key>/capture.mp4` live: H.264 at a near-lossless CRF 12 with one-second fragments (`+frag_keyframe+empty_moov`), so a take that dies leaves a file that plays up to its last complete second. Master frame k is the picture at t0 + k/30, so wall clock → video time stays one line and `videoClock()` keeps its contract (`outAt`, the trim, the time-lapse spans). `buildVideo()` is now a cut of the master: `trim` for the opening, a `select` that keeps one frame in `factor` across every `Stage.fast()` span and re-times the rest back to back, the chapter markers, the final CRF 17 pass; no frame files are read. Each segment keeps `capture.mp4` + `timeline.json` (what `--reencode` re-cuts from) in place of `frames/`; a failed take's `failed-<take>/` keeps the master only when no video could be cut from it, as it kept the frames. The timeline is rewritten at every mark, so a recorder killed mid-take leaves a cuttable master and clock. A dead encoder fails the take at its next step (`encoder_failed`) instead of filming into nothing. `DEMO_KEEP_FRAMES=1` also dumps every screencast frame to `frames/` (with `timeline.json` `frames` timestamps) for debugging. Measured on one take against the 12.41.0 recipe run on the same frames: see `tests/demo/test_live_encode.py` (SSIM against the frames recipe and against a lossless build of the frames; the pipe's video is as close to the frames as the single-encode recipe was). `contact_sheet.py` already read the video. Timelines recorded by earlier versions (frames, no master) are not re-cut: re-record the segment.
+
+## [12.41.0] — 2026-10-03
+
+### Added
+- **Demo: `walkthrough.mjs record` turns a storyline into a sealed, vault-checked proof (WT-G2, DES-walkthrough-proof §4.4–4.7).** `wicked-garden run scripts/demo/walkthrough.mjs record` reads `WICKED_EVIDENCE_ROOT`, `WICKED_RUN_ID`, `WICKED_RUN_UNIT` and `WICKED_TREE` and copies the storyline into the root. It `git archive`s the tree into `<root>/app/`, starts the fixture by argv on a free loopback port with `DATA_DIR=<root>/data`, and records each segment through the existing recorder with the fixture origin as the one writable origin. At each `ctx.check(id)` it captures by collector: `locator`, `probe` (parses json, jsonl, sqlite-json or text), `artifact` (under `DATA_DIR` only; absolute paths and `../` are refused), `guard` (foreign writes, console errors) or `join`. Captures are recorded into a vault anchored at `<root>/vault/`, never an ancestor vault, under a contract derived from the storyline, and each chapter is cross-checked. A chapter is PASS only from the vault's cross-check. A failing verifier or a check that is never reached is FAIL. A vault, `jq` or ledger that is missing or failing makes the chapter INCONCLUSIVE, never PASS. `unjailed_host`, `fixture_unavailable`, `storyline_refused` and the disk cap list every chapter as INCONCLUSIVE. Ledger rows (`crew_run_id`, `step_id`, `tree`, `take`) and a 2.1 manifest per chapter with `scenario_evidence.walkthrough` go under `<root>/.wicked-qe/`. Last, the tool writes `result.json` and `progress.json` and prints `WALKTHROUGH-SEAL` (`tree`, `storyline_sha`, `contract_shas`, `bundle_sha` over every file except `app/` and `data/`, `overall`, `chapters`). `seal --root` recomputes it. `record.mjs` exports `makeSegmentRecorder` and `stage.mjs` takes a console handler that is attached before navigation. Tests: `tests/demo/test_walkthrough.py` against `tests/demo/fixtures/`.
+
 ## [12.40.0] — 2026-10-02
 
 ### Added
@@ -961,7 +971,9 @@ through `v9.2.18`. Major themes across that span:
 
 For each of those releases, see the corresponding tag in git history.
 
-[Unreleased]: https://github.com/mikeparcewski/wicked-garden/compare/v12.40.0...HEAD
+[Unreleased]: https://github.com/mikeparcewski/wicked-garden/compare/v12.42.0...HEAD
+[12.42.0]: https://github.com/mikeparcewski/wicked-garden/compare/v12.41.0...v12.42.0
+[12.41.0]: https://github.com/mikeparcewski/wicked-garden/compare/v12.40.0...v12.41.0
 [12.40.0]: https://github.com/mikeparcewski/wicked-garden/compare/v12.39.0...v12.40.0
 [12.39.0]: https://github.com/mikeparcewski/wicked-garden/compare/v12.38.1...v12.39.0
 [12.38.1]: https://github.com/mikeparcewski/wicked-garden/compare/v12.38.0...v12.38.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.40.0",
+  "version": "12.42.0",
   "type": "module",
   "description": "Curated toolkit for what AI coding agents can't do alone: evidence-gated work, codegraph relationships, deterministic multi-file refactor, multi-model second opinions, and cross-session memory. Installs as a Claude Code plugin.",
   "keywords": [

package/scripts/demo/postprocess.mjs

@@ -1,60 +1,91 @@
-// Part of the wicked-garden-demo skill. Turns a recorded timeline (frames + marks) into a 1080p H.264 MP4 with chapter markers.
+// Part of the wicked-garden-demo skill. Cuts a take's master (capture.mp4 + timeline.json) into a 1080p H.264 MP4
+// with chapter markers.
 //
-// Each screencast frame lasts until the next one; spans marked by Stage.fast() are compressed by their factor,
-// so long model waits play as a visible time-lapse while the on-screen badge states the real elapsed time.
+// The master is the take at a constant FPS, encoded live while it recorded (stage.mjs): frame k is the picture at
+// t0 + k/FPS, so wall clock and master time are the same line. The cut drops the opening trim, keeps one frame in
+// `factor` across every span marked by Stage.fast() and re-times what is left back to back, so long model waits play
+// as a visible time-lapse while the on-screen badge states the real elapsed time; the chapter marks land where
+// videoClock().outAt() says. No frame file is read or written.
 // Usage: wicked-garden run scripts/demo/postprocess.mjs <outDir> [output.mp4]
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { pathToFileURL } from "node:url";
 
-const FPS = 30;
+/** The master's constant frame rate. */
+export const FPS = 30;
+/** The master's file name inside a take's directory. */
+export const CAPTURE = "capture.mp4";
+/** ffprobe beside a given ffmpeg binary (`FFMPEG=/path/to/ffmpeg` is honoured for both). */
+export const ffprobeOf = (ffmpeg) => ffmpeg.replace(/ffmpeg(\.exe)?$/i, "ffprobe$1");
 
 /**
- * The video clock of a timeline: the frames buildVideo keeps, the time-lapse spans, and `outAt(t)`, the
- * position in the built video (seconds) of a wall-clock instant `t`. Throws when no frame is kept.
+ * The video clock of a timeline, in master frames so it agrees with the cut to the frame: `inFrame`, the first
+ * master frame kept; `spans`, the time-lapse spans as [a, b) frame ranges with their factor; `keptBefore(k)`, how many
+ * cut frames precede master frame k; and `outAt(t)`, the position in the cut video (seconds) of a wall-clock instant.
+ * Throws when a closed take says nothing was recorded past the trim; a timeline a killed take left (no frame count)
+ * is clocked from its t0 and the master is counted by buildVideo.
  */
 export function videoClock(tl, trimStart = 0) {
-  const frames = tl.frames.filter((f) => f.t >= tl.t0 + trimStart);
-  if (!frames.length) throw new Error("no frames recorded");
-  const speed = [...tl.marks.speed].sort((a, b) => a.start - b.start);
-
-  // Output time for a wall-clock instant: integrate 1/factor over the marked spans.
-  const origin = frames[0].t;
-  const outAt = (t) => {
-    let out = t - origin;
-    for (const s of speed) {
-      const a = Math.max(s.start, origin), b = Math.min(s.end, t);
-      if (b > a) out -= (b - a) * (1 - 1 / s.factor);
+  const fps = tl.capture?.fps ?? FPS;
+  const inFrame = Math.max(0, Math.ceil(trimStart * fps - 1e-9));
+  if (typeof tl.capture?.frames === "number" && tl.capture.frames <= inFrame) throw new Error("no frames recorded");
+  const toFrame = (t) => Math.round((t - tl.t0) * fps);
+  // Inside a span only frame a and every frame where floor((k - a) / factor) advances are kept: one in `factor`.
+  // Spans never overlap here: a later span starts where the one before it ends (a nested Stage.fast() counts once).
+  const spans = [];
+  for (const s of [...tl.marks.speed].sort((x, y) => x.start - y.start)) {
+    const a = Math.max(inFrame, toFrame(s.start), spans.length ? spans[spans.length - 1].b : 0), b = toFrame(s.end);
+    if (b > a && s.factor > 1) spans.push({ a, b, f: s.factor });
+  }
+  const keptIn = (a, b, f) => (b > a ? Math.floor((b - a - 1) / f) + 1 : 0);
+  const keptBefore = (k) => {
+    let kept = Math.max(0, k - inFrame);
+    for (const s of spans) {
+      const b = Math.min(s.b, k);
+      if (b > s.a) kept -= (b - s.a) - keptIn(s.a, b, s.f);
     }
-    return out;
+    return kept;
   };
-  return { frames, speed, outAt };
+  const outAt = (t) => keptBefore(toFrame(t)) / fps;
+  return { inFrame, fps, spans, keptIn, keptBefore, outAt, speed: tl.marks.speed };
+}
+
+/** Frames in the master, by demuxing it (exact for a master whose writer died: the complete packets count). */
+function countFrames(ffprobe, file) {
+  const r = spawnSync(ffprobe, ["-v", "error", "-select_streams", "v:0", "-count_packets", "-show_entries", "stream=nb_read_packets", "-of", "csv=p=0", file],
+    { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`ffprobe failed on ${file}: ${(r.error?.message ?? r.stderr ?? "").slice(-500)}`);
+  const n = Number(r.stdout.trim());
+  if (!Number.isInteger(n)) throw new Error(`ffprobe gave no frame count for ${file}: ${r.stdout.slice(0, 200)}`);
+  return n;
 }
 
 export function buildVideo(outDir, outFile, { ffmpeg = process.env.FFMPEG || "ffmpeg", tail = 0.2, trimStart = 0 } = {}) {
   const tl = JSON.parse(fs.readFileSync(path.join(outDir, "timeline.json"), "utf8"));
-  const { frames, speed, outAt } = videoClock(tl, trimStart);
-
-  // Resample to constant frame rate: output tick k shows the newest frame captured at or before k/FPS, and each
-  // run of identical picks becomes one concat entry lasting (run length / FPS). Bursts collapse, gaps hold.
-  const outTimes = frames.map((f) => outAt(f.t));
-  // The screencast only emits a frame when the picture changes, so a static hold at the end (a closing card, a final
-  // pause) has no frame of its own: end at the moment recording stopped, not at the last captured frame.
-  const total = Math.max(outTimes[outTimes.length - 1] + 1 / FPS, outAt(tl.tEnd ?? frames[frames.length - 1].t)) + tail;
-  const ticks = Math.ceil(total * FPS);
-  const runs = [];
-  for (let k = 0, i = 0; k < ticks; k++) {
-    while (i + 1 < frames.length && outTimes[i + 1] <= k / FPS) i++;
-    if (runs.length && runs[runs.length - 1].i === i) runs[runs.length - 1].n++;
-    else runs.push({ i, n: 1 });
+  const capture = path.join(outDir, tl.capture?.file ?? CAPTURE);
+  if (!fs.existsSync(capture)) {
+    throw new Error(tl.capture?.error ?? `${path.basename(capture)} not found in ${outDir}` +
+      (Array.isArray(tl.frames) && !tl.capture ? " (recorded from frames by an earlier version; re-record the segment)" : ""));
   }
-  const lines = ["ffconcat version 1.0"];
-  for (const r of runs) lines.push(`file 'frames/${frames[r.i].file}'`, `duration ${(r.n / FPS).toFixed(6)}`);
-  lines.push(`file 'frames/${frames[runs[runs.length - 1].i].file}'`); // concat demuxer needs the last file repeated
-  fs.writeFileSync(path.join(outDir, "frames.ffconcat"), lines.join("\n"));
+  const { inFrame, fps, spans, keptBefore, outAt, speed } = videoClock(tl, trimStart);
+  // What the master holds is what counts: an encoder that died late still left playable fragments to cut, and its
+  // failure is the explanation only when nothing can be.
+  let nFrames;
+  try { nFrames = countFrames(ffprobeOf(ffmpeg), capture); } catch (e) { throw new Error(tl.capture?.error ?? e.message); }
+  if (nFrames <= inFrame) throw new Error(tl.capture?.error ?? "no frames recorded");
+
+  // Master frame k is the picture at t0 + k/fps. Inside a marked span one frame in `factor` is kept; the kept frames
+  // are re-timed back to back at fps. In the select expression n counts frames after the trim (n = k - inFrame).
+  const keep = spans.filter((s) => s.a < nFrames).reduce((rest, s) => {
+    const a = s.a - inFrame, b = Math.min(s.b, nFrames) - inFrame - 1;
+    return `if(between(n\\,${a}\\,${b})\\,gt(floor((n-${a})/${s.f})\\,floor((n-${a}-1)/${s.f}))\\,${rest})`;
+  }, "1");
+  const kept = keptBefore(nFrames);
+  const total = kept / fps + tail;
 
-  const chapters = tl.marks.chapters.map((c) => ({ ...c, out: Math.max(0, outAt(c.t)) }));
+  // A chapter marked after the master's last frame (a take killed within the second) sits at the end, not past it.
+  const chapters = tl.marks.chapters.map((c) => ({ ...c, out: Math.min(Math.max(0, outAt(c.t)), kept / fps) }));
   const meta = [";FFMETADATA1", `title=${(tl.title || "Demo").replace(/[=;#\\\n]/g, " ")}`];
   chapters.forEach((c, i) => {
     const start = Math.round(c.out * 1000), end = Math.round((i + 1 < chapters.length ? chapters[i + 1].out : total) * 1000);
@@ -62,15 +93,18 @@ export function buildVideo(outDir, outFile, { ffmpeg = process.env.FFMPEG || "ff
   });
   fs.writeFileSync(path.join(outDir, "chapters.ffmeta"), meta.join("\n") + "\n");
 
-  const args = ["-y", "-f", "concat", "-safe", "0", "-i", "frames.ffconcat", "-i", "chapters.ffmeta", "-map_metadata", "1", "-map_chapters", "1",
-    "-t", total.toFixed(3), "-vf", `fps=${FPS},format=yuv420p`, "-c:v", "libx264", "-preset", "slow", "-crf", "17", "-tune", "stillimage", "-movflags", "+faststart", path.resolve(outFile)];
+  // tpad holds the last picture for `tail` (a static close has frames of its own in the master, but the cut
+  // should not end on the very tick recording stopped).
+  const vf = `trim=start_frame=${inFrame},select='${keep}',setpts=N/(${fps}*TB),tpad=stop_mode=clone:stop_duration=${tail.toFixed(3)},format=yuv420p`;
+  const args = ["-y", "-i", capture, "-i", "chapters.ffmeta", "-map_metadata", "1", "-map_chapters", "1", "-vf", vf, "-r", String(fps), "-fps_mode", "cfr",
+    "-c:v", "libx264", "-preset", "slow", "-crf", "17", "-tune", "stillimage", "-movflags", "+faststart", path.resolve(outFile)];
   const r = spawnSync(ffmpeg, args, { cwd: outDir, stdio: ["ignore", "ignore", "pipe"] });
-  if (r.status !== 0) throw new Error(`ffmpeg failed: ${r.stderr?.toString().slice(-2000)}`);
+  if (r.status !== 0) throw new Error(`ffmpeg failed: ${(r.error?.message ?? r.stderr?.toString() ?? "").slice(-2000)}`);
 
   const fmt = (s) => `${Math.floor(s / 60)}:${String(Math.floor(s % 60)).padStart(2, "0")}`;
   const md = ["| Time | Chapter |", "|---|---|", ...chapters.map((c) => `| ${fmt(c.out)} | ${c.title} |`)];
   fs.writeFileSync(path.join(outDir, "chapters.md"), md.join("\n") + "\n");
-  return { seconds: total, chapters: chapters.map((c) => ({ at: fmt(c.out), title: c.title })), speedups: speed.length, frames: frames.length };
+  return { seconds: total, chapters: chapters.map((c) => ({ at: fmt(c.out), title: c.title })), speedups: speed.length, frames: nFrames - inFrame };
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {