@officexapp/vidfarm-devcli 0.21.34 → 0.21.35

package/dist/src/devcli/qa-check.js

@@ -25,6 +25,33 @@
 // Pure DOM (linkedom) — no ffmpeg, no network, no Chrome. Local-only: this is a
 // devcli capability with no cloud/REST equivalent.
 import { parseHTML } from "linkedom";
+/**
+ * Build the "now go watch it" directive. `dir` is substituted into the commands
+ * so the agent can paste them; the JSON default is the generic placeholder.
+ */
+export function watchTheVideoDirective(dir = "<dir>", renderPath) {
+    const video = renderPath || "<render>.mp4";
+    return {
+        required: true,
+        why: "`vidfarm qa` is a static DOM check. It did NOT render this composition, and it has never seen a single pixel of the video — " +
+            "so it cannot tell you whether the video is any good. A clean QA run means the markup is clean; it says nothing about drift " +
+            "across scenes, a frozen render, a caption sitting on top of the subject, a join that lands like a slap, or audio nobody can " +
+            "hear. Those are the defects that actually ship. Watching the video is a required step, not a nicety — and 'it looks fine' " +
+            "from an agent that never opened a frame was wrong on every video of a 32-video batch.",
+        steps: [
+            renderPath
+                ? `Re-render if you have edited since: \`vidfarm render ${dir} --target local\` (newest render: ${renderPath})`
+                : `Render it: \`vidfarm render ${dir} --target local\``,
+            `Look at the WHOLE thing: \`vidfarm stills ${dir} --sheet\` — then actually OPEN ${dir}/stills/contact-sheet.png and read it as an image. Reading the filenames is not looking at the video.`,
+            "Judge it as one sequence, not scene by scene: one type scale, steady margins, one palette, deliberate pacing, clean joins, no dead bands.",
+            "Judge every caption AGAINST ITS PICTURE: is the line sitting in the emptiest part of that frame, or on top of the subject? Is it small enough not to run edge-to-edge? Does it even need its plate? qa cannot see pixels — you can.",
+            "Compare frames from two DIFFERENT scenes — a frozen render passes duration, frame-count and audio-hash checks and still ships a still image.",
+            "Time it against your own thumb: name the seconds you would cut. Any beat you can delete without losing the payoff IS fluff — cut it and ripple the hole closed. Assume your first cut is 30–50% too long, and say out loud which beat you cut, or why nothing could go.",
+            `Measure the audio instead of vibing it: \`ffmpeg -i ${video} -af volumedetect -f null -\` (peak < 0 dBFS, speech ~12–15 dB over the bed).`,
+            "Report what you MEASURED separately from what you JUDGED, and say plainly if you did not watch it."
+        ]
+    };
+}
 // ── The font regime ───────────────────────────────────────────────────────────
 // Mirrors CAPTION_FONT_REGIME in composition-edit.ts / COMPOSITION_FONT_IMPORT
 // in services/studio-project-adapter.ts. A family outside this set is not even
@@ -78,6 +105,45 @@ function coversTime(node, t) {
 function textOf(node) {
     return String(node?.textContent ?? "").replace(/\s+/g, " ").trim();
 }
+function wordsIn(text) {
+    return text.split(/\s+/).filter(Boolean).length;
+}
+/** Merge [start,end) spans into non-overlapping, ascending cover intervals. */
+function mergeSpans(spans) {
+    const sorted = spans
+        .filter((s) => Number.isFinite(s.start) && Number.isFinite(s.end) && s.end > s.start)
+        .sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const span of sorted) {
+        const last = merged[merged.length - 1];
+        if (last && span.start <= last.end + 0.001)
+            last.end = Math.max(last.end, span.end);
+        else
+            merged.push({ start: span.start, end: span.end });
+    }
+    return merged;
+}
+/**
+ * The widest stretch INSIDE the words — first cue to last — where nothing is on
+ * screen to read. Leading silence is the hook's problem (own rule) and trailing
+ * silence is the tail's, so both are excluded here.
+ */
+function widestGap(cover) {
+    let widest = null;
+    for (let i = 1; i < cover.length; i += 1) {
+        const gap = { start: cover[i - 1].end, end: cover[i].start };
+        if (!widest || gap.end - gap.start > widest.end - widest.start)
+            widest = gap;
+    }
+    return widest;
+}
+function median(values) {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
 function classTokens(node) {
     return String(node?.getAttribute?.("class") ?? "").split(/\s+/).filter(Boolean);
 }
@@ -167,11 +233,19 @@ export function qaCompositionHtml(html) {
             verdict: "clean",
             errors: [],
             warnings: [],
-            checked: { layers: 0, text_layers: 0, canvas: null }
+            checked: { layers: 0, text_layers: 0, canvas: null },
+            watch_the_video: watchTheVideoDirective()
         };
     }
     if (!root) {
-        return { ok: true, verdict: "clean", errors: [], warnings: [], checked: { layers: 0, text_layers: 0, canvas: null } };
+        return {
+            ok: true,
+            verdict: "clean",
+            errors: [],
+            warnings: [],
+            checked: { layers: 0, text_layers: 0, canvas: null },
+            watch_the_video: watchTheVideoDirective()
+        };
     }
     const push = (f) => findings.push(f);
     const all = Array.from(root.querySelectorAll("*"));
@@ -457,8 +531,41 @@ export function qaCompositionHtml(html) {
                     fix: `Aim for ~${Math.round(canvasW * 0.033)}–${Math.round(canvasW * 0.06)}px.`
                 });
             }
+            else if (canvasW && sizePx > canvasW * 0.075 && wordsIn(textOf(node)) >= 5) {
+                // Display type is for one to three hook words. On a whole sentence it
+                // runs frame-edge to frame-edge, wraps to three lines, and eats a third
+                // of the picture — which is also what forces a full-width plate under
+                // it. TWO signals required (size AND length), so a huge two-word hook
+                // card never trips this.
+                push({
+                    rule: "caption-oversize",
+                    severity: "warn",
+                    message: `font-size ${Math.round(sizePx)}px on a ${wordsIn(textOf(node))}-word line (canvas ${canvasW}px wide) — display type on a full sentence runs edge-to-edge, wraps, and covers the frame.`,
+                    where: label(node, "text layer"),
+                    fix: `Shrink the type to ~${Math.round(canvasW * 0.033)}–${Math.round(canvasW * 0.06)}px, or keep this size and cut the cue to 1–3 words. If a line reaches the frame edges the fix is smaller text or fewer words — never a wider box. Then place it where the frame is empty (\`vidfarm stills <dir> --at <t>\` first): text with room around it usually needs no plate at all.`
+                });
+            }
         }
     }
+    // ── Rule: wall of text ─────────────────────────────────────────────────────
+    // A caption layer is a PAGE, not a transcript. Past ~14 words in one static
+    // run the viewer has to read a paragraph while watching the video, and does
+    // neither. Layers that are already part of an animated caption run are
+    // exempt — those ARE the paged form.
+    for (const node of textLayers) {
+        const words = wordsIn(textOf(node));
+        if (words < 14 || isAnimatedCaptionPart(node))
+            continue;
+        const duration = numAttrOf(node, "data-duration");
+        const held = Number.isFinite(duration) && duration > 0 ? ` held for ${duration.toFixed(1)}s` : "";
+        push({
+            rule: "wall-of-text",
+            severity: "warn",
+            message: `One static text layer carries ${words} words${held} — a paragraph, not a caption. A scrolling viewer reads none of it.`,
+            where: label(node, "text layer"),
+            fix: "Page it into kinetic cues: `vidfarm captions generate <dir> --style word-pop` (or `spotlight`/`karaoke`) splits narration into ~3–5-word cues on real word timings; in the web editor, the `/primitives/audio/captions` job → `set_captions`. Short cues also read at a smaller size, which frees frame space and usually removes the need for a plate. Static text is for hook lines, payoff numbers, and title cards."
+        });
+    }
     // ── Rule: caption safe zone ────────────────────────────────────────────────
     // Local renders auto-normalize this, but the editor preview and cloud render
     // do not — so flag it as a warning rather than silently relying on the fixer.
@@ -539,6 +646,72 @@ export function qaCompositionHtml(html) {
             fix: "Start the hook line at 0 so the poster frame states the promise. Ignore this if the video deliberately opens on a clean face/product shot."
         });
     }
+    // ── Rules: density — every second has to earn its place ────────────────────
+    // A second that carries nothing is a free exit: the viewer re-decides to stay
+    // continuously, so dead screen time is the cheapest retention loss there is.
+    // All three are warnings, never errors — a held beat can be the joke, and a
+    // long take can be the whole point. They point at seconds worth defending.
+    const compDuration = Number.parseFloat(String(root.getAttribute?.("data-duration") ?? ""));
+    const textSpans = textLayers
+        .map((node) => ({ start: numAttrOf(node, "data-start"), end: numAttrOf(node, "data-start") + numAttrOf(node, "data-duration") }))
+        .filter((span) => Number.isFinite(span.start) && Number.isFinite(span.end) && span.end > span.start);
+    const textCover = mergeSpans(textSpans);
+    // Dead air: a hole BETWEEN cues. Needs 3+ cues so a two-card title sequence
+    // (where the space between cards is the design) never trips it. Counted on
+    // the RUNS, not the merged cover — back-to-back cues collapse into one span.
+    if (textSpans.length >= 3 && textCover.length >= 2) {
+        const gap = widestGap(textCover);
+        const seconds = gap ? gap.end - gap.start : 0;
+        if (gap && seconds >= 2.5) {
+            const gapsOver = textCover.reduce((count, span, i) => (i > 0 && span.start - textCover[i - 1].end >= 2.5 ? count + 1 : count), 0);
+            const others = gapsOver - 1;
+            push({
+                rule: "dead-air",
+                severity: "warn",
+                message: `${seconds.toFixed(1)}s with nothing to read (${gap.start.toFixed(1)}s–${gap.end.toFixed(1)}s)${others > 0 ? `, and ${others} more gap(s) ≥2.5s` : ""} — dead screen time is a free exit.`,
+                where: `timeline ${gap.start.toFixed(1)}s–${gap.end.toFixed(1)}s`,
+                fix: "Apply the deletion test to that stretch: if it carries no charge (hook/loop/payoff/bait), cut it and CLOSE the hole — `vidfarm ripple <dir> --at <sec> --delta -<sec>` — don't leave the gap. If the beat earns its seconds (a held comedic pause, the payoff playing out), keep it and ignore this."
+            });
+        }
+    }
+    // The tail: footage still rolling after the last word. Almost always an outro,
+    // an end card, or a clip nobody trimmed.
+    if (textSpans.length >= 2 && textCover.length) {
+        const lastWord = textCover[textCover.length - 1].end;
+        const visualEnd = layers
+            .filter(isVisualClip)
+            .reduce((acc, node) => Math.max(acc, numAttrOf(node, "data-start") + numAttrOf(node, "data-duration")), 0);
+        const contentEnd = Math.max(Number.isFinite(compDuration) ? compDuration : 0, Number.isFinite(visualEnd) ? visualEnd : 0);
+        const tail = contentEnd - lastWord;
+        if (tail > 1.5) {
+            push({
+                rule: "dead-tail",
+                severity: "warn",
+                message: `The video keeps running ${tail.toFixed(1)}s after the last word (${lastWord.toFixed(1)}s → ${contentEnd.toFixed(1)}s) — an outro nobody watches.`,
+                where: `timeline ${lastWord.toFixed(1)}s–${contentEnd.toFixed(1)}s`,
+                fix: "End on the bait. Trim the trailing clip (`vidfarm trim <dir> --layer <key> --edge end --to-time <sec>`) and pull the composition duration in (`vidfarm set-composition <dir> --duration <sec>`) so the last frame is the one that loops best."
+            });
+        }
+    }
+    // One scene that drags. Judged RELATIVE to the video's own rhythm, so a
+    // deliberately slow piece passes and only the outlier in a fast cut is named.
+    const sceneDurations = layers
+        .filter(isVisualClip)
+        .map((node) => numAttrOf(node, "data-duration"))
+        .filter((value) => Number.isFinite(value) && value > 0);
+    if (sceneDurations.length >= 3) {
+        const mid = median(sceneDurations);
+        const worst = Math.max(...sceneDurations);
+        if (mid > 0 && worst > 6 && worst > mid * 2.5) {
+            push({
+                rule: "slow-scene",
+                severity: "warn",
+                message: `One clip runs ${worst.toFixed(1)}s while the rest of the video cuts every ~${mid.toFixed(1)}s — that scene is where viewers leave.`,
+                where: "timeline — longest visual clip",
+                fix: "Split it and cut away (`vidfarm split <dir> --layer <key> --at <sec>`), speed-ramp the middle, or trim it toward the video's own rhythm. Keep it only if something is genuinely changing on screen for the whole take — the payoff playing out is a legitimate long hold."
+            });
+        }
+    }
     const errors = findings.filter((f) => f.severity === "error");
     const warnings = findings.filter((f) => f.severity === "warn");
     return {
@@ -550,7 +723,8 @@ export function qaCompositionHtml(html) {
             layers: layers.length,
             text_layers: textLayers.length,
             canvas: canvasW && canvasH ? `${canvasW}×${canvasH}` : null
-        }
+        },
+        watch_the_video: watchTheVideoDirective()
     };
 }
 function aspectLabel(width, height) {
@@ -561,7 +735,7 @@ function aspectLabel(width, height) {
     return `${width / divisor}:${height / divisor}`;
 }
 /**
- * Derive the facts a QA_REGIME.md can assert against. Pure, tolerant of
+ * Derive the facts a HARNESS.md can assert against. Pure, tolerant of
  * malformed input (returns empty facts rather than throwing) — same contract as
  * qaCompositionHtml, because a regime run must never break a render either.
  */
@@ -578,6 +752,9 @@ export function extractCompositionFacts(html) {
         first_frame_text: null,
         first_text_at_sec: null,
         max_simultaneous_text: 0,
+        max_words_in_run: 0,
+        max_dead_air_sec: 0,
+        tail_silence_sec: 0,
         off_regime_fonts: [],
         all_text: ""
     };
@@ -627,6 +804,12 @@ export function extractCompositionFacts(html) {
         if (overlapping > maxSimultaneous)
             maxSimultaneous = overlapping;
     }
+    // Pacing facts: the hole between cues, and the run-on after the last word.
+    const textCover = mergeSpans(textRuns.map((run) => ({ start: run.start, end: run.start + run.duration })));
+    const gap = widestGap(textCover);
+    const lastWordAt = textCover.length ? textCover[textCover.length - 1].end : 0;
+    const visualEnd = visualClips.reduce((acc, clip) => Math.max(acc, clip.start + clip.duration), 0);
+    const contentEnd = Math.max(Number.isFinite(duration) ? duration : 0, visualEnd);
     const openingText = textRuns.filter((run) => run.start <= 0.001 && run.start + run.duration > 0.001);
     const sortedStarts = textRuns.map((run) => run.start).sort((a, b) => a - b);
     return {
@@ -641,10 +824,32 @@ export function extractCompositionFacts(html) {
         first_frame_text: openingText.length ? openingText.map((run) => run.text).join(" ").trim() : null,
         first_text_at_sec: sortedStarts.length ? sortedStarts[0] : null,
         max_simultaneous_text: maxSimultaneous,
+        max_words_in_run: textRuns.reduce((acc, run) => Math.max(acc, wordsIn(run.text)), 0),
+        max_dead_air_sec: gap ? Number((gap.end - gap.start).toFixed(2)) : 0,
+        tail_silence_sec: textCover.length ? Number(Math.max(0, contentEnd - lastWordAt).toFixed(2)) : 0,
         off_regime_fonts: [...new Set(textRuns.map((run) => run.font).filter((font) => Boolean(font) && !FONT_REGIME.includes(font)))],
         all_text: textRuns.map((run) => run.text).join(" \n ")
     };
 }
+/**
+ * The closing block, printed on EVERY run including a clean one. Deliberately
+ * the last thing on screen and phrased as an instruction to the agent, because
+ * the failure mode this exists to stop is an agent pasting "✓ no HTML slop
+ * found" to the user as if it were a review of the video.
+ */
+export function formatWatchTheVideoNotice(directive, colors) {
+    const { yellow, dim, reset } = colors;
+    const bold = colors.bold ?? "";
+    const lines = [
+        "",
+        `${yellow}${bold}▶ NOW WATCH THE VIDEO — this check never did.${reset}`,
+        `${dim}${directive.why}${reset}`
+    ];
+    directive.steps.forEach((step, index) => {
+        lines.push(`  ${dim}${index + 1}.${reset} ${step}`);
+    });
+    return lines.join("\n");
+}
 /** Human-readable report body (no trailing summary line — the CLI adds that). */
 export function formatQaReport(report, colors) {
     const { red, yellow, dim, reset } = colors;

package/dist/src/devcli/skill-docs.js

@@ -0,0 +1,136 @@
+// Local, offline access to the skill pack that ships INSIDE the devcli tarball.
+//
+// WHY THIS EXISTS: `.agents/skills/**` is in package.json `files`, so every
+// `npm i -g @officexapp/vidfarm-devcli` already puts the whole director pack on
+// disk. Until now nothing could READ it without either installing it into a
+// project (`vidfarm skills add`) or fetching it over the network — so an agent
+// with the CLI in front of it still had to go online to learn how to use the
+// CLI. That is backwards for a local-first tool.
+//
+// THE CONTRACT, and its honest limit:
+//   • The bundled pack is a SNAPSHOT pinned to this devcli version. It is the
+//     right pairing — skill and CLI move together, and a mismatched pair is the
+//     usual cause of "the skill says to do X but it fails".
+//   • It costs nothing, needs no account, and works on a plane.
+//   • It is DOCUMENTATION, not entitlement. The capabilities it describes split
+//     into free-local (clipping, hyperframes, local render, qa, harnesses,
+//     dedupe, Kokoro TTS) and paid-cloud (AI generation, hosted render, social
+//     recycle, media download, marketplace). Reading about a paid primitive
+//     offline does not make it run offline — those still need `vidfarm login`
+//     and a network call. Nothing here should imply otherwise.
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export const DEFAULT_PACK = "vidfarm";
+/** Walk up from this module to the packaged `.agents/skills/<name>` directory. */
+export function bundledPackDir(name = DEFAULT_PACK) {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i += 1) {
+        const candidate = path.join(dir, ".agents", "skills", name);
+        if (existsSync(candidate) && statSync(candidate).isDirectory())
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function listPackDocs(name = DEFAULT_PACK) {
+    const root = bundledPackDir(name);
+    if (!root)
+        return [];
+    const out = [];
+    const walk = (dir, prefix) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => (a.name < b.name ? -1 : 1))) {
+            const abs = path.join(dir, entry.name);
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory())
+                walk(abs, rel);
+            else if (entry.isFile() && entry.name.endsWith(".md")) {
+                const raw = readFileSync(abs, "utf8");
+                out.push({ rel, abs, bytes: Buffer.byteLength(raw), lines: raw.split("\n").length });
+            }
+        }
+    };
+    walk(root, "");
+    // SKILL.md first — it is the entry point and carries the File Index.
+    return out.sort((a, b) => (a.rel === "SKILL.md" ? -1 : b.rel === "SKILL.md" ? 1 : a.rel < b.rel ? -1 : 1));
+}
+export class AmbiguousDocRef extends Error {
+    ref;
+    candidates;
+    constructor(ref, candidates) {
+        super(`"${ref}" matches ${candidates.length} files: ${candidates.join(", ")}. Be more specific.`);
+        this.ref = ref;
+        this.candidates = candidates;
+    }
+}
+/**
+ * Resolve a user-typed reference to one doc. Agents type `hooks`, humans type
+ * `references/hooks-and-virality.md`, and both should work — an exact-path-only
+ * lookup would make the local copy annoying enough that people go back online.
+ * Traversal is impossible by construction: we only ever match against the
+ * enumerated file list, never join user input onto a path.
+ */
+export function resolvePackDoc(ref, name = DEFAULT_PACK) {
+    const docs = listPackDocs(name);
+    if (!docs.length) {
+        throw new Error(`No bundled "${name}" skill pack found next to this devcli install. Fetch it with \`vidfarm skills add ${name}\`.`);
+    }
+    const needle = ref.replace(/\\/g, "/").replace(/^\.?\//, "").toLowerCase();
+    const exact = docs.find((doc) => doc.rel.toLowerCase() === needle)
+        ?? docs.find((doc) => doc.rel.toLowerCase() === `${needle}.md`);
+    if (exact)
+        return exact;
+    const base = (doc) => path.basename(doc.rel).toLowerCase();
+    const byBasename = docs.filter((doc) => base(doc) === needle || base(doc) === `${needle}.md`);
+    if (byBasename.length === 1)
+        return byBasename[0];
+    if (byBasename.length > 1)
+        throw new AmbiguousDocRef(ref, byBasename.map((doc) => doc.rel));
+    // `hooks` → references/hooks-and-virality.md; `harness` → harnesses/README.md
+    const fuzzy = docs.filter((doc) => doc.rel.toLowerCase().includes(needle));
+    if (fuzzy.length === 1)
+        return fuzzy[0];
+    if (fuzzy.length > 1) {
+        // Prefer a README when the ref names a directory ("harnesses", "recipes").
+        const readme = fuzzy.find((doc) => path.basename(doc.rel).toLowerCase() === "readme.md" && path.dirname(doc.rel).toLowerCase().includes(needle));
+        if (readme)
+            return readme;
+        throw new AmbiguousDocRef(ref, fuzzy.map((doc) => doc.rel));
+    }
+    throw new Error(`No file in the bundled "${name}" pack matches "${ref}". Run \`vidfarm skill ls\` to see all ${docs.length}.`);
+}
+export function readPackDoc(ref, name = DEFAULT_PACK) {
+    const doc = resolvePackDoc(ref, name);
+    return { doc, contents: readFileSync(doc.abs, "utf8") };
+}
+/**
+ * Grep the pack. This is the affordance that makes a local copy genuinely
+ * better than the network one: "where does it say anything about greenscreen"
+ * is answerable in one call, across 22 files, without loading any of them into
+ * context.
+ */
+export function searchPackDocs(term, options = {}) {
+    const limit = options.limit ?? 40;
+    const needle = term.toLowerCase();
+    const matches = [];
+    for (const doc of listPackDocs(options.name ?? DEFAULT_PACK)) {
+        const lines = readFileSync(doc.abs, "utf8").split("\n");
+        for (let i = 0; i < lines.length; i += 1) {
+            if (!lines[i].toLowerCase().includes(needle))
+                continue;
+            // Long skill lines are paragraphs; show the window around the hit rather
+            // than 900 characters of surrounding prose.
+            const at = lines[i].toLowerCase().indexOf(needle);
+            const start = Math.max(0, at - 60);
+            const snippet = `${start > 0 ? "…" : ""}${lines[i].slice(start, at + needle.length + 100).trim()}${at + needle.length + 100 < lines[i].length ? "…" : ""}`;
+            matches.push({ rel: doc.rel, line: i + 1, text: snippet });
+            if (matches.length >= limit)
+                return matches;
+        }
+    }
+    return matches;
+}
+//# sourceMappingURL=skill-docs.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@officexapp/vidfarm-devcli",
-  "version": "0.21.34",
+  "version": "0.21.35",
   "description": "Local bridge for the Vidfarm Trackpad Editor. `vidfarm serve <template_id>` boots the FULL editor on localhost (disk-backed records/storage, free in-process render); edit composition.html on disk (Claude Code, Codex, etc.) and the browser live-morphs it.",
   "type": "module",
   "bin": {
@@ -28,8 +28,9 @@
     "dist/src/devcli/port-utils.js",
     "dist/src/devcli/process-scan.js",
     "dist/src/devcli/qa-check.js",
-    "dist/src/devcli/qa-regime.js",
+    "dist/src/devcli/harness.js",
     "dist/src/devcli/sequence.js",
+    "dist/src/devcli/skill-docs.js",
     "dist/src/devcli/skills.js",
     "dist/src/devcli/speech.js",
     "dist/src/devcli/sticker-pack.js",
@@ -99,7 +100,7 @@
     "test:stickers": "node --import tsx --test test/sticker-pack.test.ts",
     "test:social-recycle": "node --import tsx --test test/social-recycle.test.ts",
     "test:dedupe": "node --import tsx --test test/dedupe-recipe.test.ts",
-    "check:skills": "node scripts/build-director-skill-rollup.mjs --check && node scripts/check-skill-routes.mjs",
+    "check:skills": "node scripts/build-director-skill-rollup.mjs --check && node scripts/check-skill-routes.mjs && node scripts/check-skill-nav.mjs",
     "benchmark:editor-chat": "node --import tsx scripts/benchmark-editor-chat-harness.mjs",
     "cdk:deploy:prod-serverless": "npm run build && dotenv -e .env.production -- npx aws-cdk deploy --app 'node dist/infra/cdk/bin/vidfarm-prod.js'",
     "cdk:synth:staging-serverless": "npm run build && dotenv -e .env.staging -- npx aws-cdk synth --app 'node dist/infra/cdk/bin/vidfarm-serverless-staging.js'",

package/.agents/skills/vidfarm/regimes/README.md

@@ -1,79 +0,0 @@
-# QA_REGIME.md — the per-style quality contract
-
-`vidfarm qa`'s built-in rules are **universal**: no HTML slop, the caption font regime, the thumbnail frame. They're the same for every video anyone makes, so they live in code.
-
-A **QA_REGIME.md is the opposite**: it's what makes *your* format good — your audience, your hook shape, your banned vocabulary, your pacing, your compliance line. That changes per account, per offer, per campaign, so it can't be hard-coded. It lives next to the work as Markdown you own, edit, and version.
-
-**It matters most in scripting mode.** One video gets human eyes on every frame; fifty variants generated in a loop do not. The regime is what the batch is graded against — the thing that keeps variant #37 as good as variant #1.
-
-## Using one
-
-```bash
-vidfarm regime list                                   # what ships with the CLI
-vidfarm regime show hooks                             # read one
-vidfarm regime init short-form --out ./work/QA_REGIME.md   # copy it next to your work, then EDIT it
-
-vidfarm qa ./work                                     # auto-uses ./work/QA_REGIME.md if present
-vidfarm qa ./work --regime hooks                      # a built-in by name
-vidfarm qa ./work --regime ./brand/HOUSE_RULES.md     # any file, anywhere
-vidfarm qa ./work --regime short-form --regime ./work/QA_REGIME.md   # they STACK
-vidfarm qa ./work --json                              # checks + review items, for a scripted batch
-```
-
-Regimes compose: a shared house regime plus a per-campaign one is the intended shape. `--no-regime` skips auto-discovery; `VIDFARM_QA_REGIME` sets a default for a whole scripting run.
-
-## The format
-
-Plain Markdown, with two machine-readable affordances:
-
-**1. Optional front matter with a `checks:` block** — the assertions the CLI settles deterministically from the composition, instantly, with no AI and no network:
-
-```markdown
----
-name: my-house-style
-video_type: what this regime is for
-checks:
-  duration_sec: 8-34        # also "<=34", ">=8", or "30"
-  aspect: 9:16              # "9:16|1:1" to allow several
-  first_frame_visual: required
-  first_frame_text: required | forbidden
-  hook_words_max: 7
-  text_by_sec: 1.0
-  audio: required | forbidden
-  captions: required
-  font_regime: required
-  safe_zone: required
-  scenes: 3-12
-  max_scene_sec: 8
-  max_text_cards: 3
-  max_simultaneous_text: 2
-  forbid_text: ["link in bio", "comment below"]
-  require_text: []
----
-```
-
-Unknown keys are reported and ignored, never silently dropped.
-
-**2. Any `- [ ]` checkbox line** in the body becomes a **review item** — a question handed back for the agent or the human to answer. "Is the withheld answer one the viewer can't supply themselves?" is a judgment call; pretending a linter settles it would be a lie.
-
-Everything else is prose the agent reads for context. That split is the whole design: the CLI is honest about which half it can enforce, and it never passes a video on the strength of the half it can't.
-
-## Writing your own
-
-Start from the closest built-in (`vidfarm regime init <name>`), then **delete what doesn't apply and add what makes your format yours**. A regime you didn't edit isn't about your videos.
-
-Good regimes tend to have: a **Part 0** naming the viewer in one line (the thing that decides everything else), an **anatomy** section for the beats your format needs, **rules** with the reason attached — a rule whose "why" is missing gets argued away by the next agent that reads it — and a **pre-flight checklist** of `- [ ]` items, which is the part the CLI hands back on every run.
-
-Keep the checklist short enough that answering it honestly is cheaper than skipping it.
-
-**Give every regime a "whole-video review" block, and put it last.** The bundled ones all have one. Front-matter `checks:` grade the composition's structure and `vidfarm qa` grades its DOM — neither can see the finished video, and the defects that actually ship are sequence-level: margins that shift scene to scene, three type sizes, an accent colour that wanders, N identically-long beats, a jarring join, a dead band under top-anchored content. Those come from how the video was built (one scene at a time, each correct in isolation), so they are invisible to every per-scene check *and* to the agent that built it — across a 32-video batch, every first-pass video had a real defect its own author had already called "verified, looks good." The review block is what forces the contact-sheet pass that catches them. Method: `references/reviewing-renders.md`.
-
-## Built-ins
-
-| Name | For |
-|---|---|
-| `short-form` | The general default: the four charges (hook / loop / payoff / bait) + the standalone rule. Start here |
-| `hooks` | Hook-variant batches — chunk-1 legibility, the unguessable test, the anti-patterns that only appear at volume |
-| `ugc-testimonial` | A person vouching for a product. Mostly rules about what NOT to add |
-| `explainer` | Faceless educational video: one claim, invented visuals |
-| `product-demo` | Real product doing a real thing — the highest slop-risk format in the catalog |