@erclx/canon 5.55.0 → 5.57.0

package/src/commands/markdown.ts

@@ -141,9 +141,10 @@ export function register(program: Command): void {
         'Depth weight is a judgment a reader settles, so it reports and never',
         'fails a run.',
         '',
-        'Density holds six limits: a 350-character paragraph, 2 paragraphs in',
-        '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',
+        'Density holds eight limits: a 350-character paragraph, 2 paragraphs in',
+        'a row, a 200-character bullet, 5 plain bullets in a row, no H4, a',
+        'paragraph or table opening every H3, a 120-character table cell, and no',
+        'list as the block after a table. Only context, docs, skills, tooling',
         'seeds and references, the wiki, README.md, and CONTRIBUTING.md take a',
         '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',
@@ -154,10 +155,9 @@ export function register(program: Command): void {
         '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.',
+        'Tables take two more limits on the same paths, CLAUDE.md aside: 8 body',
+        'rows, and a code span with a run past 30 characters. Each 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',
@@ -637,15 +637,19 @@ const DENSITY_LABELS: Record<DensityKind, string> = {
   'bullet-run': 'bullets in a row',
   'heading-depth': 'heading depth',
   'h3-opening': 'H3 opening',
+  'table-cell': 'cell length',
+  'table-then-list': 'list after table',
 }
 
 function describeDensity(finding: GatedDensityFinding): string {
   const measured =
     finding.kind === 'h3-opening'
       ? 'opens with neither a paragraph nor a table'
-      : finding.kind === 'heading-depth'
-        ? `H${finding.value} past H${finding.limit}`
-        : `${finding.value} past ${finding.limit}`
+      : finding.kind === 'table-then-list'
+        ? 'follows the table with no lead sentence'
+        : finding.kind === 'heading-depth'
+          ? `H${finding.value} past H${finding.limit}`
+          : `${finding.value} past ${finding.limit}`
   const gate = finding.gating ? '  gating' : ''
   return `  :${finding.line}  ${DENSITY_LABELS[finding.kind]}  ${measured}${gate}`
 }
@@ -662,10 +666,10 @@ function reportDensity(
 ): void {
   logStep('Density')
   logInfo(
-    `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.`,
+    `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, an H3 opening with neither a paragraph nor a table, a table cell past ${TABLE_CELL} characters, and a list directly after 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. CLAUDE.md and its seed take the bullet run and the H3 opening inside Key paths alone. 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, with no table finding. Every other path takes no density finding.',
   )
   logInfo(densityGatingLine(gated, source))
 
@@ -689,7 +693,7 @@ function reportDensity(
   )
   if (gating > 0) logWarn('A gating finding fails the run.')
   logInfo(
-    'Split a long block at its seam, put a heading or a table between paragraphs, give a long list H3s, and open each H3 with a sentence or a table.',
+    'Split a long block at its seam, put a heading or a table between paragraphs, give a long list H3s, open each H3 with a sentence or a table, move a long cell into a bullet under the lead, and give a trailing list its own lead sentence.',
   )
   pipeOutput(
     carrying
@@ -718,29 +722,23 @@ function densityGatingLine(
 }
 
 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}`
+  return `  :${finding.line}  ${TABLE_LABELS[finding.kind]}  ${finding.value} past ${finding.limit}`
 }
 
 /**
- * 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.
+ * Lists the table findings that only report, on the density scope's paths. The
+ * cell and the trailing list gate as density kinds, so `reportDensity` lists
+ * them.
  */
 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.`,
+    `Tables past ${TABLE_ROWS} body rows 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.',
@@ -760,7 +758,7 @@ function reportTables(reports: readonly FileReport[]): void {
     `${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.',
+    'Split a long table into groups each under a lead sentence, and move a wide token out of the table.',
   )
   pipeOutput(
     carrying
@@ -917,11 +915,9 @@ function reportBullets(
 ): void {
   logStep('Bullets')
   logInfo(
-    'Top-level bullets measure characters, folding in continuation lines.',
-  )
-  logInfo(
-    'Nested items and fenced blocks are excluded. Weight is a judgment, never a defect.',
+    'Bullets measure characters, folding in continuation lines, and a nested bullet measures on its own.',
   )
+  logInfo('Fenced blocks are excluded. Weight is a judgment, never a defect.')
 
   const carrying = reports
     .filter((report) => report.structure.heavyBullets.length > 0)

package/src/commands/tasks.ts

@@ -668,12 +668,15 @@ export function register(program: Command): void {
         '  no-board   the repository holds no `.canon/tasks/` board',
         '  no-match   no task matches the selector',
         '  ambiguous  more than one task matches the selector',
-        '  bad-input  a task and a plan both named, or neither',
+        '  bad-input  a task and a plan both named',
         '',
         'Exit codes:',
         '  0  the task is read, whether or not it closes',
         '  1  refused, with the reason on stderr or in the JSON record',
         '',
+        'With no task or plan named, the task whose plan derives the branch is read,',
+        'and a branch nothing owns is no-match.',
+        '',
         'Reads the `Issue:` lines, each `#NNN` or a comma list, and reports',
         '`issues` and `closing`. The pull request closes them only when it is',
         "the task's last slice, the condition the merge-time archive applies:",
@@ -1513,15 +1516,18 @@ async function runCloses(
   opts: ClosesCommandOptions,
 ): Promise<number> {
   const emitJson = opts.json ?? false
-  const selector = selectorFor(task, opts.plan)
+  const branch = opts.branch ?? (await workingBranch())
+  const branches = branch ? [branch, ...(await formerNames(branch))] : []
+  const selector =
+    !task && !opts.plan
+      ? ({ kind: 'branch', branches } as const)
+      : selectorFor(task, opts.plan)
 
   if ('ok' in selector) {
     return reportRecord('canon tasks closes', selector, emitJson, process.cwd())
   }
 
   const root = opts.root ?? (await mainWorktreeRoot())
-  const branch = opts.branch ?? (await workingBranch())
-  const branches = branch ? [branch, ...(await formerNames(branch))] : []
   const outcome = await readClosure(
     root,
     selector,

package/src/labels/density.ts

@@ -1,10 +1,6 @@
-import {
-  type DensityFinding,
-  type DensityKind,
-  densityFindings,
-} from '@/markdown/density'
-import { type BodyLine, bodyLines, visibleText } from '@/markdown/scan'
-import { CHECKPOINTS, LIST_ITEM } from '@/markdown/structure'
+import { type DensityKind, densityFindings } from '@/markdown/density'
+import { type BodyLine, bodyLines } from '@/markdown/scan'
+import { LIST_ITEM } from '@/markdown/structure'
 
 /**
  * The four counted limits a pull request section carries. The heading limits
@@ -119,7 +115,6 @@ export interface PostDensityFinding extends Omit<BodyDensityFinding, 'kind'> {
 }
 
 const LENGTHS: readonly DensityKind[] = ['paragraph-length', 'bullet-length']
-const NESTED_ITEM = /^(\s+)(?:[-*+]|\d+\.)\s+(.*)$/
 const CHECKBOX = /^\s*[-*+]\s+\[[ xX]\]/
 const FOOTER = /^🤖/
 
@@ -134,8 +129,8 @@ const FOOTER = /^🤖/
  * paragraph run, and a checklist box under `What to look at` takes no length
  * limit, since a driver needs its route, action, and result.
  *
- * A nested item is measured as a bullet of its own, which `densityFindings()`
- * leaves out of its parent, so a finding's subject and its evidence never sum.
+ * A nested item is measured as a bullet of its own by `densityFindings()`, which
+ * leaves it out of its parent, so a finding's subject and its evidence never sum.
  */
 export function postDensity(body: string): PostDensityFinding[] {
   const lines = bodyLines(body).map((line) =>
@@ -153,7 +148,6 @@ export function postDensity(body: string): PostDensityFinding[] {
         (chunk) => densityFindings(chunk),
       ),
       ...densityFindings(inside).filter(({ kind }) => LENGTHS.includes(kind)),
-      ...nestedLengths(section.lines),
     ]
 
     for (const finding of measured) {
@@ -214,41 +208,6 @@ function foldedApart(lines: readonly BodyLine[]): {
   return { outside, inside }
 }
 
-/**
- * A `bullet-length` finding for each nested item past the bullet limit, its
- * length taken over the item and the lines indented under it that open no
- * item of their own.
- */
-function nestedLengths(lines: readonly BodyLine[]): DensityFinding[] {
-  const found: DensityFinding[] = []
-
-  for (const [index, line] of lines.entries()) {
-    const match = line.fenced ? null : NESTED_ITEM.exec(line.text)
-    if (!match) continue
-
-    const indent = match[1].length
-    const parts = [match[2].trim()]
-    for (const next of lines.slice(index + 1)) {
-      const lead = /^\s*/.exec(next.text)?.[0].length ?? 0
-      if (next.fenced || next.text.trim() === '' || lead <= indent) break
-      if (LIST_ITEM.test(next.text)) break
-      parts.push(next.text.trim())
-    }
-
-    const length = visibleText(parts.join(' ')).length
-    if (length > CHECKPOINTS.bullet) {
-      found.push({
-        kind: 'bullet-length',
-        line: line.number,
-        value: length,
-        limit: CHECKPOINTS.bullet,
-      })
-    }
-  }
-
-  return found
-}
-
 function sectionsOf(lines: readonly BodyLine[]): Section[] {
   const sections: Section[] = []
   let current: { name: string | null; lines: BodyLine[] } = {

package/src/markdown/density.ts

@@ -22,6 +22,8 @@ export type DensityKind =
   | 'bullet-run'
   | 'heading-depth'
   | 'h3-opening'
+  | 'table-cell'
+  | 'table-then-list'
 
 export interface DensityFinding {
   readonly kind: DensityKind
@@ -52,14 +54,16 @@ type Block =
  * here it belongs to the item: it counts toward the bullet's length and never
  * toward a paragraph run, since a reader sees it inside the list.
  *
- * A nested item is left out of its parent, as `heavyBullets` leaves it, and so
- * is everything indented under the nested item. An indented fence inside an
- * item stays with the item, and a column-zero one ends it.
+ * A nested item is a block of its own, taking the lines indented past its
+ * marker, and its parent leaves it out along with everything indented under it.
+ * An indented fence inside an item joins neither and ends the nested item, and
+ * a column-zero one ends both.
  */
 function blocksOf(lines: readonly BodyLine[]): Block[] {
   const blocks: Block[] = []
   let paragraph: { line: number; parts: string[] } | undefined
   let item: { line: number; parts: string[]; nested: boolean } | undefined
+  let child: { line: number; parts: string[]; indent: number } | undefined
   let inFence = false
   let afterBlank = false
 
@@ -74,7 +78,19 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
     paragraph = undefined
   }
 
+  const closeChild = (): void => {
+    if (child) {
+      blocks.push({
+        kind: 'item',
+        line: child.line,
+        text: child.parts.join(' '),
+      })
+    }
+    child = undefined
+  }
+
   const closeItem = (): void => {
+    closeChild()
     if (item) {
       blocks.push({ kind: 'item', line: item.line, text: item.parts.join(' ') })
     }
@@ -95,7 +111,8 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
       // The opening delimiter decides who owns the block. `bodyLines` marks a
       // delimiter and the body alike, so the opener is the first fenced line.
       if (!inFence) {
-        if (!(item && indented)) {
+        if (item && indented) closeChild()
+        else {
           closeAll()
           blocks.push({ kind: 'other', line: line.number, table: false })
         }
@@ -108,13 +125,27 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
 
     if (text === '') {
       closeParagraph()
+      closeChild()
       afterBlank = true
       continue
     }
 
     if (indented && item) {
-      if (LIST_ITEM.test(raw)) item.nested = true
-      else if (!item.nested && !TABLE_ROW.test(raw)) item.parts.push(text)
+      const lead = leadOf(raw)
+      if (LIST_ITEM.test(raw)) {
+        closeChild()
+        item.nested = true
+        child = {
+          line: line.number,
+          parts: [text.replace(LIST_ITEM, '')],
+          indent: lead,
+        }
+      } else if (child && lead > child.indent) {
+        if (!TABLE_ROW.test(raw)) child.parts.push(text)
+      } else {
+        closeChild()
+        if (!item.nested && !TABLE_ROW.test(raw)) item.parts.push(text)
+      }
       afterBlank = false
       continue
     }
@@ -163,6 +194,10 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
   return blocks
 }
 
+function leadOf(raw: string): number {
+  return raw.length - raw.trimStart().length
+}
+
 /**
  * Every breach of the six density limits, in line order.
  *

package/src/markdown/scope.ts

@@ -4,6 +4,7 @@ import {
   densityFindings,
 } from '@/markdown/density'
 import type { BodyLine } from '@/markdown/scan'
+import { tableDensityFindings } from '@/markdown/tables'
 
 /** The surfaces the retired bullet-stacks stage held, per `ALWAYS_GATED`. */
 const BULLET_RUN_SCOPE = [
@@ -68,12 +69,16 @@ function keyPathsSection(lines: readonly BodyLine[]): readonly BodyLine[] {
  * The density findings a path takes, being every finding on a density-scope
  * file and the Key paths findings on a `CLAUDE.md`. The audit, the init probe,
  * and `canon claude sync` all read this, so the three agree on what counts.
+ * The table cell and trailing-list findings join on a density-scope path only,
+ * since `densityFindings` stays what its direct callers grade.
  */
 export function scopedDensityFindings(
   rel: string,
   lines: readonly BodyLine[],
 ): DensityFinding[] {
-  if (inDensityScope(rel)) return densityFindings(lines)
+  if (inDensityScope(rel)) {
+    return [...densityFindings(lines), ...tableDensityFindings(lines)]
+  }
   if (!KEY_PATHS_SCOPE.test(rel)) return []
   return densityFindings(keyPathsSection(lines)).filter((finding) =>
     KEY_PATHS_KINDS.includes(finding.kind),

package/src/markdown/structure.ts

@@ -415,10 +415,10 @@ export function longestRun(
 }
 
 /**
- * Finds the top-level bullets carrying more than a decision.
+ * Finds the bullets carrying more than a decision, nested ones included.
  *
- * A nested item is left out rather than folded into its parent, since the
- * checkpoint asks what one bullet carries and a child carries its own. Lines
+ * A nested item is measured on its own and never folded into its parent, since
+ * the checkpoint asks what one bullet carries and a child carries its own. Lines
  * continuing a bullet do fold in, so a heavy bullet cannot fall under the
  * checkpoint by being wrapped across two source lines. A fenced line closes the
  * open bullet, which keeps a bullet from absorbing the example below it.
@@ -436,6 +436,8 @@ export function heavyBullets(
 interface FoldedBullet extends BulletFinding {
   /** The bullet's source lines joined by the space a wrap would have carried. */
   readonly text: string
+  /** The width of the indent before the marker, which a continuation must pass. */
+  readonly indent: number
 }
 
 /** The walk `heavyBullets` reports from. */
@@ -459,18 +461,18 @@ function foldBullets(
 
     const item = line.text.match(LIST_ITEM)
     const text = line.text.trim()
+    const lead = line.text.length - line.text.trimStart().length
 
     // Structure is read off the raw line and only the weight is masked. A line
     // carrying nothing but an autolink has no visible text at all, and reading
     // its masked form as blank would close the bullet it continues.
     if (item) {
       close()
-      if (item[1].length === 0) {
-        open = {
-          line: line.number,
-          characters: visibleText(text).length,
-          text,
-        }
+      open = {
+        line: line.number,
+        characters: visibleText(text).length,
+        text,
+        indent: item[1].length,
       }
       continue
     }
@@ -480,6 +482,13 @@ function foldBullets(
       continue
     }
 
+    // An indented line that does not pass the marker's indent belongs to a
+    // parent or to nothing, so it ends a nested item rather than extending it.
+    if (open && lead > 0 && lead <= open.indent) {
+      close()
+      continue
+    }
+
     // The joining space a wrapped line would have carried, so folding two
     // source lines measures what one unwrapped line would have.
     if (open)

package/src/markdown/tables.ts

@@ -1,3 +1,4 @@
+import type { DensityFinding } from '@/markdown/density'
 import { type BodyLine, visibleText } from '@/markdown/scan'
 import { LIST_ITEM, TABLE_ROW, TABLE_SEPARATOR } from '@/markdown/structure'
 
@@ -10,19 +11,14 @@ export const TABLE_ROWS = 8
 /** The longest unbroken run a code span in a table cell may carry. */
 export const TABLE_TOKEN = 30
 
-export type TableKind =
-  | 'table-cell'
-  | 'table-rows'
-  | 'table-then-list'
-  | 'table-token'
+export type TableKind = 'table-rows' | 'table-token'
 
 export interface TableFinding {
   readonly kind: TableKind
-  /** The row holding the cell or span, the header for a row count, or the list's first item. */
+  /** The span's row, or the header for a row count. */
   readonly line: number
-  /** What was measured, or null for a trailing list, which is a shape rather than a count. */
-  readonly value: number | null
-  readonly limit: number | null
+  readonly value: number
+  readonly limit: number
 }
 
 /**
@@ -55,16 +51,22 @@ function cellsOf(row: string): string[] {
 }
 
 /**
- * Every breach of the four table limits, in line order.
+ * Every breach of the four table limits, in line order, split by whether it
+ * gates.
  *
  * A table is a run of pipe rows whose second row is a delimiter, the shape a
  * renderer draws. Pipe lines with no delimiter render as paragraph text, and a
  * fenced line is an example, so neither is measured. The limits are a
  * 120-character cell, 8 body rows, a list as the next block, and a code span
- * holding a run past 30 characters. Every finding reports and none gates.
+ * holding a run past 30 characters. The cell and the trailing list are density
+ * findings, and the row count and the wide token report and never gate.
  */
-export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
-  const found: TableFinding[] = []
+function measureTables(lines: readonly BodyLine[]): {
+  reported: TableFinding[]
+  density: DensityFinding[]
+} {
+  const reported: TableFinding[] = []
+  const density: DensityFinding[] = []
   let index = 0
 
   while (index < lines.length) {
@@ -96,7 +98,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
       for (const cell of cellsOf(row.text)) {
         const length = visibleText(cell).length
         if (length > TABLE_CELL) {
-          found.push({
+          density.push({
             kind: 'table-cell',
             line: row.number,
             value: length,
@@ -106,7 +108,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
         for (const span of codeSpans(cell)) {
           const run = unbrokenRun(span)
           if (run > TABLE_TOKEN) {
-            found.push({
+            reported.push({
               kind: 'table-token',
               line: row.number,
               value: run,
@@ -119,7 +121,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
 
     const bodyRows = tableRows.length - 1
     if (bodyRows > TABLE_ROWS) {
-      found.push({
+      reported.push({
         kind: 'table-rows',
         line: header.number,
         value: bodyRows,
@@ -135,7 +137,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
       !following.fenced &&
       LIST_ITEM.test(following.text)
     ) {
-      found.push({
+      density.push({
         kind: 'table-then-list',
         line: following.number,
         value: null,
@@ -146,5 +148,17 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
     index = end
   }
 
-  return found.sort((a, b) => a.line - b.line)
+  return { reported, density }
+}
+
+/** The row count and wide token findings, which report and never gate. */
+export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
+  return measureTables(lines).reported.sort((a, b) => a.line - b.line)
+}
+
+/** The cell and trailing-list findings, which gate as density kinds do. */
+export function tableDensityFindings(
+  lines: readonly BodyLine[],
+): DensityFinding[] {
+  return measureTables(lines).density.sort((a, b) => a.line - b.line)
 }

package/src/pr/bijection.ts

@@ -150,6 +150,7 @@ function coversIgnoreAddition(
  * path written short from a path written wrong.
  */
 function covers(claim: PathClaim, path: string): boolean {
+  if (claim.bare) return path === claim.path
   if (claim.directory) {
     return claim.anchored
       ? path.startsWith(claim.path)
@@ -212,6 +213,8 @@ export function compareKeyChanges(input: BijectionInput): Bijection {
       continue
     }
 
+    if (claim.bare) continue
+
     if (claim.anchored && claim.leading && !evidenceUnread) unmet.push(claim)
     else unresolved.push(claim)
   }
@@ -240,9 +243,8 @@ export function compareKeyChanges(input: BijectionInput): Bijection {
  * and an unanchored claim never accuses, so the first branch to open one would
  * silently lose the graded direction.
  *
- * A path with no folder above it contributes nothing, since a claim carrying no
- * slash never reaches the extractor's output and no root would ever be read
- * against it.
+ * A path with no folder above it contributes nothing, since a bare claim is
+ * never anchored and no root would ever be read against it.
  */
 export function treeRoots(
   tracked: readonly string[],

package/src/pr/paths.ts

@@ -36,6 +36,16 @@ export interface PathClaim {
    * accuse with.
    */
   readonly leading: boolean
+  /**
+   * True when the span carried no slash, such as `README.md` or `bun`.
+   *
+   * A bare claim credits a changed file whose whole path is exactly that name
+   * and nothing else, so `package.json` never reaches `web/package.json`. It
+   * never accuses: nothing separates a bare file name from a word of prose, so
+   * one matching no changed file is reported nowhere. Same asymmetry as
+   * `anchored` and `leading`.
+   */
+  readonly bare: boolean
   /** The span exactly as the body wrote it, before the line suffix came off. */
   readonly span: string
   /** One-based index of the bullet inside the section. */
@@ -282,17 +292,22 @@ function splitBullets(section: string): string[] {
 interface ResolvedSpan {
   readonly path: string
   readonly directory: boolean
+  readonly bare: boolean
 }
 
 function resolveSpan(span: string): ResolvedSpan | undefined {
   if (span === '' || isNotRepositoryPath(span)) return undefined
 
-  // A bare name is the fourth observed false-positive class and it drops
-  // outright. Resolved as a sibling of a path earlier in the bullet it produced
-  // seven wrong paths across this corpus against two right ones, because a
-  // compound bullet names a sibling folder as often as a sibling file. Dropping
-  // it under-reports in the unnamed direction and never fires in the other.
-  if (!span.includes('/')) return undefined
+  // A bare name cannot be resolved as a sibling of a path earlier in the
+  // bullet: that produced seven wrong paths across this corpus against two right
+  // ones, because a compound bullet names a sibling folder as often as a sibling
+  // file. It resolves to itself as a root-level path and is marked bare, which
+  // keeps it from ever accusing.
+  if (!span.includes('/')) {
+    return isDottedNumber(span)
+      ? undefined
+      : { path: span, directory: false, bare: true }
+  }
 
   if (span.endsWith('/')) {
     // A single top-level folder is never a claim. Nobody reports having changed
@@ -300,10 +315,12 @@ function resolveSpan(span: string): ResolvedSpan | undefined {
     // something lives.
     return span.indexOf('/') === span.length - 1
       ? undefined
-      : { path: span, directory: true }
+      : { path: span, directory: true, bare: false }
   }
 
-  return isDottedNumber(span) ? undefined : { path: span, directory: false }
+  return isDottedNumber(span)
+    ? undefined
+    : { path: span, directory: false, bare: false }
 }
 
 /**
@@ -371,7 +388,9 @@ export function extractKeyChangePaths(
 
       const resolved = resolveSpan(bare)
       if (resolved === undefined) continue
-      claimed = true
+      // A bare span is no evidence a path claim came first, so it leaves the
+      // citation guard above reading only the claims it was written for.
+      if (!resolved.bare) claimed = true
       // First occurrence wins, across bullets as well as inside one. A path
       // named trailing here and leading three bullets later keeps the weaker
       // reading, which loses an accusation and can never add one.
@@ -381,8 +400,11 @@ export function extractKeyChangePaths(
       claims.push({
         path: resolved.path,
         directory: resolved.directory,
-        anchored: roots.has(resolved.path.slice(0, resolved.path.indexOf('/'))),
+        anchored:
+          !resolved.bare &&
+          roots.has(resolved.path.slice(0, resolved.path.indexOf('/'))),
         leading: match.start < accusesBefore,
+        bare: resolved.bare,
         span,
         bullet: index + 1,
         preview,