@erclx/canon 4.15.0 → 4.16.0

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

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

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

@@ -10,7 +10,7 @@ Chain the post-plan pipeline in a single run. Every step has a stop condition. S
 
 ## Guards
 
-- All `.canon/plans/` and `.canon/review/` reads resolve at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`.
+- All `.canon/plans/` and `.canon/review/` reads resolve at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does.
 - Derive `<slug>` per `${CLAUDE_SKILL_DIR}/../../standards/slug.md`. This skill takes the stop rather than the `latest` fallback, since it commits and opens a pull request. If empty, stop: `❌ Detached HEAD. Checkout the feature branch first.` Every later step keys its output on this slug, being the worktree, the review receipt, the branch, and the memory proposal, regardless of which plan Step 1 reads.
 - Resolve `<plan>` in Step 1, ahead of any other read.
 - If the working tree has uncommitted changes unrelated to the plan, stop: `❌ Uncommitted changes outside the plan. Commit or stash before autoshipping.`

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

@@ -49,7 +49,7 @@ Read these in parallel from the current worktree root (`pwd`), not the main work
 - `.claude/DESIGN.md`
 - `.claude/wireframes/index.md` and every `.claude/wireframes/<surface>.md`
 
-Read the task board from the main worktree root instead, per Worktrees in `CLAUDE.md`. It is gitignored scratch and never commits with the branch:
+Read the task board from the main worktree root instead, resolving that root the way `claude-worktree` does. It is gitignored scratch and never commits with the branch:
 
 - `.canon/tasks/index.md` first, then the task files this session touched. That narrow read serves the marking step, which is the only step here that opens a task file.
 
@@ -210,7 +210,7 @@ Report a block left unfolded rather than dropping it:
 
 ## Step 9: sweep consumed receipts
 
-Sweep the review and memory receipts this session consumed. Resolve all paths at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`.
+Sweep the review and memory receipts this session consumed. Resolve all paths at the main worktree root, not the current worktree, the way `claude-worktree` does.
 
 Every delete below is a shell operation, so send each as a plain single `Bash` command rather than joining two with `&&`, which is refused as compound from a linked worktree.
 

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

@@ -81,7 +81,7 @@ Omit empty sections. Do not print `None identified.` in chat.
 
 ### Full mode
 
-Derive a 2-to-4-word kebab-case slug from the feature description. Write the full plan to `.canon/plans/feature-<slug>.md` at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`. Create the directory if it does not exist.
+Derive a 2-to-4-word kebab-case slug from the feature description. Write the full plan to `.canon/plans/feature-<slug>.md` at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does. Create the directory if it does not exist.
 
 From a linked worktree the file-editing tools refuse that path, so the plan goes out through `Bash`. Send the `mkdir -p` and the heredoc as two plain commands rather than joining them with `&&`, which is refused as compound.
 

package/claude/skills/claude-markdown-propose/SKILL.md

@@ -25,7 +25,7 @@ Derive `<slug>` from the concern and the surface, kebab-case, naming the subject
 - No matching folder, or the operator names a concern and a surface: **Propose**.
 - A matching folder exists and the operator says apply, ship, or commit the answers: **Apply**.
 
-All `.canon/proposals/` reads and writes resolve at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`.
+All `.canon/proposals/` reads and writes resolve at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does.
 
 ## Write scope
 

package/claude/skills/claude-memory-capture/SKILL.md

@@ -13,7 +13,7 @@ The filename and its type prefix, the frontmatter, the body shape each type carr
 
 ## Guards
 
-- All `.canon/memory/` reads and writes resolve at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`.
+- All `.canon/memory/` reads and writes resolve at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does.
 - From a linked worktree the file-editing tools refuse every path below, so each write in this skill goes out through `Bash` as a plain single command. A memory entry holds one fact and this session has read it, so an update rewrites the whole file with a heredoc rather than editing a line inside it.
 - If `.canon/memory/` does not exist at the main worktree root, create it, along with an `index.md` carrying `title` and `subtitle` frontmatter. `canon claude init` seeds both, and a project predating that seed has neither. Regeneration errors without the index, so the first write into a bare folder would report a frontmatter failure against a file that is fine.
 - If the session produced no user corrections, confirmations, or context disclosures worth persisting, stop: `✅ Nothing worth capturing.`

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

@@ -21,7 +21,7 @@ If the user re-pings the skill with no new phrase and a receipt exists, default
 
 ## Guards
 
-- All `.canon/memory/` reads, edits, and archive moves resolve at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`.
+- All `.canon/memory/` reads, edits, and archive moves resolve at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does.
 - If no `.canon/memory/` directory exists at the main worktree root, stop: `❌ No .canon/memory/ directory found.`
 - If `.canon/memory/` contains no `*.md` entries other than `index.md`, stop: `✅ No memory entries to review.`
 - Cleanup is exempt from the two stops above. It works on receipts in `.canon/review/`, and a drained pen is the normal state once Apply has run, so a pen-shaped stop would strand the receipt it exists to delete.

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

@@ -23,7 +23,7 @@ session's review are different passes, and how a feature is sized.
 
 ## On invocation
 
-Read the board in parallel, resolving the paths at the main worktree root per Worktrees in `CLAUDE.md`:
+Read the board in parallel, resolving the paths at the main worktree root the way `claude-worktree` does:
 
 - `.canon/tasks/priority.md`: execution order and what each task is waiting on
 - `.canon/tasks/backlog.md`: what is not being scheduled, when the file exists

package/claude/skills/claude-orchestrate/references/orchestrator-dispatch.md

@@ -80,7 +80,7 @@ claude --bg --model <model> -n "worker-<project>-<slug>" "Run /canon:claude-work
 
 The prefix reads `worker-` because that is the role it marks. It read `orchestrator-` until 2026-08-31, and no controlling session ever carried it, so a worker filtering the roster for that string found a sibling or itself on every row. Nothing matches the prefix programmatically, which is what kept the rename down to three strings.
 
-`<project>` is the basename of the main worktree root, not of wherever the dispatcher happens to be running. Resolve the main root first, the way `claude-worktree` Step 1 does, since a bare `git rev-parse --show-toplevel` inside a linked worktree returns the worktree path rather than the project's. See Worktrees in `CLAUDE.md`.
+`<project>` is the basename of the main worktree root, not of wherever the dispatcher happens to be running. Resolve the main root first, the way `claude-worktree` Step 1 does, since a bare `git rev-parse --show-toplevel` inside a linked worktree returns the worktree path rather than the project's.
 
 `claude agents` lists every session on the machine with no path column and no per-project filter, so `<project>` in the name is the only thing left telling two fleets apart, and a session named off the worktree path instead would carry the branch folder rather than the project. Two projects each dispatching a bare `worker-page-driver` used to read as one row in that view.
 

package/claude/skills/claude-orchestrate/references/orchestrator-parked.md

@@ -15,7 +15,7 @@ The sweep's own question stays distinct from this one. It asks which parked row
 
 ## Scope
 
-Every row under `## Up next` and `## Needs a plan` in `.canon/tasks/priority.md`. A `## Run now` row carries no blocker by definition, so the pass skips it. Resolve the board and each task file at the main worktree root, per Worktrees in `CLAUDE.md`.
+Every row under `## Up next` and `## Needs a plan` in `.canon/tasks/priority.md`. A `## Run now` row carries no blocker by definition, so the pass skips it. Resolve the board and each task file at the main worktree root, the way `claude-worktree` does.
 
 Take the rows in board order and finish one before opening the next. Clearing a row changes what the next row collides with, so a pass that measures every row first and writes afterwards writes against a board it has already invalidated.
 

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

@@ -36,7 +36,7 @@ Read these in parallel from the project root, skipping any that do not exist:
 - `CLAUDE.md`: project type, conventions, and commands
 - `.claude/REQUIREMENTS.md`: feature scope and non-goals
 - `.claude/ARCHITECTURE.md`: technical design decisions
-- `.canon/tasks/priority.md`: where this feature sits on the board and what each neighboring row waits on. Resolve this one at the main worktree root per Worktrees in `CLAUDE.md`, since the board is gitignored and a linked worktree holds no copy of it
+- `.canon/tasks/priority.md`: where this feature sits on the board and what each neighboring row waits on. Resolve this one at the main worktree root the way `claude-worktree` does, since the board is gitignored and a linked worktree holds no copy of it
 - `.canon/plans/feature-<slug>.md` for the branch, when present: the intent the PR should satisfy
 
 Coding standards from `.claude/rules/` are auto-loaded by Claude Code.

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

@@ -120,7 +120,7 @@ If nothing is wrong, use: `✅ No findings.`
 
 Derive `<slug>` per `${CLAUDE_SKILL_DIR}/../../standards/slug.md`. Fall back to `latest` on an empty result.
 
-Write the full report directly to `.canon/review/branch/review-<slug>.md` at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`. Create the directory if it does not exist. Always overwrite.
+Write the full report directly to `.canon/review/branch/review-<slug>.md` at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does. Create the directory if it does not exist. Always overwrite.
 
 From a linked worktree the file-editing tools refuse that path, so the report goes out through `Bash`. Send the `mkdir -p` and the heredoc as two plain commands rather than joining them with `&&`, which is refused as compound.
 

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

@@ -12,7 +12,7 @@ Read `${CLAUDE_SKILL_DIR}/../../standards/tasks.md` before writing any file. It
 ## Guards
 
 - Resolve the board at the main worktree root, not `pwd`. Run `git worktree list --porcelain | grep -m 1 '^worktree ' | cut -d' ' -f2-`, falling back to `pwd` outside a git repo. Every read and write below resolves against that root. The board is gitignored scratch shared across worktrees, so a linked worktree writing to its own `pwd` creates a second board nothing else reads.
-- From a linked worktree the file-editing tools refuse that root, so a new task file goes out through `Bash` as a plain single command carrying a heredoc. Archiving already runs through `canon tasks archive`, which resolves the root in-process. Marking an outcome shipped is `claude-docs` and runs through `canon tasks outcome`. See Worktrees in `CLAUDE.md`.
+- From a linked worktree the file-editing tools refuse that root, so a new task file goes out through `Bash` as a plain single command carrying a heredoc. Archiving already runs through `canon tasks archive`, which resolves the root in-process. Marking an outcome shipped is `claude-docs` and runs through `canon tasks outcome`. Resolve that root the way `claude-worktree` does.
 - If `.canon/tasks/` does not exist at that root, stop: `❌ No .canon/tasks/ board. Run canon claude init to set it up.`
 - Route on the request rather than on a flag. Creating names work that does not exist yet, archiving names a task file already on the board. If the request fits neither, stop: `❌ Ambiguous. Say whether to create a task or archive one.`
 - Never hand-edit `.canon/tasks/index.md`. A hook regenerates it from sibling frontmatter after a write. Do not run the regen command directly, except after a shell write from a linked worktree: the hook matches `Write|Edit|MultiEdit` and nothing fires on `Bash`, so that one case regenerates explicitly with `canon indexes regen --no-stage --root <main-root> <main-root>/.canon/tasks/index.md`.

package/claude/skills/claude-ui-test/SKILL.md

@@ -59,7 +59,7 @@ If all changes are automatable, skip the manual checklist:
 
 Derive `<slug>` per `${CLAUDE_SKILL_DIR}/../../standards/slug.md`. Fall back to `latest` on an empty result.
 
-When a manual checklist is produced, write it directly to `.canon/review/ui-checklist-<slug>.md` at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`. Create the directory if it does not exist. Always overwrite.
+When a manual checklist is produced, write it directly to `.canon/review/ui-checklist-<slug>.md` at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does. Create the directory if it does not exist. Always overwrite.
 
 From a linked worktree the file-editing tools refuse that path, so the checklist goes out through `Bash`. Send the `mkdir -p` and the heredoc as two plain commands rather than joining them with `&&`, which is refused as compound.
 

package/claude/skills/claude-ux-audit/SKILL.md

@@ -59,7 +59,7 @@ If nothing is wrong, use: `✅ No observations.`
 
 Derive `<slug>` per `${CLAUDE_SKILL_DIR}/../../standards/slug.md`. Fall back to `latest` on an empty result.
 
-Write the full report directly to `.canon/review/ux-audit-<slug>.md` at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`. Create the directory if it does not exist. Always overwrite.
+Write the full report directly to `.canon/review/ux-audit-<slug>.md` at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does. Create the directory if it does not exist. Always overwrite.
 
 From a linked worktree the file-editing tools refuse that path, so the report goes out through `Bash`. Send the `mkdir -p` and the heredoc as two plain commands rather than joining them with `&&`, which is refused as compound.
 

package/claude/skills/claude-ux-measure/SKILL.md

@@ -106,7 +106,7 @@ Report the reading and stop there. A remedy for a poor verdict is a change with
 
 Derive `<slug>` per `${CLAUDE_SKILL_DIR}/../../standards/slug.md`. Fall back to `latest` on an empty result.
 
-Write the full reading directly to `.canon/review/ux-measure-<slug>.md` at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`. Create the directory if it does not exist. Always overwrite.
+Write the full reading directly to `.canon/review/ux-measure-<slug>.md` at the main worktree root, not the current worktree. Resolve that root the way `claude-worktree` does. Create the directory if it does not exist. Always overwrite.
 
 From a linked worktree the file-editing tools refuse that path, so the reading goes out through `Bash`. Send the `mkdir -p` and the heredoc as two plain commands rather than joining them with `&&`, which is refused as compound.
 

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

@@ -23,7 +23,7 @@ Run in parallel:
 - `git branch --show-current 2>/dev/null || echo ""`
 - `git config --get core.bare 2>/dev/null || echo false`
 
-Plans always live at the main root, never inside a linked worktree. See Worktrees in `CLAUDE.md`.
+Plans always live at the main root, never inside a linked worktree.
 
 `EnterWorktree` writes `core.bare = true` into the shared config, and nothing restores it, so the repository can already be broken before this session arrives. Repair it before entering when the value is `true` and `<main-root>/.git` is a directory:
 

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

@@ -145,7 +145,7 @@ canon tasks pull-request <number> --plan feature-<slug> --json
 
 The slug is a guess at which plan this branch carries rather than a fact about the task, which is why the verb re-checks it against the board and refuses instead of writing on a near miss. A branch whose slug names no plan file falls to the silent skip below, the same as one whose plan no task cites.
 
-The verb resolves the board at the main worktree root in-process, adds `Pull request: #NNN` under the `Plan:`, `Groundwork:`, `Intake:`, or `Issue:` lines the task already carries, and corrects the number in place when the line exists. This is the route because the write is an edit inside an existing file, which the file-editing tools refuse from a linked worktree and which no shell stream editor may make. See Worktrees in `CLAUDE.md`.
+The verb resolves the board at the main worktree root in-process, adds `Pull request: #NNN` under the `Plan:`, `Groundwork:`, `Intake:`, or `Issue:` lines the task already carries, and corrects the number in place when the line exists. This is the route because the write is an edit inside an existing file, which the file-editing tools refuse from a linked worktree and which no shell stream editor may make. That root is the one `claude-worktree` resolves on entry.
 
 Skip this silently when the record is `ok: false` and `reason` is `no-board`, `no-match`, or `ambiguous`. Those are the three cases a guessed write would compound: no board, no task naming the plan, or more than one. One task, one pull request, and a wrong match archives the wrong task unattended once the branch merges. Report any other refusal rather than swallowing it.
 

package/claude/skills/session-resume/SKILL.md

@@ -7,7 +7,7 @@ description: Resumes a previous session by reading the handoff it left behind, t
 
 ## Step 1: read tracked work
 
-Resolve `.canon/plans/`, `.canon/memory/`, and `.canon/tasks/` at the main worktree root per Worktrees in `CLAUDE.md`.
+Resolve `.canon/plans/`, `.canon/memory/`, and `.canon/tasks/` at the main worktree root the way `claude-worktree` does.
 
 Read these in parallel, skipping any that do not exist:
 
@@ -40,7 +40,7 @@ End with one line: `Start with: <first Up next item>` and note whether it has a
 
 When the board is empty and a handoff was found, name what the handoff leaves open instead: `Start with: <the open thread the handoff names>`. A recommendation slot filled with nothing reads as a failed run, and a handoff on an empty board is the shape a session leaves when it was reasoning rather than shipping.
 
-Do not offer to remove entries. A completed task is archived out of `.canon/tasks/` when work ships. The git log is the authoritative record of shipped work. Plan files are archived per the plan lifecycle rule in `CLAUDE.md`.
+Do not offer to remove entries. A completed task is archived out of `.canon/tasks/` when work ships. The git log is the authoritative record of shipped work. Plan files are archived per the lifecycle rule in `${CLAUDE_SKILL_DIR}/../../standards/plan.md`.
 
 Memory is updated only when a recorded fact becomes wrong, never on resume. A domain fact reaches a session through `.claude/context/`, which `claude-memory-capture` routes to and the three-tier model loads on demand, so the memory folder read here is the residue no context entry owns.
 

package/docs/agents/commands.md

@@ -68,7 +68,7 @@ Full help: `canon <command> --help`. Behavior notes for the install and sync ver
 | `canon secrets scan`          | Report credential-shaped values in the tree the package ships, keyed on issued values rather than on words (`--json`)                                                 |
 | `canon deps audit`            | Report published advisories against the resolved dependency set, refusing rather than reporting clean when the index is unreachable (`--json`)                        |
 | `canon labels audit`          | Report the labels a changed set earns from the pull request label map and the paths no row reaches (`--json`)                                                         |
-| `canon labels scan`           | Fail a pull request whose title or body carries a phase label, sorting a release pull request's tokens as semver rather than as a leak (`--event`, `--json`)          |
+| `canon labels scan`           | Fail a pull request whose title or body names the board, by a phase label, a label a code span quotes, or a gitignored record path (`--event`, `--json`)              |
 | `canon autoship classify`     | Decide whether a changed set needs the review pass, naming the file and the test that decided it (`--json`)                                                           |
 | `canon pr key-changes`        | Compare the files a pull request body's Key Changes names against its own diff, in both directions (`--body`, `--base`, `--json`)                                     |
 | `canon repo metadata propose` | Compare a description, homepage, and topic set computed from the README and `package.json` against what the remote carries, writing nothing (`--root`, `--json`)      |

package/package.json

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

package/src/claude/skills-headings.ts

@@ -0,0 +1,70 @@
+/**
+ * The citation shape that sends a reader to a named section of the consuming
+ * project's own `CLAUDE.md`.
+ *
+ * A shipped body reaches a target through the plugin cache, and no `CLAUDE.md`
+ * in this repository or in any known target carries the section these lines
+ * named. The pointer resolves to nothing, which a session answers by guessing
+ * the rule or dropping it, so the shape is banned rather than repaired one
+ * body at a time.
+ *
+ * It is a prose pattern rather than a resolution, because no check can read a
+ * target's own root file. A `See` or a `per`, then anything up to a period,
+ * then ` in ` and a backticked `CLAUDE.md`. The two verbs are what separate a
+ * citation from a mention: dropping them returns five extra lines that name
+ * the file without pointing into it, and the period is what stops the match at
+ * a sentence boundary so a body discussing the file two sentences earlier does
+ * not fail.
+ *
+ * The period is the only boundary, and excluding a backtick alongside it was
+ * the first shape. It reads as a tighter bound and is a hole, because
+ * `markdown.md` has a body backtick a named thing, so the natural spelling of
+ * the citation is `` See the `Parallel sessions` heading in `CLAUDE.md` `` and
+ * a class stopping at the first backtick never reaches the file. That heading
+ * is real in this repository's own root file. Both classes returned the same
+ * twenty lines over `claude/skills/` at the stamp, so the backtick exclusion
+ * was carrying nothing and hiding the spelling an author would reach for.
+ *
+ * Both verbs match in either case. The measured corpus spelled them `See` and
+ * `per` and the insensitive form returned the identical twenty hits with no
+ * false positive, so it costs nothing and catches a sentence-initial `Per`.
+ *
+ * A later body phrasing a legitimate reference this way fails the check and
+ * changes its phrasing. There is no exemption marker, since the point is that
+ * the target does not resolve for the reader who holds the body.
+ */
+const HEADING_CITATION = /\b(?:see|per)\b[^.]* in `CLAUDE\.md`/i
+
+export interface HeadingCitation {
+  readonly file: string
+  /** One-based, matching the `file:line` form a reader clicks. */
+  readonly line: number
+  /** The whole line, so a report names what has to be rephrased. */
+  readonly text: string
+}
+
+/**
+ * Every line in one body carrying the banned citation.
+ *
+ * The unit is the line rather than the match, since a report names a line for
+ * rephrasing and two hits on one line would arrive as identical entries.
+ *
+ * The corpus walk is deliberately absent. Keeping the shape separate from the
+ * tree read is what lets the pattern be tested against a string rather than
+ * against a fixture, the way `citationsIn` splits the same seam in
+ * `skills-reach.ts`.
+ */
+export function headingCitationsIn(
+  file: string,
+  text: string,
+): HeadingCitation[] {
+  const citations: HeadingCitation[] = []
+
+  for (const [index, line] of text.split('\n').entries()) {
+    if (!HEADING_CITATION.test(line)) continue
+
+    citations.push({ file, line: index + 1, text: line })
+  }
+
+  return citations
+}

package/src/commands/labels.ts

@@ -90,7 +90,7 @@ export function register(program: Command): void {
   labels
     .command('scan')
     .description(
-      'Fail a pull request whose title or body carries a phase label',
+      'Fail a pull request whose title or body carries a phase label or a board identifier',
     )
     .helpOption('-h, --help', 'Show this help message')
     .option(
@@ -112,10 +112,16 @@ export function register(program: Command): void {
         'other pull request may carry neither, so any token found there is a',
         'leaked phase label.',
         '',
+        'It reports a board identifier beside that, being text naming the task',
+        'board rather than the change: a version token a code span quotes, and a',
+        'path under a record root, both of which a reader on the remote holds no',
+        'copy of. A path under a tracked folder is left alone, so a rule or a',
+        'skill any clone resolves is not reported.',
+        '',
         'Exit codes:',
-        '  0  no phase label found',
+        '  0  no phase label and no board identifier found',
         '  1  refused, with the reason on stderr or in the JSON record',
-        '  2  the title or body carries a phase label',
+        '  2  the title or body carries a phase label or a board identifier',
         '',
         'Examples:',
         '  canon labels scan --event "$GITHUB_EVENT_PATH"',
@@ -345,6 +351,18 @@ async function runScan(opts: ScanOptions): Promise<number> {
     for (const label of result.phaseLabels) logWarn(label)
   }
 
+  logStep(
+    result.boardReferences.length === 0 ? 'Clean' : 'Board identifier found',
+  )
+  if (result.boardReferences.length === 0) {
+    logInfo('no quoted label or record path in the title or body')
+  } else {
+    logWarn(
+      `${plural(result.boardReferences.length, 'board identifier')} in the title or body. Name what a reader on the remote can open, since a record path is gitignored there and a quoted label reads as one only from the board.`,
+    )
+    for (const reference of result.boardReferences) logWarn(reference)
+  }
+
   outro()
 
   if (emitJson) {
@@ -353,9 +371,12 @@ async function runScan(opts: ScanOptions): Promise<number> {
         cutsRelease: result.cutsRelease,
         phaseLabels: result.phaseLabels,
         semverTags: result.semverTags,
+        boardReferences: result.boardReferences,
       })}\n`,
     )
   }
 
-  return result.phaseLabels.length === 0 ? 0 : 2
+  return result.phaseLabels.length === 0 && result.boardReferences.length === 0
+    ? 0
+    : 2
 }

package/src/labels/phase.ts

@@ -1,4 +1,5 @@
 import { linesOutsideFences, maskCodeSpans } from '@/markdown/scan'
+import { RECORD_ENTRIES, RECORD_ROOTS, spell } from '@/record-root'
 
 /**
  * The two version namespaces `standards/versioning.md` keeps apart, and why a
@@ -22,10 +23,81 @@ export interface PhaseScanResult {
   readonly cutsRelease: boolean
   readonly phaseLabels: readonly string[]
   readonly semverTags: readonly string[]
+  /**
+   * Text naming the board rather than the change: a version token a code span
+   * quotes, and a path under a record root.
+   *
+   * It sits beside the two namespaces rather than inside either, because a
+   * record path is version-shaped in neither and a quoted token is one the
+   * reading below has already declined to sort. Both are one defect at the
+   * destination, which is a reader on a remote holding neither the task board
+   * nor the gitignored folder a path names.
+   */
+  readonly boardReferences: readonly string[]
 }
 
 const VERSION_TOKEN = /\bv\d+(?:\.\d+){1,2}\b/g
 
+/**
+ * A code span holding a version token and nothing else.
+ *
+ * The closing delimiter refers back to the opening one, so a span opened on two
+ * backticks closes on two, which is the rule `maskCodeSpans` reads a span by.
+ * Content is the token alone rather than a token found inside longer content,
+ * which is the whole of what separates a quoted phase label from `#1208`.
+ */
+const VERSION_SPAN = /(`+)(v\d+(?:\.\d+){1,2})\1/g
+
+/** Sentence punctuation a path picks up at the end of a clause. */
+const TRAILING_PUNCTUATION = /[.,;]+$/
+
+/** Escapes a literal so it can sit inside a constructed pattern. */
+function escapeLiteral(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+/**
+ * What is ignored under a root beyond the entries the record move relocated.
+ *
+ * `RECORD_ENTRIES` answers which folders that move carried across, and this
+ * check asks which paths a reader on a remote cannot open. The two questions
+ * differ by exactly one entry: the worktrees folder is ignored and stays out of
+ * that list deliberately, since the harness creates a worktree there and
+ * requires its target to sit there, so adding it upstream would tell the
+ * migration to relocate a folder the harness pins.
+ *
+ * It is also the entry a worker announcement names most often, which is what
+ * makes the gap a live class rather than a theoretical one.
+ */
+const IGNORED_BEYOND_RECORDS: readonly string[] = ['worktrees']
+
+/**
+ * A path a reader on a remote cannot open, which is a root plus one of the
+ * entries that root ignores rather than the root alone.
+ *
+ * `.claude/` is tracked and holds `rules`, `skills`, `hooks`, and `context`, so
+ * a rule path resolves in any clone and is not a board reference. The scratch
+ * folder goes through `spell` because it is the one entry whose name differs by
+ * root. Reading the roots and the relocated entries from `src/record-root.ts`
+ * is what makes a folder added there matched here without an edit, and the list
+ * above is what covers the one thing that module deliberately does not carry.
+ *
+ * The tail runs to the first whitespace or closing delimiter, so a report names
+ * the whole path an author has to remove rather than the prefix that matched.
+ */
+const RECORD_PATH = new RegExp(
+  `(?<![\\w./-])(?:${RECORD_ROOTS.map(
+    (root) =>
+      `${escapeLiteral(root)}/(?:${[
+        ...RECORD_ENTRIES,
+        ...IGNORED_BEYOND_RECORDS,
+      ]
+        .map((entry) => escapeLiteral(spell(root, entry)))
+        .join('|')})`,
+  ).join('|')})(?![\\w-])[^\\s\`)\\]]*`,
+  'g',
+)
+
 /**
  * The head branch release-please opens every release pull request under.
  *
@@ -53,6 +125,15 @@ function isReleasePullRequest(input: PhaseScanInput): boolean {
   )
 }
 
+/** Replaces a version span's delimiters with spaces, holding the line's width. */
+function unquoteVersionSpans(line: string): string {
+  return line.replace(
+    VERSION_SPAN,
+    (_span, ticks: string, token: string) =>
+      `${' '.repeat(ticks.length)}${token}${' '.repeat(ticks.length)}`,
+  )
+}
+
 /**
  * Drops a fenced block outright and blanks a code span inside what remains,
  * so a token quoted rather than written is read the way a reader reads it:
@@ -69,9 +150,34 @@ function isReleasePullRequest(input: PhaseScanInput): boolean {
  * compare link's URL, and masking it would empty `semverTags` on the one
  * pull request this check exists to pass, trading the corpus's one code-span
  * leak for a hole in every release.
+ *
+ * `keepVersionSpans` widens that reading for the board-reference pass alone. A
+ * span whose whole content is a version token survives it, which is the shape
+ * the leak reached the remote through, and longer content stays blanked, which
+ * is what holds `#1208` closed. Two passes over one source rather than one pass
+ * sorting its own output, because a token is a board reference by virtue of the
+ * span it came out of and nothing downstream of the match can see that.
  */
-function readable(text: string): string {
-  return linesOutsideFences(text).map(maskCodeSpans).join('\n')
+function readable(text: string, keepVersionSpans = false): string {
+  return linesOutsideFences(text)
+    .map((line) =>
+      maskCodeSpans(keepVersionSpans ? unquoteVersionSpans(line) : line),
+    )
+    .join('\n')
+}
+
+function versionTokens(text: string): string[] {
+  return [...new Set(text.match(VERSION_TOKEN) ?? [])]
+}
+
+function recordPaths(text: string): string[] {
+  return [
+    ...new Set(
+      (text.match(RECORD_PATH) ?? []).map((path) =>
+        path.replace(TRAILING_PUNCTUATION, ''),
+      ),
+    ),
+  ]
 }
 
 /**
@@ -83,13 +189,42 @@ function readable(text: string): string {
  * legitimately carries, and every other pull request's tokens are read as
  * leaked phase labels, which is what `standards/versioning.md` names the
  * defect this exists to catch.
+ *
+ * A release pull request reports no board reference either, and the ground is
+ * coverage rather than exemption. Release-please generates that body from
+ * merged history, and every commit in that history came through a pull request
+ * this same check already scanned, so a board reference cannot reach a release
+ * body without passing the gate on its own. That its author has nothing to
+ * rewrite is true as well and is the weaker half, since it would leave the
+ * reference standing and unresolvable.
  */
 export function scanPhaseLabels(input: PhaseScanInput): PhaseScanResult {
-  const text = readable(`${input.title}\n${input.body}`)
-  const tokens = [...new Set(text.match(VERSION_TOKEN) ?? [])]
+  const source = `${input.title}\n${input.body}`
+  const tokens = versionTokens(readable(source))
   const cutsRelease = isReleasePullRequest(input)
 
-  return cutsRelease
-    ? { cutsRelease, phaseLabels: [], semverTags: tokens }
-    : { cutsRelease, phaseLabels: tokens, semverTags: [] }
+  if (cutsRelease) {
+    return {
+      cutsRelease,
+      phaseLabels: [],
+      semverTags: tokens,
+      boardReferences: [],
+    }
+  }
+
+  // Dropped where the same token is also written bare, since the phase-label
+  // half already names it and reporting it twice asks for one removal twice.
+  const quoted = versionTokens(readable(source, true)).filter(
+    (token) => !tokens.includes(token),
+  )
+
+  return {
+    cutsRelease,
+    phaseLabels: tokens,
+    semverTags: [],
+    boardReferences: [
+      ...quoted,
+      ...recordPaths(linesOutsideFences(source).join('\n')),
+    ],
+  }
 }

package/standards/pr.md

@@ -14,6 +14,7 @@ Does not govern:
 - Commit subject format, which shares the title form: `commit.md`
 - Branch naming: `branch.md`
 - Whether a phase label or a semver tag may appear in a title or body: `versioning.md`
+- Whether a quoted label or a gitignored record path may appear in a title or body, which `canon labels scan` fails on: `publish.md`
 - Voice, rhythm, and sentence construction in pull request prose: the `write-human` skill
 - Punctuation, formatting, and banned words in pull request prose: `markdown.md`
 

package/standards/publish.md

@@ -22,6 +22,8 @@ Wherever text leaves through a channel no automated check covers, the author is
 
 Run the scan as an explicit step against the finished text. Having read the underlying rules before drafting does not cover it, because the check has to happen after the text exists.
 
+Scope every check below by destination. Text published to a remote takes all of them. Text staying in the repository takes the character bans alone, since those hold wherever the text lands, and skips whichever check depends on the reader holding something only this checkout carries. The two checks below that depend on it say so under their own headings.
+
 ## Banned characters
 
 `markdown.md` holds the character bans and the banned words alike. Read it at scan time rather than working the sets from memory, then scan the drafted text and rewrite each occurrence.
@@ -32,7 +34,17 @@ Restructure the sentence rather than substituting the character. A semicolon swa
 
 `versioning.md` holds the label rule and the table of surfaces. Read it at scan time rather than working the format from memory.
 
-Scope this check by destination. Text published to a remote takes it. Text scanned on its way into the repository, where the reader has the task board, skips it.
+This check is one of the two the destination rule above scopes. The reader inside the repository has the task board and the reader on a remote does not.
+
+## Board identifiers
+
+A phase label is one way text names the board, and a path under a record root is the other. Both resolve for a reader holding this checkout and neither resolves for anyone else, so this check is the second one the destination rule scopes.
+
+Two shapes get past a reader scanning for a bare label. A code span quoting a label is still the label, so read a span whose whole content is one as a hit and leave a longer token inside a span alone, which is a fixture name rather than a reference. The second shape is a path under a record root, gitignored and therefore absent from every clone, so `.canon/review/feedback/` names a folder the remote's reader cannot open. Under a tracked folder there is no hit, since `.claude/rules/core/005-behavior.md` resolves everywhere.
+
+Rewrite a hit to name what the reader can reach rather than deleting it. A row's subject stated plainly replaces its label, and what a record folder holds, said in a sentence, replaces its path.
+
+`canon labels scan` runs this check and the phase-label one over a pull request title and body. It reads that pair alone, so every other channel is the author's own scan.
 
 ## Cross-reference form