@erclx/canon 4.13.0 → 4.14.1

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "canon",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "4.13.0",
+  "version": "4.14.1",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/claude-orchestrate/SKILL.md

@@ -113,7 +113,7 @@ Write no shape for a correction. A correction is a sentence, and a format for ad
 3. Verify the plan against the tree. Reading it is not enough, since a plan goes stale from whatever merged after it was written. Grep for each construct it names and count the sites against the count it claims. Check that every phase label it cites is still open. Open each file it describes rather than trusting its account of the contents. Correct the plan before handing it over.
 4. Hand off. Read `${CLAUDE_SKILL_DIR}/references/orchestrator-dispatch.md` and follow it: check the branch is unclaimed, check the row's file set against every track in flight, then dispatch a background worker with `claude --bg`. Fall back to the human-launch line it replaces when the check refuses, the sets overlap, or a stated reason serializes the row behind something already out.
 5. Review the PR. When a worker opens a PR, run `claude-pr-review` to post findings to it. This is the deep, independent pass. The worker's autoship self-review was only the green gate.
-   - Learning that a PR moved is the mechanical half, so read `${CLAUDE_SKILL_DIR}/references/orchestrator-poll.md` and start the poll it carries on the first dispatch rather than checking the board by hand. That runbook holds the routing, and a summary of it here is a second source that drifts from it.
+   - Learning that a PR moved is the mechanical half, so read `${CLAUDE_SKILL_DIR}/references/orchestrator-poll.md` and run the poll under the condition it states rather than checking the board by hand. That runbook holds the routing and the trigger, and a summary of it here is a second source that drifts from it.
 6. Dispatch the handback. A pass posting anything owed, a finding at any severity or a testing question, tells the session holding that branch to run `claude-address-review`, rather than waiting for a person to relay it. Re-review when the worker's own message says the address pass finished, per the channel `claude-worker` states, rather than polling for an answer nothing else marks as landed. Then the human merges. Tell the trailing worker to rebase when its branch shares a seam with the merged one.
    - Read the threshold off `claude-pr-review`, which states it once and governs the heading with it, so an open heading and an owed dispatch answer the same question and either one is enough to send
    - Resolve the target at the moment of sending with `canon sessions list --branch`, never from a mapping written down earlier, since names rotate as sessions end and one recorded earlier in a session has failed inside the hour. The runbook read at step 5 routes on the count and the confidence it answers with

package/claude/skills/claude-pr-review/SKILL.md

@@ -119,7 +119,7 @@ Test every ticked box too, bounded to one naming a file or a command. Confirm wh
 
 Test what `## Key Changes` claims against the diff it describes, with `canon pr key-changes <number> --json`. This repository squash-merges, so that section becomes the commit message and the record on the trunk once the branch is gone, which is the same thing a stale ticked box corrupts. Branch on the record rather than on the exit code, which a shell function wrapping `canon` can flatten to zero.
 
-Read `unmet` as a `should-fix` finding under the same `**PR body**` block the stale box takes, one entry per path, quoting the bullet the record carries on `preview` and naming the `head` the comparison ran at. Read the bullet before filing it, since one class survives the reader: a bullet citing where something is defined while claiming an edit elsewhere, which puts a real path in the claim region and points the change at a locative the path does not name. Report that as the class rather than as a stale claim. A body is edited between pushes, so the reading is true at that commit and can be false a minute later. Read `unnamed` as a question rather than a finding, since the class covers a real omission and equally a lockfile, a generated asset, or a regenerated index that earns no bullet, and raise it only where a reader would want the bullet. Report `unresolved` nowhere: a path written partially was judged in neither direction and says nothing about the body.
+Read `unmet` as a `should-fix` finding under the same `**PR body**` block the stale box takes, one entry per path, quoting the bullet the record carries on `preview` and naming the `head` the comparison ran at. Read the bullet before filing it, since one class survives the reader: a bullet citing where something is defined while claiming an edit elsewhere, which puts a real path in the claim region and points the change at a locative the path does not name. Report that as the class rather than as a stale claim. A body is edited between pushes, so the reading is true at that commit and can be false a minute later. Read `unnamed` for yourself and raise nothing off the count. The class still covers a real omission and equally a generated asset or a regenerated index that earns no bullet, and the entries the reader can name as owing none are already held apart under `incidental`. Open the section and confirm no bullet names the file before putting a single one to the author, because this instruction has sent the question to three pull requests in one day over bullets that had named the files all along, and one of those authors added bullets nobody needed. Report `unresolved` and `incidental` nowhere: the first was judged in neither direction and the second owes no bullet, so neither says anything about the body.
 
 A `reason` of `no-claims` means the reader resolved no path out of a section that exists, which is the extractor failing over prose rather than the body being wrong. Say so and raise nothing. `no-section` is the body carrying no such heading, which is a finding only where the pull request template asks for one.
 

package/docs/agents/index.md

@@ -23,7 +23,7 @@ CLI catalog and invocation rules for agents, split by command domain. Start with
 - [Indexes](indexes.md): Flags, exit codes, and JSON shape for canon indexes regen, plus when it auto-stages what it rewrote
 - [Install and sync](install-and-sync.md): What each install and sync verb writes, refuses, or leaves alone, and how drift is attributed in a target project
 - [Intake](intake.md): Reading intake folder counts and items, the three read states an item can be in, landing a batch of selections in one cluster, the refusal reasons, and why a call is scoped to one file
-- [Key Changes bijection](key-changes.md): Comparing the files a pull request body's Key Changes names against its own diff, the two directions and why they are graded apart, the span rules the extractor was measured into, and the three refusals that separate a clean pass from a read that produced nothing
+- [Key Changes bijection](key-changes.md): Comparing the files a pull request body's Key Changes names against its own diff, the two directions and the split inside each that decides what is worth raising, the span rules the extractor was measured into, and the three refusals that separate a clean pass from a read that produced nothing
 - [Label coverage](label-coverage.md): Reading a changed set against the pull request label map, the two tables it matches, how a gap is separated from a decision, and why an absent map is an answer
 - [Markdown audit](markdown-audit.md): Running the audit over any markdown path, where its bans and checkpoints are read from, what each check reports, and why the ban half gates while the structural half reports
 - [Output shape](output-shape.md): Two framed shapes every command renders into, how JSON and --names modes keep stdout clean, and the exit discipline that lets piped output drain

package/docs/agents/key-changes.md

@@ -1,6 +1,6 @@
 ---
 title: Key Changes bijection
-description: Comparing the files a pull request body's Key Changes names against its own diff, the two directions and why they are graded apart, the span rules the extractor was measured into, and the three refusals that separate a clean pass from a read that produced nothing
+description: Comparing the files a pull request body's Key Changes names against its own diff, the two directions and the split inside each that decides what is worth raising, the span rules the extractor was measured into, and the three refusals that separate a clean pass from a read that produced nothing
 ---
 
 # Key Changes bijection
@@ -32,19 +32,24 @@ That view caps its file list at 100 rows and says nothing about having done so,
 
 They are reported apart because they want different tolerances.
 
-- **`unmet`** is a whole path the body claims and the diff does not carry. This is the graded direction and it sets the exit code. A bullet naming an untouched file is wrong more often than not, and it corrupts the record that reaches the trunk.
-- **`unnamed`** is a changed file no bullet reached. Reported with no grade, since the class covers a real omission and equally a lockfile, a generated asset, or a regenerated index that earns no bullet. Grading it would fire on nearly every branch.
-- **`unresolved`** is a path written partially, such as `claude-worker/SKILL.md` for a file under `claude/skills/`. It is judged in neither direction.
+- **`unmet`** is a whole path the body claims ahead of its bullet's first comma and the diff does not carry. This is the graded direction and it sets the exit code. A bullet naming an untouched file is wrong more often than not, and it corrupts the record that reaches the trunk.
+- **`unnamed`** is a changed file no bullet reached that a reader might have wanted one for. Reported with no grade, since a change can be too small to describe and still be correctly absent. Grading it would fire on nearly every branch.
+- **`incidental`** is a changed file no bullet reached that owes none: a test beside its subject, anything under a fixture or snapshot folder, and a lockfile a package manager writes. Held apart so the count above reads, and reported rather than dropped so a run still says what it set aside.
+- **`unresolved`** is a path the reading could not judge either way. Two causes reach it: a path written partially, such as `claude-worker/SKILL.md` for a file under `claude/skills/`, and a path past its bullet's first comma.
 
-A partial path can credit a changed file and can never accuse one. Nothing separates a path written short from a path written wrong, so the asymmetry keeps the accusing direction to spans the tree can anchor.
+Each direction splits on one question, which is whether the evidence is strong enough to raise with a person. A partial path and a trailing path can each credit a changed file and can never accuse one, because nothing separates a path written short from a path written wrong, or a second claim from a file cited for context. Neither split drops anything: what comes out of `unmet` lands in `unresolved` and what comes out of `unnamed` lands in `incidental`, so a count a reader can act on never costs a file the run stayed silent about.
+
+A generated asset and a regenerated index belong in the incidental class and are deliberately absent from it, because neither has a spelling that holds outside one project. Guessing at one would set aside a file that did owe a bullet, which hides a real omission, where leaving them out only leaves the count where it already was.
 
 ## What counts as a claim
 
 Only `## Key Changes` is read. `## Technical Context` legitimately names files a branch never touched, such as an install stamp inside a target, so widening the read manufactures a finding out of every argument an author made for the change.
 
-Inside the section, the claim region of a bullet ends at its first comma outside a backticked span. That one lever was chosen by measurement. Over the 23 merged pull requests in this repository carrying the section, reading whole bullets reported 16 paths as claimed-but-untouched and every one was a file the body named for context. Cutting at the comma left 110 claims of the original 149 and took the false reports to 2. A list of sixteen clause-opening words tried beside it removed nothing the comma had not already removed, because this corpus punctuates every one of them.
+Inside the section, every backticked span in a bullet is read, and the bullet's first comma outside a span divides the ones that can accuse from the ones that can only credit. That one lever was chosen by measurement. Over the 23 merged pull requests in this repository carrying the section, reading whole bullets reported 16 paths as claimed-but-untouched and every one was a file the body named for context. Cutting at the comma left 110 claims of the original 149 and took the false reports to 2. A list of sixteen clause-opening words tried beside it removed nothing the comma had not already removed, because this corpus punctuates every one of them.
+
+The cut used to decide whether a span was read at all, and the paths past the comma fell out of the claim set into `unnamed`. That was accepted on the ground that the ungraded direction does no damage, and it did: `claude-pr-review` read `unnamed` as a question to put to the branch author, so on 2026-09-01 the question went to three pull requests over bullets that had named the files all along. Reading the whole bullet as claims outright is the obvious repair and the corpus refuses it, taking `unmet` from 10 to 19 over the 40 most recent merged pull requests carrying the section, with all nine additions in the context class the cut exists to exclude. Reading the whole bullet and gating the accusation on the cut gives claims 243 to 314 and unnamed 1124 to 1058 with `unmet` identical entry for entry.
 
-A span inside the claim region has to survive all of these:
+A span anywhere in the bullet has to survive all of these:
 
 | Rule                                              | What it keeps out                                      |
 | ------------------------------------------------- | ------------------------------------------------------ |
@@ -88,16 +93,18 @@ An empty extraction read as a clean pass is the failure shape this repository ha
 
 ## What it was measured against
 
-Driven over the 40 most recent merged pull requests in this repository, 23 of which carry the section, the shipped verb reported zero unmet paths and one `no-claims` refusal. The naive extractor it replaced reported 16.
+Driven over the 40 most recent merged pull requests in this repository at the time, 23 of which carry the section, the shipped verb reported zero unmet paths and one `no-claims` refusal. The naive extractor it replaced reported 16.
+
+The re-measurement behind the trailing-path split is a wider corpus and its numbers do not compare to those. It takes the 40 most recent merged pull requests that carry the section, which reaches back through 90 merges rather than 40, and the reader reports 10 unmet over it. Those 10 predate the split and survive it entry for entry, which is the check that the widening moved nothing into the graded direction. Three name a gitignored path a diff can never carry and one is the definition-site class named below. The remaining six were not run down, so the residual over that corpus is 10 rather than zero and how much of it is the reader rather than the bodies is unmeasured.
 
 The first body written after that corpus closed produced two, which is what the no-change marker and the open class above come from. One was the disclaiming bullet and the rule now covers it at no cost to the corpus. The other is the definition-site class, left open with the report naming it.
 
 The bound is that the corpus is one repository writing to one house style. A project that punctuates differently loses claims to the comma cut rather than gaining false ones, since every rule above drops rather than invents, so the check degrades toward silence rather than toward noise.
 
-What it cannot see is a bullet claiming a change to a file the branch did touch for another reason, a path written without backticks, and a claim in a second coordinated clause after the comma. The last of those falls to the ungraded direction rather than out of the reading.
+What it cannot see is a bullet claiming a change to a file the branch did touch for another reason, and a path written without backticks. A claim in a second coordinated clause after the comma is read and credited, and it stays out of the graded direction, since nothing here separates it from a file the same clause cites for context.
 
 One class stays open and is named rather than closed. A bullet can cite where something is defined while claiming an edit somewhere else, as `#1274` does with "Name the slug transform in `standards/slug.md` inline in the same step". The path is a definition site, the edit target is the step, and separating the two needs the sentence parsed rather than cut. A finding on such a bullet is this class rather than a stale claim, and a reader weighing an `unmet` path checks whether the bullet's real target is a locative the path does not name.
 
 ## Where it runs
 
-`claude-pr-review` Step 3 calls it and files an `unmet` path as a `should-fix` finding under the `**PR body**` block the stale ticked box already takes, since what both corrupt is the merge record rather than a file in the diff. A body is edited between pushes, so a finding names the head the comparison ran at.
+`claude-pr-review` Step 3 calls it and files an `unmet` path as a `should-fix` finding under the `**PR body**` block the stale ticked box already takes, since what both corrupt is the merge record rather than a file in the diff. A body is edited between pushes, so a finding names the head the comparison ran at. `unnamed` is read there and raised off no count, since the step's own history is a question sent over bullets that already answered it. `unresolved` and `incidental` are reported nowhere.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "4.13.0",
+  "version": "4.14.1",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/commands/pr.ts

@@ -107,12 +107,14 @@ export function register(program: Command): void {
         'bullet names leaves it incomplete.',
         '',
         'The two directions carry different weight:',
-        '  unmet      a whole path the body claims and the diff does not carry,',
-        '             which is the graded direction',
-        '  unnamed    a changed file no bullet reached, reported without a grade,',
-        '             since a lockfile or a generated asset earns no bullet',
-        '  unresolved a path written partially, which can credit a changed file',
-        '             and never accuse one',
+        "  unmet      a whole path the body claims ahead of its bullet's first",
+        '             comma and the diff does not carry, the graded direction',
+        '  unnamed    a changed file no bullet reached that a reader might have',
+        '             wanted one for, reported without a grade',
+        '  incidental a changed file no bullet reached that owes none: a test, a',
+        '             fixture, or a lockfile, held apart so the count above reads',
+        '  unresolved a path written partially, or one past its first comma,',
+        '             which can credit a changed file and never accuse one',
         '',
         `Only ## ${KEY_CHANGES} is read. ## Technical Context legitimately names`,
         'files a branch never touched, so widening the read manufactures findings.',
@@ -361,11 +363,16 @@ async function runKeyChanges(
       )
     }
   }
+  if (report.incidental.length > 0) {
+    logInfo(
+      `${plural(report.incidental.length, 'further changed file')} set aside as owing no bullet, whole in the --json record.`,
+    )
+  }
 
   if (report.unresolved.length > 0) {
     logStep('Unresolved')
     logInfo(
-      `${plural(report.unresolved.length, 'path')} written partially, so neither direction judged it.`,
+      `${plural(report.unresolved.length, 'path')} written partially or trailing its bullet's first comma, so neither direction judged it.`,
     )
     for (const claim of report.unresolved) logInfo(claim.path)
   }
@@ -384,6 +391,7 @@ async function runKeyChanges(
         claims: report.claims,
         unmet: report.unmet,
         unnamed: report.unnamed,
+        incidental: report.incidental,
         unresolved: report.unresolved,
       })}\n`,
     )

package/src/commands/upgrade.ts

@@ -32,6 +32,13 @@ interface UpgradeRecord {
   readonly latest?: string
   readonly state: 'upgraded' | 'current' | 'cancelled' | 'refused'
   readonly reason?: string
+  /**
+   * One rendered line for a caller that reports the outcome without parsing
+   * the rest of the record, such as `.husky/post-merge`. `current` reuses
+   * `describeSkew` verbatim so its wording never drifts from the line `canon
+   * sync --check` and `canon claude skills drift` already report.
+   */
+  readonly message: string
 }
 
 export function register(program: Command): void {
@@ -116,6 +123,7 @@ async function runUpgrade(opts: UpgradeOptions): Promise<number> {
       ...base(before, manager, command, skew),
       after: before,
       state: 'current',
+      message: describeSkew(skew),
     })
     return 0
   }
@@ -152,7 +160,11 @@ async function applyUpgrade(
   if (!proceed) {
     logWarn('Cancelled')
     outro()
-    emit(opts, { ...base(before, manager, command, skew), state: 'cancelled' })
+    emit(opts, {
+      ...base(before, manager, command, skew),
+      state: 'cancelled',
+      message: `Cancelled. ${describeSkew(skew)}`,
+    })
     return 0
   }
 
@@ -169,10 +181,11 @@ async function applyUpgrade(
   })
 
   if (result.exitCode !== 0) {
+    const target = latestOf(skew) ?? UNKNOWN_LABEL
     return refuse(
       opts,
       before,
-      `\`${command.join(' ')}\` exited ${result.exitCode}. Run it yourself to read what it reported.`,
+      `\`${command.join(' ')}\` exited ${result.exitCode} moving from ${before} to ${target}. Run it yourself to read what it reported.`,
       manager,
     )
   }
@@ -186,16 +199,23 @@ async function applyUpgrade(
     ...base(before, manager, command, skew),
     after,
     state: 'upgraded',
+    message: upgradedMessage(before, after),
   })
   return 0
 }
 
+export function upgradedMessage(before: string, after: string): string {
+  return after === before
+    ? `Reinstalled ${after}, unchanged.`
+    : `Upgraded ${before} to ${after}.`
+}
+
 function base(
   before: string,
   manager: Manager,
   command: readonly string[],
   skew: SkewReport,
-): Omit<UpgradeRecord, 'state'> {
+): Omit<UpgradeRecord, 'state' | 'message'> {
   const latest = latestOf(skew)
 
   return {
@@ -221,11 +241,28 @@ function refuse(
     before,
     state: 'refused',
     reason,
+    message: reason,
   })
   return 1
 }
 
 function emit(opts: UpgradeOptions, record: UpgradeRecord): void {
   if (opts.json !== true) return
-  process.stdout.write(`${JSON.stringify(record)}\n`)
+  process.stdout.write(
+    `${JSON.stringify({ ...record, message: singleLine(record.message) })}\n`,
+  )
+}
+
+/**
+ * `message` is the one field carrying arbitrary text: `describeSkew`'s
+ * `unknown` branch embeds a registry error verbatim, and a registry answering
+ * with HTML produces one already carrying a double quote. `.husky/post-merge`
+ * reads this field with a pattern rather than a parser, so a quote makes it
+ * through `JSON.stringify` as an escaped `\"` that the pattern stops at,
+ * truncating the line it prints. Collapsing whitespace and swapping the quote
+ * for an apostrophe here, once, is what keeps every emitter of `message` from
+ * having to reason about that reader.
+ */
+export function singleLine(text: string): string {
+  return text.replace(/\s+/g, ' ').replace(/"/g, "'")
 }

package/src/pr/bijection.ts

@@ -24,17 +24,35 @@ export interface BijectionReport {
    */
   readonly unmet: readonly PathClaim[]
   /**
-   * Claims whose first segment names no entry in the tree, so the comparison
-   * could not judge them either way. Reported so a run says what it declined
-   * rather than counting a partial spelling as met.
+   * Claims no changed file answers that the comparison could not judge either
+   * way, reported so a run says what it declined rather than counting them met.
+   *
+   * Two causes land here. A claim whose first segment names no entry in the
+   * tree is a path written partially, and one past its bullet's first comma is
+   * a path the reader cannot separate from a file cited for context. Both are
+   * evidence strong enough to credit a changed file and too weak to accuse one,
+   * so neither reaches `unmet`, and the cause is on the claim rather than in a
+   * bucket of its own: a reader acts on both the same way, by opening the
+   * bullet on `preview`.
    */
   readonly unresolved: readonly PathClaim[]
   /**
-   * Changed files no claim reaches. Reported without a severity, since the
-   * class covers a real omission and equally a lockfile, a generated asset, or
-   * a regenerated index that legitimately earns no bullet.
+   * Changed files no claim reaches that a reader might have wanted a bullet
+   * for. Reported without a severity, since a change can be too small to
+   * describe and still be correctly absent from the section.
    */
   readonly unnamed: readonly string[]
+  /**
+   * Changed files no claim reaches that owe no bullet in the first place.
+   *
+   * Held apart rather than dropped, so a run still says what it set aside.
+   * `#1331` reported seven unnamed files of which four were a test or a
+   * fixture, which is what makes the raw count unreadable: a number mixing
+   * files that owe a bullet with files that never could cannot be acted on at
+   * any value, and the reviewing skill reads `unnamed` as a question to a
+   * branch author.
+   */
+  readonly incidental: readonly string[]
 }
 
 export type Bijection =
@@ -50,6 +68,32 @@ export interface BijectionInput {
   readonly title?: string
 }
 
+/**
+ * A changed file that owes no bullet, so its absence from the section is not a
+ * gap a reader would want reported.
+ *
+ * Three classes, each conventional rather than named for this repository: a
+ * test beside the subject it covers, anything under a fixture or snapshot
+ * folder, and a lockfile a package manager writes. All three change constantly
+ * as a consequence of work the section describes in its own terms, which is why
+ * a body naming them reads as noise rather than as diligence.
+ *
+ * A generated asset and a regenerated index belong in the class and are
+ * deliberately absent, because neither has a spelling that holds outside one
+ * project. Guessing at one would set aside a file that did owe a bullet, which
+ * is the direction that hides a real omission, where leaving them out only
+ * leaves the count where it already was.
+ */
+const INCIDENTAL: readonly RegExp[] = [
+  /(?:^|\/)[^/]+\.(?:test|spec)\.[A-Za-z0-9]+$/,
+  /(?:^|\/)(?:__tests__|__fixtures__|__snapshots__|fixtures|testdata)\//,
+  /(?:^|\/)(?:bun\.lockb?|package-lock\.json|yarn\.lock|pnpm-lock\.yaml|Cargo\.lock|Gemfile\.lock|poetry\.lock|uv\.lock|composer\.lock|go\.sum)$/,
+]
+
+function owesNoBullet(path: string): boolean {
+  return INCIDENTAL.some((pattern) => pattern.test(path))
+}
+
 /**
  * Whether one changed path is the file, or a file under the folder, a claim
  * names.
@@ -80,6 +124,13 @@ function covers(claim: PathClaim, path: string): boolean {
  * correct. Merging them into one count would either grade the second or excuse
  * the first.
  *
+ * Each direction then splits again on the same question, which is whether the
+ * evidence is strong enough to raise with a person. A claim reaches `unmet`
+ * only when it is both whole and leading, and a changed file reaches `unnamed`
+ * only when a bullet was owed for it. What each split sets aside is still
+ * reported, under `unresolved` and `incidental`, so a count a reader can act on
+ * never comes at the price of a file the run stayed silent about.
+ *
  * Pure, so the whole judgment is testable against a fixture. The caller reads
  * the body, the changed set, and the tree roots and hands all three in.
  */
@@ -104,10 +155,12 @@ export function compareKeyChanges(input: BijectionInput): Bijection {
     const hits = input.changed.filter((path) => covers(claim, path))
     for (const path of hits) named.add(path)
     if (hits.length > 0) continue
-    if (claim.anchored) unmet.push(claim)
+    if (claim.anchored && claim.leading) unmet.push(claim)
     else unresolved.push(claim)
   }
 
+  const reached = input.changed.filter((path) => !named.has(path))
+
   return {
     kind: 'measured',
     head: input.head,
@@ -115,7 +168,8 @@ export function compareKeyChanges(input: BijectionInput): Bijection {
     claims: read.claims,
     unmet,
     unresolved,
-    unnamed: input.changed.filter((path) => !named.has(path)),
+    unnamed: reached.filter((path) => !owesNoBullet(path)),
+    incidental: reached.filter(owesNoBullet),
   }
 }
 

package/src/pr/paths.ts

@@ -24,6 +24,16 @@ export interface PathClaim {
    * genuinely wrong one.
    */
   readonly anchored: boolean
+  /**
+   * True when the span sits ahead of the bullet's first comma.
+   *
+   * A trailing span is a path the bullet names without the reader being able to
+   * tell a second claim from a file cited for context, so it credits a changed
+   * file and never accuses one. Same asymmetry as `anchored`, on a second
+   * question: both mark evidence strong enough to confirm and too weak to
+   * accuse with.
+   */
+  readonly leading: 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. */
@@ -101,7 +111,7 @@ function maskSpans(text: string): string {
 }
 
 /**
- * The part of a bullet that asserts a change, which ends at its first comma.
+ * The part of a bullet that can accuse, which ends at its first comma.
  *
  * This is the one lever that separates a claim from a mention, and it was
  * chosen by measurement rather than by grammar. Over the 23 merged pull
@@ -113,10 +123,27 @@ function maskSpans(text: string): string {
  * removed nothing the comma had not already removed, because this corpus
  * punctuates every one of them.
  *
- * What it costs is a claim in a second coordinated clause, as in "Add `x` to
- * `a.ts`, and delete the old inline `y` from `b.ts`", where `b.ts` stops being
- * claimed and falls to the unnamed direction instead. That direction reports
- * without grading, so the cost lands where it does no damage.
+ * The cut used to bound what the scan collected at all, and that is the half
+ * that came out. A path past the comma was left out of the claim set entirely
+ * and fell to the unnamed direction, accepted here on the ground that the
+ * direction reports without grading. It graded anyway, one consumer removed:
+ * `claude-pr-review` reads `unnamed` as a question to put to the branch author,
+ * and on 2026-09-01 the question went to three pull requests over bullets that
+ * had named the files all along, with `#1329` gaining bullets it did not need.
+ *
+ * Collecting the whole bullet as claims was measured against the 40 most recent
+ * merged pull requests carrying the section and is not the repair: it takes
+ * `unmet` from 10 to 19, and every one of the nine is the class the cut was
+ * tuned to exclude, as in `#1276`'s "following the frame, the stream split, and
+ * the exit ladder `src/commands/labels.ts` already carries". So the scan reads
+ * the whole bullet and this cut decides `leading` instead, which is what lets a
+ * trailing path credit a changed file while `unmet` stays where the corpus put
+ * it. The same 40 give claims 243 to 314, unnamed 1124 to 1058, and unmet 10
+ * either way.
+ *
+ * `disclaimsChange` reads this region too, and for its own reason rather than
+ * by sharing this one: a disclaimer opens its bullet, so the cut reaches every
+ * one the corpus carries, and `NO_CHANGE` below records what depends on that.
  */
 function claimRegion(bullet: string): string {
   const at = maskSpans(bullet).indexOf(',')
@@ -149,8 +176,8 @@ function claimRegion(bullet: string): string {
 const NO_CHANGE =
   /\b(?:untouched|unchanged)\b|\bas written\b|^\s*(?:do not|don't|never)\b/i
 
-function disclaimsChange(region: string): boolean {
-  return NO_CHANGE.test(maskSpans(region))
+function disclaimsChange(bullet: string): boolean {
+  return NO_CHANGE.test(maskSpans(claimRegion(bullet)))
 }
 
 /**
@@ -296,12 +323,12 @@ export function extractKeyChangePaths(
       trimmed.length > PREVIEW_LIMIT
         ? `${trimmed.slice(0, PREVIEW_LIMIT)}…`
         : trimmed
-    const region = claimRegion(trimmed)
-    if (disclaimsChange(region)) continue
+    if (disclaimsChange(trimmed)) continue
 
+    const accusesBefore = claimRegion(trimmed).length
     let claimed = false
 
-    for (const match of region.matchAll(BACKTICKED)) {
+    for (const match of trimmed.matchAll(BACKTICKED)) {
       const span = match[1] ?? ''
       const bare = span.replace(LINE_SUFFIX, '')
 
@@ -317,6 +344,9 @@ export function extractKeyChangePaths(
       const resolved = resolveSpan(bare)
       if (resolved === undefined) continue
       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.
       if (seen.has(resolved.path)) continue
       seen.add(resolved.path)
 
@@ -324,6 +354,7 @@ export function extractKeyChangePaths(
         path: resolved.path,
         directory: resolved.directory,
         anchored: roots.has(resolved.path.slice(0, resolved.path.indexOf('/'))),
+        leading: (match.index ?? 0) < accusesBefore,
         span,
         bullet: index + 1,
         preview,