fix(lint): unconditional dense content_overlap pass + honor 500ms floor

Round-1 blocker: the dense motion-overlap re-pass was gated on sparse-grid
geometry fingerprints changing, so an animation aliased to the sparse grid
(identical fingerprints, yet colliding between samples) bypassed the pass —
exactly the transient false-negative it was built to catch. Remove the gate:
the dense pass now runs unconditionally (bounded, text-only), driven by the
composition timeline rather than a fingerprint heuristic.

Round-2 follow-ups:
- Persistence-tier drift: at 8fps, occurrences>=2 spans only ~125ms, not the
  ~500ms the design intends, and it short-circuited before the ms floor.
  content_overlap promotion now requires BOTH occurrences>=2 AND a literal
  firstSeen..lastSeen span >= 500ms, so the wall-clock floor is honored at any
  sampling density. Comment block updated to match.
- Sample cap scales to hold a true 8fps grid up to ~75s (raised 120 -> 600)
  with an explicit note that longer comps degrade below 8fps to stay bounded.

Tests:
- Replaced the trivial "warning at every sample" test with a real between-grid
  regression: a collision living only inside (3.5,4.5) — a gap the sparse grid
  seeks past — is detected and, held ~750ms, promoted to error.
- Replaced the now-invalid "skips when static" test with one asserting the
  dense pass runs even when sparse fingerprints are identical (aliased motion).
- Added a tiering regression: two dense occurrences spanning ~125ms stay a
  warning (not error). Both new guards verified red before the fix.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: xuanruli

packages/cli/src/commands/check.test.ts

@@ -1346,30 +1346,44 @@ describe("contrast candidate round-trip", () => {
 });
 
 describe("dense motion-overlap re-sampling", () => {
-  it("surfaces a held content_overlap that only the dense grid observes", async () => {
-    // collectLayout (sparse base grid) sees nothing; collectOverlap (dense
-    // grid) reports the collision — as it would for a mid-motion crossing the
-    // base samples seek past. Held across the dense grid, it promotes to error.
+  // The default grid is 9 base samples at index+0.5 (0.5,1.5,...,8.5) over a 9s
+  // composition; the collision below lives entirely inside (3.5, 4.5), a gap
+  // the sparse grid seeks straight past. Only the 8fps dense pass observes it.
+  const inBetweenGridWindow = (time: number): boolean => time >= 3.6 && time <= 4.4;
+
+  it("detects a content_overlap that occurs ONLY between two sparse grid samples", async () => {
     const driver = fakeDriver({
+      // Sparse base grid sees nothing at any base sample time.
       collectLayout: vi.fn(async (_time: number) => []),
-      collectOverlap: vi.fn(async (time: number) => [
-        layoutIssue("warning", { time, code: "content_overlap" }),
-      ]),
+      // The transient exists only strictly between base samples 3.5 and 4.5.
+      collectOverlap: vi.fn(async (time: number) =>
+        inBetweenGridWindow(time)
+          ? [layoutIssue("warning", { time, code: "content_overlap" })]
+          : [],
+      ),
     });
     const { report } = await runScenario(driver);
     expect(driver.collectOverlap).toHaveBeenCalled();
     expect(report.layout.findings.some((f) => f.code === "content_overlap")).toBe(true);
+    // Held ~750ms across the dense grid (>= the 500ms floor) -> promoted.
     expect(report.layout.errorCount).toBeGreaterThan(0);
   });
 
-  it("skips the dense overlap pass when the composition never animates", async () => {
-    // A constant geometry fingerprint means the timeline never advanced — no
-    // transient crossing is possible, so the dense pass must not run.
+  it("runs the dense pass even when sparse fingerprints are identical (aliased motion)", async () => {
+    // A constant geometry fingerprint no longer suppresses the pass: an
+    // animation aliased to the sparse grid has identical fingerprints yet still
+    // collides between samples — the false-negative the removed gate caused.
     const driver = fakeDriver({
       collectLayoutGeometry: vi.fn(async () => "static"),
-      collectOverlap: vi.fn(async (_time: number) => []),
+      collectLayout: vi.fn(async (_time: number) => []),
+      collectOverlap: vi.fn(async (time: number) =>
+        inBetweenGridWindow(time)
+          ? [layoutIssue("warning", { time, code: "content_overlap" })]
+          : [],
+      ),
     });
-    await runScenario(driver);
-    expect(driver.collectOverlap).not.toHaveBeenCalled();
+    const { report } = await runScenario(driver);
+    expect(driver.collectOverlap).toHaveBeenCalled();
+    expect(report.layout.findings.some((f) => f.code === "content_overlap")).toBe(true);
   });
 });

packages/cli/src/utils/checkPipeline.ts

@@ -426,12 +426,15 @@ async function collectGridSamples(
 // mid-orbit text-on-text crossing that only overlaps for a fraction of a
 // second: an in-corpus orbit (samples/fuzz016) collides at 28% area for ~0.4s,
 // entirely between two adjacent base samples. 8fps (~0.125s spacing) lands
-// >= 2 samples inside a window that narrow, which is what persistence tiering
-// needs to promote the finding to error. Overlap collection is text-only
-// (collectSolidTextBlocks), far cheaper than a full layout audit, so a fine
-// grid here is affordable where densifying every detector would not be.
+// enough samples inside a window that narrow to observe it. Overlap collection
+// is text-only (collectSolidTextBlocks), far cheaper than a full layout audit,
+// so a fine grid here is affordable where densifying every detector would not.
 const OVERLAP_SAMPLE_FPS = 8;
-const OVERLAP_MAX_SAMPLES = 120;
+// Absolute ceiling on dense seeks so the pass stays bounded. This holds a true
+// 8fps grid for compositions up to OVERLAP_MAX_SAMPLES / OVERLAP_SAMPLE_FPS
+// (~75s); longer compositions degrade below 8fps rather than growing the seek
+// budget without limit. (Corpus compositions run 7-8s, well inside 8fps.)
+const OVERLAP_MAX_SAMPLES = 600;
 
 function buildOverlapSampleTimes(duration: number): number[] {
   if (!Number.isFinite(duration) || duration <= 0) return [];
@@ -449,19 +452,24 @@ function buildOverlapSampleTimes(duration: number): number[] {
  * Dense motion-overlap re-sampling. Reruns ONLY content_overlap on a fine time
  * grid so transient text collisions during continuous motion are observed at
  * all — the detector itself is unchanged (same 0.2-area threshold), only the
- * sampling density is. Gated on the composition actually animating (the
- * frozen-sweep geometry fingerprints differ across the base grid): a static
- * card produces no new work and no new findings. Findings feed the existing
- * collapse/persistence tiering, so a one-sample graze stays info while a held
- * collision (samples/fuzz016) re-promotes to error. Skips times already in the
- * base grid to avoid double-collecting the overlaps collectLayout already found.
+ * sampling density is.
+ *
+ * This runs UNCONDITIONALLY (bounded + text-only), NOT gated on sparse-grid
+ * geometry fingerprints changing. That gate was the motivating false-negative:
+ * an animation aliased to the sparse grid (the same pose sampled at every base
+ * point) has identical fingerprints yet still collides *between* those samples,
+ * so gating on fingerprint change skipped the exact transient this pass exists
+ * to catch. A static composition simply yields no overlaps at the extra times,
+ * so the only cost of running always is a bounded set of cheap text-only seeks.
+ * Findings feed the existing collapse/persistence tiering (a graze stays info,
+ * a held collision re-promotes to error). Skips times already in the base grid
+ * to avoid double-collecting overlaps collectLayout already found.
  */
 async function collectMotionOverlapSamples(
   driver: CheckAuditDriver,
   grid: SampleGrid,
   collected: GridSamples,
 ): Promise<void> {
-  if (new Set(collected.geometrySignatures).size <= 1) return;
   const baseTimes = new Set(grid.layoutSamples);
   for (const time of buildOverlapSampleTimes(grid.duration)) {
     if (baseTimes.has(time)) continue;

packages/cli/src/utils/layoutAudit.test.ts

@@ -227,6 +227,21 @@ describe("persistence-tiered severity (#U10)", () => {
     expect(collapsed[0]).toMatchObject({ severity: "error", occurrences: 2 });
   });
 
+  it("keeps a content_overlap that spans under the 500ms floor as a warning, even with 2 occurrences", () => {
+    // Two occurrences from the dense 8fps re-pass span only ~125ms — under the
+    // held-duration floor, so occurrences>=2 alone must NOT promote to error.
+    const collapsed = collapseStaticLayoutIssues(
+      [
+        { ...issue("content_overlap", "warning"), time: 4.0 },
+        { ...issue("content_overlap", "warning"), time: 4.125 },
+      ],
+      73,
+    );
+
+    expect(collapsed).toHaveLength(1);
+    expect(collapsed[0]).toMatchObject({ severity: "warning", occurrences: 2 });
+  });
+
   it("promotes a held, canvas-scale canvas_overflow breach from info to warning", () => {
     const breach = {
       ...issue("canvas_overflow", "info"),

packages/cli/src/utils/layoutAudit.ts

@@ -183,19 +183,17 @@ export function dedupeLayoutIssues(issues: LayoutIssue[]): LayoutIssue[] {
 
 // Persistence-tier thresholds (#U10, adapted from Adam Rosler's visual-linter
 // design). The approach doc frames these as held-duration floors — ignore
-// under ~250ms, re-promote content_overlap at >= ~500ms — measured against
-// the SAME firstSeen/lastSeen span this collapse step already tracks. At the
-// default 9-sample grid over a multi-second composition, a single collapsed
-// occurrence is held 0ms (one entrance/exit transient sample) and two
-// collapsed occurrences are already >= one sample-to-sample gap, which is
-// well past 500ms — so "held under 250ms" reduces to `occurrences <= 1` and
-// "held >= 500ms" reduces to `occurrences >= 2`. Tiering below is written in
-// those sample-count terms (the mapping the approach doc asks to document),
-// with the literal ms span (CONTENT_OVERLAP_HELD_ERROR_MS) kept as a fallback
-// for callers whose samples really are spaced close enough together for the
-// ms floor to matter on its own (dense `--at`/`--at-transitions` runs). The
-// ~250ms ignore floor needs no separate constant — see the occurrences <= 1
-// branch below.
+// under ~250ms, re-promote content_overlap at >= ~500ms — measured against the
+// SAME firstSeen/lastSeen span this collapse step already tracks. `occurrences`
+// is a NECESSARY guard (one sample can't span any duration), but it is NOT a
+// sufficient proxy for the 500ms floor: the dense content_overlap re-pass
+// (checkPipeline collectMotionOverlapSamples) samples at 8fps, so two adjacent
+// occurrences there span only ~125ms — the old "occurrences >= 2 => held >=
+// 500ms" shortcut held only for the coarse ~1s-spaced base grid and breaks
+// under dense sampling. content_overlap promotion therefore requires BOTH
+// occurrences >= 2 AND a literal firstSeen..lastSeen span >= 500ms, so the
+// wall-clock floor is honored regardless of sampling density. The ~250ms
+// ignore floor needs no separate constant — see the occurrences <= 1 branch.
 const CONTENT_OVERLAP_HELD_ERROR_MS = 500;
 const HELD_ACROSS_SAMPLES_MIN_OCCURRENCES = 2;
 
@@ -317,11 +315,14 @@ function isCanvasBreachHeldLarge(issue: LayoutIssue, occurrences: number): boole
   return overlapX > 0 && overlapY > 0;
 }
 
-// Split out of applyPersistenceTier so the two independent "held long enough"
-// signals (sample count vs. wall-clock span) read as one boolean question
-// instead of adding a third compound branch to the tiering ladder above.
+// Split out of applyPersistenceTier so the compound "held long enough" test
+// (>= 2 samples AND wall-clock span >= the ms floor) reads as one boolean
+// question instead of adding a compound branch to the tiering ladder above.
 function isContentOverlapHeldLongEnough(issue: LayoutIssue, occurrences: number): boolean {
-  if (occurrences >= HELD_ACROSS_SAMPLES_MIN_OCCURRENCES) return true;
+  // Need at least two samples to measure a span at all, AND that span must
+  // clear the wall-clock floor — dense 8fps re-sampling makes occurrences>=2
+  // alone (potentially ~125ms) too weak to imply a genuinely held collision.
+  if (occurrences < HELD_ACROSS_SAMPLES_MIN_OCCURRENCES) return false;
   const firstSeen = issue.firstSeen ?? issue.time;
   const lastSeen = issue.lastSeen ?? issue.time;
   const heldMs = (lastSeen - firstSeen) * 1000;