@revola-ai/video-craft 0.2.1

package/src/rules/poweredByRevolaWatermark.ts

@@ -0,0 +1,19 @@
+import type { Rule } from "../types";
+
+/**
+ * The house branding default, set for all Revola videos (2026-07-30). Sourced
+ * from the shared kit (`RevolaWatermark`) so it is one import, not a per-project
+ * reimplementation.
+ */
+export const poweredByRevolaWatermark: Rule = {
+  id: "powered-by-revola-watermark",
+  claim: "Every video carries the 'Powered by Revola' watermark - the kit's RevolaWatermark, rendered in screen space at the film level - unless the video explicitly specifies otherwise.",
+  why: "It is the standing brand default for Revola videos; sourcing it from @revola-ai/video-kit keeps it one import instead of a per-project reimplementation, and a film-level screen-space placement holds it fixed through scene camera moves and off the very edge so a minor crop cannot shave it.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/react/bricks/RevolaWatermark.tsx", symbol: "RevolaWatermark" },
+  },
+};

package/src/rules/predrawContentPresentAtTheCut.ts

@@ -0,0 +1,21 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from revola-video/BUILD_NOTES_CRAFT.md: "Spine now drawn from
+ * start={-20}: start=0/dur=1 still evaluates to *zero* progress on frame 0,
+ * so the cut landed on a black frame."
+ */
+export const predrawContentPresentAtTheCut: Rule = {
+  id: "predraw-content-present-at-the-cut",
+  claim: "Give anything that must be visible on a scene's first frame a negative draw-on start (e.g. start={-20}); start=0 evaluates to zero progress on frame 0 and the cut lands on an empty frame.",
+  why: "The S3 spine with start=0 made the cut land on a black frame; a negative start pre-draws it while frame still advances, keeping the line boil alive.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "gate",
+  verify: "`video radar:film --project <dir> --video <mp4> --check dead-frame-at-cut`",
+  owner: "dead-frame-at-cut",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/ink.tsx", symbol: "drawP" },
+  },
+};

package/src/rules/premiumSurfacesNotFlatBorders.ts

@@ -0,0 +1,20 @@
+import type { Rule } from "../types";
+
+/**
+ * Adopted from spec-videos/src/components/GlassPanel.tsx, whose own source
+ * comment names the tell: 'flat borders are the #1 cheap-glass tell'. The
+ * product-room draft used flat 1px borders on every panel and read cheap
+ * next to the same layout rendered with the layered treatment.
+ */
+export const premiumSurfacesNotFlatBorders: Rule = {
+  id: "premium-surfaces-not-flat-borders",
+  claim: "Give panels a layered surface - contact plus ambient plus long-throw shadow, a top sheen, and a gradient hairline ring - instead of a flat 1px border.",
+  why: "Flat borders are the single clearest cheap-glass tell, and the surface treatment is what separated the reference videos from a first draft that used the same layout and the same palette.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/productroom/Glass.tsx" },
+  },
+};

package/src/rules/radarDispositionsAreHumanOnly.ts

@@ -0,0 +1,28 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from docs/superpowers/specs/2026-07-31-defect-radar-design.md:
+ * "Disposition authority is human-only: the CLI refuses to write a
+ * disposition without an `--operator <name>` that doctrine forbids agents to
+ * pass, and the CLAUDE.md projection carries the one-liner 'never accept or
+ * dismiss a radar claim; surface it and continue.'" Added by the codex red
+ * team round (2026-08-01, finding 11): nothing in the CLI can authenticate a
+ * human, so the doctrine plus a committed, auditable ledger is the designed
+ * trust model - this rule is what puts that one-liner in the registry the
+ * projections are generated from, rather than leaving it as prose nobody
+ * mines back into CLAUDE.md.
+ */
+export const radarDispositionsAreHumanOnly: Rule = {
+  id: "radar-dispositions-are-human-only",
+  claim: "Never accept or dismiss a radar claim; surface it and continue. Disposition authority is human-only.",
+  why: "An agent that quietly disposes its own findings is the exact single-pair-of-eyes failure the radar exists to remove - a judge claim an agent waved through on the operator's behalf is indistinguishable from one nobody ever reviewed.",
+  learnedFrom: "docs/superpowers/specs/2026-07-31-defect-radar-design.md",
+  tier: "gate",
+  verify: "`video radar:accept`/`radar:dismiss` refuse without a human `--operator <name>` and refuse outright under an agent process (`CLAUDECODE` set)",
+  owner: "coherence",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/cli.ts" },
+  },
+};

package/src/rules/realAssetsNotPlaceholders.ts

@@ -0,0 +1,21 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from claude-sessions-digest/portfolio-reels.md ("Replace them with
+ * icons, not dots or squares"; "IT SHOULD MIMIC CURSOR EXACTLY AND BE SUPER
+ * DETAILED ... NO FLUFF") and revola-usecase-book-meeting.md ("why are the 4
+ * cards at the beginning empty"; "why is everything, including the agent
+ * answers, so short?? it should be super detailed").
+ */
+export const realAssetsNotPlaceholders: Rule = {
+  id: "real-assets-not-placeholders",
+  claim: "Mock UIs and cards carry real assets and realistic, detailed content: brand SVG logos and icons (never colored dots or gradient squares), full-length plausible copy, no empty placeholder cards.",
+  why: "Placeholder shapes and short generic copy are the second half of the AI-template read; every video needed a de-placeholder round, and detail density was the fix that made recreated UIs land.",
+  learnedFrom: "claude-sessions-digest/portfolio-reels.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule is a content-density judgment over scene JSX; no single code location expresses it.",
+  },
+};

package/src/rules/rebuildUiFromReconNotScreenshots.ts

@@ -0,0 +1,21 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from act854-video/BUILD_NOTES.md, which records the client bounce
+ * that proves the why: "panels rebuilt 1:1 from the live portal. The old
+ * CBOM/HBOM/SBOM panels were a stub ... They now reproduce the real Summary
+ * Audit Dashboard." Merged with HOW_I_BUILD_VIDEOS.md's doctrine statement
+ * ("Screenshots can't be re-themed, animated per-element, or scrubbed").
+ */
+export const rebuildUiFromReconNotScreenshots: Rule = {
+  id: "rebuild-ui-from-recon-not-screenshots",
+  claim: "Rebuild product pages 1:1 as React components from recon captures; never embed screenshots in scenes or ship a generic stub.",
+  why: "Screenshots cannot be re-themed, animated per-element, or data-scrubbed, and a stub misrepresents the product: the v1 BOM panels were a one-chart stub and the client bounced them.",
+  learnedFrom: "act854-video/BUILD_NOTES.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "qpa-video/03_scenes/act854/panels.jsx" },
+  },
+};

package/src/rules/reconStrandsRunInParallel.ts

@@ -0,0 +1,63 @@
+import type { Rule } from "../types";
+
+/**
+ * Recon is several unrelated investigations wearing one name, and running them
+ * in series is the single largest avoidable block of wall clock in a build.
+ *
+ * Measured on the QGuard build: 17 minutes from kickoff to a finished VO script,
+ * all of it sequential - read the rulebook, read the brief, browse the live
+ * site, rasterise and pixel-count the PDF, write the brand document, then draft
+ * the script. The reference sessions in `claude-sessions-digest/` fire research
+ * subagents in the FIRST action of the session and carry on.
+ *
+ * The strands are genuinely independent:
+ *
+ *   - brand      palette, type, logo geometry, from the live product and its
+ *                collateral (`sample-brand-from-product`)
+ *   - product    the walkthrough capture: screenshots, colours, text dump
+ *                (`rebuild-ui-from-recon-not-screenshots`)
+ *   - artifacts  making what appears on screen true - real header shapes, real
+ *                policy syntax, real log lines, the mechanics of whatever the
+ *                film claims
+ *   - script     the VO draft, which depends on the brief and not on any of the
+ *                above (`vo-script-locks-spoken-words`)
+ *
+ * Give each strand exactly one declared output path before starting. Two strands
+ * wanting the same file is the signal that they were one strand.
+ *
+ * Each strand still gets its own worktree (`isolation: "worktree"`), and the
+ * join collects their outputs. The first version of this rule waived that,
+ * arguing disjoint writes cannot collide so the isolation machinery was "pure
+ * overhead here". Both halves were wrong:
+ *
+ *   - A worktree costs a few hundred milliseconds against a strand that runs for
+ *     minutes, and it serialises nothing. There was no overhead to save.
+ *   - Disjoint OUTPUT paths are narrower than the collision surface. Four agents
+ *     in one working tree share the git index, and an agent that runs `git add`
+ *     or `git commit` - which they do reflexively - sweeps up the other three
+ *     strands' half-written files. `node_modules` and the beads DB are shared
+ *     the same way. None of those is the declared output path.
+ *
+ * And the declared path was never enforced by anything. This repo's whole
+ * history is declarations without checks drifting: a zone guard handed a number
+ * 55px wrong, seventeen captions consistently lowercase, that guard's own remedy
+ * text pointing the wrong way for four rounds. `isolation: "worktree"` is a
+ * check that already exists and costs nothing to use.
+ *
+ * The parallelism is the point of this rule and is untouched by any of that.
+ *
+ * The plan is the join point: it consumes all four and cannot be finished until
+ * they land. Everything before the join runs at once.
+ */
+export const reconStrandsRunInParallel: Rule = {
+  id: "recon-strands-run-in-parallel",
+  claim: "Run brand, product, artifact-accuracy and VO-script recon concurrently, each strand in its own worktree and owning exactly one declared output path; the plan is the join, and nothing before it runs in series.",
+  why: "The strands share no inputs and no outputs, so serialising them adds their durations instead of taking their maximum - 17 minutes of the QGuard build's 40-minute pre-scene phase was recon done one step at a time.",
+  learnedFrom: "qse-qguard-video/BUILD_NOTES.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/schema.ts" },
+  },
+};

package/src/rules/registryBeforeHandrolling.ts

@@ -0,0 +1,20 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md: "It is the animation vocabulary going
+ * forward for anything generic - reach for the registry before
+ * hand-authoring a counter, a bar chart, or a text reveal." The anchor is a
+ * vendored registry component, the first stop the rule mandates.
+ */
+export const registryBeforeHandrolling: Rule = {
+  id: "registry-before-handrolling",
+  claim: "Reach for the remocn registry before hand-authoring any generic animated element (counter, bar chart, text reveal, backdrop, transition).",
+  why: "Hand-authoring what the registry already provides creates one-off implementations with no upstream, repeating the pre-registry _lib sprawl.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/components/remocn/backdrop.tsx" },
+  },
+};

package/src/rules/remapRateEndpointFormula.ts

@@ -0,0 +1,19 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from revola-video/BUILD_NOTES_CRAFT.md: "(D-1)/(P-1), not D/P, on
+ * purpose: the last playback frame must map to the scene's exact last design
+ * frame, because S2's match cut derives off D_S1 - 1."
+ */
+export const remapRateEndpointFormula: Rule = {
+  id: "remap-rate-endpoint-formula",
+  claim: "Compute a scene's playback rate as (D-1)/(P-1), never D/P, so the last playback frame maps exactly onto the last design frame.",
+  why: "Seam contracts are derived off a scene's last design frame; D/P leaves an endpoint error and the match cut drifts.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/tokensCraft.ts", symbol: "rate" },
+  },
+};

package/src/rules/remocnContentTailwindChrome.ts

@@ -0,0 +1,19 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md: "remocn animates the content, Tailwind
+ * utilities structure the frame." The anchor is the reference scene
+ * demonstrating the split.
+ */
+export const remocnContentTailwindChrome: Rule = {
+  id: "remocn-content-tailwind-chrome",
+  claim: "Use remocn components for animated content (counters, charts, text reveals, backdrops, transitions) and hand-built Tailwind for all container chrome (card shells, browser chrome, grids, layout).",
+  why: "remocn has no card, spotlight, or panel primitive, so sourcing chrome from the registry stalls the build; hand-animating counters and charts wastes the registry. The split is the norm, not a workaround.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/V2Beat4DashboardRemocn.tsx" },
+  },
+};

package/src/rules/retimeOnlyViaPlaybackOrDesignTokens.ts

@@ -0,0 +1,18 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from revola-video/BUILD_NOTES_CRAFT.md: "Do NOT re-time a scene by
+ * editing its internal beats to fit audio; that's what R_Sx is for."
+ */
+export const retimeOnlyViaPlaybackOrDesignTokens: Rule = {
+  id: "retime-only-via-playback-or-design-tokens",
+  claim: "Retime by moving P_* (audio changed) or D_* (choreography changed) and let rates and seams re-derive; never edit a scene's internal beats to fit audio, and shorten a rushed beat in design space.",
+  why: "Editing internal beats to fit audio bypasses the remap layer, silently breaking every derived rate, seam contract, and cue anchor.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/tokensCraft.ts" },
+  },
+};

package/src/rules/reviewTheRenderByFrameSweep.ts

@@ -0,0 +1,23 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from the product-room build: the author verified each round with
+ * per-beat stills and still shipped an empty hero card, unpadded panels and a
+ * click that never rendered. A blanket 2fps sweep of the finished mp4 found
+ * the first two together (build notes, "Round 3b - frame-sweep audit"); the
+ * dead click surfaced two rounds later while verifying something else. So the
+ * sweep is necessary and not sufficient - which is why `video review` also
+ * gates on staleness and on the render's length matching timing.json.
+ */
+export const reviewTheRenderByFrameSweep: Rule = {
+  id: "review-the-render-by-frame-sweep",
+  claim: "Before calling a round done, sweep the RENDERED file at ~2fps into labelled contact sheets and scan every frame; source review and hand-picked stills do not count.",
+  why: "Three defects in one build were invisible in source and obvious in the render - a wrapper that silently wiped every panel's padding, an animated sub-scene rendering as an empty box, and a click beat scheduled past its sequence end so it never drew - and all three survived rounds of per-beat stills because the stills were chosen where the author expected problems, not where they were.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/review.ts" },
+  },
+};

package/src/rules/rollingNumberBoundedSequence.ts

@@ -0,0 +1,21 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md, "Gotchas found wiring it into bespoke
+ * scenes", item 2. One of the three gotchas WS1 currently hardcodes in its
+ * plan; migrating it here is the proof that projection works end to end.
+ */
+export const rollingNumberBoundedSequence: Rule = {
+  id: "rolling-number-bounded-sequence",
+  claim: "Wrap RollingNumber in a Sequence spanning the whole card window and use the speed prop to settle early.",
+  why: "RollingNumber reads useVideoConfig().durationInFrames, so it counts over its Sequence's duration rather than its own. Left unwrapped it rolls for the entire shot; wrapped in a short Sequence it unmounts and the number vanishes mid-card.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "rolling-number", field: "gotcha" },
+  enforcement: {
+    kind: "prose",
+    // Anchored to the owned Tier A port (WS1); the guidance was originally
+    // learned on the vendored Tier B copy in revola-video.
+    anchor: { file: "packages/video-kit/src/motion/rolling-number.tsx" },
+  },
+};

package/src/rules/rollingNumberSequenceLayoutNone.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md, "Gotchas found wiring it into bespoke
+ * scenes": "the default Sequence wraps children in an AbsoluteFill, which
+ * breaks inline/flow layout inside a card. Always pass layout=\"none\"...".
+ * The default-wrapper behavior itself is documented Remotion behavior; the
+ * house rule is the always-pass-it policy when time-shifting in flow layout.
+ */
+export const rollingNumberSequenceLayoutNone: Rule = {
+  id: "rolling-number-sequence-layout-none",
+  claim: "When the Sequence around RollingNumber exists only to shift time, always pass layout=\"none\".",
+  why: "The default Sequence wraps children in an AbsoluteFill, which silently breaks inline/flow layout inside a card - elements stack at the container origin.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  upstream: "remotion:rules/sequencing.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "rolling-number", field: "gotcha" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/motion/rolling-number.tsx" },
+  },
+};

package/src/rules/rollingNumberTightBoxAlignment.ts

@@ -0,0 +1,19 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md, "Gotchas found wiring it into bespoke
+ * scenes": "remocn primitives are centered AbsoluteFills ... Give it too wide
+ * a box and the text floats to the middle (or wraps mid-word)."
+ */
+export const rollingNumberTightBoxAlignment: Rule = {
+  id: "rolling-number-tight-box-alignment",
+  claim: "To flow-align RollingNumber (or any remocn primitive), wrap it in a position: relative box sized to roughly the content's natural width, never a full-width box.",
+  why: "remocn primitives are centered AbsoluteFills filling their nearest positioned ancestor; in a too-wide box the number floats to the middle or wraps mid-word.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "rolling-number", field: "gotcha" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/motion/rolling-number.tsx" },
+  },
+};

package/src/rules/rollingNumberWhenNotToUse.ts

@@ -0,0 +1,24 @@
+import type { Rule } from "../types";
+
+/**
+ * Recovered from the WS1 plan's original hand-authored rolling-number.meta.ts
+ * block (deleted by the Task-8 reconciliation without being captured as a
+ * rule): "Do not use for multiple simultaneous stats (use a stat grid), for
+ * non-numeric emphasis, or when the value must be pixel-aligned to bespoke
+ * chrome without a wrapping box."
+ */
+export const rollingNumberWhenNotToUse: Rule = {
+  id: "rolling-number-when-not-to-use",
+  claim:
+    "Do not use RollingNumber for multiple simultaneous stats (use a stat grid), for non-numeric emphasis, or when the value must be pixel-aligned to bespoke chrome without a wrapping box.",
+  why: "A grid of rolling odometers makes every stat move so nothing reads as focal, and without a wrapping position: relative box its AbsoluteFill centering fights any pixel-alignment to bespoke chrome.",
+  learnedFrom: "docs/plans/2026-07-18-ws1-manifest-check-before-build-plan.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "rolling-number", field: "whenNotToUse" },
+  enforcement: {
+    kind: "prose",
+    // Anchored to the owned Tier A port (WS1); the guidance was originally
+    // learned on the vendored Tier B copy in revola-video.
+    anchor: { file: "packages/video-kit/src/motion/rolling-number.tsx" },
+  },
+};

package/src/rules/rollingNumberWhenToUse.ts

@@ -0,0 +1,23 @@
+import type { Rule } from "../types";
+
+/**
+ * Recovered from the WS1 plan's original hand-authored rolling-number.meta.ts
+ * block (deleted by the Task-8 reconciliation without being captured as a
+ * rule): "An animated odometer for a single headline number (users, revenue,
+ * count). Best when the number is the beat's focal point."
+ */
+export const rollingNumberWhenToUse: Rule = {
+  id: "rolling-number-when-to-use",
+  claim:
+    "Use RollingNumber as the animated odometer for a single headline number (users, revenue, count) that is the beat's focal point.",
+  why: "Skipping it means hand-rolling a counter (a duplicate motion primitive), and animating a number that is not the focal point turns the odometer into background noise competing with the real subject of the beat.",
+  learnedFrom: "docs/plans/2026-07-18-ws1-manifest-check-before-build-plan.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "rolling-number", field: "whenToUse" },
+  enforcement: {
+    kind: "prose",
+    // Anchored to the owned Tier A port (WS1); the guidance was originally
+    // learned on the vendored Tier B copy in revola-video.
+    anchor: { file: "packages/video-kit/src/motion/rolling-number.tsx" },
+  },
+};

package/src/rules/sameFamilySameProject.ts

@@ -0,0 +1,20 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md: "A new video for the same product family
+ * should be a new composition in the existing setup (act854 model), not a
+ * fresh repo." / "_lib is forked across ... colors.js sits at three distinct
+ * hashes".
+ */
+export const sameFamilySameProject: Rule = {
+  id: "same-family-same-project",
+  claim: "Build a new video for the same product family as a new composition inside the existing npm project, never as a fresh repo.",
+  why: "A fresh repo forks _lib, fonts, and node_modules - the exact fork that left colors.js at three hashes and SceneTransition.jsx at five across the old projects.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "Repo-layout doctrine; no code symbol encodes it.",
+  },
+};

package/src/rules/sampleBrandFromProduct.ts

@@ -0,0 +1,19 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md: "Brand | palette, logo files, fonts,
+ * accent ... | Sample from the real product, don't guess". The sampled values
+ * land in the project's token module.
+ */
+export const sampleBrandFromProduct: Rule = {
+  id: "sample-brand-from-product",
+  claim: "Sample brand colors, fonts, and accents from the real product's recon capture; never guess them.",
+  why: "Guessed brand values produce a video the client immediately flags as off-brand, triggering an avoidable feedback round.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/tokens.ts" },
+  },
+};

package/src/rules/sampleVelocityFromPreviousFramePosition.ts

@@ -0,0 +1,21 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from revola-video/BUILD_NOTES_CRAFT.md: "cursor velocity was sampled
+ * in bezier PARAMETER space (travel - 0.035), so the clamped tail reported
+ * fake speed and the cursor would have blurred permanently at rest. Now
+ * sampled from the previous frame." The corrected pattern is
+ * bezier(curTravel(frame - 1), ...) in S2Turn.tsx.
+ */
+export const sampleVelocityFromPreviousFramePosition: Rule = {
+  id: "sample-velocity-from-previous-frame-position",
+  claim: "Compute motion-blur velocity from the previous frame's evaluated position, never from a delta in curve-parameter space.",
+  why: "Parameter-space sampling on a clamped bezier reports fake speed at the clamped tail, so the cursor would have blurred permanently while at rest.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/S2Turn.tsx" },
+  },
+};

package/src/rules/sceneRootTagDeclared.test.ts

@@ -0,0 +1,43 @@
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { toolchainRepoRoot as repoRoot } from "../testSupport";
+import { checkFile } from "../sourceCheck";
+import { sceneRootTagDeclared } from "./sceneRootTagDeclared";
+
+const check = () => {
+  if (sceneRootTagDeclared.enforcement.kind !== "source") throw new Error("expected a source rule");
+  return sceneRootTagDeclared.enforcement.check;
+};
+
+// Same shape as dataRadarTagsDeclared.test.ts: each fixture directory is its
+// own one-project world (its own plan*.yaml), project-wide scope.
+const runIn = (fixture: string, name: string) => {
+  const rel = `packages/video-craft/src/fixtures/${fixture}/${name}`;
+  return checkFile(check(), join(repoRoot, rel), rel, repoRoot);
+};
+
+describe("sceneRootTagDeclared", () => {
+  test("fires when a radar-adopting project carries no data-radar-scene-root anywhere", () => {
+    const findings = runIn("scene-root-missing", "SceneHook.tsx");
+    expect(findings).toHaveLength(1);
+    expect(findings[0].match).toBe("data-radar-scene-root");
+    expect(findings[0].message).toMatch(/radar:scene refuses at setup/);
+    expect(findings[0].message).toMatch(/data-radar-scene-root="static"/);
+    expect(findings[0].message).toMatch(/innermost full-bleed camera layer/);
+    // Attributed to the plan, where the names: bindings that make the
+    // project radar-adopting live.
+    expect(findings[0].file).toMatch(/plan\.fixture\.yaml$/);
+  });
+
+  test("clean when the scene's root declares data-radar-scene-root=\"static\"", () => {
+    expect(runIn("scene-root-declared", "SceneHook.tsx")).toEqual([]);
+  });
+
+  test("clean when a SIBLING shell file carries the tag (the qguard shape)", () => {
+    expect(runIn("scene-root-shell", "SceneHook.tsx")).toEqual([]);
+  });
+
+  test("vacuous pass for a project whose plan declares no names: bindings", () => {
+    expect(runIn("scene-root-no-names", "SceneHook.tsx")).toEqual([]);
+  });
+});

package/src/rules/sceneRootTagDeclared.ts

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import type { Rule, SourceFinding } from "../types";
+import { declaredElements, findPlanDir, INCLUDE, isReporterFile, projectSourceFiles } from "./dataRadarTagsDeclared";
+
+/**
+ * Mined from docs/superpowers/specs/2026-08-08-build2-track-b-round2-report.md
+ * (Task B, "Setup refusal"): every geometry check's numbers come from scene
+ * space, and the sampler derives scene space from the `[data-radar-scene-root]`
+ * element. A radar-adopting scene emitted without the tag makes `radar:scene`
+ * refuse at the first sampled frame ("no [data-radar-scene-root] element").
+ * Both build2 first passes hit that refusal IDENTICALLY - Claude's 7-scene
+ * fan-out (40a7fb5) needed a dedicated fix round (c662df7) before its first
+ * sweep, and the Gemini replays reproduced the same absence 6/6 - because the
+ * scene-node contract never taught the convention. The contract text now does
+ * (HOW_I_BUILD_VIDEOS.md, scene/amplify dispatch); this rule is the free,
+ * no-render source check that catches the omission at authoring time.
+ *
+ * SCOPE: PROJECT-WIDE, like `data-radar-tags-declared`, and for the same
+ * reason: the tag routinely lives outside the scene module. qse-qguard-video
+ * carries it once in the shared `Shell.tsx` every scene renders inside, so a
+ * per-scene-file check would false-fail correct code. The honest source-level
+ * claim is "some element in this project's source declares scene space";
+ * which element is the RIGHT one (root AbsoluteFill vs innermost camera
+ * layer) is not decidable from source and stays with the runtime sampler,
+ * which refuses an untransformed-root shape outright and names the fix.
+ *
+ * A project whose plans declare no `names:` bindings is not radar-adopting:
+ * no geometry check will ever run against declared elements there, the
+ * contract is not owed, and the check passes vacuously - which is also what
+ * keeps the legacy corpus (qpa-video, revola-video, datapeak, qse-*) clean
+ * without a single KNOWN_EXCEPTIONS row.
+ */
+export const sceneRootTagDeclared: Rule = {
+  id: "scene-root-tag-declared",
+  claim: "A scene declares its scene-space contract: the root AbsoluteFill carries data-radar-scene-root=\"static\" when the scene has no whole-scene camera transform; when it has one, the innermost full-bleed camera layer carries data-radar-scene-root instead.",
+  why: "radar:scene derives every geometry number from the [data-radar-scene-root] element and refuses at setup without it; both build2 first passes (Claude's fan-out and the Gemini replays) shipped scenes missing the tag and cost a dedicated fix round (c662df7) before the first sweep could run.",
+  learnedFrom: "docs/superpowers/specs/2026-08-08-build2-track-b-round2-report.md",
+  tier: "gate",
+  verify: "`vitest run packages/video-craft` (source-level, no render) - at runtime `video radar:scene --project <dir> --comp <id>` refuses at setup naming the missing tag",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "source",
+    check: {
+      include: INCLUDE,
+      run(_file, relPath, root): SourceFinding[] {
+        const absPath = join(root, relPath);
+        const planDir = findPlanDir(dirname(absPath), root);
+        if (!planDir || !existsSync(planDir)) return [];
+        if (sceneRootTagDeclared.enforcement.kind !== "source") return [];
+        const selfCheck = sceneRootTagDeclared.enforcement.check;
+        if (!isReporterFile(planDir, absPath, selfCheck, root)) return [];
+
+        const declared = declaredElements(planDir, root);
+        if (declared.length === 0) return []; // not a radar-adopting project
+
+        // Textual containment is the whole check: the attribute NAME is the
+        // contract (any value form - "static", a camera declaration - counts),
+        // and ts-morph adds nothing over a substring for an attribute name.
+        const tagged = projectSourceFiles(planDir, selfCheck, root)
+          .some((f) => readFileSync(f, "utf8").includes("data-radar-scene-root"));
+        if (tagged) return [];
+
+        const planFile = declared[0].planFile;
+        const projRel = relative(root, planDir).split(sep).join("/");
+        return [{
+          file: planFile,
+          line: 1,
+          match: "data-radar-scene-root",
+          message: `${projRel} declares names: bindings but no data-radar-scene-root attribute exists anywhere in its `
+            + `source, so radar:scene refuses at setup on every scene. Put data-radar-scene-root="static" on the `
+            + `scene's root AbsoluteFill when the scene has no whole-scene camera transform; when it has one, tag `
+            + `the innermost full-bleed camera layer instead.`,
+        }];
+      },
+    },
+  },
+};

package/src/rules/scrubDemoDataToGenericRoles.ts

@@ -0,0 +1,19 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from act854-video/BUILD_NOTES.md: "Demo data scrubbed to generic
+ * roles (A. Admin, A. Auditor, etc.)." The exemplar is the members table in
+ * panels.jsx.
+ */
+export const scrubDemoDataToGenericRoles: Rule = {
+  id: "scrub-demo-data-to-generic-roles",
+  claim: "Scrub all demo data visible in rebuilt UI to generic role placeholders (A. Admin, A. Auditor) before render; never carry real names, emails, or org data from recon captures into panels.",
+  why: "Recon captures come from a live authenticated portal, so copied-in table rows are real PII by default; unscrubbed panels leak a client's real user data into a marketing video.",
+  learnedFrom: "act854-video/BUILD_NOTES.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "qpa-video/03_scenes/act854/panels.jsx" },
+  },
+};