agentvfx 0.0.0-stage → 0.3.4

package/skills/agentvfx/test/impact.test.mjs

@@ -0,0 +1,231 @@
+import { after, before, describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { loadLibrary } from "../engine/core/templates.mjs";
+import { validateScore } from "../engine/core/validate.mjs";
+import { renderScore } from "../engine/node/render.mjs";
+import { runJob } from "../engine/node/job.mjs";
+import { findFfmpeg } from "../engine/node/encode.mjs";
+import { openFootage } from "../engine/node/footage.mjs";
+
+const lib = loadLibrary();
+const W = 320;
+const H = 180;
+const SR = 48000;
+const IDS = ["impact-invert", "impact-1bit", "punch-shake", "rgb-hit", "speedline-burst", "strobe-burst"];
+const FLASHING = { "impact-invert": "possible", "impact-1bit": "possible", "speedline-burst": "possible", "strobe-burst": "strobe" };
+let tmp;
+let clip;
+let click;
+let calm;
+let baseFrames;
+
+function wav(seconds, times) {
+  const n = Math.floor(seconds * SR);
+  const data = Buffer.alloc(n * 4);
+  for (const c of times) {
+    for (let k = 0; k < 96 && Math.floor(c * SR) + k < n; k++) {
+      const v = Math.round(Math.sin((2 * Math.PI * 2000 * k) / SR) * Math.exp(-k / 24) * 0.9 * 32767);
+      const o = (Math.floor(c * SR) + k) * 4;
+      data.writeInt16LE(v, o);
+      data.writeInt16LE(v, o + 2);
+    }
+  }
+  const h = Buffer.alloc(44);
+  h.write("RIFF", 0);
+  h.writeUInt32LE(36 + data.length, 4);
+  h.write("WAVEfmt ", 8);
+  h.writeUInt32LE(16, 16);
+  h.writeUInt16LE(1, 20);
+  h.writeUInt16LE(2, 22);
+  h.writeUInt32LE(SR, 24);
+  h.writeUInt32LE(SR * 4, 28);
+  h.writeUInt16LE(4, 32);
+  h.writeUInt16LE(16, 34);
+  h.write("data", 36);
+  h.writeUInt32LE(data.length, 40);
+  return Buffer.concat([h, data]);
+}
+
+const score = (hits, extra = {}) => {
+  const v = validateScore({ version: 1, template: "sacred", params: { blend: 0 }, input: { video: clip }, durationSec: 3, seed: 5, hits, out: "t", credit: { overlay: false }, ...extra }, lib);
+  assert.equal(v.ok, true, JSON.stringify(v.errors));
+  return v.value;
+};
+
+async function frames(sc, keep, audio = null) {
+  const footage = openFootage(clip, { fps: 30, durationSec: sc.durationSec, longEdge: W });
+  const kept = new Map();
+  const dir = mkdtempSync(path.join(tmp, "r-"));
+  try {
+    await renderScore(sc, lib, { outDir: dir, width: W, height: H, footage, replay: false, features: audio, onFrame: (f, a) => { if (keep.includes(f)) kept.set(f, Buffer.from(a.rgba)); } });
+  } finally {
+    footage.close();
+  }
+  return kept;
+}
+
+function diff(a, b, ch = [0, 1, 2]) {
+  let s = 0;
+  for (let i = 0; i < W * H; i++) for (const c of ch) s += Math.abs(a[i * 4 + c] - b[i * 4 + c]);
+  return s / (W * H * ch.length);
+}
+const same = (a, b) => diff(a, b) === 0;
+
+function lumaPerFrame(film) {
+  const r = spawnSync(findFfmpeg(), ["-v", "error", "-i", film, "-vf", "scale=16:9:flags=area,format=gray", "-f", "rawvideo", "-"], { maxBuffer: 1 << 26 });
+  assert.equal(r.status, 0, r.stderr?.toString());
+  const out = [];
+  for (let f = 0; f * 144 < r.stdout.length; f++) out.push(r.stdout.subarray(f * 144, f * 144 + 144).reduce((s, v) => s + v, 0) / 144);
+  return out;
+}
+
+before(async () => {
+  tmp = mkdtempSync(path.join(tmpdir(), "agentvfx-impact-"));
+  clip = path.join(tmp, "in.mp4");
+  const r = spawnSync(findFfmpeg(), ["-v", "error", "-y", "-f", "lavfi", "-i", `testsrc2=size=${W}x${H}:rate=30`, "-t", "4", "-c:v", "libx264", "-pix_fmt", "yuv420p", clip], { encoding: "utf8" });
+  assert.equal(r.status, 0, r.stderr);
+  calm = path.join(tmp, "calm.mp4");
+  const g = spawnSync(findFfmpeg(), ["-v", "error", "-y", "-f", "lavfi", "-i", `color=c=0x3a4048:size=${W}x${H}:rate=30`, "-t", "4", "-c:v", "libx264", "-pix_fmt", "yuv420p", calm], { encoding: "utf8" });
+  assert.equal(g.status, 0, g.stderr);
+  click = path.join(tmp, "click-240.wav");
+  writeFileSync(click, wav(4, Array.from({ length: 15 }, (_, k) => k * 0.25)));
+  baseFrames = await frames(score([]), Array.from({ length: 90 }, (_, i) => i));
+});
+after(() => rmSync(tmp, { recursive: true, force: true }));
+
+describe("impact family library contract", () => {
+  for (const id of IDS) {
+    it(`${id}: declared honestly, 3+ presets, safe substitute for flashing templates, demo validates`, () => {
+      const t = lib.get(id);
+      assert.ok(t, `${id} missing from the library`);
+      assert.equal(t.family, "impact");
+      assert.ok(Object.keys(t.fx.X_AGENTVFX.presets).length >= 3);
+      assert.equal(t.fx.X_AGENTVFX.flash, FLASHING[id] ?? "none");
+      if (FLASHING[id]) {
+        const sub = t.fx.X_AGENTVFX.safeSubstitute;
+        assert.ok(sub, `${id} needs safeSubstitute`);
+        if (sub.template) assert.equal(lib.get(sub.template).fx.X_AGENTVFX.flash, "none");
+        else assert.ok(sub.params && sub.params.pulses === 1 && sub.params.level <= 0.09, "params-only substitute must be a single low-level pulse");
+      }
+      for (const preset of Object.keys(t.fx.X_AGENTVFX.presets)) score([{ t: 1, template: id, preset, durationFrames: 6 }]);
+    });
+  }
+});
+
+describe("hit behaviour at frame level (hit at frame 30)", () => {
+  const run = async (id, preset, durationFrames, params, keep) => frames(score([{ t: 1, template: id, preset, params, durationFrames }]), keep);
+
+  it("impact-invert: hard negative, chunky (no blended pixels) while decaying, clean after", async () => {
+    const k = await run("impact-invert", "invert-snap", 4, { hitFrames: 4, holdFrames: 1, decayCurve: 1 }, [29, 30, 31, 34]);
+    assert.ok(same(k.get(29), baseFrames.get(29)));
+    assert.ok(diff(k.get(30), baseFrames.get(30)) > 60, "frame 30 is a hard negative");
+    const a = k.get(31);
+    const b = baseFrames.get(31);
+    let changed = 0;
+    let acc = 0;
+    for (let i = 0; i < W * H; i++) {
+      const d = Math.abs(a[i * 4] - b[i * 4]) + Math.abs(a[i * 4 + 1] - b[i * 4 + 1]) + Math.abs(a[i * 4 + 2] - b[i * 4 + 2]);
+      if (d > 6) { changed += 1; acc += d; }
+    }
+    const frac = changed / (W * H);
+    assert.ok(frac > 0.2 && frac < 0.95, `decay frame changes ${(frac * 100).toFixed(0)}% of pixels`);
+    assert.ok(acc / changed / 3 > 40, "changed pixels are fully inverted, not a milky mix");
+    assert.ok(same(k.get(34), baseFrames.get(34)), "clean frame after the hit");
+  });
+
+  it("impact-1bit: two flat colours only, clean after the hit", async () => {
+    const k = await run("impact-1bit", "onebit-hard", 3, { hitFrames: 3, holdFrames: 2 }, [30, 33]);
+    const f = k.get(30);
+    let flat = 0;
+    for (let i = 0; i < W * H; i++) if ([0, 1, 2].every((c) => f[i * 4 + c] <= 8) || [0, 1, 2].every((c) => f[i * 4 + c] >= 247)) flat += 1;
+    assert.ok(flat / (W * H) > 0.99, `${((flat / (W * H)) * 100).toFixed(1)}% pure black or white`);
+    assert.ok(same(k.get(33), baseFrames.get(33)));
+  });
+
+  it("punch-shake: scales and shakes the frame, decays, clean after hitFrames", async () => {
+    const k = await run("punch-shake", "punch-hard", 6, {}, [29, 30, 32, 35, 36]);
+    assert.ok(same(k.get(29), baseFrames.get(29)));
+    const d0 = diff(k.get(30), baseFrames.get(30));
+    assert.ok(d0 > 15, `punch frame differs by ${d0.toFixed(1)}`);
+    assert.ok(diff(k.get(35), baseFrames.get(35)) < d0, "decays");
+    assert.ok(same(k.get(36), baseFrames.get(36)));
+  });
+
+  it("rgb-hit: only red and blue move, green untouched, back to clean", async () => {
+    const k = await run("rgb-hit", "rgb-slam", 6, { tearRows: 0, pop: 1, hitFrames: 6 }, [30, 36]);
+    const a = k.get(30);
+    const b = baseFrames.get(30);
+    assert.ok(diff(a, b, [1]) <= 1, "green channel unchanged");
+    assert.ok(diff(a, b, [0]) > 4 && diff(a, b, [2]) > 4, "red and blue are displaced");
+    assert.ok(same(k.get(36), baseFrames.get(36)));
+  });
+
+  it("speedline-burst: hard white core at the centre, lines reach the edge, clean after", async () => {
+    const k = await run("speedline-burst", "speed-white", 5, {}, [30, 35]);
+    const f = k.get(30);
+    const o = ((H >> 1) * W + (W >> 1)) * 4;
+    assert.deepEqual([f[o], f[o + 1], f[o + 2]], [255, 255, 255]);
+    assert.ok(diff(f, baseFrames.get(30)) > 20);
+    assert.ok(same(k.get(35), baseFrames.get(35)));
+  });
+});
+
+describe("strobe-burst: 240 BPM grid, stage and safe variant", () => {
+  const P = { tempo: 240, division: 16, pulses: 8, duty: 0.5, offDim: 0.35 };
+  const period = (60 / 240 * 4) / 16 * 30;
+  const litAt = (n) => {
+    const p = Math.floor(n / period + 1e-4);
+    return p < P.pulses && n - p * period < Math.max(1, Math.floor(period * P.duty + 0.5)) - 1e-4;
+  };
+  const sc = () => score([], { input: { video: clip, audio: click }, durationSec: 4 });
+
+  it("stage mode renders every scheduled flash on the detected beats, writes SAFETY.txt", async () => {
+    const dir = mkdtempSync(path.join(tmp, "job-"));
+    const probe = await runJob({ ...sc(), hits: [] }, lib, { outDir: dir, width: 160, height: 90, replay: false });
+    const beats = JSON.parse(readFileSync(path.join(dir, "features.json"), "utf8")).meta.beats;
+    assert.ok(beats.length >= 4, `only ${beats.length} beats detected`);
+    for (const b of beats) assert.ok(Array.from({ length: 16 }, (_, k) => Math.round(k * 7.5)).some((c) => Math.abs(c - b) <= 1), `beat ${b} is not on the 240 BPM clicks`);
+    assert.equal(probe.ok, true);
+    const hitLen = 8;
+    const run = await runJob(score(beats.map((b) => ({ beat: beats.indexOf(b), template: "strobe-burst", params: P, durationFrames: hitLen })), { input: { video: clip, audio: click }, durationSec: 4 }), lib, { outDir: dir, width: W, height: H, replay: false });
+    const lum = lumaPerFrame(run.render.film);
+    for (const b of beats) {
+      if (b + hitLen > lum.length) continue;
+      assert.ok(lum[b] > 240, `hit at beat ${b} is not a full white frame (${lum[b].toFixed(0)})`);
+      for (let n = 0; n < hitLen; n++) {
+        if (litAt(n)) assert.ok(lum[b + n] > 240, `scheduled flash at beat ${b}+${n} missing (${lum[b + n].toFixed(0)})`);
+        else assert.ok(lum[b + n] < 240, `frame ${b + n} should be between flashes`);
+      }
+    }
+    assert.ok(existsSync(path.join(dir, "SAFETY.txt")), "SAFETY.txt written in stage mode");
+    assert.equal(run.flash.exceeds, true);
+  });
+
+  it("safeVariant: film.safe.mp4 stays within the flash limits", async () => {
+    const hits = Array.from({ length: 16 }, (_, k) => ({ t: k * 0.25, template: "strobe-burst", params: { tempo: 240, division: 16 }, durationFrames: 2 }));
+    const dir = mkdtempSync(path.join(tmp, "job-"));
+    const run = await runJob(score(hits, { input: { video: calm, audio: click }, durationSec: 4, safety: { mode: "stage", safeVariant: true } }), lib, { outDir: dir, width: W, height: H, replay: false });
+    assert.equal(run.flash.exceeds, true, "the stage master flashes too much by design");
+    assert.ok(run.safeVariant, "safe variant rendered");
+    assert.equal(run.safeVariant.flash.exceeds, false, JSON.stringify(run.safeVariant.flash));
+    assert.ok(existsSync(path.join(dir, "film.safe.mp4")));
+    assert.ok(run.safeVariant.substitutions.length > 0, "over-rate hits were substituted");
+  });
+});
+
+describe("every impact template renders, replays deterministically, reports flashes", () => {
+  for (const id of IDS) {
+    it(id, async () => {
+      const dir = mkdtempSync(path.join(tmp, "job-"));
+      const preset = Object.keys(lib.get(id).fx.X_AGENTVFX.presets)[0];
+      const run = await runJob(score([{ t: 1, template: id, preset, durationFrames: 6 }]), lib, { outDir: dir, width: W, height: H, replay: true });
+      assert.equal(run.render.frames, 90);
+      assert.equal(run.determinism.pass, true);
+      assert.ok(run.flash && typeof run.flash.exceeds === "boolean", "flash report present");
+    });
+  }
+});

package/skills/agentvfx/test/imports.test.mjs

@@ -0,0 +1,39 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const SKILL = fileURLToPath(new URL("..", import.meta.url));
+const ENGINE = path.join(SKILL, "engine");
+
+const walk = (dir) => readdirSync(dir).flatMap((n) => {
+  const p = path.join(dir, n);
+  return statSync(p).isDirectory() ? walk(p) : p.endsWith(".mjs") ? [p] : [];
+});
+const files = walk(ENGINE);
+
+test("every relative import in the engine stays inside skill/agentvfx", () => {
+  for (const f of files) {
+    const text = readFileSync(f, "utf8");
+    for (const m of text.matchAll(/(?:from|import)\s*\(?\s*["'](\.{1,2}\/[^"']+)["']/gu)) {
+      const target = path.resolve(path.dirname(f), m[1]);
+      assert.ok(target.startsWith(SKILL), `${path.relative(SKILL, f)} imports ${m[1]} outside the skill`);
+    }
+  }
+});
+
+// Browser entry modules touch the DOM at load; for them only check that every relative import exists.
+const isBrowserEntry = (f) => /\bdocument\.getElementById\b/u.test(readFileSync(f, "utf8"));
+
+for (const f of files) {
+  test(`imports ${path.relative(SKILL, f)}`, async () => {
+    if (!isBrowserEntry(f)) {
+      await import(pathToFileURL(f).href);
+      return;
+    }
+    for (const m of readFileSync(f, "utf8").matchAll(/from\s*["'](\.{1,2}\/[^"']+)["']/gu)) {
+      assert.ok(existsSync(path.resolve(path.dirname(f), m[1])), `${path.relative(SKILL, f)} imports missing ${m[1]}`);
+    }
+  });
+}

package/skills/agentvfx/test/light.test.mjs

@@ -0,0 +1,200 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createFlashAuditor } from "../engine/core/flash.mjs";
+import { loadLibrary } from "../engine/core/templates.mjs";
+import { validateScore, validateTemplate } from "../engine/core/validate.mjs";
+import { openFootage } from "../engine/node/footage.mjs";
+import { renderScore } from "../engine/node/render.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const clip = path.join(root, "test-media/clip-01.mp4");
+const familyDir = path.join(root, "templates/light");
+const IDS = ["bloom-glow", "anamorphic-streak", "god-rays", "light-leak", "neon-saber", "lens-flare", "light-sweep"];
+const BASES = ["light-stage"];
+
+function rec709(buf, o) {
+  return (0.2126 * buf[o] + 0.7152 * buf[o + 1] + 0.0722 * buf[o + 2]) / 255;
+}
+
+/** Mean display luma of the 1px ring at radius r around (cx, cy). */
+function ringMean(buf, w, h, cx, cy, r) {
+  const steps = Math.max(24, Math.ceil(Math.PI * 2 * r));
+  let sum = 0;
+  let n = 0;
+  for (let i = 0; i < steps; i++) {
+    const a = (i / steps) * Math.PI * 2;
+    const x = Math.round(cx + Math.cos(a) * r);
+    const y = Math.round(cy + Math.sin(a) * r);
+    if (x < 0 || y < 0 || x >= w || y >= h) continue;
+    sum += rec709(buf, (y * w + x) * 4);
+    n += 1;
+  }
+  return sum / n;
+}
+
+/** Mean display luma of the darkest fifth of the frame. */
+function darkestMean(buf, w, h) {
+  const n = w * h;
+  const lum = new Float64Array(n);
+  for (let i = 0; i < n; i++) lum[i] = rec709(buf, i * 4);
+  const sorted = Float64Array.from(lum).sort();
+  const k = Math.max(1, Math.floor(n * 0.2));
+  let sum = 0;
+  for (let i = 0; i < k; i++) sum += sorted[i];
+  return sum / k;
+}
+
+function findImpulse(buf, w, h) {
+  let best = -1;
+  let x = 0;
+  let y = 0;
+  const x0 = Math.floor(w * 0.35);
+  const x1 = Math.ceil(w * 0.65);
+  const y0 = Math.floor(h * 0.35);
+  const y1 = Math.ceil(h * 0.65);
+  for (let yy = y0; yy < y1; yy++) {
+    for (let xx = x0; xx < x1; xx++) {
+      const o = (yy * w + xx) * 4;
+      const s = buf[o] + buf[o + 1] + buf[o + 2];
+      if (s > best) {
+        best = s;
+        x = xx;
+        y = yy;
+      }
+    }
+  }
+  return { x, y };
+}
+
+/** Radius, as a fraction of height, where the halo falls through half its inner-ring peak. */
+function halfRadiusFrac(buf, w, h, cx, cy) {
+  const maxR = Math.floor(h * 0.45);
+  const rings = [];
+  for (let r = 1; r <= maxR; r++) rings.push(ringMean(buf, w, h, cx, cy, r));
+  let worstRise = 0;
+  let worstStep = 0;
+  for (let i = 0; i < rings.length - 1; i++) {
+    worstRise = Math.max(worstRise, rings[i + 1] - rings[i]);
+    worstStep = Math.max(worstStep, rings[i] - rings[i + 1]);
+  }
+  const peak = rings[0];
+  let half = rings.length + 1;
+  for (let i = 0; i < rings.length; i++) {
+    if (rings[i] < peak * 0.5) {
+      half = i + 1;
+      break;
+    }
+  }
+  return { worstRise, worstStep, peak, frac: half / h };
+}
+
+test("light family", { timeout: 1_800_000 }, async (t) => {
+  const lib = loadLibrary();
+
+  await t.test("seven templates validate and each demo score validates", () => {
+    assert.deepEqual([...lib.keys()].filter((id) => lib.get(id).family === "light").sort(), [...IDS, ...BASES].sort());
+    for (const id of [...IDS, ...BASES]) {
+      const tpl = lib.get(id);
+      const v = validateTemplate(tpl.fx, id);
+      assert.equal(v.ok, true, `${id} ${JSON.stringify(v.errors)}`);
+      assert.equal(tpl.fx.X_AGENTVFX.family, "light");
+      assert.ok(Object.keys(tpl.fx.X_AGENTVFX.presets).length >= 3);
+      if (!IDS.includes(id)) continue;
+      const demos = readdirSync(path.join(familyDir, id)).filter((f) => f.startsWith("demo-") && f.endsWith(".json"));
+      assert.ok(demos.length >= 1, `${id} needs a demo score`);
+      for (const demo of demos) {
+        const score = JSON.parse(readFileSync(path.join(familyDir, id, demo), "utf8"));
+        const s = validateScore(score, lib);
+        assert.equal(s.ok, true, `${demo} ${JSON.stringify(s.errors)}`);
+      }
+    }
+  });
+
+  for (const id of IDS) {
+    await t.test(`${id} renders 90 frames, determinism passes, flash audit is recorded`, async () => {
+      const tpl = lib.get(id);
+      const preset = Object.keys(tpl.fx.X_AGENTVFX.presets)[0];
+      const dir = mkdtempSync(path.join(tmpdir(), "agentvfx-light-"));
+      const ref = openFootage(clip, { fps: 30, durationSec: 3, longEdge: 320 });
+      const src0 = Buffer.from(await ref.frame(0));
+      ref.close();
+      const footage = openFootage(clip, { fps: 30, durationSec: 3, longEdge: 320 });
+      const auditor = createFlashAuditor({ fps: 30, width: footage.width, height: footage.height });
+      let out0 = null;
+      try {
+        const v = validateScore({
+          version: 1, template: id, preset, input: { video: clip }, durationSec: 3, seed: 12, out: id,
+        }, lib);
+        assert.equal(v.ok, true, JSON.stringify(v.errors));
+        const report = await renderScore(v.value, lib, {
+          outDir: dir,
+          width: footage.width,
+          height: footage.height,
+          footage,
+          replay: true,
+          onFrame: (f, a) => {
+            auditor.push({ width: footage.width, height: footage.height, data: a.rgba });
+            if (f === 0 && !out0) out0 = Buffer.from(a.rgba);
+          },
+        });
+        const flash = auditor.finish();
+        assert.equal(report.frames, 90);
+        const rise = darkestMean(out0, footage.width, footage.height) - darkestMean(src0, footage.width, footage.height);
+        assert.ok(rise <= 0.03, `${id} darkest-fifth luma rose ${rise.toFixed(4)}`);
+        assert.equal(report.determinism.pass, true, JSON.stringify(report.determinism));
+        assert.equal(typeof flash.flashesPerSecondMax, "number");
+        assert.equal(typeof flash.redFlashes, "number");
+        assert.equal(typeof flash.exceeds, "boolean");
+        assert.equal(flash.limits.frames, 90);
+      } finally {
+        footage.close();
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  }
+
+  await t.test("bloom-glow on one white pixel falls off smoothly and the radius scales", async () => {
+    const probe = {
+      version: 1,
+      template: "bloom-glow",
+      params: {
+        probeDot: 1, paletteMix: 0, tint: [1, 1, 1, 1], toneMap: 1,
+        bloomRadius: 0.36, bloomMix: 0.15, bloomGain: 16, levelGain: 1.6,
+        coreTrim: 0.04, threshold: 0.15, knee: 0.9,
+      },
+      durationSec: 3,
+      seed: 3,
+      out: "bloom-probe",
+    };
+    const v = validateScore(probe, lib);
+    assert.equal(v.ok, true, JSON.stringify(v.errors));
+    const measured = [];
+    for (const [w, h] of [[960, 540], [1920, 1080]]) {
+      const dir = mkdtempSync(path.join(tmpdir(), "agentvfx-bloom-"));
+      let kept = null;
+      try {
+        const report = await renderScore(v.value, lib, {
+          outDir: dir, width: w, height: h, replay: false,
+          onFrame: (f, a) => { if (f === 0) kept = Buffer.from(a.rgba); },
+        });
+        assert.equal(report.frames, 90);
+        const spot = findImpulse(kept, w, h);
+        const centre = rec709(kept, (spot.y * w + spot.x) * 4);
+        assert.ok(centre > 0.75, `impulse pixel ${centre.toFixed(3)} at ${w}x${h}`);
+        const m = halfRadiusFrac(kept, w, h, spot.x, spot.y);
+        assert.ok(m.peak >= 12 / 255, `halo peak ${(m.peak * 255).toFixed(1)}/255 at ${w}x${h}`);
+        assert.ok(m.worstRise * 255 <= 2, `rise ${(m.worstRise * 255).toFixed(2)}/255 at ${w}x${h}`);
+        assert.ok(m.worstStep * 255 <= 2, `step ${(m.worstStep * 255).toFixed(2)}/255 at ${w}x${h}`);
+        measured.push(m.frac);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+    const rel = Math.abs(measured[0] - measured[1]) / Math.max(measured[1], 1e-4);
+    assert.ok(rel <= 0.05, `relative radii ${measured.map((n) => n.toFixed(4)).join(" vs ")} differ by ${(rel * 100).toFixed(1)}%`);
+  });
+});

package/skills/agentvfx/test/loop.test.mjs

@@ -0,0 +1,80 @@
+// Ping-pong loop tool: no audio, 2N-2 frames, seamless wrap, flash audit over the loop played twice.
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { findFfmpeg, findFfprobe, probeVideo } from "../engine/node/encode.mjs";
+import { auditLoop, pingpong, readFrames } from "../scripts/loop.mjs";
+
+const ffmpeg = findFfmpeg();
+const ffprobe = findFfprobe();
+
+function makeClip(dir, n = 30) {
+  // 1 s, 30 fps, 160x90 ffmpeg test pattern (moves every frame), with a sine audio track that must be dropped.
+  const src = path.join(dir, "src.mp4");
+  const r = spawnSync(ffmpeg, ["-y", "-v", "error", "-f", "lavfi", "-i", "testsrc2=s=160x90:r=30:d=1",
+    "-f", "lavfi", "-i", "sine=f=440:d=1",
+    "-frames:v", String(n), "-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac", "-shortest", src]);
+  assert.equal(r.status, 0, String(r.stderr));
+  return src;
+}
+
+test("pingpong drops audio, has 2N-2 frames and wraps without a jump", { skip: !ffmpeg || !ffprobe }, () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "agentvfx-loop-"));
+  try {
+    const src = makeClip(dir);
+    const out = path.join(dir, "loop.mp4");
+    const res = pingpong(src, out);
+    assert.equal(res.frames, 58);
+    const audio = spawnSync(ffprobe, ["-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0", out], { encoding: "utf8" });
+    assert.equal(audio.stdout.trim(), "", "no audio stream");
+    assert.equal(probeVideo(out).frames, 58);
+    const frames = readFrames(out);
+    const mad = (a, b) => { let s = 0; for (let i = 0; i < a.data.length; i += 4) s += Math.abs(a.data[i] - b.data[i]); return s / (a.data.length / 4); };
+    const step = mad(frames[0], frames[1]);
+    const wrap = mad(frames.at(-1), frames[0]);
+    assert.ok(step > 0.5, "the box moves");
+    assert.ok(wrap <= step * 1.5, `wrap step ${wrap} vs normal step ${step}`);
+    const jump = mad(readFrames(src).at(-1), readFrames(src)[0]);
+    assert.ok(jump > step * 5, "negative control: the source loop jumps");
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("pingpong hold freezes each turn for the given frames", { skip: !ffmpeg || !ffprobe }, () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "agentvfx-loop-"));
+  try {
+    const out = path.join(dir, "hold.mp4");
+    assert.equal(pingpong(makeClip(dir), out, { hold: 3 }).frames, 64);
+    assert.equal(probeVideo(out).frames, 64);
+    const f = readFrames(out);
+    const mad = (a, b) => { let s = 0; for (let i = 0; i < a.data.length; i += 4) s += Math.abs(a.data[i] - b.data[i]); return s / (a.data.length / 4); };
+    assert.ok(mad(f[29], f[32]) < 1, "frames 29..32 are the held turn");
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("auditLoop fails a full-frame strobe (negative control)", { skip: !ffmpeg || !ffprobe }, async () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "agentvfx-loop-"));
+  try {
+    const src = path.join(dir, "strobe.mp4");
+    const r = spawnSync(ffmpeg, ["-y", "-v", "error", "-f", "lavfi", "-i", "color=c=black:s=160x90:r=30:d=1",
+      "-vf", "geq=lum='if(mod(N,2),235,16)':cb=128:cr=128", "-c:v", "libx264", "-pix_fmt", "yuv420p", src]);
+    assert.equal(r.status, 0, String(r.stderr));
+    const out = path.join(dir, "loop.mp4");
+    pingpong(src, out);
+    assert.equal((await auditLoop(out)).pass, false);
+    assert.throws(() => pingpong(src, out, { hold: 1.5 }), /hold/);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("auditLoop reports a pass for a calm clip, played twice", { skip: !ffmpeg || !ffprobe }, async () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "agentvfx-loop-"));
+  try {
+    const out = path.join(dir, "loop.mp4");
+    pingpong(makeClip(dir), out);
+    const a = await auditLoop(out);
+    assert.equal(a.pass, true);
+    assert.equal(a.limits.frames, 116);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});

package/skills/agentvfx/test/psychedelic.test.mjs

@@ -0,0 +1,99 @@
+// Psychedelic family tests (plan task 8 acceptance criteria).
+// Every template: validates, renders 120 frames, determinism passes with a
+// recorded flash audit. echo-flow and mosh-melt declare a persistent pass.
+// hologram-scan flicker is visible in strips (frame-to-frame fill change).
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadLibrary } from "../engine/core/templates.mjs";
+import { validateScore } from "../engine/core/validate.mjs";
+import { runJob } from "../engine/node/job.mjs";
+
+const lib = loadLibrary({ includeTest: true });
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const W = 320;
+const H = 180;
+const CLIP = "test-media/clip-01.mp4";
+
+const CASES = [
+  ["tidal-bands", "tidal-classic"],
+  ["kaleido-fold", "kaleido-six"],
+  ["hologram-scan", "holo-cyan"],
+  ["echo-flow", "echo-trail"],
+  ["mosh-melt", "mosh-classic"],
+];
+
+function scoreFor(template, preset, extra = {}) {
+  const v = validateScore(
+    { version: 1, template, preset, input: { video: CLIP }, durationSec: 4, seed: 11, out: "t", ...extra },
+    lib,
+  );
+  assert.equal(v.ok, true, JSON.stringify(v.errors));
+  return v.value;
+}
+
+for (const [template, preset] of CASES) {
+  test(`${template}/${preset}: validates, renders 120 frames, deterministic, flash audit recorded`, async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "agentvfx-psy-"));
+    try {
+      const gate = await runJob(scoreFor(template, preset), lib, { outDir: dir, width: W, height: H, replay: true, cwd: ROOT });
+      assert.equal(gate.render.frames, 120, `rendered ${gate.render.frames} frames`);
+      assert.equal(gate.determinism.checked, true);
+      assert.equal(gate.determinism.pass, true, JSON.stringify(gate.determinism.firstDifference));
+      assert.ok(gate.flash && typeof gate.flash.exceeds === "boolean", "flash audit missing");
+      assert.ok(gate.stills.sheet, "contact sheet missing");
+      assert.ok(gate.stills.strips.length >= 1, "strips missing");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+}
+
+test("echo-flow and mosh-melt declare a persistent pass", () => {
+  for (const id of ["echo-flow", "mosh-melt"]) {
+    const t = lib.get(id);
+    assert.ok(t, `${id} missing from library`);
+    const persistent = (t.fx.PASSES ?? []).filter((p) => p.PERSISTENT === true);
+    assert.ok(persistent.length >= 1, `${id} has no PERSISTENT pass`);
+  }
+});
+
+test("hologram-scan flicker is visible: fill luminance swing >= 0.1 at peaks", async () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "agentvfx-psy-"));
+  try {
+    const gate = await runJob(scoreFor("hologram-scan", "holo-storm"), lib, { outDir: dir, width: W, height: H, replay: false, cwd: ROOT });
+    const film = gate.render.film;
+    const p = spawnSync("ffmpeg", ["-v", "error", "-i", film, "-f", "rawvideo", "-pix_fmt", "rgb24", "pipe:1"], { maxBuffer: 1 << 30 });
+    assert.equal(p.status, 0, p.stderr?.toString());
+    const stride = W * H * 3;
+    const n = Math.floor(p.stdout.length / stride);
+    assert.ok(n >= 115, `decoded ${n} frames`);
+    const meanLuma = (k) => {
+      const o = k * stride;
+      let s = 0;
+      let c = 0;
+      for (let y = H >> 2; y < (3 * H) >> 2; y += 2) {
+        for (let x = W >> 2; x < (3 * W) >> 2; x += 2) {
+          const i = o + (y * W + x) * 3;
+          s += 0.2126 * p.stdout[i] + 0.7152 * p.stdout[i + 1] + 0.0722 * p.stdout[i + 2];
+          c++;
+        }
+      }
+      return s / (c * 255);
+    };
+    let peak = 0;
+    let prev = meanLuma(0);
+    for (let k = 1; k < n; k++) {
+      const m = meanLuma(k);
+      peak = Math.max(peak, Math.abs(m - prev));
+      prev = m;
+    }
+    assert.ok(peak >= 0.1, `flicker peak swing ${peak.toFixed(3)}`);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});