@revola-ai/video-craft 0.2.1

package/src/fixtures/scene-root-missing/plan.fixture.yaml

@@ -0,0 +1,10 @@
+doctrine: 1
+sections:
+  - id: hook
+    kind: motion
+    component: SceneHook
+    vo: "The hero image opens the film."
+    names:
+      - cue: 0
+        element: hero
+        says: "the hero image"

package/src/fixtures/scene-root-no-names/SceneHook.tsx

@@ -0,0 +1,6 @@
+// A project whose plan declares no names: bindings never runs radar:scene's
+// geometry checks against declared elements, so the scene-root contract is
+// not owed here and its absence is not a finding.
+export default function SceneHook() {
+  return <div style={{ width: 900, height: 500 }} />;
+}

package/src/fixtures/scene-root-no-names/plan.fixture.yaml

@@ -0,0 +1,6 @@
+doctrine: 0
+sections:
+  - id: hook
+    kind: motion
+    component: SceneHook
+    vo: "No names bindings anywhere: not a radar-adopting plan."

package/src/fixtures/scene-root-shell/SceneHook.tsx

@@ -0,0 +1,8 @@
+// The qse-qguard-video shape: the scene module itself carries no scene-root
+// tag because a shared Shell component (a sibling file) carries it for every
+// scene. Project-wide scope keeps this from being a false positive.
+export default function SceneHook() {
+  return (
+    <div data-radar="hero" style={{ width: 900, height: 500 }} />
+  );
+}

package/src/fixtures/scene-root-shell/Shell.tsx

@@ -0,0 +1,9 @@
+// The shared shell owns the scene-space contract for every scene it wraps
+// (this project has no whole-scene camera transform, hence "static").
+export function Shell({ children }: { children: React.ReactNode }) {
+  return (
+    <div data-radar-scene-root="static" style={{ position: "absolute", inset: 0 }}>
+      {children}
+    </div>
+  );
+}

package/src/fixtures/scene-root-shell/plan.fixture.yaml

@@ -0,0 +1,10 @@
+doctrine: 1
+sections:
+  - id: hook
+    kind: motion
+    component: SceneHook
+    vo: "The hero image opens the film."
+    names:
+      - cue: 0
+        element: hero
+        says: "the hero image"

package/src/fixtures/shorthand-undefined-clean.tsx

@@ -0,0 +1,23 @@
+// Fixture: shapes that must NOT fire.
+export const Fine = ({ on, blur }: { on: boolean; blur: number }) => (
+  <>
+    {/* a ternary yielding undefined is the sanctioned way to omit a value */}
+    <div style={{ filter: blur > 0.5 ? `blur(${blur}px)` : undefined }} />
+    {/* longhand undefined with NO shorthand sibling cannot clear anything */}
+    <div style={{ paddingTop: undefined, color: "red" }} />
+    {/* both defined is legal CSS-in-JS cascade */}
+    <div style={{ padding: 4, paddingTop: 12 }} />
+    {/* borderRadius is not a longhand of border: border does not reset it.
+        The CORNER spellings are the ones that actually slip through a prefix
+        match, so they are the cases that must be pinned. */}
+    <div style={{ border: "1px solid", borderRadius: undefined }} />
+    <div style={{ border: "1px solid", borderTopLeftRadius: undefined }} />
+    <div style={{ border: "1px solid", borderTopRightRadius: undefined }} />
+    <div style={{ border: "1px solid", borderBottomLeftRadius: undefined }} />
+    <div style={{ border: "1px solid", borderBottomRightRadius: undefined }} />
+    {/* background does not reset background-blend-mode */}
+    <div style={{ background: "red", backgroundBlendMode: undefined }} />
+    {/* the shorthand itself may be undefined */}
+    <div style={{ padding: on ? 8 : undefined }} />
+  </>
+);

package/src/fixtures/shorthand-undefined-longhand.tsx

@@ -0,0 +1,17 @@
+import React from "react";
+
+// Fixture: a longhand explicitly set to `undefined` beside its shorthand.
+// React writes the longhand after the shorthand and clears it, so the
+// shorthand silently stops applying. This is the exact shape that wiped
+// every panel's padding in the product-room build.
+export const Bad = ({ style }: { style?: React.CSSProperties }) => {
+  const { padding, paddingTop, ...rest } = style ?? {};
+  return (
+    <>
+      <div style={{ padding, paddingTop, paddingLeft: undefined }} />
+      <div style={{ margin: 8, marginRight: undefined }} />
+      <div style={{ background: "red", backgroundColor: undefined }} />
+      <div style={{ ...rest }} />
+    </>
+  );
+};

package/src/fixtures/token-scene.tsx

@@ -0,0 +1,9 @@
+// A scene that references only token-object members; rgba()/hsl() strings are
+// deliberately out of the rule's scope (hex only).
+const CK = { panel: "tokenized", ink: "tokenized" } as const;
+
+export const Panel = () => (
+  <div style={{ background: CK.panel, color: CK.ink }}>
+    <div style={{ boxShadow: "0 0 12px rgba(0, 0, 0, 0.4)" }} />
+  </div>
+);

package/src/includeCoverage.test.ts

@@ -0,0 +1,176 @@
+// A NEW video project must not silently arrive with zero machine gates.
+//
+// Every source rule enumerates its `include` globs per project, because
+// layouts differ (`qpa-video/03_scenes/**` against `revola-video/src/scenes/**`)
+// and a silent default would make each rule's blast radius a guess - the
+// reasoning in types.ts's `SourceCheck.include` doc. The cost of that
+// decision is that creating a project is invisible to every rule until
+// somebody edits ten include lists by hand, and nothing failed when they
+// did not: `klaviyo-segments-video` and `radar-fixture-video` were both
+// absent from every rule's include list for their entire build, and
+// `qse-qguard-video` was excluded from every source check for its whole
+// build (the incident `deterministic-scene-source`'s own comment records).
+//
+// This test is the missing failure (production-readiness P5). It compares the
+// projects that exist against the projects each rule's globs name, so a new
+// project turns the suite red until it is either enrolled or deliberately
+// excused here with a reason.
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { globSync } from "tinyglobby";
+import { describe, expect, test } from "vitest";
+import { RULES } from "./registry";
+import { toolchainRepoRoot as repoRoot } from "./testSupport";
+
+/**
+ * Deliberately narrower than "every project", with the reason. An entry here
+ * is a scope decision on the record, not a silent omission - and the test
+ * below fails on a STALE entry too, so an excuse cannot outlive its project.
+ */
+const NARROW_BY_DESIGN: Record<string, { projects: string[]; why: string }> = {
+  // Entries excusing projects that stayed upstream in remotion-videos at the
+  // 2026-08-24 extraction were pruned: the staleness test below is the reason
+  // an excuse cannot outlive its project, and those projects are not in this
+  // repo. The historical scope decisions live in remotion-videos' copy of
+  // this file.
+  "tokens-not-raw-hexes": {
+    projects: ["qse-qguard-video", "radar-fixture-video"],
+    why: "scoped to projects with a committed token module to check against; "
+      + "both fixture projects would report their whole palette as a violation with nothing to point at instead",
+  },
+};
+
+/**
+ * Source rules with no subject in THIS repo, with the reason. Unlike
+ * NARROW_BY_DESIGN (which excuses a rule from one project), an entry here says
+ * the rule's globs currently reach nothing at all. The staleness test below
+ * deletes the excuse for you: the moment a matching file lands, the entry
+ * fails until it is removed and the rule is enforced for real again.
+ */
+const NO_SUBJECTS_HERE: Record<string, string> = {
+  // Empty, and that is the design working. Both former entries expired when
+  // `workday-dple-video` landed with a committed token module (src/tokens.ts)
+  // and geometry sidecars, exactly as each entry's own text predicted it would
+  // - "this entry expires the moment the first sidecar is written". The
+  // staleness test below is what deleted them: an excuse here cannot outlive
+  // the condition that justified it.
+};
+
+/** Top-level project directories that actually carry scene source today. A
+ *  plan-and-assets-only directory (act854-video, whose scenes live under
+ *  qpa-video/03_scenes/act854) has nothing for a source rule to read. */
+const projectsWithSceneSource = (): string[] =>
+  readdirSync(repoRoot)
+    .filter((name) => !name.startsWith(".") && statSync(join(repoRoot, name)).isDirectory())
+    .filter((name) => /-video$/.test(name) || name === "spec-videos" || name === "datapeak-usecases" || name === "remocn-sandbox")
+    .filter((name) => existsSync(join(repoRoot, name, "package.json")))
+    .filter((name) => globSync(["src/**/*.{jsx,tsx}", "03_scenes/**/*.{jsx,tsx}"], {
+      cwd: join(repoRoot, name),
+      ignore: ["**/node_modules/**", "**/build/**"],
+    }).length > 0)
+    .sort();
+
+/** The top-level directories a rule's include globs reach. `*` as the first
+ *  segment (geometry-sidecar-exports-typed's `*​/src/scenes/...`) covers every
+ *  project by construction. */
+const projectsCoveredBy = (include: string[]): { names: Set<string>; wildcard: boolean } => {
+  const names = new Set<string>();
+  let wildcard = false;
+  for (const glob of include) {
+    const head = glob.split("/")[0];
+    if (head === "*" || head === "**") { wildcard = true; continue; }
+    names.add(head);
+  }
+  return { names, wildcard };
+};
+
+describe("source-rule include coverage", () => {
+  const projects = projectsWithSceneSource();
+
+  test("finds the projects at all (a broken discovery must not read as full coverage)", () => {
+    // Post-extraction this repo carries exactly the two test-fixture projects
+    // (the vendored qpa-video slice has no package.json on purpose, so it is
+    // fixture data, not a project). A discovery that misses either one would
+    // silently shrink every rule's blast radius to nothing.
+    expect(projects).toContain("qse-qguard-video");
+    expect(projects).toContain("radar-fixture-video");
+    expect(projects.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("every project with scene source is in every source rule's include list", () => {
+    const gaps: string[] = [];
+    for (const rule of RULES) {
+      if (rule.enforcement.kind !== "source") continue;
+      const { names, wildcard } = projectsCoveredBy(rule.enforcement.check.include);
+      if (wildcard) continue;
+      const excused = new Set(NARROW_BY_DESIGN[rule.id]?.projects ?? []);
+      for (const project of projects) {
+        if (names.has(project) || excused.has(project)) continue;
+        gaps.push(`${rule.id} does not cover ${project}`);
+      }
+    }
+    expect(
+      gaps,
+      "A new video project starts with ZERO machine gates until it is added to each rule's include list. "
+      + "Add the project's own glob to the rule (layouts differ, so it must be explicit), or - if the rule "
+      + "genuinely does not apply - add it to NARROW_BY_DESIGN in this file with the reason.",
+    ).toEqual([]);
+  });
+
+  // The coverage test above asks "is every project reached by each rule?".
+  // It cannot see the opposite failure: a rule excused for every project that
+  // exists, whose remaining globs name directories that do not, matches
+  // nothing at all and reports green forever. `tokens-not-raw-hexes` sat in
+  // exactly that state after the 2026-08-24 extraction - tier `gate`, with a
+  // `verify:` line promising a machine check, scanning zero files - and
+  // nothing failed. A gate that cannot reach a subject is a claim, not a gate.
+  test("every source rule's include globs actually match a file", () => {
+    const dark: string[] = [];
+    for (const rule of RULES) {
+      if (rule.enforcement.kind !== "source") continue;
+      const hits = globSync(rule.enforcement.check.include, {
+        cwd: repoRoot,
+        ignore: ["**/node_modules/**", "**/build/**"],
+      });
+      if (hits.length === 0 && !(rule.id in NO_SUBJECTS_HERE)) dark.push(`${rule.id} [tier=${rule.tier}] matches no file`);
+    }
+    expect(
+      dark,
+      "A source rule whose globs match nothing enforces nothing, however good its check is. "
+      + "Point the globs at a directory that exists, or - if the rule legitimately has no subject "
+      + "in this repo - add it to NO_SUBJECTS_HERE in this file with the reason.",
+    ).toEqual([]);
+  });
+
+  test("no NO_SUBJECTS_HERE entry is stale", () => {
+    const ruleIds = new Set(RULES.map((r) => r.id));
+    const stale: string[] = [];
+    for (const [ruleId, why] of Object.entries(NO_SUBJECTS_HERE)) {
+      if (!ruleIds.has(ruleId)) { stale.push(`${ruleId}: no such rule`); continue; }
+      if (!why.trim()) { stale.push(`${ruleId}: no reason given`); continue; }
+      const rule = RULES.find((r) => r.id === ruleId);
+      if (rule?.enforcement.kind !== "source") { stale.push(`${ruleId}: not a source rule`); continue; }
+      const hits = globSync(rule.enforcement.check.include, {
+        cwd: repoRoot,
+        ignore: ["**/node_modules/**", "**/build/**"],
+      });
+      // The point of the excuse is that it expires on its own: the moment a
+      // subject lands, the rule must go back to being enforced for real.
+      if (hits.length > 0) stale.push(`${ruleId}: now matches ${hits.length} file(s); remove its NO_SUBJECTS_HERE entry`);
+    }
+    expect(stale).toEqual([]);
+  });
+
+  test("no NARROW_BY_DESIGN entry is stale", () => {
+    const ruleIds = new Set(RULES.map((r) => r.id));
+    const stale: string[] = [];
+    for (const [ruleId, entry] of Object.entries(NARROW_BY_DESIGN)) {
+      if (!ruleIds.has(ruleId)) { stale.push(`${ruleId}: no such rule`); continue; }
+      if (!entry.why.trim()) stale.push(`${ruleId}: no reason given`);
+      for (const project of entry.projects) {
+        if (!projects.includes(project)) stale.push(`${ruleId}: excuses "${project}", which is not a project with scene source`);
+      }
+    }
+    expect(stale).toEqual([]);
+  });
+});

package/src/learnedFrom.test.ts

@@ -0,0 +1,32 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { isUpstreamProvenance, upstreamCitationError } from "./provenance";
+import { RULES } from "./registry";
+import { toolchainRepoRoot as repoRoot } from "./testSupport";
+
+/**
+ * Every rule's learnedFrom must point at a file that exists, or cite the
+ * upstream remotion-videos repo this toolchain was extracted from (see
+ * UPSTREAM_PROVENANCE_ROOTS). The digest and notes files are primary
+ * sources, not living notes, so they carry no (Rule: `<id>`.)
+ * back-references and drift.test.ts does not scan them - this check is the
+ * whole provenance guard for such sources: a typo'd, renamed, or deleted
+ * local source file fails here instead of rotting silently in an unchecked
+ * history string, and an upstream citation still has to be well-formed.
+ */
+describe("learnedFrom provenance", () => {
+  test("every local learnedFrom path exists in the repo", () => {
+    const missing = RULES.filter(
+      (r) => !isUpstreamProvenance(r.learnedFrom) && !existsSync(join(repoRoot, r.learnedFrom)),
+    ).map((r) => `${r.id} -> ${r.learnedFrom}`);
+    expect(missing).toEqual([]);
+  });
+
+  test("every upstream learnedFrom citation is well-formed", () => {
+    const malformed = RULES.filter(
+      (r) => isUpstreamProvenance(r.learnedFrom) && upstreamCitationError(r.learnedFrom),
+    ).map((r) => `${r.id} -> ${r.learnedFrom}`);
+    expect(malformed).toEqual([]);
+  });
+});

package/src/projectDoc.test.ts

@@ -0,0 +1,230 @@
+import { describe, expect, test } from "vitest";
+import { renderClaudeMdBlock, renderPipelineBlock, spliceBlock } from "./projectDoc";
+import type { Rule } from "./types";
+
+const rule = (id: string, claim: string, why: string, over: Partial<Rule> = {}): Rule => ({
+  id, claim, why,
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: { kind: "prose", unanchorable: "test fixture" },
+  ...over,
+});
+
+const gate = (id: string, claim: string, verify: string): Rule =>
+  rule(id, claim, `${id} why.`, { tier: "gate", verify });
+
+describe("spliceBlock", () => {
+  const doc = [
+    "# Title",
+    "",
+    "<!-- craft:begin rules -->",
+    "stale content",
+    "<!-- craft:end rules -->",
+    "",
+    "Trailing prose.",
+  ].join("\n");
+
+  test("replaces only what is between the markers", () => {
+    const out = spliceBlock(doc, "rules", "fresh content");
+    expect(out).toContain("fresh content");
+    expect(out).not.toContain("stale content");
+    expect(out).toContain("# Title");
+    expect(out).toContain("Trailing prose.");
+  });
+
+  test("keeps the markers so the block can be spliced again", () => {
+    const once = spliceBlock(doc, "rules", "first body");
+    expect(spliceBlock(once, "rules", "second body")).toContain("second body");
+    expect(spliceBlock(once, "rules", "second body")).not.toContain("first body");
+  });
+
+  test("throws when the marker is missing rather than appending silently", () => {
+    expect(() => spliceBlock("# Title", "rules", "x")).toThrow(/marker "craft:begin rules" not found/);
+  });
+
+  test("throws when the end marker is missing", () => {
+    expect(() => spliceBlock("<!-- craft:begin rules -->", "rules", "x"))
+      .toThrow(/marker "craft:end rules" not found/);
+  });
+});
+
+describe("renderPipelineBlock", () => {
+  test("renders each rule as claim plus why, sorted by id", () => {
+    const out = renderPipelineBlock([rule("zebra", "Z claim.", "Z why."), rule("alpha", "A claim.", "A why.")]);
+    expect(out.indexOf("A claim.")).toBeLessThan(out.indexOf("Z claim."));
+    expect(out).toContain("A why.");
+  });
+
+  test("cites where each rule was learned", () => {
+    expect(renderPipelineBlock([rule("a", "A.", "B.")])).toContain("revola-video/BUILD_NOTES_CRAFT.md");
+  });
+
+  test("says it is generated", () => {
+    expect(renderPipelineBlock([])).toContain("generated");
+  });
+});
+
+describe("renderClaudeMdBlock", () => {
+  test("names every pipeline rule, sorted by id, without its why", () => {
+    const out = renderClaudeMdBlock([
+      rule("b-rule", "Do B.", "Because B."),
+      rule("a-rule", "Do A.", "Because A."),
+    ]);
+    expect(out.split("\n")[0]).toMatch(/generated from packages\/video-craft/);
+    // Craft-tier and unwaived, so each is named by id rather than by claim
+    // (video-toolchain-cg6); ordering by id is unchanged.
+    expect(out).toContain("`a-rule`");
+    expect(out).toContain("`b-rule`");
+    expect(out.indexOf("`a-rule`")).toBeLessThan(out.indexOf("`b-rule`"));
+    // Compact by design: the why lives in HOW_I_BUILD_VIDEOS.md, not here.
+    expect(out).not.toContain("Because A.");
+  });
+
+  test("a gate still renders as a full claim line", () => {
+    const out = renderClaudeMdBlock([gate("g-rule", "Do G.", "video check-pin --project x")]);
+    expect(out).toContain("- Do G. (`g-rule`)");
+    expect(out).toContain("verify: video check-pin --project x");
+  });
+
+  test("excludes component-scoped rules", () => {
+    const component: Rule = {
+      ...rule("c-rule", "Do C.", "Because C."),
+      scope: { kind: "component", slug: "rolling-number", field: "gotcha" },
+    };
+    expect(renderClaudeMdBlock([component])).not.toContain("c-rule");
+  });
+});
+
+// Trial 3 run 1 produced five rebuild rounds. Every defect that cost a round sat
+// in a rule that was stated and not checked, and the flat list gave an agent no
+// way to tell those rules from a comment-hygiene note. Tiering exists to put the
+// expensive rules first and carry the command that settles each one.
+describe("renderClaudeMdBlock tiering", () => {
+  const rules = [
+    rule("zulu-craft", "Craft Z.", "why."),
+    gate("alpha-gate", "Gate A.", "video render-twice --comp x"),
+    rule("mike-process", "Process M.", "why.", { tier: "process" }),
+    rule("alpha-craft", "Craft A.", "why."),
+    gate("zulu-gate", "Gate Z.", "video check-pin --project x"),
+  ];
+
+  // Asserted on ids rather than claims: gates carry their claim, craft and
+  // process compact to an id index (see below), so the id is the one token
+  // every rule contributes at every tier.
+  test("gates come before craft, and craft before process", () => {
+    const out = renderClaudeMdBlock(rules);
+    expect(out.indexOf("`alpha-gate`")).toBeLessThan(out.indexOf("`alpha-craft`"));
+    expect(out.indexOf("`alpha-craft`")).toBeLessThan(out.indexOf("`mike-process`"));
+  });
+
+  test("sorts by id inside a tier", () => {
+    const out = renderClaudeMdBlock(rules);
+    expect(out.indexOf("`alpha-gate`")).toBeLessThan(out.indexOf("`zulu-gate`"));
+    expect(out.indexOf("`alpha-craft`")).toBeLessThan(out.indexOf("`zulu-craft`"));
+  });
+
+  // Guards the above against being read as a whole-tier invariant. A compacted
+  // tier renders as TWO id-sorted groups - waived rules in full, then the index
+  // - so a waived rule with a late id prints above a plain rule with an early
+  // one. Asserting whole-tier id order would fail on correct output the moment
+  // any fixture rule gained a waiver; sorting is per-group, by construction.
+  test("a waived rule hoists above the index regardless of its id", () => {
+    const out = renderClaudeMdBlock([
+      rule("alpha-craft", "Alpha claim.", "why."),
+      rule("zulu-craft", "Zulu claim.", "why.", {
+        exceptions: [{ project: "p", decision: "d", recordedIn: "p/docs/spec.md" }],
+      }),
+    ]);
+    expect(out.indexOf("`zulu-craft`")).toBeLessThan(out.indexOf("`alpha-craft`"));
+  });
+
+  test("carries each gate's verify command, so the rule is settled by running something", () => {
+    const out = renderClaudeMdBlock(rules);
+    expect(out).toContain("video render-twice --comp x");
+    expect(out).toContain("video check-pin --project x");
+  });
+
+  test("labels the gate tier so its weight is legible without reading every rule", () => {
+    expect(renderClaudeMdBlock(rules)).toMatch(/remember nothing else/i);
+  });
+
+  test("still emits every rule - tiering reorders, it never drops", () => {
+    const out = renderClaudeMdBlock(rules);
+    for (const r of rules) expect(out).toContain(`\`${r.id}\``);
+  });
+
+  // CLAUDE.md is injected into EVERY session; HOW_I_BUILD only when a session
+  // touches pipeline behaviour. Spending ~6k tokens per session restating 107
+  // claims that HOW_I_BUILD carries verbatim buys nothing, but dropping the
+  // craft rules outright would leave a session that never opens HOW_I_BUILD
+  // unaware they exist. So gates stay in full and everything else is named by
+  // id: an agent can never not know a rule exists, and fetches the claim when
+  // the id looks relevant. (video-toolchain-cg6)
+  describe("craft and process compact to an id index", () => {
+    test("a plain craft rule contributes its id but not its claim", () => {
+      const out = renderClaudeMdBlock(rules);
+      expect(out).toContain("`alpha-craft`");
+      expect(out).not.toContain("Craft A.");
+    });
+
+    test("a plain process rule contributes its id but not its claim", () => {
+      const out = renderClaudeMdBlock(rules);
+      expect(out).toContain("`mike-process`");
+      expect(out).not.toContain("Process M.");
+    });
+
+    test("gates keep their full claim and verify line", () => {
+      const out = renderClaudeMdBlock(rules);
+      expect(out).toContain("Gate A.");
+      expect(out).toContain("video render-twice --comp x");
+    });
+
+    test("points at where the compacted claims can be read", () => {
+      expect(renderClaudeMdBlock(rules)).toMatch(/HOW_I_BUILD_VIDEOS\.md/);
+    });
+  });
+
+  // The one exemption, and the reason it is not optional: exceptionLines' own
+  // doc comment records that a waiver invisible in the projection is how a
+  // session inside the waived project "fixes" the client's decision back out.
+  // Compacting a waived rule to a bare id would reintroduce exactly that.
+  describe("waived rules stay in full at any tier", () => {
+    const waived = rule("waived-craft", "Waived craft claim.", "why.", {
+      exceptions: [{ project: "some-video", decision: "client chose otherwise", recordedIn: "some-video/docs/spec.md" }],
+    });
+
+    test("keeps the claim, so the waiver is not attached to an invisible rule", () => {
+      expect(renderClaudeMdBlock([waived])).toContain("Waived craft claim.");
+    });
+
+    test("keeps the waiver line naming the project and where it was recorded", () => {
+      const out = renderClaudeMdBlock([waived]);
+      expect(out).toContain("waived in `some-video`");
+      expect(out).toContain("some-video/docs/spec.md");
+    });
+
+    test("an unwaived neighbour in the same tier still compacts", () => {
+      const out = renderClaudeMdBlock([waived, rule("plain-craft", "Plain craft claim.", "why.")]);
+      expect(out).toContain("Waived craft claim.");
+      expect(out).not.toContain("Plain craft claim.");
+      expect(out).toContain("`plain-craft`");
+    });
+  });
+
+  test("omits a tier heading when that tier is empty", () => {
+    expect(renderClaudeMdBlock([rule("only-craft", "C.", "why.")])).not.toMatch(/remember nothing else/i);
+  });
+});
+
+describe("renderPipelineBlock tiering", () => {
+  test("states each rule's tier, so the reference doc agrees with the injected block", () => {
+    expect(renderPipelineBlock([rule("a", "A.", "B.")])).toMatch(/Tier: craft/);
+  });
+
+  test("gives a gate its verify, so the reference doc says how to settle it", () => {
+    const out = renderPipelineBlock([gate("g", "G.", "video check-pin --project x")]);
+    expect(out).toMatch(/Tier: gate/);
+    expect(out).toContain("video check-pin --project x");
+  });
+});