@revola-ai/video-craft 0.2.1

package/dist/rules/darkButNeverDim.js

@@ -0,0 +1,15 @@
+const darkButNeverDim = {
+  id: "dark-but-never-dim",
+  claim: "The dark cinematic canvas never costs legibility: lift values, use lighter material (white-paper artifacts on the dark shell), keep tonal variety inside the theme, and hold the canvas consistent scene to scene - 'too dark to read comfortably' and 'these scenes look like different videos' are both hard fails.",
+  why: "'Very low contrast, it exhausted my eyes' and 'add more colors, everything looks too dark, but don't go outside the theming' show the dark theme failing on comfort while staying on brand; darkness is the style, dimness and canvas drift are the defects.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A contrast-and-consistency judgment across scenes at 1080p; no single code location expresses it."
+  }
+};
+export {
+  darkButNeverDim
+};

package/dist/rules/dataRadarTagsDeclared.js

@@ -0,0 +1,193 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { globSync } from "tinyglobby";
+import { SyntaxKind } from "ts-morph";
+import { parse as parseYaml } from "yaml";
+import { matchedFiles } from "../sourceCheck.js";
+const toPosix = (p) => p.split(sep).join("/");
+const INCLUDE = [
+  "qpa-video/03_scenes/**/*.{js,jsx,ts,tsx}",
+  "revola-video/src/scenes/**/*.{js,jsx,ts,tsx}",
+  "workday-dple-video/src/scenes/**/*.{js,jsx,ts,tsx}",
+  "datapeak-video/**/*.{js,jsx,ts,tsx}",
+  "datapeak-usecases/**/*.{js,jsx,ts,tsx}",
+  "qse-video/**/*.{js,jsx,ts,tsx}",
+  "qse-investor-video/**/*.{js,jsx,ts,tsx}",
+  "qse-qguard-video/src/**/*.{ts,tsx}",
+  "spec-videos/**/*.{js,jsx,ts,tsx}",
+  "klaviyo-segments-video/**/*.{js,jsx,ts,tsx}",
+  "radar-fixture-video/src/**/*.{js,jsx,ts,tsx}",
+  "rcp-fund7-video/src/**/*.{ts,tsx}",
+  "expanse-video/src/**/*.{ts,tsx}",
+  "reverence-video/src/**/*.{ts,tsx}"
+];
+function findPlanDir(startDir, root) {
+  let dir = startDir;
+  for (; ; ) {
+    if (globSync("plan*.yaml", { cwd: dir }).length > 0) return dir;
+    if (dir === root || !dir.startsWith(root)) return null;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function declaredElements(planDir, root) {
+  const out = [];
+  for (const planFile of globSync("plan*.yaml", { cwd: planDir, absolute: true })) {
+    let plan;
+    try {
+      plan = parseYaml(readFileSync(planFile, "utf8"));
+    } catch {
+      continue;
+    }
+    for (const section of plan.sections ?? []) {
+      for (const binding of section.names ?? []) {
+        if (typeof binding.element !== "string") continue;
+        out.push({
+          sectionId: section.id ?? "(unnamed section)",
+          elementId: binding.element,
+          planFile: toPosix(relative(root, planFile))
+        });
+      }
+    }
+  }
+  return out;
+}
+const isTagAttrName = (name) => name === "data-radar";
+const attrLiteralsByName = (files) => {
+  const byName = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    for (const attr of file.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+      const value = literalOf(attr.getInitializer());
+      if (value === null) continue;
+      const name = attr.getNameNode().getText();
+      const set = byName.get(name) ?? /* @__PURE__ */ new Set();
+      set.add(value);
+      byName.set(name, set);
+    }
+  }
+  return byName;
+};
+function literalOf(init) {
+  if (!init) return null;
+  if (init.isKind(SyntaxKind.StringLiteral)) return init.getLiteralValue();
+  if (init.isKind(SyntaxKind.JsxExpression)) {
+    const expr = init.getExpression();
+    if (!expr) return null;
+    if (expr.isKind(SyntaxKind.StringLiteral)) return expr.getLiteralValue();
+    if (expr.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) return expr.getLiteralValue();
+  }
+  return null;
+}
+function templatePattern(text) {
+  const body = text.replace(/^`|`$/g, "");
+  if (!body.includes("${")) return null;
+  const escaped = body.split(/\$\{[^}]*\}/g).map((chunk) => chunk.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".+");
+  return new RegExp(`^${escaped}$`);
+}
+function buildTagIndex(files, root) {
+  const literals = /* @__PURE__ */ new Set();
+  const patterns = [];
+  const opaque = [];
+  const byAttrName = attrLiteralsByName(files);
+  for (const file of files) {
+    const rel = toPosix(relative(root, file.getFilePath()));
+    for (const attr of file.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+      if (!isTagAttrName(attr.getNameNode().getText())) continue;
+      const init = attr.getInitializer();
+      const literal = literalOf(init);
+      if (literal !== null) {
+        literals.add(literal);
+        continue;
+      }
+      const expr = init?.isKind(SyntaxKind.JsxExpression) ? init.getExpression() : void 0;
+      if (expr?.isKind(SyntaxKind.TemplateExpression)) {
+        const pattern = templatePattern(expr.getText());
+        if (pattern) {
+          patterns.push(pattern);
+          continue;
+        }
+      }
+      if (expr?.isKind(SyntaxKind.Identifier)) {
+        const forwarded = byAttrName.get(expr.getText());
+        if (forwarded?.size) {
+          for (const v of forwarded) literals.add(v);
+          continue;
+        }
+      }
+      opaque.push({ file: rel, line: attr.getStartLineNumber(), text: attr.getText().slice(0, 60) });
+    }
+  }
+  return { literals, patterns, opaque };
+}
+const IGNORES = ["**/node_modules/**", "**/.worktrees/**", "**/04_exports/**", "**/*.test.{ts,tsx,jsx}", "**/build/**"];
+const includedUnder = (planDir, check, root) => matchedFiles(check, root).filter((f) => f.startsWith(planDir + sep));
+function projectSourceFiles(planDir, check, root) {
+  const included = includedUnder(planDir, check, root);
+  if (included.length) return included;
+  return globSync("**/*.{js,jsx,ts,tsx}", { cwd: planDir, absolute: true, ignore: IGNORES }).sort();
+}
+function isReporterFile(planDir, absPath, check, root) {
+  const included = includedUnder(planDir, check, root);
+  return included.length === 0 || included[0] === absPath;
+}
+const dataRadarTagsDeclared = {
+  id: "data-radar-tags-declared",
+  claim: "Every element id a plan's `names:` binding declares carries a matching `data-radar` attribute somewhere in that project's source.",
+  why: "vo-element-sync joins a declared binding to speech-map timings and geometry samples; a declared element-id with no matching data-radar tag anywhere in the project is a certain finding, and catching it at authoring time (no render, no sampler) is strictly cheaper than catching it at radar:scene time.",
+  learnedFrom: "docs/superpowers/specs/2026-07-31-defect-radar-design.md",
+  tier: "gate",
+  verify: "`vitest run packages/video-craft` (source-level, no render) - `video radar:scene --project <dir> --comp <id> --check tag-coverage` re-verifies the same binding against sampled frames at runtime",
+  owner: "tag-coverage",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "source",
+    check: {
+      include: INCLUDE,
+      run(file, relPath, root) {
+        const absPath = join(root, relPath);
+        const planDir = findPlanDir(dirname(absPath), root);
+        if (!planDir || !existsSync(planDir)) return [];
+        if (dataRadarTagsDeclared.enforcement.kind !== "source") return [];
+        const selfCheck = dataRadarTagsDeclared.enforcement.check;
+        if (!isReporterFile(planDir, absPath, selfCheck, root)) return [];
+        const declared = declaredElements(planDir, root);
+        if (declared.length === 0) return [];
+        const project = file.getProject();
+        const index = buildTagIndex(
+          projectSourceFiles(planDir, selfCheck, root).map((f) => project.addSourceFileAtPath(f)),
+          root
+        );
+        const findings = [];
+        for (const site of index.opaque) {
+          findings.push({
+            file: site.file,
+            line: site.line,
+            match: site.text,
+            message: `data-radar is bound to an expression this gate cannot evaluate (${site.text}), so no declared element id in ${toPosix(relative(root, planDir))} can be verified from source. Use a string literal, a template whose literal prefix is stable, or forward it through a prop named \`dataRadar\` that call sites pass a literal to.`
+          });
+        }
+        if (findings.length) return findings;
+        for (const { sectionId, elementId, planFile } of declared) {
+          if (index.literals.has(elementId)) continue;
+          if (index.patterns.some((p) => p.test(elementId))) continue;
+          findings.push({
+            file: planFile,
+            line: 1,
+            match: elementId,
+            message: `plan section "${sectionId}" declares names: element "${elementId}", but no data-radar="${elementId}" attribute exists anywhere in ${toPosix(relative(root, planDir))}'s source. Tag the element the cue names, or make the binding an explained \`element: null\`.`
+          });
+        }
+        return findings;
+      }
+    }
+  }
+};
+export {
+  INCLUDE,
+  dataRadarTagsDeclared,
+  declaredElements,
+  findPlanDir,
+  isReporterFile,
+  projectSourceFiles
+};

package/dist/rules/declareAVerticalZoneMap.js

@@ -0,0 +1,15 @@
+const declareAVerticalZoneMap = {
+  id: "declare-a-vertical-zone-map",
+  claim: "Declare a vertical zone map at the top of each scene file - copy band, breath band (nothing may enter), stage band - and make camera keys and world layout enforce that animation never rises into the copy band.",
+  why: "Without declared bands, text and animation collide (a tag overlapping the headline, fog slicing the clock) and each collision gets patched ad hoc.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/S3Line.tsx" }
+  }
+};
+export {
+  declareAVerticalZoneMap
+};

package/dist/rules/deleteRejectedRigsCompletely.js

@@ -0,0 +1,15 @@
+const deleteRejectedRigsCompletely = {
+  id: "delete-rejected-rigs-completely",
+  claim: "When a transition or effect is rejected in review, delete the rig, its tokens, and its plumbing (props, overlay slots) entirely; revert call sites rather than leaving the machinery dead.",
+  why: "The rejected light bridge left LightBridge, BRIDGE_* tokens, and the CraftStage overlay prop as attractive dead plumbing; deleting it and reverting S2's usage is what makes the rejection stick.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The artifact of following this rule is the absence of code; there is no symbol to point at."
+  }
+};
+export {
+  deleteRejectedRigsCompletely
+};

package/dist/rules/deriveSeamsDontMeasure.js

@@ -0,0 +1,17 @@
+const deriveSeamsDontMeasure = {
+  id: "derive-seams-dont-measure",
+  claim: "Derive a cross-scene seam from the neighbouring scene's exported geometry, never from a number measured off a render.",
+  why: "A measured constant is a bug with a delay fuse: it stays correct until the neighbouring scene is recut, then silently misplaces the seam with nothing failing. Deriving it means a recut re-derives the seam for free.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "gate",
+  verify: "`video radar:film --project <dir> --video <mp4> --comp <id> --check seam-fidelity`",
+  owner: "seam-fidelity",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/S1Graveyard.tsx", symbol: "STRIKE_PTS" }
+  }
+};
+export {
+  deriveSeamsDontMeasure
+};

package/dist/rules/deterministicSceneSource.js

@@ -0,0 +1,65 @@
+import { SyntaxKind } from "ts-morph";
+const deterministicSceneSource = {
+  id: "deterministic-scene-source",
+  claim: "Scene and kit source must be render-deterministic: no Math.random(), no Date.now(), no argless new Date(); use seeded randomness and explicit dates.",
+  why: "A nondeterministic value is re-evaluated on every render pass, so elements jitter between frames and two renders of the same composition differ; the sessions caught these only via an ad-hoc grep gate after the fact.",
+  learnedFrom: "claude-sessions-digest/revola-usecase-book-meeting.md",
+  upstream: "remotion:@remotion/eslint-plugin/deterministic-randomness",
+  tier: "gate",
+  verify: "render the same frame range twice and diff every frame; all must report YMAX=0 (automation owed: remotion-videos-5oi)",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "source",
+    check: {
+      // Determinism is a crash-class invariant, not a per-project doctrine,
+      // so the blast radius matches interpolate-literal-keys-monotonic: every
+      // scene tree plus the kit. The corpus runs clean across all of them.
+      include: [
+        "qpa-video/03_scenes/**/*.{js,jsx,ts,tsx}",
+        "reverence-video/src/scenes/**/*.{js,jsx,ts,tsx}",
+        "workday-dple-video/src/scenes/**/*.{js,jsx,ts,tsx}",
+        "revola-video/src/scenes/**/*.{js,jsx,ts,tsx}",
+        "datapeak-video/**/*.{js,jsx,ts,tsx}",
+        "datapeak-usecases/**/*.{js,jsx,ts,tsx}",
+        "qse-video/**/*.{js,jsx,ts,tsx}",
+        "qse-investor-video/**/*.{js,jsx,ts,tsx}",
+        "qse-qguard-video/src/**/*.{ts,tsx}",
+        "rcp-fund7-video/src/**/*.{ts,tsx}",
+        "expanse-video/src/**/*.{ts,tsx}",
+        "reverence-video/src/**/*.{ts,tsx}",
+        "spec-videos/**/*.{js,jsx,ts,tsx}",
+        // Added Task 23: klaviyo-segments-video and radar-fixture-video were
+        // silently excluded (this list said "every scene tree" but named
+        // neither) - the exact silent-default trap this rule's own claim
+        // exists to catch, applied to the checker itself.
+        "klaviyo-segments-video/src/**/*.{js,jsx,ts,tsx}",
+        "radar-fixture-video/src/**/*.{js,jsx,ts,tsx}",
+        "packages/video-kit/src/**/*.{ts,tsx}"
+      ],
+      run(file, relPath) {
+        const findings = [];
+        const report = (node, what) => {
+          findings.push({
+            file: relPath,
+            line: node.getStartLineNumber(),
+            match: node.getText().slice(0, 60),
+            message: `nondeterministic ${what} in scene/kit source; seed it or pass an explicit value`
+          });
+        };
+        for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+          const callee = call.getExpression().getText();
+          if (callee === "Math.random" || callee === "Date.now") report(call, `${callee}()`);
+        }
+        for (const nw of file.getDescendantsOfKind(SyntaxKind.NewExpression)) {
+          if (nw.getExpression().getText() === "Date" && nw.getArguments().length === 0) {
+            report(nw, "new Date()");
+          }
+        }
+        return findings;
+      }
+    }
+  }
+};
+export {
+  deterministicSceneSource
+};

package/dist/rules/diegeticSoundForOnscreenActions.js

@@ -0,0 +1,15 @@
+const diegeticSoundForOnscreenActions = {
+  id: "diegetic-sound-for-onscreen-actions",
+  claim: "On-screen actions are heard: typing on screen plays asmr-typing.wav in sync, clicks land a soft UI click on the click frame, seams never cross in dead silence, and the music bed is an upbeat tech-reveal track (the Linear-reel EDM track is the reference), subtle and ducked under payoffs.",
+  why: "'Use asmr-typing.wav anywhere that shows typing' canonized the diegetic-sync expectation, and 'use a more upbeat bg, maybe the one used in the Linear reel' pinned the bed genre; the palette rule alone let silent typing and a wrong-genre bed through.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "An audio-to-visual sync judgment against the render; no single code location expresses it."
+  }
+};
+export {
+  diegeticSoundForOnscreenActions
+};

package/dist/rules/distinctTransitionPerBeat.js

@@ -0,0 +1,15 @@
+const distinctTransitionPerBeat = {
+  id: "distinct-transition-per-beat",
+  claim: "Adjacent beats use distinct, directionally coherent transitions (exit left pairs with enter right, exit up with enter down); never the same transition twice in a row, never an unmotivated hard swap.",
+  why: "Back-to-back identical transitions read as template output, and directionally incoherent exits/entries were flagged as 'half left, half middle' confusion; direction logic is what makes cuts feel authored.",
+  learnedFrom: "claude-sessions-digest/revola-usecase-book-meeting.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule is a sequencing judgment across scene boundaries; no single code location expresses it."
+  }
+};
+export {
+  distinctTransitionPerBeat
+};

package/dist/rules/downloadOrDrawRichAssets.js

@@ -0,0 +1,15 @@
+const downloadOrDrawRichAssets = {
+  id: "download-or-draw-rich-assets",
+  claim: "When a beat needs an element, download the real asset (brand SVG, icon set, map or geo data, texture, 3D model, font) at authoring time and commit it, or hand-author a detailed custom SVG; a styled-div rectangle, basic shape, or emoji standing in for art is a defect, and render-time fetching is banned so renders stay deterministic.",
+  why: "The gap between prompted builds that looked professional and pipeline builds that looked flat was largely asset quality: agents defaulted to CSS primitives unless told downloading was allowed, while the standing instruction 'download anything you want, or make custom SVGs' produced rich marks every time it was issued.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "An asset-quality judgment per visible element; no single code location expresses it."
+  }
+};
+export {
+  downloadOrDrawRichAssets
+};

package/dist/rules/elementOnscreenForItsVoSentence.js

@@ -0,0 +1,17 @@
+const elementOnscreenForItsVoSentence = {
+  id: "element-onscreen-for-its-vo-sentence",
+  claim: "The element a voiceover sentence names is fully on screen, build-in complete, for the whole duration of that sentence; secondary marks (partner logos) enter when mentioned, not at frame zero.",
+  why: "Visuals lagging or leading their VO line was the dominant ACT854 feedback category, re-broken by every new voiceover take; the sentence-to-element contract is what re-timing must preserve.",
+  learnedFrom: "claude-sessions-digest/act854-qpa-video.md",
+  tier: "gate",
+  verify: "`video radar:scene --project <dir> --comp <id> --check vo-element-sync --check edge-touch`",
+  owner: "vo-element-sync",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/measure.ts" }
+  }
+};
+export {
+  elementOnscreenForItsVoSentence
+};

package/dist/rules/emitBuildNotes.js

@@ -0,0 +1,15 @@
+const emitBuildNotes = {
+  id: "emit-build-notes",
+  claim: "Maintain BUILD_NOTES.md (or the automated equivalent) per video: current wired WAV, frame layout, and every feedback decision, newest round on top.",
+  why: "Without it nobody, human or agent, can pick the project up later; the notes are the only record of why timings and content are what they are.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A documentation convention; its exemplars are docs, not live code."
+  }
+};
+export {
+  emitBuildNotes
+};

package/dist/rules/energyFromTimingNotPartCount.js

@@ -0,0 +1,15 @@
+const energyFromTimingNotPartCount = {
+  id: "energy-from-timing-not-part-count",
+  claim: "Scene energy comes from timing and material, never from part count: one subject performing beautifully beats ten things wiggling, and a beat where several subjects compete for the eye at once is as much a defect as a static hold.",
+  why: "'It looks overwhelming, I wanted to do it more with the camera' arrived in the same corpus as the too-static notes; answering flatness by adding elements produced the opposite failure, so density must be bought with overlapping beats in time, not with simultaneous objects.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "An attention-competition judgment per beat; no single code location expresses it."
+  }
+};
+export {
+  energyFromTimingNotPartCount
+};

package/dist/rules/evidenceBeforeClaimingFixed.js

@@ -0,0 +1,15 @@
+const evidenceBeforeClaimingFixed = {
+  id: "evidence-before-claiming-fixed",
+  claim: "Never report a fix without evidence from the artifact itself: a still at the affected frames, a grep proving the removed effect is gone, or an audio probe proving the sound is present.",
+  why: "Three separate 'fixes' shipped unverified and bounced with 'it's still there'; each unverified claim costs a full human review round, the most expensive resource in the loop.",
+  learnedFrom: "claude-sessions-digest/portfolio-reels.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule prescribes review-loop discipline; no repo code implements evidence capture to point at."
+  }
+};
+export {
+  evidenceBeforeClaimingFixed
+};

package/dist/rules/exactPeerLockstep.js

@@ -0,0 +1,15 @@
+const exactPeerLockstep = {
+  id: "exact-peer-lockstep",
+  claim: "The kit pins its peers exactly; a project that bumps Remotion must get a matching kit release before its next freeze.",
+  why: "A peer-range mismatch lets a project silently render against a Remotion version the kit was never tested with, or blocks the freeze at the worst moment.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/kitShell.ts" }
+  }
+};
+export {
+  exactPeerLockstep
+};

package/dist/rules/firstPassIsADraft.js

@@ -0,0 +1,15 @@
+const firstPassIsADraft = {
+  id: "first-pass-is-a-draft",
+  claim: "Treat every scene's first build as a draft: a dedicated amplification pass (faster, more detailed, more layered motion; unnecessary text removed) is a mandatory pipeline stage, not an optional polish.",
+  why: "In the best-documented build, all five scenes received the same 'too basic, blow people away' round; budgeting the second pass up front converts a guaranteed feedback round into a pipeline stage.",
+  learnedFrom: "claude-sessions-digest/revola-craft-video.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule prescribes a pipeline stage; no code location expresses it yet."
+  }
+};
+export {
+  firstPassIsADraft
+};

package/dist/rules/fixCrowdingByRebandingNotNudging.js

@@ -0,0 +1,15 @@
+const fixCrowdingByRebandingNotNudging = {
+  id: "fix-crowding-by-rebanding-not-nudging",
+  claim: "When a layout reads crowded or crumbled, fix the band allocation by moving the whole stage, not by nudging individual elements.",
+  why: "The S3 spine at y660 squeezed every station into 360px while the bottom 240px of frame sat empty; the root cause was layout allocation, not element size, and shrinking elements would not have fixed it.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/S3Line.tsx" }
+  }
+};
+export {
+  fixCrowdingByRebandingNotNudging
+};

package/dist/rules/fixesPreserveApprovedElements.js

@@ -0,0 +1,15 @@
+const fixesPreserveApprovedElements = {
+  id: "fixes-preserve-approved-elements",
+  claim: "A fix scoped to one complaint is a minimal diff against the approved baseline: additive unless removal was requested, and previously-praised elements are never deleted while fixing a neighbour.",
+  why: "Twice a scoped complaint was 'fixed' by deleting elements the reviewer loved, costing a restoration round each time; feedback on one aspect of a scene is not license to rebuild the scene.",
+  learnedFrom: "claude-sessions-digest/revola-usecase-book-meeting.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule prescribes diff discipline for feedback rounds; no code location expresses it."
+  }
+};
+export {
+  fixesPreserveApprovedElements
+};

package/dist/rules/floatingNotBoxed.js

@@ -0,0 +1,15 @@
+const floatingNotBoxed = {
+  id: "floating-not-boxed",
+  claim: "Content floats free on the canvas, grounded by soft contact shadows, instead of sitting in boxed panels; every container must earn its chrome - a filler background rectangle behind an SVG is a defect, and when a panel does exist it is a premium layered surface.",
+  why: "'I prefer floating svgs instead of containers' and 'remove the ugly bg colors from the SVGs - let them float' were standing preferences across rounds; boxed content read as template while floating, shadow-grounded elements read as designed.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A does-this-container-earn-its-chrome judgment per element; no single code location expresses it."
+  }
+};
+export {
+  floatingNotBoxed
+};

package/dist/rules/focusBeatsRecedeTheContext.js

@@ -0,0 +1,15 @@
+const focusBeatsRecedeTheContext = {
+  id: "focus-beats-recede-the-context",
+  claim: "When a beat introduces a new subject over existing UI, recede the context behind it - dim, blur, scale back, scrim - and give the new subject cleared space; never draw the new layer on top of live content.",
+  why: "A diagram drawn over a fully lit room put its label character-for-character on top of a card's caption and its connector lines read as scratches across the UI; receding the room turned the same beat into a clean shot with no geometry changes.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A composition discipline spanning scene and overlay layers; no single symbol owns it."
+  }
+};
+export {
+  focusBeatsRecedeTheContext
+};

package/dist/rules/fontVarsBrandRemocn.js

@@ -0,0 +1,15 @@
+const fontVarsBrandRemocn = {
+  id: "font-vars-brand-remocn",
+  claim: "Brand all remocn components at once by pointing --font-geist-sans and --font-geist-mono at the project's loaded fonts in CSS; never touch font settings in component source.",
+  why: "Editing fonts per-component forfeits Tier B update-safety and reintroduces per-file drift; the CSS vars brand ~110 components with zero source changes.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/index.css" }
+  }
+};
+export {
+  fontVarsBrandRemocn
+};

package/dist/rules/geometricSeamsNotCrossfades.js

@@ -0,0 +1,23 @@
+const geometricSeamsNotCrossfades = {
+  id: "geometric-seams-not-crossfades",
+  claim: "Make a seam physical: the clicked element becomes the next scene, or the camera travels through it; overlap adjacent sections by a few frames so the handoff happens mid-air rather than as a dissolve between slides.",
+  why: "Praised cuts in the reference films are all motivated - a card expands into the next shot, the camera flies through a control - while crossfades read as slides advancing; the geometric handoff is also what makes a cut survive a re-time.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "gate",
+  // Added by the codex red team round (2026-08-01): the r2 sudden-seams class
+  // (5 of 6 seams, BUILD_NOTES round 2 feedback item 1, bead
+  // remotion-videos-t0s) escaped every prior check because the two seam bans
+  // this rule states are satisfiable by doing nothing - `seam-continuity` is
+  // the check that verifies the CONSTRUCTIVE half: every seam carries either
+  // a shared geometry-sidecar carrier or a declared overlap of >=4 frames.
+  verify: "`video radar:film --project <dir> --video <mp4> --check seam-continuity`",
+  owner: "seam-continuity",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/productroom/PRColdOpen.tsx" }
+  }
+};
+export {
+  geometricSeamsNotCrossfades
+};

package/dist/rules/geometrySidecarExportsTyped.js

@@ -0,0 +1,36 @@
+const geometrySidecarExportsTyped = {
+  id: "geometry-sidecar-exports-typed",
+  claim: "A scene's geometry sidecar exports `const geometry` typed as `SceneGeometry`.",
+  why: "The compose:registry generator and film assembly import a seam's geometry sidecar by convention (src/scenes/scene.<id>.geometry.ts) and read its `geometry` export at compile time; an untyped or missing export turns that compile-time check into a silent `undefined` at runtime, at the exact moment - a scene cut - where the seam contract is supposed to be enforced.",
+  learnedFrom: "docs/superpowers/plans/2026-07-30-video-task-graph-phase1.md",
+  tier: "gate",
+  verify: "`vitest run packages/video-craft` - machine-checked over every geometry sidecar file",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "source",
+    check: {
+      // One level deep under each project directory, matching
+      // geometrySidecarPath()'s convention exactly: <project>/src/scenes/scene.<id>.geometry.ts.
+      include: ["*/src/scenes/scene.*.geometry.ts"],
+      run(file, relPath) {
+        const text = file.getFullText();
+        const hasExport = text.includes("export const geometry");
+        const hasType = text.includes(": SceneGeometry");
+        if (hasExport && hasType) return [];
+        const missing = [
+          !hasExport && "`export const geometry`",
+          !hasType && "`: SceneGeometry`"
+        ].filter((x) => !!x).join(" and ");
+        return [{
+          file: relPath,
+          line: 1,
+          match: relPath.split("/").pop() ?? relPath,
+          message: `geometry sidecar is missing ${missing}; a sidecar at this path must read \`export const geometry: SceneGeometry = { ... }\` (packages/video-kit/src/pure/geometry.ts)`
+        }];
+      }
+    }
+  }
+};
+export {
+  geometrySidecarExportsTyped
+};

package/dist/rules/glowIsAFocalAccent.js

@@ -0,0 +1,22 @@
+const glowIsAFocalAccent = {
+  id: "glow-is-a-focal-accent",
+  claim: "Reserve glow and drop-shadow for one or two focal moments per scene; a uniform glow on every panel is banned, frosted-glass surfaces are the sanctioned depth cue.",
+  why: "Uniform glows read as cheap template styling; de-glowing was part of every de-AI-ification round in the reels.",
+  learnedFrom: "claude-sessions-digest/portfolio-reels.md",
+  tier: "craft",
+  exceptions: [
+    {
+      project: "qse-qguard-video",
+      decision: "client chose ACT854's breathing accent bloom on every panel and glyph tile for the QGuard restyle; the bloom lives on rings and tiles, never behind body copy",
+      recordedIn: "qse-qguard-video/docs/motion-brand-spec.md"
+    }
+  ],
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule is a styling-restraint judgment across scenes; no single code location expresses it."
+  }
+};
+export {
+  glowIsAFocalAccent
+};