@erclx/canon 5.49.0 → 5.50.0

package/src/commands/claude.ts

@@ -71,6 +71,9 @@ import {
   serializeSettings,
   writeSettings,
 } from '@/claude/settings'
+import { bodyLines } from '@/markdown/scan'
+import { scopedDensityFindings } from '@/markdown/scope'
+import { CAP } from '@/markdown/stacks'
 import { readSessionDefaults } from '@/migrate/session-defaults'
 import { copyPreservingMode } from '@/sync/copy'
 import { checkoutMismatchWarning, PROJECT_ROOT } from '@/roots/project'
@@ -176,6 +179,22 @@ export function seededDirPath(resolved: string, name: string): string {
     ? surfaceDir(resolved, name)
     : recordDir(resolved, name)
 }
+
+/**
+ * Each bullet run past the limit in the target's `CLAUDE.md` Key paths, read
+ * through the scope the audit gates on. Sync warns rather than gates, since a
+ * target gates only the prefixes its own config lists.
+ */
+export async function longKeyPathsRuns(
+  resolved: string,
+): Promise<{ line: number; count: number }[]> {
+  const path = join(resolved, 'CLAUDE.md')
+  if (!existsSync(path)) return []
+  const lines = bodyLines(await readFile(path, 'utf8'))
+  return scopedDensityFindings('CLAUDE.md', lines)
+    .filter((finding) => finding.kind === 'bullet-run')
+    .map((finding) => ({ line: finding.line, count: finding.value ?? 0 }))
+}
 const USER_DIR = join('tooling', 'claude', 'user')
 const STATUSLINE = 'statusline-command.sh'
 const PLUGIN_MANIFEST = join('claude', '.claude-plugin', 'plugin.json')
@@ -244,7 +263,8 @@ export function register(program: Command): void {
         'Writes .gitignore alone: adds the entries the claude manifest lists',
         'and drops ones under its headers that the manifest no longer lists.',
         'A seeded file is reported, never rewritten, and a missing one points',
-        'at `canon claude init`.',
+        'at `canon claude init`. A CLAUDE.md Key paths running past 5 bullets',
+        'is reported with the H3 grouping that fixes it.',
         '',
         'Exit codes:',
         '  0  synced, already up to date, or the prompt was cancelled',
@@ -665,6 +685,11 @@ async function runSync(target: string): Promise<number> {
     if (isDirectory(seededDirPath(resolved, name))) logInfo(`${name}/`)
     else logWarn(`${name}/ missing. Run \`canon claude init\``)
   }
+  for (const run of await longKeyPathsRuns(resolved)) {
+    logWarn(
+      `CLAUDE.md:${run.line} runs ${run.count} Key paths bullets past ${CAP}. Group them under H3s, each opening on a lead sentence`,
+    )
+  }
 
   // Sync never rewrites an existing settings file, so a target seeded before
   // the session defaults learns of them only here.

package/src/commands/gate.ts

@@ -130,22 +130,9 @@ async function runGate(opts: RunCommandOptions): Promise<number> {
       process.stderr.write(`${failed.label}: ${failed.failure}\n`)
     }
     process.stdout.write(
-      `${JSON.stringify({
-        ok: code === 0,
-        root,
-        scoped: changed.scoped,
-        changed: changed.files.length,
-        summary,
-        ms: results.reduce((total, result) => total + result.ms, 0),
-        stages: results.map(({ id, label, status, failure, ms, queuedMs }) => ({
-          id,
-          label,
-          status,
-          failure,
-          ms,
-          queuedMs,
-        })),
-      })}\n`,
+      `${JSON.stringify(
+        gateRecord({ ok: code === 0, root, changed, summary, results }),
+      )}\n`,
     )
     return code
   }
@@ -154,6 +141,60 @@ async function runGate(opts: RunCommandOptions): Promise<number> {
   return code
 }
 
+/** Lines of a failed stage's output the record keeps, counted from the end. */
+const OUTPUT_TAIL_LINES = 200
+
+interface GateRecordInput {
+  readonly ok: boolean
+  readonly root: string
+  readonly changed: {
+    readonly scoped: boolean
+    readonly files: readonly string[]
+  }
+  readonly summary: Summary
+  readonly results: readonly StageResult[]
+}
+
+/**
+ * The `--json` record. A failed stage carries the tail of the output its
+ * checks printed, since a caller reading the record alone otherwise reruns
+ * the stage by hand to learn which test failed. The tail rather than a parse
+ * of the `FAIL` lines, so a generic stage stays free of one runner's format,
+ * and a dot-reporter run prints its failures and summary last.
+ */
+export function gateRecord(input: GateRecordInput) {
+  const { ok, root, changed, summary, results } = input
+  return {
+    ok,
+    root,
+    scoped: changed.scoped,
+    changed: changed.files.length,
+    summary,
+    ms: results.reduce((total, result) => total + result.ms, 0),
+    stages: results.map(
+      ({ id, label, status, failure, ms, queuedMs, emissions }) => ({
+        id,
+        label,
+        status,
+        failure,
+        ms,
+        queuedMs,
+        output: status === 'failed' ? outputTail(emissions) : undefined,
+      }),
+    ),
+  }
+}
+
+function outputTail(emissions: StageResult['emissions']): string {
+  const lines = emissions
+    .filter((emission) => emission.kind === 'output')
+    .map((emission) => emission.text.trimEnd())
+    .filter((text) => text !== '')
+    .join('\n')
+    .split('\n')
+  return lines.slice(-OUTPUT_TAIL_LINES).join('\n')
+}
+
 function report(result: StageResult): void {
   logStep(result.label)
   for (const emission of result.emissions) {

package/src/commands/markdown.ts

@@ -6,7 +6,7 @@ import { BAN_SETS, emptyBanSets } from '@/markdown/bans'
 import { isChangelog, lengthExemption } from '@/markdown/ceiling'
 import { type ColonFinding, findColons } from '@/markdown/colons'
 import { type MarkdownAuditRefusal, resolveMarkdown } from '@/markdown/files'
-import { densityFindings, type DensityKind } from '@/markdown/density'
+import type { DensityKind } from '@/markdown/density'
 import {
   type GatedDensityFinding,
   type GatedReferenceShapeFinding,
@@ -38,7 +38,19 @@ import {
   readGatedConfig,
   resolveGatedList,
 } from '@/markdown/gated'
-import { densityGates, inDensityScope } from '@/markdown/scope'
+import {
+  densityGates,
+  inDensityScope,
+  scopedDensityFindings,
+} from '@/markdown/scope'
+import {
+  TABLE_CELL,
+  TABLE_ROWS,
+  TABLE_TOKEN,
+  type TableFinding,
+  tableFindings,
+  type TableKind,
+} from '@/markdown/tables'
 import {
   BASELINE,
   CHECKPOINTS,
@@ -86,6 +98,8 @@ interface FileReport {
   readonly headingCase: readonly HeadingCaseFinding[]
   /** Empty on a path outside the density scope, so a plan never carries one. */
   readonly density: readonly GatedDensityFinding[]
+  /** Empty outside the density scope, and never gating anywhere. */
+  readonly tables: readonly TableFinding[]
   /** Empty on a page whose frontmatter does not carry `kind: reference`. */
   readonly referenceShape: readonly GatedReferenceShapeFinding[]
   readonly structure: StructureReport
@@ -131,13 +145,20 @@ export function register(program: Command): void {
         'a row, a 200-character bullet, 5 plain bullets in a row, no H4, and a',
         'paragraph or table opening every H3. Only context, docs, skills, tooling',
         'seeds and references, the wiki, README.md, and CONTRIBUTING.md take a',
-        'finding. In a canon checkout one gates under a prefix in GATED_PATHS in',
-        'src/markdown/scope.ts, and a bullet run gates in context, docs, and',
-        'skills from the start. Elsewhere one gates only under a prefix',
-        'canon/config/markdown.toml lists, which canon markdown gated add writes,',
-        'and with no such file every density finding reports and none gates.',
+        'finding. CLAUDE.md and its seed take only the bullet run and the H3',
+        'opening, inside Key paths. In a canon checkout one gates under a',
+        'prefix in GATED_PATHS in src/markdown/scope.ts, and a bullet run gates',
+        'in context, docs, and skills from the start. Elsewhere one gates only',
+        'under a prefix canon/config/markdown.toml lists, which canon markdown',
+        'gated add writes, and with no such file every density finding reports',
+        'and none gates.',
         'A config that does not parse refuses with its path named.',
         '',
+        'Tables take four limits on the same paths, CLAUDE.md aside: a',
+        '120-character cell, 8 body rows, a list as the next block, and a code',
+        'span with a run past 30 characters. A table finding reports and never',
+        'fails a run.',
+        '',
         'A page whose frontmatter carries kind: reference takes the reference',
         'shape: no H2 beyond Output, Refusals, and See also, each at most once',
         'and in that order, no H3, and no table whose first header cell names',
@@ -361,17 +382,16 @@ async function runAudit(
         bans: scanBans(lines, bans),
         colons: advisory ? findColons(lines) : [],
         headingCase: advisory ? findHeadingCase(source) : [],
-        density: inDensityScope(rel)
-          ? densityFindings(lines).map((finding) => ({
-              ...finding,
-              gating: densityGates(
-                rel,
-                finding.kind,
-                gated.prefixes,
-                gated.alwaysGated,
-              ),
-            }))
-          : [],
+        density: scopedDensityFindings(rel, lines).map((finding) => ({
+          ...finding,
+          gating: densityGates(
+            rel,
+            finding.kind,
+            gated.prefixes,
+            gated.alwaysGated,
+          ),
+        })),
+        tables: inDensityScope(rel) ? tableFindings(lines) : [],
         referenceShape: referenceShapeFindings(source).map((finding) => ({
           ...finding,
           gating: referenceShapeGates(rel, gated.prefixes),
@@ -393,6 +413,7 @@ async function runAudit(
   reportColons(reports)
   reportHeadingCase(reports)
   reportDensity(reports, gated, resolution.source)
+  reportTables(reports)
   reportReferenceShape(reports, gated)
   reportBullets(reports, checkpoints)
   reportParagraphs(reports, checkpoints)
@@ -430,6 +451,7 @@ async function runAudit(
           colons: report.colons,
           headingCase: report.headingCase,
           density: report.density,
+          tables: report.tables,
           referenceShape: report.referenceShape,
           longestRun: report.structure.longestRun,
           longestRunLine: report.structure.longestRunLine,
@@ -643,7 +665,7 @@ function reportDensity(
     `Paragraphs past ${CHECKPOINTS.paragraph} characters, more than 2 paragraphs in a row, bullets past ${CHECKPOINTS.bullet} characters, more than 5 plain bullets in a row, a heading past H3, and an H3 opening with neither a paragraph nor a table.`,
   )
   logInfo(
-    'Measured on context entries, docs, skill bodies, references, and requirements, tooling seeds and stack references, the wiki, README.md, and CONTRIBUTING.md. Every other path takes no density finding.',
+    'Measured on context entries, docs, skill bodies, references, and requirements, tooling seeds and stack references, the wiki, README.md, and CONTRIBUTING.md. CLAUDE.md and its seed take the bullet run and the H3 opening inside Key paths alone. Every other path takes no density finding.',
   )
   logInfo(densityGatingLine(gated, source))
 
@@ -695,6 +717,63 @@ function densityGatingLine(
     : `A finding gates under a prefix ${GATED_CONFIG_REL} lists (${listed}). Every other finding reports.`
 }
 
+const TABLE_LABELS: Record<TableKind, string> = {
+  'table-cell': 'cell length',
+  'table-rows': 'rows',
+  'table-then-list': 'list after table',
+  'table-token': 'wide token',
+}
+
+function describeTable(finding: TableFinding): string {
+  const measured =
+    finding.kind === 'table-then-list'
+      ? 'follows the table with no lead sentence'
+      : `${finding.value} past ${finding.limit}`
+  return `  :${finding.line}  ${TABLE_LABELS[finding.kind]}  ${measured}`
+}
+
+/**
+ * Lists every table finding on the density scope's paths. None gates yet,
+ * since a gate is decided per path rather than per kind, and a new density
+ * kind would fail every gated folder carrying a table hit at once.
+ */
+function reportTables(reports: readonly FileReport[]): void {
+  logStep('Tables')
+  logInfo(
+    `Cells past ${TABLE_CELL} characters, tables past ${TABLE_ROWS} body rows, a list directly after a table, and a code span in a cell holding a run past ${TABLE_TOKEN} characters.`,
+  )
+  logInfo(
+    'Measured on the paths density measures in full, so never on CLAUDE.md, outside fenced blocks. This never fails a run.',
+  )
+
+  const carrying = reports
+    .filter((report) => report.tables.length > 0)
+    .sort((a, b) => b.tables.length - a.tables.length)
+
+  if (carrying.length === 0) {
+    logInfo('No table finding.')
+    return
+  }
+
+  const total = carrying.reduce((sum, report) => sum + report.tables.length, 0)
+  logWarn(
+    `${plural(total, 'finding')} across ${plural(carrying.length, 'file')}`,
+  )
+  logInfo(
+    'Move a long cell into a bullet under the lead, split a long table into groups each under a lead sentence, give a trailing list its own lead, and move a wide token out of the table.',
+  )
+  pipeOutput(
+    carrying
+      .map(
+        (report) =>
+          `${report.rel}  ${plural(report.tables.length, 'finding')}\n${report.tables
+            .map(describeTable)
+            .join('\n')}`,
+      )
+      .join('\n'),
+  )
+}
+
 const REFERENCE_SHAPE_LABELS: Record<ReferenceShapeKind, string> = {
   'extra-section': 'section outside the shape',
   'section-order': 'section out of order or repeated',

package/src/context/audit.ts

@@ -108,13 +108,14 @@ export const OTHER_FOLDERS = 'Other folders'
 export const SCRIPTS_HEADING = 'Scripts'
 
 /**
- * Whether an entry path is the development entry, being the flat entry, the
- * overview of a split one a target may still carry, or this repository's
- * `local-loop` entry. The standard exempts the
- * `Scripts` H3 for that entry alone, so the path is what tells.
+ * Whether an entry path is the development entry, being the flat entry or any
+ * entry directly under a `development/` folder, since a split folder names its
+ * scripts entry by project, as `local-loop` here and `local` in another. The
+ * standard exempts the `Scripts` H3 for that entry alone, so the path is what
+ * tells.
  */
 function isDevelopmentEntry(rel: string): boolean {
-  return /(?:^|\/)development(?:\/(?:overview|local-loop))?\.md$/.test(rel)
+  return /(?:^|\/)development(?:\/[^/]+)?\.md$/.test(rel)
 }
 
 /**

package/src/design/budget.ts

@@ -1,7 +1,7 @@
 import { canonicalHeading } from '@/design/parse'
 
 /**
- * The prose budget `claude/skills/canvas-board/references/design.md` sets for a design record, and the
+ * The prose budget `claude/skills/design-record/references/design.md` sets for a design record, and the
  * counter the `design` gate stage reads it through.
  *
  * The limits live here and in the standard, never in the stage, so the stage

package/src/design/components.ts

@@ -15,7 +15,7 @@
  * `buildDesignCss`'s `components` option, which is what widening that option
  * from a boolean to `boolean | readonly Component[]` bought.
  *
- * It does not live in `canon/DESIGN.md`. `claude/skills/canvas-board/references/design.md` keeps CSS class
+ * It does not live in `canon/DESIGN.md`. `claude/skills/design-record/references/design.md` keeps CSS class
  * names out of that record and says they live in code, which is here.
  */
 

package/src/design/document.ts

@@ -94,7 +94,7 @@ function borderRows(tokens: readonly BorderToken[]): string[][] {
  * and every reason behind them lives in the entry.
  */
 const LEAD = [
-  'Authoring guidance: `claude/skills/canvas-board/references/design.md`. Rendered from `src/design/tokens.ts` by `canon design regen`, so edit the module and never this file.',
+  'Authoring guidance: `claude/skills/design-record/references/design.md`. Rendered from `src/design/tokens.ts` by `canon design regen`, so edit the module and never this file.',
   'Why each value was chosen lives in `canon/context/features/design.md`.',
 ].join(' ')
 

package/src/design/regen.ts

@@ -16,7 +16,7 @@ import { NEUTRAL_TOKENS } from '@/design/neutral'
  * gate stage is what keeps silently out of it.
  */
 
-/** The rendered record, at the path `claude/skills/canvas-board/references/design.md` fixes for it. */
+/** The rendered record, at the path `claude/skills/design-record/references/design.md` fixes for it. */
 export const DESIGN_DOCUMENT = join('canon', 'DESIGN.md')
 
 /**

package/src/design/render.ts

@@ -105,7 +105,7 @@ interface Confidence {
 }
 
 /**
- * The columns the confidence ratio reads, fixed by `claude/skills/canvas-board/references/design.md`. The
+ * The columns the confidence ratio reads, fixed by `claude/skills/design-record/references/design.md`. The
  * first column of each table names its row, and `Multiplier` and `When used`
  * restate what the row already carries, so none of them is something a source
  * could anchor and none belongs in the denominator.

package/src/gate/hand-suite.ts

@@ -0,0 +1,52 @@
+/**
+ * Names the machine lock a gate holds while a stage's commands run, so the
+ * suite it spawns knows not to wait on its own parent.
+ */
+export const HELD_LOCK_VARIABLE = 'CANON_HELD_LOCK'
+
+/**
+ * The vitest invocation a hand-run lock decision reads.
+ */
+export interface VitestRun {
+  /** The CLI arguments after the vitest entry, as `process.argv.slice(2)`. */
+  readonly args: readonly string[]
+  readonly ci: boolean
+  readonly watch: boolean
+  /**
+   * The lock a parent gate already holds for this run, from `HELD_LOCK_VARIABLE`.
+   * A gate's own suite waiting on that lock would wait on its parent forever.
+   */
+  readonly heldLock: string | undefined
+}
+
+const SUBCOMMANDS = new Set(['run'])
+
+/** `-t` and its long forms filter by test name, which scopes the run. */
+function isNameFilter(arg: string): boolean {
+  return (
+    arg === '-t' ||
+    arg.startsWith('-t=') ||
+    arg === '--testNamePattern' ||
+    arg.startsWith('--testNamePattern=') ||
+    arg === '--test-name-pattern' ||
+    arg.startsWith('--test-name-pattern=')
+  )
+}
+
+/**
+ * Whether a hand-run vitest invocation runs the whole suite and so queues on
+ * the machine lock the gate's Tests stage holds.
+ *
+ * A scoped run is seconds of work, and queueing it behind a full suite costs
+ * more than any collision it causes. Vitest exposes no setup-time API naming
+ * the CLI filters, so any bare argument other than the subcommand reads as a
+ * file filter. That includes the value of a flag spelled `--flag value`, which
+ * misreads such a run as scoped. The misread skips a lock rather than queueing
+ * a scoped run, which is the side to err on.
+ */
+export function locksHandSuite(run: VitestRun): boolean {
+  if (run.ci || run.watch || run.heldLock !== undefined) return false
+
+  const args = SUBCOMMANDS.has(run.args[0] ?? '') ? run.args.slice(1) : run.args
+  return !args.some((arg) => isNameFilter(arg) || !arg.startsWith('-'))
+}

package/src/gate/measures.ts

@@ -56,7 +56,14 @@ export interface CommandResult {
   readonly spawnError?: string
 }
 
-export type RunCommand = (argv: readonly string[]) => Promise<CommandResult>
+/**
+ * Spawns one command. `env` adds variables to the child's environment, which a
+ * locked stage uses to tell its child which lock the gate already holds.
+ */
+export type RunCommand = (
+  argv: readonly string[],
+  env?: Readonly<Record<string, string>>,
+) => Promise<CommandResult>
 
 export interface MeasureContext {
   readonly root: string
@@ -331,7 +338,7 @@ export const designProse: Measure = async (ctx) => {
   if (failures.length > 0) {
     return {
       emissions: [],
-      failure: `${failures.join(' ')} Cut to the budget in claude/skills/canvas-board/references/design.md, moving the why to the context entry.`,
+      failure: `${failures.join(' ')} Cut to the budget in claude/skills/design-record/references/design.md, moving the why to the context entry.`,
     }
   }
   if (emissions.length === 0)

package/src/gate/sequencer.ts

@@ -8,6 +8,7 @@ import type {
   MeasureContext,
   RunCommand,
 } from '@/gate/measures'
+import { HELD_LOCK_VARIABLE } from '@/gate/hand-suite'
 import type { Check, Stage } from '@/gate/stages'
 import {
   acquireSuiteLock,
@@ -248,7 +249,7 @@ async function executeStage(
   }
 
   // CI runs one suite per runner, so a lock there queues behind nothing.
-  if (stage.lock === undefined || ctx.ci) return runChecks(stage, ctx, [])
+  if (stage.lock === undefined || ctx.ci) return runChecks(stage, ctx, [], {})
 
   const held = await acquireSuiteLock({
     path: machineLockPath(stage.lock),
@@ -266,8 +267,10 @@ async function executeStage(
         ]
 
   try {
+    // The suite's own global setup takes this lock for a hand run, so the
+    // child is told its parent holds it rather than waiting on the parent.
     const outcome = withLoadLine(
-      await runChecks(stage, ctx, queued),
+      await runChecks(stage, ctx, queued, { [HELD_LOCK_VARIABLE]: stage.lock }),
       stage,
       ctx,
     )
@@ -310,11 +313,12 @@ async function runChecks(
   stage: Stage,
   ctx: GateContext,
   leading: readonly Emission[],
+  env: Readonly<Record<string, string>>,
 ): Promise<StageOutcome> {
   const emissions: Emission[] = [...leading]
 
   for (const check of stage.checks) {
-    const outcome = await runCheck(check, ctx)
+    const outcome = await runCheck(check, ctx, env)
     emissions.push(...outcome.emissions)
 
     if (outcome.failure !== undefined) {
@@ -363,7 +367,11 @@ interface CheckOutcome {
   readonly unmeasured?: string
 }
 
-async function runCheck(check: Check, ctx: GateContext): Promise<CheckOutcome> {
+async function runCheck(
+  check: Check,
+  ctx: GateContext,
+  env: Readonly<Record<string, string>>,
+): Promise<CheckOutcome> {
   if (check.kind === 'measure') {
     const report = await check.measure(ctx)
     return {
@@ -378,7 +386,7 @@ async function runCheck(check: Check, ctx: GateContext): Promise<CheckOutcome> {
   }
 
   const run = check.kind === 'cli' ? ctx.cli : ctx.run
-  const result = await run(check.argv)
+  const result = await run(check.argv, env)
   return {
     emissions: [{ kind: 'output', text: result.all }],
     failure: result.exitCode === 0 ? undefined : check.failure,
@@ -492,7 +500,7 @@ export function exitCodeFor(results: readonly StageResult[]): number {
  * repository the hook points at rather than the tree being verified.
  */
 export function commandRunner(root: string): RunCommand {
-  return async (argv) => spawn(argv[0], argv.slice(1), root)
+  return async (argv, env) => spawn(argv[0], argv.slice(1), root, env)
 }
 
 /**
@@ -504,19 +512,20 @@ export function commandRunner(root: string): RunCommand {
  */
 export function cliRunner(root: string): RunCommand {
   const cli = join(PROJECT_ROOT, 'src', 'cli.ts')
-  return async (argv) => spawn(process.execPath, [cli, ...argv], root)
+  return async (argv, env) => spawn(process.execPath, [cli, ...argv], root, env)
 }
 
 async function spawn(
   file: string,
   args: readonly string[],
   cwd: string,
+  env: Readonly<Record<string, string>> = {},
 ): Promise<CommandResult> {
   const result = await execa(file, [...args], {
     cwd,
     reject: false,
     all: true,
-    env: { ...gitEnv(), CANON_NON_INTERACTIVE: '1' },
+    env: { ...gitEnv(), CANON_NON_INTERACTIVE: '1', ...env },
     extendEnv: false,
   })
 

package/src/markdown/gated.ts

@@ -9,7 +9,7 @@ import {
 import { readFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { listRepositoryFiles } from '@/git/files'
-import { densityFindings, type DensityKind } from '@/markdown/density'
+import type { DensityKind } from '@/markdown/density'
 import { referenceShapeGates } from '@/markdown/gate'
 import {
   type ReferenceShapeKind,
@@ -20,7 +20,7 @@ import {
   densityGates,
   GATED_PATHS,
   GATED_SCOPE_ROOTS,
-  inDensityScope,
+  scopedDensityFindings,
 } from '@/markdown/scope'
 import { isOwnCheckout } from '@/roots/project'
 
@@ -198,11 +198,9 @@ export async function findingsUnder(
   const found = await Promise.all(
     under.map(async (rel) => {
       const source = await readFile(join(root, rel), 'utf8')
-      const density = inDensityScope(rel)
-        ? densityFindings(bodyLines(source)).filter((finding) =>
-            densityGates(rel, finding.kind, [prefix], false),
-          )
-        : []
+      const density = scopedDensityFindings(rel, bodyLines(source)).filter(
+        (finding) => densityGates(rel, finding.kind, [prefix], false),
+      )
       const shape = referenceShapeGates(rel, [prefix])
         ? referenceShapeFindings(source)
         : []