@erclx/canon 4.118.0 → 4.119.0

package/src/gov/adapter.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs'
 import { basename, join, relative, resolve } from 'node:path'
-import { canonRulesDir } from '@/gov/install'
+import { canonRulesDir, ruleSubdir } from '@/gov/install'
+import { loadRenames, resolveSuccessor } from '@/gov/renames'
 import { resolveMissingRules } from '@/gov/stacks'
 import type { InstalledFile, RetiredSurface, SyncAdapter } from '@/sync/engine'
 import { readStamp, stampedChain } from '@/sync/stamp'
@@ -49,11 +50,14 @@ export function indexSourceRules(root: string): Map<string, string> {
  * `.claude/rules/canon/` leaves outside the walk, so everything the walk does
  * reach is the toolkit's. A rule there with no source is one the toolkit
  * retired or renamed, and the sync deletes it rather than leaving it loaded.
+ * A rename `governance/renames.toml` declares also installs the rule under its
+ * new name.
  * A `projectSubdir` would compute a stale `canon/project/` destination, which
  * is wrong rather than merely redundant.
  */
 export function createGovAdapter(root: string): SyncAdapter {
   const index = indexSourceRules(root)
+  const renames = loadRenames(root)
 
   return {
     banner: 'canon gov sync',
@@ -67,10 +71,56 @@ export function createGovAdapter(root: string): SyncAdapter {
     collectRetired: (target: string) => collectRetiredGov(target),
     collectMissing: (target: string) => collectMissingGov(root, target),
     ownsInstalledRoot: true,
+    locateSuccessor: (file: InstalledFile, target: string) => {
+      const successor = resolveSuccessor(
+        renames,
+        index,
+        basename(file.path, '.md'),
+      )
+      if (successor === undefined) return undefined
+
+      const source = index.get(successor)
+      if (source === undefined) return undefined
+
+      return {
+        source,
+        dest:
+          heldRulePath(target, successor) ??
+          join(
+            canonRulesDir(target),
+            ruleSubdir(source, rulesSourceDir(root)),
+            `${successor}.md`,
+          ),
+      }
+    },
     stamp: { domain: 'governance', toolkitRoot: root },
   }
 }
 
+/**
+ * Where the target already holds a rule, in whichever band folder. A
+ * successor held outside the source's band stays where it is, the same way
+ * `locateSource` syncs a moved rule in place, rather than gaining a second copy.
+ *
+ * Holding the predecessor is the whole entitlement test, so no stamped chain
+ * is read here. That covers a rule `--add` layered on and a target installed
+ * before chains were stamped alike.
+ */
+function heldRulePath(target: string, rule: string): string | undefined {
+  const dir = canonRulesDir(target)
+  if (!existsSync(dir)) return undefined
+
+  for (const rel of new Bun.Glob(`**/${rule}.md`).scanSync({
+    cwd: dir,
+    onlyFiles: true,
+    dot: true,
+  })) {
+    return join(dir, rel)
+  }
+
+  return undefined
+}
+
 /**
  * Rules the target's recorded chain entitles it to and its tree does not
  * hold. Reports as `notice` text through the same shape `collectRetired`

package/src/gov/install.ts

@@ -38,8 +38,14 @@ export function installedInternalRulesDir(target: string): string {
  * Rule names a target already holds, read off the installed `canon/` tree by
  * basename rather than off a recorded stack, since a target may hold rules
  * `--add` layered on that no stack lists.
+ *
+ * `successorOf` adds the name a held rule was renamed to, since the next sync
+ * installs it and a reader treating it as missing would name it twice.
  */
-export function installedRuleNames(target: string): Set<string> {
+export function installedRuleNames(
+  target: string,
+  successorOf?: (name: string) => string | undefined,
+): Set<string> {
   const dir = canonRulesDir(target)
   const names = new Set<string>()
   if (!existsSync(dir)) return names
@@ -49,7 +55,11 @@ export function installedRuleNames(target: string): Set<string> {
     onlyFiles: true,
     dot: true,
   })) {
-    names.add(basename(rel, '.md'))
+    const name = basename(rel, '.md')
+    names.add(name)
+
+    const successor = successorOf?.(name)
+    if (successor !== undefined) names.add(successor)
   }
 
   return names
@@ -84,7 +94,7 @@ export function listRuleSourcePaths(root: string): string[] {
  * in two subdirectories resolves deterministically rather than by whichever
  * entry the filesystem yielded first.
  */
-function indexRuleSources(root: string): Map<string, string> {
+export function indexRuleSources(root: string): Map<string, string> {
   const rulesRoot = rulesSourceDir(root)
   const byName = new Map<string, string>()
 

package/src/gov/renames.ts

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { indexRuleSources } from '@/gov/install'
+
+/** Old rule basename to the basename the same rule ships under now. */
+export type Renames = ReadonlyMap<string, string>
+
+function renamesPath(root: string): string {
+  return join(root, 'governance', 'renames.toml')
+}
+
+/**
+ * Reads the shipped rename ledger. A toolkit without one declares no renames,
+ * which leaves every sourceless rule on the retire path it took before the
+ * ledger existed.
+ */
+export function loadRenames(root: string): Renames {
+  const path = renamesPath(root)
+  if (!existsSync(path)) return new Map()
+
+  const parsed = Bun.TOML.parse(readFileSync(path, 'utf8')) as Record<
+    string,
+    unknown
+  >
+  const table = parsed.renamed
+  if (typeof table !== 'object' || table === null) return new Map()
+
+  return new Map(
+    Object.entries(table).filter(
+      (entry): entry is [string, string] => typeof entry[1] === 'string',
+    ),
+  )
+}
+
+/**
+ * Follows a declared rename to the name the toolkit ships the rule under now,
+ * through every later rename of that name. The ledger is never pruned, so a
+ * target several releases behind still reaches the current name.
+ *
+ * Returns nothing when the chain ends on a name with no source, or loops,
+ * since installing a guess is worse than the retire the caller falls back to.
+ */
+export function resolveSuccessor(
+  renames: Renames,
+  index: ReadonlyMap<string, string>,
+  name: string,
+): string | undefined {
+  const visited = new Set([name])
+  let current = renames.get(name)
+
+  while (current !== undefined) {
+    if (visited.has(current)) return undefined
+    visited.add(current)
+
+    const next = renames.get(current)
+    if (next === undefined) break
+    current = next
+  }
+
+  if (current === undefined || !index.has(current)) return undefined
+  return current
+}
+
+/**
+ * Binds the ledger and the source tree at `root` once, for a caller asking
+ * about many held names.
+ */
+export function successorResolver(
+  root: string,
+): (name: string) => string | undefined {
+  const renames = loadRenames(root)
+  if (renames.size === 0) return () => undefined
+
+  const index = indexRuleSources(root)
+  return (name) => resolveSuccessor(renames, index, name)
+}

package/src/gov/stacks.ts

@@ -7,6 +7,7 @@ import {
   type RuleSource,
   rulesSourceDir,
 } from '@/gov/install'
+import { successorResolver } from '@/gov/renames'
 
 export interface GovStack {
   readonly name: string
@@ -163,6 +164,9 @@ export function unreferencedRules(root: string): string[] {
  * so reading its leaf entry is enough; no second walk resolves the chain
  * itself. A stack the toolkit no longer ships resolves to nothing rather than
  * throwing, the same way `readNewRules`'s band fallback already treats it.
+ *
+ * A held rule's declared successor counts as held, since the sync that
+ * renames the old file installs it.
  */
 export function resolveMissingRules(
   root: string,
@@ -176,7 +180,7 @@ export function resolveMissingRules(
   if (!resolution.ok) return []
 
   const { found } = lookupRules(root, resolution.rules)
-  const held = installedRuleNames(target)
+  const held = installedRuleNames(target, successorResolver(root))
 
   return found
     .filter((source) => !held.has(source.rule))

package/src/sync/check.ts

@@ -4,6 +4,7 @@ import { execa } from 'execa'
 import { gitEnv } from '@/git-env'
 import { createDesignAdapter, DESIGN_INSTALL_DIR } from '@/design/adapter'
 import { createGovAdapter, rulesSourceDir } from '@/gov/adapter'
+import { successorResolver } from '@/gov/renames'
 import { loadGovStack, resolveMissingRules, resolveRules } from '@/gov/stacks'
 import { planSync, type ScanEntry, type SyncAdapter } from '@/sync/engine'
 import {
@@ -80,6 +81,7 @@ export interface StateCounts {
   readonly stranded: number
   readonly missing: number
   readonly retired: number
+  readonly renamed: number
 }
 
 export interface DomainReport {
@@ -316,6 +318,7 @@ export function countStates(entries: readonly ScanEntry[]): StateCounts {
     stranded: count(entries, 'stranded'),
     missing: count(entries, 'missing'),
     retired: count(entries, 'retired'),
+    renamed: count(entries, 'renamed'),
   }
 }
 
@@ -347,6 +350,8 @@ export function countStates(entries: readonly ScanEntry[]): StateCounts {
  *
  * `retired` counts, since a sync deletes it mechanically. A target's CI goes
  * red the day a release retires a rule it holds, and one sync clears it.
+ * `renamed` counts on the same grounds, since the sync that moves it is
+ * equally mechanical.
  */
 export function hasDrift(report: CheckReport): boolean {
   if (report.unmigrated.length > 0) return true
@@ -357,7 +362,8 @@ export function hasDrift(report: CheckReport): boolean {
         domain.counts.customized +
         domain.counts.drifted +
         domain.counts.stranded +
-        domain.counts.retired >
+        domain.counts.retired +
+        domain.counts.renamed >
       0,
   )
 }
@@ -488,8 +494,14 @@ export function parseNewSkills(paths: string): string[] {
  * chain a target consumed survives nowhere else. `installRules` copies each
  * rule into the subdirectory it was authored in, which is what makes the band
  * folders legible as evidence.
+ *
+ * `successorOf` adds the name a held rule was renamed to, which the next sync
+ * installs, so the fallback does not report it as new.
  */
-export function readInstalledRules(target: string): {
+export function readInstalledRules(
+  target: string,
+  successorOf?: (name: string) => string | undefined,
+): {
   held: Set<string>
   bands: Set<string>
 } {
@@ -506,7 +518,10 @@ export function readInstalledRules(target: string): {
     const posix = rel.split(sep).join('/')
     const boundary = posix.indexOf('/')
 
-    held.add(basename(posix, '.md'))
+    const name = basename(posix, '.md')
+    held.add(name)
+    const successor = successorOf?.(name)
+    if (successor !== undefined) held.add(successor)
     if (boundary > 0) bands.add(posix.slice(0, boundary))
   }
 
@@ -640,7 +655,7 @@ export async function readNewRules(
     'governance/rules/',
   ])
 
-  const { held, bands } = readInstalledRules(target)
+  const { held, bands } = readInstalledRules(target, successorResolver(root))
   return selectNewRules(paths, held, bands.union(baseBands(root)))
 }
 

package/src/sync/engine.ts

@@ -70,6 +70,11 @@ export type SyncChange =
  * sync deletes it. A stamped file the toolkit no longer installs to is
  * stranded, which is a relocation waiting on a decision.
  *
+ * `renamed` is the fourth sourceless state and the only one that installs.
+ * It is a retired file whose rule the adapter declares still ships under a
+ * new name, so the sync deletes the old file and copies the rule to the new
+ * one.
+ *
  * `missing` is the one state the walk cannot produce on its own, since the
  * walk only iterates files that exist. It comes from `collectMissing`
  * instead, an adapter naming an entitled file the target does not hold.
@@ -81,6 +86,7 @@ export type EntryState =
   | 'drifted'
   | 'orphaned'
   | 'retired'
+  | 'renamed'
   | 'stranded'
   | 'missing'
 
@@ -165,9 +171,20 @@ export interface SyncAdapter {
    * no source is a leftover of a rule the toolkit retired or renamed rather
    * than something a project wrote. Setting it turns that file into a
    * `retired` entry and queues its delete, edited or not, whatever the stamp
-   * holds. Unset, the file stays `orphaned` and untouched.
+   * holds, or a `renamed` one when `locateSuccessor` names where it ships
+   * now. Unset, the file stays `orphaned` and untouched.
    */
   readonly ownsInstalledRoot?: boolean
+  /**
+   * Where a sourceless file's rule ships now, when the toolkit declares it
+   * renamed rather than retired. Reached only on a root the adapter owns and
+   * never past the newer-install guard. Unset, or returning nothing, leaves
+   * the file `retired`.
+   */
+  locateSuccessor?(
+    file: InstalledFile,
+    target: string,
+  ): { readonly source: string; readonly dest: string } | undefined
   /** Defaults to applying. */
   readonly nonInteractive?: NonInteractivePolicy
   /** Runs on a completed sync, including one with no changes. */
@@ -224,6 +241,7 @@ export function planSync(adapter: SyncAdapter, target: string): SyncPlan {
   const hashes = stampedHashes(stamp, adapter.stamp?.domain)
   const newerInstall = newerInstallingVersion(stamp, adapter.stamp?.domain)
   const walked = new Set<string>()
+  const pendingCopies = new Set<string>()
 
   for (const file of listInstalled(
     adapter.installedRoot(target),
@@ -243,16 +261,44 @@ export function planSync(adapter: SyncAdapter, target: string): SyncPlan {
     if (source === undefined || !existsSync(source)) {
       if (adapter.ownsInstalledRoot !== true) {
         entries.push(misplacedOrphan(adapter, target, file))
-      } else if (newerInstall !== undefined) {
+        continue
+      }
+
+      if (newerInstall !== undefined) {
         entries.push(heldForNewerInstall(file, newerInstall))
-      } else {
+        continue
+      }
+
+      const successor = adapter.locateSuccessor?.(file, target)
+      if (successor === undefined) {
         entries.push({
           state: 'retired',
           rel: file.rel,
           notice: `${file.rel} (no longer shipped by the toolkit, removing)`,
         })
         changes.push({ kind: 'delete', dest: file.path, rel: file.rel })
+        continue
       }
+
+      const destRel = relative(target, successor.dest)
+      entries.push({
+        state: 'renamed',
+        rel: file.rel,
+        notice: renamedNotice(file, destRel, attribute(hashes, file)),
+      })
+
+      // A second predecessor of one successor, or a successor the target
+      // already holds, still loses its old file but must not overwrite.
+      if (!existsSync(successor.dest) && !pendingCopies.has(successor.dest)) {
+        pendingCopies.add(successor.dest)
+        changes.push({
+          kind: 'copy',
+          source: successor.source,
+          dest: successor.dest,
+          rel: destRel,
+        })
+      }
+      changes.push({ kind: 'delete', dest: file.path, rel: file.rel })
       continue
     }
 
@@ -470,6 +516,8 @@ function report(adapter: SyncAdapter, plan: SyncPlan): void {
       logWarn(`${entry.rel} (locally customized)`)
     else if (entry.state === 'retired')
       logWarn(entry.notice ?? `${entry.rel} (no longer shipped by the toolkit)`)
+    else if (entry.state === 'renamed')
+      logWarn(entry.notice ?? `${entry.rel} (renamed by the toolkit)`)
     else if (entry.state === 'stranded')
       logWarn(`${entry.rel} (installed here by an older toolkit, now moved)`)
     else if (entry.state === 'missing')
@@ -617,6 +665,22 @@ function newerInstallingVersion(
   return { stamped, running }
 }
 
+/**
+ * The new name gets the toolkit's source rather than the old file's content,
+ * so a local edit is dropped the way a retire drops one. With no stamp the
+ * edit cannot be proven either way, so the line hedges rather than asserts.
+ */
+function renamedNotice(
+  file: InstalledFile,
+  destRel: string,
+  state: EntryState,
+): string {
+  const base = `${file.rel} (renamed to ${destRel} by the toolkit, moving`
+  if (state === 'customized') return `${base}. Local edits were not carried.)`
+  if (state === 'drifted') return `${base}. Any local edits were not carried.)`
+  return `${base})`
+}
+
 function heldForNewerInstall(
   file: InstalledFile,
   versions: { readonly stamped: string; readonly running: string },

package/src/tasks/archive.ts

@@ -46,6 +46,7 @@ export const ARCHIVE_REFUSALS = [
   'ambiguous',
   'no-outcomes',
   'open-outcomes',
+  'earlier-slice',
   'bad-input',
 ] as const
 
@@ -235,12 +236,19 @@ export function readOutcomes(text: string): TaskOutcomes {
 
 /**
  * Reads the `Pull request:` line `git-pr` writes when a pull request opens.
- * The number is a bare `#NNN` the way `Issue:` is, since neither is a path and
- * a full URL would write the remote into a gitignored file.
+ * Each number is a bare `#NNN` the way `Issue:` is, since neither is a path and
+ * a full URL would write the remote into a gitignored file. A task shipped in
+ * slices lists one per slice, oldest first, so the line reads as a list. A line
+ * carrying anything besides that list reads as naming none, rather than as the
+ * numbers that happened to parse.
  */
-export function readPullRequest(text: string): number | undefined {
-  const match = /^Pull request:\s*#(\d+)\s*$/m.exec(text)
-  return match ? Number(match[1]) : undefined
+export function readPullRequest(text: string): readonly number[] {
+  const match = /^Pull request:[ \t]*(#\d+(?:[ \t]*,[ \t]*#\d+)*)[ \t]*$/m.exec(
+    text,
+  )
+  if (!match) return []
+
+  return match[1].split(',').map((entry) => Number(entry.trim().slice(1)))
 }
 
 /**
@@ -628,11 +636,13 @@ async function matchByPullRequest(
   const read = await Promise.all(
     stems.map(async (stem) => ({
       stem,
-      number: readPullRequest(await readFile(join(dir, `${stem}.md`), 'utf8')),
+      numbers: readPullRequest(await readFile(join(dir, `${stem}.md`), 'utf8')),
     })),
   )
 
-  return read.filter((entry) => entry.number === number).map(({ stem }) => stem)
+  return read
+    .filter((entry) => entry.numbers.includes(number))
+    .map(({ stem }) => stem)
 }
 
 /**
@@ -748,6 +758,17 @@ export async function archiveTask(
   const from = join(dir, `${stem}.md`)
   const text = await readFile(from, 'utf8')
 
+  // `docs-fold` ticks outcomes at ship time, before the merge, so an earlier
+  // slice merging after the last slice shipped would find every box ticked
+  // while the last slice is still open. Only the last number closes the task.
+  const last = readPullRequest(text).at(-1)
+  if (selector.kind === 'pull-request' && last !== selector.number) {
+    return refuse(
+      'earlier-slice',
+      `${stem} lists #${last} after #${selector.number}, so the task closes when #${last} merges.`,
+    )
+  }
+
   const { open, closed, cut } = readOutcomes(text)
 
   if (open.length > 0) {

package/src/tasks/record.ts

@@ -10,6 +10,7 @@ import {
   OUTCOME_PATTERN,
   planLine,
   readPlanTarget,
+  readPullRequest,
   tasksDir,
 } from '@/tasks/archive'
 
@@ -49,7 +50,7 @@ export type RecordSelector =
   | { readonly kind: 'stem'; readonly stem: string }
   | { readonly kind: 'plan'; readonly plan: string }
 
-export type LineAction = 'added' | 'corrected' | 'unchanged'
+export type LineAction = 'added' | 'appended' | 'corrected' | 'unchanged'
 
 export interface PullRequestRecorded {
   readonly ok: true
@@ -101,9 +102,10 @@ function planKey(reference: string): string {
 
 /**
  * Places the `Pull request:` line under the origin lines the task already
- * carries, and corrects the number in place when the line exists. A task with
- * no origin line takes it under the H1, which is the only other anchor the
- * board format guarantees.
+ * carries. A task shipped in slices lists every pull request, so a new number
+ * appends to an existing line rather than replacing it, and a line that does
+ * not read as a list is replaced whole. A task with no origin line takes it
+ * under the H1, which is the only other anchor the board format guarantees.
  */
 export function writePullRequestLine(
   text: string,
@@ -114,9 +116,14 @@ export function writePullRequestLine(
   const existing = lines.findIndex((entry) => entry.startsWith('Pull request:'))
 
   if (existing !== -1) {
-    if (lines[existing] === line) return { text, action: 'unchanged' }
-    lines[existing] = line
-    return { text: lines.join('\n'), action: 'corrected' }
+    const listed = readPullRequest(lines[existing])
+    if (listed.includes(number)) return { text, action: 'unchanged' }
+    if (listed.length === 0) {
+      lines[existing] = line
+      return { text: lines.join('\n'), action: 'corrected' }
+    }
+    lines[existing] = `${lines[existing].trimEnd()}, #${number}`
+    return { text: lines.join('\n'), action: 'appended' }
   }
 
   const origin = lastOriginLine(lines)
@@ -143,8 +150,8 @@ function lastOriginLine(lines: readonly string[]): number | undefined {
 }
 
 /**
- * Places the `Plan:` line right after the H1, mirroring
- * `writePullRequestLine`'s add/correct/unchanged shape. `Plan:` is the first
+ * Places the `Plan:` line right after the H1, and corrects the target in place
+ * when the line exists, since a task runs under one plan. `Plan:` is the first
  * origin line a task carries, so it anchors on the heading itself rather than
  * on the last origin line above it.
  */

package/src/tasks/validate.ts

@@ -1071,7 +1071,9 @@ async function checkCitedTask(
   const { open, closed } = readOutcomes(text)
   if (open.length > 0 || closed.length === 0) return nothing()
 
-  const pullRequest = readPullRequest(text)
+  // The last number is the newest slice, and an earlier one closed without
+  // merging never lands, so only the last says whether the work reached trunk.
+  const pullRequest = readPullRequest(text).at(-1)
   if (pullRequest === undefined) {
     return untestedRow(
       group,

package/standards/tasks.md

@@ -173,6 +173,8 @@ Add no third heading. Status stays inline on an outcome rather than becoming an
 
 Size the outcomes so one pull request closes all of them. A task whose outcomes span two pull requests ships the first half and leaves the rest open, with nothing recording which outcomes the merged work covered, so the board reads as in-progress work that no branch is carrying. Split the task before handing it off rather than after. This is what `## Archiving` below depends on, since a task closes whole or not at all.
 
+A sliced task is the one allowed exception: a task the operator decided to ship across several pull requests on purpose, one slice each. Its `Pull request:` line lists every slice, so the board records which merged work covered which outcomes, and it closes whole when the last slice's merge finds every outcome ticked.
+
 Prefix the H1 with the `vX.Y:` phase label, then a short title whose form depends on the task type:
 
 - Feature: an outcome describing what the user can now do
@@ -227,15 +229,15 @@ A project that archived plans before the folder nested under `.canon/plans/` hol
 
 One plan per task. A plan cited by two tasks is a misfile rather than a shape to design for, which is why the sweep counts citations before archiving: the count is a guard against the misfile stranding a pointer, not support for the shape.
 
-`canon tasks plan-link <task> <plan>` writes or corrects the `Plan:` line, mirroring how `canon tasks pull-request` writes its own. `plan-feature` calls it right after the plan file lands, when an existing task names the feature, so the line is a mechanical write rather than hand-edited markdown.
+`canon tasks plan-link <task> <plan>` writes or corrects the `Plan:` line. `plan-feature` calls it right after the plan file lands, when an existing task names the feature, so the line is a mechanical write rather than hand-edited markdown.
 
 `Groundwork:` points at `../groundwork/<slug>/`, the folder `plan-groundwork` fills. It names the surface it points at the way `Plan:` does. Use this key alone. `Research record` and `Decision record` are earlier spellings of the same thing and both convert to it.
 
 `Intake:` points at `../intake/<slug>/`, the folder an intake pass fills. Use it rather than `Groundwork:`, because a groundwork track measures one question in depth while an intake dispositions many across a tree, and one key covering both loses which kind of pass produced the task. The line names the folder rather than an item inside it. A task routinely promotes several items at once, so an anchored line would name one and drop the rest, and the item numbers belong in that task's `## Findings`.
 
-`Pull request:` records which pull request carries the task's work, as a bare `#NNN` the way `Issue:` does. It is not an origin, so a task without one is well-formed. `git-pr` writes it when a pull request opens, which is the one step that always runs whether the chain drives it or a person does.
+`Pull request:` records which pull requests carry the task's work, each as a bare `#NNN` the way `Issue:` does. It lists every pull request that shipped part of the task, oldest first and separated by commas, as in `Pull request: #NNN, #NNN`, and a task shipped whole lists one. It is not an origin, so a task without one is well-formed. `git-pr` writes it when a pull request opens, which is the one step that always runs whether the chain drives it or a person does, and appends to the line rather than replacing it.
 
-The line is what lets a merge close its own task. Every merge on `main` is a squash carrying the number in its subject, so the number survives where a branch name does not, and `canon tasks archive --pull-request <n>` resolves the task from it. Without the line the board can only be swept blind, and a blind sweep cannot tell a shipped task from an abandoned one. One task, one pull request: two tasks naming the same number refuse to archive rather than both moving.
+The line is what lets a merge close its own task. Every merge on `main` is a squash carrying the number in its subject, so the number survives where a branch name does not, and `canon tasks archive --pull-request <n>` finds the task by any number the line lists and archives it only on the last, since outcomes are ticked at ship time and an earlier slice can merge after the last one shipped. Without the line the board can only be swept blind, and a blind sweep cannot tell a shipped task from an abandoned one. One pull request, one task: two tasks naming the same number refuse to archive rather than both moving.
 
 ## What goes in
 

package/governance/rules/core/091-channel.md

@@ -1,13 +0,0 @@
----
-description: The addressing and timing a session holding neither role-worker nor role-planner owes when it must message whoever dispatched it
----
-
-# Channel standards
-
-## A session holding neither role
-
-- Resolve the addressee at send time through `canon sessions list --json`, keyed on the id or branch the dispatcher named at launch, never by name prefix. A name is derived from what a session turns out to be doing and goes stale before a build finishes.
-- Send a block out as a message before it becomes an interactive prompt. A session already waiting on input never reaches the tool round that drains an inbound message, so an answer relayed afterwards arrives under the open question and changes nothing.
-- Leave the message content, and which transition earns one, to whatever dispatched this session. Both are task-specific and already stated where they apply.
-- A session holding `canon:role-worker` or `canon:role-planner` follows that body's own addressee ladder instead, stated in its own `## The channel` section. This rule states what neither role leaves stated elsewhere, not a replacement for either ladder.
-- Report it rather than proceeding silently when neither skill resolves to check against. Both ship with the plugin and this rule ships with the CLI, so a project that installed governance alone does not have them.