@erclx/canon 4.121.0 → 4.123.0

package/docs/workflow/ai-workflow.md

@@ -55,11 +55,12 @@ One session works for most features. Prefer splitting across two sessions only w
 Work in Claude Code directly. It reads `CLAUDE.md` automatically and has full file access, no pasting needed.
 
 - When the input is a pile of findings rather than one feature, invoke `canon:plan-intake` first. It files the dump into `.canon/intake/<nn>-<slug>/`, one item per finding carrying a problem measured against the tree, a proposed fix, and a verdict, then names which items are plan-ready, which need measuring, and which are already settled.
+- When the backlog has grown past what anyone rereads, invoke `canon:backlog-triage`. It files one item per backlog row into an intake folder, suggesting decline, archive, keep, or promote and leaning toward decline, and once `canon:plan-intake-answer` has taken your answers, a second run applies the approved verdicts through the task verbs.
 - When the current state is unmeasured and more than one approach is live, invoke `canon:plan-groundwork` first. It opens a track folder under `.canon/groundwork/<nn>-<slug>/` and ends in a decision, which may be to do nothing. Skip it when the approach is already settled.
 - Invoke `canon:plan-feature` to scan for code-level conflicts and ambiguities, confirm approach before proceeding
 - Implement the feature, then Claude Code runs the commands defined in `CLAUDE.md`, fixes failures, and iterates until all pass
 - For UI changes, invoke `canon:ui-checklist` to write what a reviewer has to look at and name any behavior shipping without a test
-  End the session once the feature works and tests pass. Invoke `canon:docs-fold` to capture any decisions made during implementation before closing.
+  End the session once the feature works and tests pass. Invoke `canon:context-fold` to capture any decisions made during implementation before closing.
 
 The routing test is whether the repository can answer an item today. A session grepping handles the yes, and a groundwork track handles the no.
 
@@ -115,11 +116,13 @@ A person points it at a private repository once and both verbs refuse until they
 
 `canon records prune-tmp` reports scratch under `.canon/tmp` nobody has touched inside an age window, and deletes it only with `--write`. A `tmp/handoff/` folder and the live `tmp/pr/poll/` baseline are never offered, since a reader deletes a handoff once it is read and a poll baseline is state a session still needs. See [records](../agents/records.md) for the candidate shapes and the exit codes.
 
+`canon records stale memory` reads the memory pen as a review queue. It names each entry due for review, meaning one carrying no `reviewed` date or one older than 30 days, and every backticked path an entry cites that the tree no longer holds. Due entries come first, with the ones citing a missing path ahead of the rest, so a review takes the first batch rather than the whole pen. It writes nothing. See [records stale](../agents/records-stale.md) for how a path is read and the refusals.
+
 A plan that ships is archived, never deleted. `canon tasks archive` moves it to `.canon/plans/archive/` alongside the task it belonged to and retargets that task's `Plan:` line at the new location, so a completed task still leads to the reasoning behind it. An archive sits inside the record folder it archives rather than beside it, so one ignore entry and one backed-folder entry cover a record and everything it has retired. The folder is gitignored, which is why a deleted plan had no recovery path. A plan cited by more than one task stays put until the last of them closes, since moving it early would strand every other pointer.
 
-A branch review report takes the other route and is swept rather than archived. `review-branch` writes it flat into `.canon/review/` as `branch-<slug>.md`, the session addressing it reads it once, and the durable record of what a review found is the comment `review-pr` posts on the pull request, so `docs-fold` deletes any report whose branch is gone. The body that writes a report owns how long it lives, which leaves the shipping branch's own report on disk through the run that cites it and collects it a branch later. What that loses is a local-only review on a branch that never opened a pull request, which is why the report says so where a reader meets it.
+A branch review report takes the other route and is swept rather than archived. `review-branch` writes it flat into `.canon/review/` as `branch-<slug>.md`, the session addressing it reads it once, and the durable record of what a review found is the comment `review-pr` posts on the pull request, so `context-fold` deletes any report whose branch is gone. The body that writes a report owns how long it lives, which leaves the shipping branch's own report on disk through the run that cites it and collects it a branch later. What that loses is a local-only review on a branch that never opened a pull request, which is why the report says so where a reader meets it.
 
-`canon:docs-fold` decides which task closed by reading the diff rather than the conversation. It resolves a merge base against `origin/main`, unions the committed diff with the working tree and untracked files, then matches unchecked outcomes on the board against what shipped. A task that shipped without ever being discussed still gets marked. Requirements, architecture, and design stay session-sourced, because a diff cannot carry a judgment.
+`canon:context-fold` decides which task closed by reading the diff rather than the conversation. It resolves a merge base against `origin/main`, unions the committed diff with the working tree and untracked files, then matches unchecked outcomes on the board against what shipped. A task that shipped without ever being discussed still gets marked. Requirements, architecture, and design stay session-sourced, because a diff cannot carry a judgment.
 
 `.canon/tasks/` is gitignored and resolves at the main worktree root, so every session shares one board. One file per task is what keeps concurrent sessions from overwriting each other, since a gitignored board has no history to recover a lost write from. Its `index.md` is generated by a hook rather than by `bun run check`, because the whole-repo index walk skips gitignored folders.
 
@@ -164,15 +167,15 @@ The list stays written in the skill body as the fallback for a target whose inst
 
 #### Memory in the chain
 
-`git-ship` runs its verify gate and then opens on `memory-capture`, which sends what the session learned to the surface that owns it. `autoship` reaches the same step by invoking that skill at its Step 8 rather than restating the order. A fact about a domain carrying an entry in `canon/context/index.md` is routed to that entry, and `docs-fold` folds it in on the next step, so it ships in the same pull request. Anything no entry owns stays a file in `.canon/memory/`.
+`git-ship` runs its verify gate and then opens on `memory-capture`, which sends what the session learned to the surface that owns it. `autoship` reaches the same step by invoking that skill at its Step 8 rather than restating the order. A fact about a domain carrying an entry in `canon/context/index.md` is routed to that entry, and `context-fold` folds it in on the next step, so it ships in the same pull request. Anything no entry owns stays a file in `.canon/memory/`.
 
 Capture leads rather than trails because a routed fact edits a tracked file, which has to reach the branch before the commit steps run.
 
-The chain ends at capture, and review is run on its own.
+The chain ends at capture, and review is run on its own. Capture closes with a line naming `/canon:memory-review` once `canon records stale memory` counts 25 or more entries due, and says nothing below that.
 
-Run `memory-review` standalone to curate the whole pen. An entry it retires moves to `.canon/memory/archive/` rather than being deleted, since a bulk pass has no undo.
+Run `memory-review` standalone to curate the pen a batch at a time. Each pass takes the first 25 due entries in the order the stale verb reports, opening on those citing a path the tree no longer holds, and a named list overrides that order. An entry it retires moves to `.canon/memory/archive/` rather than being deleted, since a bulk pass has no undo. An entry it keeps is stamped with a `reviewed` date, which takes it out of the queue for 30 days.
 
-The receipt is collected once every item on it has been decided, and it survives untouched while any item is still pending. Whichever runs first takes it: Apply collects the receipt it has resolved, and `docs-fold` scans the folder on every shipped branch for one an earlier session left behind. Before the file goes, each declined item is folded into the entry it was about, since a promotion survives in its target and in git while a decline is recorded nowhere else. `canon standards memory` states what a fold writes and which entry types take one.
+The receipt is collected once every item on it has been decided, and it survives untouched while any item is still pending. Whichever runs first takes it: Apply collects the receipt it has resolved, and `context-fold` scans the folder on every shipped branch for one an earlier session left behind. Before the file goes, each declined item is folded into the entry it was about, since a promotion survives in its target and in git while a decline is recorded nowhere else. `canon standards memory` states what a fold writes and which entry types take one.
 
 ### UI polish
 
@@ -211,16 +214,17 @@ This section is the corpus the coverage claim is measured against: every name `c
 
 ### Decide what to build
 
-| Skill                      | When to use                                                                     |
-| -------------------------- | ------------------------------------------------------------------------------- |
-| `canon:plan-intake`        | When the input is a pile of findings rather than one feature                    |
-| `canon:plan-intake-answer` | When an intake folder holds unread slots waiting on your decision               |
-| `canon:plan-groundwork`    | When the state is unmeasured and more than one approach is live                 |
-| `canon:decision-escalate`  | When open decisions turn on your preference and want batching into one set      |
-| `canon:draft-and-pick`     | When the call is taste and wants several candidates rendered side by side       |
-| `canon:task-board`         | When a decided item needs a file on the board, or a shipped one needs archiving |
-| `canon:plan-feature`       | When the approach is settled and the next step is a plan                        |
-| `canon:codebase-layout`    | When a plan or change adds a file and you need to decide which folder holds it  |
+| Skill                      | When to use                                                                       |
+| -------------------------- | --------------------------------------------------------------------------------- |
+| `canon:plan-intake`        | When the input is a pile of findings rather than one feature                      |
+| `canon:plan-intake-answer` | When an intake folder holds unread slots waiting on your decision                 |
+| `canon:backlog-triage`     | When the backlog needs pruning, to file a verdict per row and apply approved ones |
+| `canon:plan-groundwork`    | When the state is unmeasured and more than one approach is live                   |
+| `canon:decision-escalate`  | When open decisions turn on your preference and want batching into one set        |
+| `canon:draft-and-pick`     | When the call is taste and wants several candidates rendered side by side         |
+| `canon:task-board`         | When a decided item needs a file on the board, or a shipped one needs archiving   |
+| `canon:plan-feature`       | When the approach is settled and the next step is a plan                          |
+| `canon:codebase-layout`    | When a plan or change adds a file and you need to decide which folder holds it    |
 
 ### Build the feature
 
@@ -249,17 +253,18 @@ This section is the corpus the coverage claim is measured against: every name `c
 
 ### Ship it
 
-| Skill                  | When to use                                                                           |
-| ---------------------- | ------------------------------------------------------------------------------------- |
-| `canon:git-ship`       | To run the whole post-feature chain from the verify gate through open PR              |
-| `canon:memory-capture` | First skill in that chain, to route what the session learned to the surface owning it |
-| `canon:docs-fold`      | When decisions diverged from the plan, or a shipped task needs its outcomes marked    |
-| `canon:docs-sync`      | When a change since main left `README.md` or `docs/` stale                            |
-| `canon:git-stage`      | When the staged set spans several concerns and wants one commit each                  |
-| `canon:git-commit`     | When the staged set is one concern, or was staged hunk by hand                        |
-| `canon:git-branch`     | When a branch name needs generating or renaming to conventional form                  |
-| `canon:git-pr`         | When a pull request needs a title and body written from the diff                      |
-| `canon:memory-review`  | When the pen has grown, to propose where each entry belongs                           |
+| Skill                  | When to use                                                                                       |
+| ---------------------- | ------------------------------------------------------------------------------------------------- |
+| `canon:git-ship`       | To run the whole post-feature chain from the verify gate through open PR                          |
+| `canon:memory-capture` | First skill in that chain, to route what the session learned to the surface owning it             |
+| `canon:context-fold`   | When decisions diverged from the plan, or a shipped task needs its outcomes marked                |
+| `canon:docs-fold`      | Never on purpose. A pointer at the old name that names `context-fold` <!-- canon-keep-retired --> |
+| `canon:docs-sync`      | When a change since main left `README.md` or `docs/` stale                                        |
+| `canon:git-stage`      | When the staged set spans several concerns and wants one commit each                              |
+| `canon:git-commit`     | When the staged set is one concern, or was staged hunk by hand                                    |
+| `canon:git-branch`     | When a branch name needs generating or renaming to conventional form                              |
+| `canon:git-pr`         | When a pull request needs a title and body written from the diff                                  |
+| `canon:memory-review`  | When the pen has grown, to propose where each entry belongs                                       |
 
 ### After the pull request opens
 
@@ -331,7 +336,7 @@ This section is the corpus the coverage claim is measured against: every name `c
 
 Every row answers a question rather than marking a point in a project's life, so a phase above would send a reader to the wrong group.
 
-A learning workspace produces two halves and only one of them leaves. A lesson is worked through once and stays in the workspace, and a reference page or a glossary carries no learner, so it belongs wherever the project already keeps prose on that subject. Asking `canon:teach-workspace` to promote sorts each durable page by who owns its subject, sending an Anthropic-owned subject to the wiki, an internal one to the matching context entry, and everything else, subject-neutral material included, to the public docs. It proposes and waits, because a promoted page is public prose that needs a line naming who owns the subject, and it writes nothing to a destination: each page the operator confirms goes to a handoff file that `canon:docs-fold` folds in from a branch. A project with no wiki folder gets a refusal naming `canon wiki init` rather than a folder it never asked for.
+A learning workspace produces two halves and only one of them leaves. A lesson is worked through once and stays in the workspace, and a reference page or a glossary carries no learner, so it belongs wherever the project already keeps prose on that subject. Asking `canon:teach-workspace` to promote sorts each durable page by who owns its subject, sending an Anthropic-owned subject to the wiki, an internal one to the matching context entry, and everything else, subject-neutral material included, to the public docs. It proposes and waits, because a promoted page is public prose that needs a line naming who owns the subject, and it writes nothing to a destination: each page the operator confirms goes to a handoff file that `canon:context-fold` folds in from a branch. A project with no wiki folder gets a refusal naming `canon wiki init` rather than a folder it never asked for.
 
 ## Feedback routing
 

package/docs/workflow/operating-model.md

@@ -218,7 +218,7 @@ coordination costs more than the change it was too small.
 
 Two tiers hold work at different altitudes.
 
-- Tasks (`.canon/tasks/`): the active few pulled into the current turn, one file each. Gitignored, high churn. Shape governed by `standards/tasks.md`. `priority.md` beside them carries execution order, and `backlog.md` carries what nobody is scheduling.
+- Tasks (`.canon/tasks/`): the active few pulled into the current turn, one file each. Gitignored, high churn. Shape governed by `standards/tasks.md`. `priority.md` beside them carries execution order, and `backlog.md` carries what nobody is scheduling, both shaped by `standards/board.md`.
 - Edits: a few lines, done immediately with no ceremony.
 
 Nothing above these sequences work into versions. Scope is stated in

package/governance/rules/claude/555-tasks.md

@@ -1,5 +1,5 @@
 ---
-description: Route .canon/tasks/ edits to the tasks standard for filenames, frontmatter, and task file format
+description: Route .canon/tasks/ edits to the tasks standard for task files and the board standard for priority.md and backlog.md
 paths:
   - '.canon/tasks/**'
 ---
@@ -9,4 +9,5 @@ paths:
 ## Authority
 
 - Follow the tasks standard for filenames, frontmatter, what belongs, and the task file format. It is the single source. Read it with `canon standards tasks`.
+- Follow the board standard for `priority.md` and `backlog.md`, their readiness groups, and row order. Read it with `canon standards board`.
 - Never hand-edit `.canon/tasks/index.md`. A hook regenerates it from sibling frontmatter.

package/governance/rules/core/045-memory.md

@@ -7,5 +7,5 @@ description: Keep memory writes scoped to .canon/memory/ and out of context-owne
 ## Writing memory
 
 - Write all memory files to `.canon/memory/`, not `~/.claude/projects/`
-- A fact about a domain goes to that domain's `canon/context/` entry, not to memory. `canon:memory-capture` routes it there and `canon:docs-fold` folds it in. Memory keeps only what no context entry owns. Report it rather than proceeding silently when either skill does not resolve. Both ship with the plugin and this rule ships with the CLI, so a project that installed governance alone does not have them.
+- A fact about a domain goes to that domain's `canon/context/` entry, not to memory. `canon:memory-capture` routes it there and `canon:context-fold` folds it in. Memory keeps only what no context entry owns. Report it rather than proceeding silently when either skill does not resolve. Both ship with the plugin and this rule ships with the CLI, so a project that installed governance alone does not have them.
 - Never delete a memory entry. Retire one by moving it to `.canon/memory/archive/`, which `canon records push` backs. A bulk retire runs through the shell, where no file edit fires a path-scoped rule.

package/package.json

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

package/src/claude/cases/setup.ts

@@ -52,7 +52,7 @@ export const SETUP_CASES: readonly SkillCase[] = [
   },
   // The performing skill wins a phrase naming its operation over the front
   // door's own routing framing, even though canon-operator's description
-  // quotes a phrase near this one. See canon/context/cli/audits.md.
+  // quotes a phrase near this one. See canon/context/cli/audits/routing.md.
   {
     prompt:
       "Whatever the right toolkit command is, get this project's rules installed.",

package/src/claude/cases/workflow.ts

@@ -35,7 +35,13 @@ export const WORKFLOW_CASES: readonly SkillCase[] = [
   },
   {
     prompt:
-      'Bring the internal planning docs under .claude up to date with what we decided this session.',
+      'Fold what we decided this session into the context entries and mark off what shipped on the task board.',
+    expect: 'context-fold',
+  },
+  {
+    prompt:
+      'I typed the old fold skill name and it says it was renamed, where did it go?',
+    // The pointer answers under its old name on purpose. canon-keep-retired
     expect: 'docs-fold',
   },
   {
@@ -104,6 +110,16 @@ export const WORKFLOW_CASES: readonly SkillCase[] = [
       'What should a review of a change look for beyond bugs, and how much evidence does a finding need?',
     expect: 'review-craft',
   },
+  {
+    prompt:
+      'Go through every task sitting in the backlog and tell me which ones are still worth doing.',
+    expect: 'backlog-triage',
+  },
+  {
+    prompt:
+      'Our backlog only ever grows, measure each row and suggest which to decline.',
+    expect: 'backlog-triage',
+  },
   {
     prompt: 'Draft me a script with beats for a screencast recording.',
     expect: 'draft-screencast',
@@ -194,6 +210,11 @@ export const WORKFLOW_CASES: readonly SkillCase[] = [
     prompt: 'Sort through this brain dump and write it up as findings.',
     expect: 'plan-intake',
   },
+  {
+    prompt:
+      'Here are my scattered notes from this week, file each one against the codebase with a verdict.',
+    expect: 'plan-intake',
+  },
   {
     prompt:
       "Go through what's still unanswered in the intake folder and decide.",

package/src/commands/records.ts

@@ -24,6 +24,12 @@ import {
   type SizeOutcome,
   sizeRecords,
 } from '@/records/size'
+import {
+  DEFAULT_REVIEW_DAYS,
+  type StaleEntry,
+  type StaleReport,
+  staleMemory,
+} from '@/records/stale'
 import {
   type Finding,
   type FindingRemedy,
@@ -75,6 +81,13 @@ interface PruneCommandOptions extends ValidateCommandOptions {
   readonly olderThan?: string
 }
 
+interface StaleCommandOptions extends ValidateCommandOptions {
+  readonly days?: string
+}
+
+/** The one kind `stale` reads, since only a memory entry carries a review date. */
+const STALE_KINDS = ['memory'] as const
+
 interface OrdinalCommandOptions extends ValidateCommandOptions {
   readonly claim?: boolean
 }
@@ -247,6 +260,52 @@ export function register(program: Command): void {
       process.exitCode = await runSize(opts)
     })
 
+  records
+    .command('stale')
+    .description(
+      'Report which entries are due for review and which cite paths the tree no longer holds',
+    )
+    .argument('<kind>', `Record folder: ${STALE_KINDS.join(', ')}`)
+    .helpOption('-h, --help', 'Show this help message')
+    .option('--json', 'Add a machine-readable record on stdout')
+    .option(
+      '--days <n>',
+      `Days after a review before an entry is due again (default ${DEFAULT_REVIEW_DAYS})`,
+    )
+    .option('--root <path>', 'Project root, defaulting to the main worktree')
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Reads the top-level entries of the memory folder, never review/, archive/,',
+        'or index.md. An entry is due when it carries no reviewed date, a reviewed',
+        'value that is not a date, or one older than --days. A path is a backticked',
+        'token holding a / and a file extension, resolved against the project root',
+        'after any :line or #heading anchor is stripped. Tokens under .canon/,',
+        'scratch, or worktrees, and any holding a placeholder, glob, variable, or',
+        'elided ... segment, are never reported.',
+        '',
+        'Entries are ordered due first, then those citing a missing path, then the',
+        'longest unreviewed, then by name, so a review takes the first N as a batch.',
+        '',
+        'Exit codes:',
+        '  0  the reading completed, whatever it found',
+        '  1  refused, with the reason on stderr or in the JSON record',
+        '',
+        'It gates nothing and writes nothing. A due entry is a queue position rather',
+        'than a failure, and a missing path is a prompt for the review to judge.',
+        '',
+        'Examples:',
+        '  canon records stale memory',
+        '  canon records stale memory --json',
+        '  canon records stale memory --days 60 --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (kind: string, opts: StaleCommandOptions) => {
+      process.exitCode = await runStale(kind, opts)
+    })
+
   records
     .command('prune-tmp')
     .description('Report scratch nobody has touched in a while, and delete it')
@@ -484,6 +543,93 @@ async function runPruneTmp(opts: PruneCommandOptions): Promise<number> {
   return reportPrune(outcome, emitJson)
 }
 
+async function runStale(
+  kind: string,
+  opts: StaleCommandOptions,
+): Promise<number> {
+  const emitJson = opts.json ?? false
+
+  if (!(STALE_KINDS as readonly string[]).includes(kind)) {
+    return reportRefusal(
+      'canon records stale',
+      {
+        reason: 'unknown-kind',
+        message: `Not a kind stale reads: ${kind}. Expected one of: ${STALE_KINDS.join(', ')}.`,
+      },
+      emitJson,
+    )
+  }
+
+  const days = Number(opts.days ?? DEFAULT_REVIEW_DAYS)
+
+  if (!Number.isInteger(days) || days <= 0) {
+    return reportRefusal(
+      'canon records stale',
+      {
+        reason: 'bad-days',
+        message: `--days must be a positive whole number of days, got ${opts.days}.`,
+      },
+      emitJson,
+    )
+  }
+
+  const root = opts.root ?? (await mainWorktreeRoot())
+  const outcome = await staleMemory(root, days)
+
+  if (!outcome.ok)
+    return reportRefusal('canon records stale', outcome, emitJson)
+
+  if (emitJson) {
+    process.stdout.write(`${JSON.stringify(outcome)}\n`)
+    return 0
+  }
+
+  reportStale(outcome)
+  return 0
+}
+
+function staleRow(entry: StaleEntry): string[] {
+  return [
+    entry.name,
+    entry.reviewed ?? (entry.invalidReviewed ? 'invalid' : 'never'),
+    entry.unresolved.join(', '),
+  ]
+}
+
+function reportStale(outcome: StaleReport): void {
+  const due = outcome.entries.filter((entry) => entry.due)
+  const moved = outcome.entries.filter((entry) => entry.unresolved.length > 0)
+
+  intro('canon records stale')
+  logStep('Due')
+
+  if (due.length === 0) {
+    logInfo(`none, every entry reviewed within ${plural(outcome.days, 'day')}`)
+  } else {
+    const headers = ['entry', 'reviewed', 'unresolved']
+    const rows = due.map(staleRow)
+    const widths = headers.map((header, column) =>
+      columnWidth(
+        header,
+        rows.map((row) => row[column]),
+      ),
+    )
+    const render = (cells: readonly string[]): string =>
+      cells
+        .map((cell, column) => cell.padEnd(widths[column]))
+        .join('  ')
+        .trimEnd()
+
+    pipeOutput([render(headers), ...rows.map(render)].join('\n'))
+  }
+
+  logStep('Total')
+  logInfo(
+    `${outcome.due} of ${outcome.total} due, ${moved.length} citing a missing path, in ${outcome.folder}`,
+  )
+  outro()
+}
+
 function pruneRow(entry: PruneUnit): string[] {
   return [
     entry.path,

package/src/commands/sandbox.ts

@@ -350,7 +350,9 @@ function runCheck(
 
   const parsed = parseTarget(target)
   if (parsed === undefined) {
-    logError('Invalid target. Use <category>:<command>, e.g. claude:docs-fold.')
+    logError(
+      'Invalid target. Use <category>:<command>, e.g. claude:context-fold.',
+    )
     outro()
     process.exitCode = 1
     return
@@ -418,7 +420,7 @@ export function register(program: Command): void {
     .description('Check a provisioned sandbox against a scenario expectation')
     .argument(
       '<target>',
-      'Scenario as <category>:<command>, e.g. claude:docs-fold',
+      'Scenario as <category>:<command>, e.g. claude:context-fold',
     )
     .argument('[arm]', 'Named scenario arm, e.g. drift')
     .helpOption('-h, --help', 'Show this help message')
@@ -443,8 +445,8 @@ export function register(program: Command): void {
       [
         '',
         'Examples:',
-        '  canon sandbox check claude:docs-fold drift',
-        '  canon sandbox check claude:docs-fold drift --envelope run.json --json',
+        '  canon sandbox check claude:context-fold drift',
+        '  canon sandbox check claude:context-fold drift --envelope run.json --json',
         '',
         'Exit codes: 0 on pass or unchecked, 1 on failure.',
         'With --strict, unchecked exits 1 as well.',

package/src/commands/tasks.ts

@@ -11,6 +11,7 @@ import {
   type DeclineOutcome,
   declineTask,
   type PlanCitations,
+  type PlanMove,
   planCitations,
 } from '@/tasks/archive'
 import {
@@ -154,9 +155,9 @@ export function register(program: Command): void {
       'after',
       [
         '',
-        'The task carries its plan with it when no other live task cites that',
-        'plan, and the archived task keeps a working Plan: pointer at the new',
-        'path. A plan several tasks share stays where it is.',
+        'The task carries each plan its Plan: line links when no other live',
+        'task cites that plan, and the archived task keeps a working pointer',
+        'at each new path. A plan several tasks share stays where it is.',
         '',
         'The ready folder the task names moves to .canon/ready/archive/ with its',
         'plan, and the Ready: line and the plan path to it are retargeted. A',
@@ -260,6 +261,7 @@ export function register(program: Command): void {
         '',
         'Locations:',
         '  unstated  the task carries no Plan: line',
+        '  several   the Plan: line links more than one plan, named in targets',
         '  live      the target resolves inside .canon/plans/',
         '  archived  the target resolves inside .canon/plans/archive/',
         '  outside   the target resolves somewhere else',
@@ -448,12 +450,14 @@ export function register(program: Command): void {
         '',
         'Exit codes:',
         '  0  the line was added, corrected, or already correct',
-        '  1  refused, with the reason on stderr or in the JSON record',
+        '  1  refused, including several-plans for a line linking more than one',
+        '     plan, with the reason on stderr or in the JSON record',
         '',
         'It writes Plan: [<label>](<target>) right after the H1, corrects the',
-        'target in place when the line exists, and resolves both a bare slug',
-        'and a board-relative path the way canon tasks plan-answers does. Safe',
-        'from a linked worktree, since it resolves the board root in-process.',
+        'target in place when the line exists and names the one it replaced,',
+        'and resolves both a bare slug and a board-relative path the way canon',
+        'tasks plan-answers does. Safe from a linked worktree, since it',
+        'resolves the board root in-process.',
         '',
         'Examples:',
         '  canon tasks plan-link v28.1-trigger-escalation dispatch-answer-gate',
@@ -793,6 +797,7 @@ function reportPlanLink(
         path: relative(root, outcome.path),
         plan: outcome.plan,
         action: outcome.action,
+        replaced: outcome.replaced,
       })}\n`,
     )
     return 0
@@ -801,6 +806,7 @@ function reportPlanLink(
   intro('canon tasks plan-link')
   logStep(outcome.action === 'unchanged' ? 'Already recorded' : 'Recorded')
   logInfo(`${outcome.stem} names plan ${outcome.plan}`)
+  if (outcome.replaced) logInfo(`replaced ${outcome.replaced}`)
   if (outcome.action !== 'unchanged') logAdd(relative(root, outcome.path))
   outro()
 
@@ -975,6 +981,10 @@ function reportCitations(
 function describeCitations(outcome: PlanCitations): string {
   if (outcome.location === 'unstated') return 'carries no Plan: line.'
 
+  if (outcome.location === 'several') {
+    return `links ${outcome.targets.length} plans (${outcome.targets.join(', ')}), so no single plan is the sweep's to settle.`
+  }
+
   if (outcome.location === 'archived') {
     return `points at ${outcome.target}, which an earlier sweep already archived.`
   }
@@ -1396,11 +1406,7 @@ function report(
   logStep('Archived')
   logRemove(relative(root, outcome.from))
   logAdd(relative(root, outcome.to))
-  if (outcome.plan) {
-    logRemove(relative(root, outcome.plan.from))
-    logAdd(relative(root, outcome.plan.to))
-    logInfo('retargeted the Plan: line')
-  }
+  logPlanMoves(outcome.plans, root)
   if (outcome.ready) {
     logRemove(relative(root, outcome.ready.from))
     logAdd(relative(root, outcome.ready.to))
@@ -1414,6 +1420,24 @@ function report(
   return 0
 }
 
+function logPlanMoves(plans: readonly PlanMove[], root: string): void {
+  for (const plan of plans) {
+    logRemove(relative(root, plan.from))
+    logAdd(relative(root, plan.to))
+  }
+  if (plans.length > 0) logInfo('retargeted the Plan: line')
+}
+
+function planMovesFor(
+  plans: readonly PlanMove[],
+  root: string,
+): readonly { readonly from: string; readonly to: string }[] {
+  return plans.map((plan) => ({
+    from: relative(root, plan.from),
+    to: relative(root, plan.to),
+  }))
+}
+
 function recordFor(
   outcome: ArchiveOutcome,
   root: string,
@@ -1434,12 +1458,7 @@ function recordFor(
     to: relative(root, outcome.to),
     priorityRowRemoved: outcome.priorityRowRemoved,
     indexRegenerated: outcome.indexRegenerated,
-    plan: outcome.plan
-      ? {
-          from: relative(root, outcome.plan.from),
-          to: relative(root, outcome.plan.to),
-        }
-      : null,
+    plans: planMovesFor(outcome.plans, root),
     ready: outcome.ready
       ? {
           from: relative(root, outcome.ready.from),
@@ -1537,11 +1556,7 @@ function reportDecline(
   logStep('Declined')
   logRemove(relative(root, outcome.from))
   logAdd(relative(root, outcome.to))
-  if (outcome.plan) {
-    logRemove(relative(root, outcome.plan.from))
-    logAdd(relative(root, outcome.plan.to))
-    logInfo('retargeted the Plan: line')
-  }
+  logPlanMoves(outcome.plans, root)
   if (outcome.priorityRowRemoved) logInfo('cleared the ordering row')
   if (outcome.backlogRowRemoved) logInfo('cleared the backlog row')
   if (outcome.indexRegenerated) logInfo('regenerated index.md')
@@ -1571,11 +1586,6 @@ function declineRecordFor(
     priorityRowRemoved: outcome.priorityRowRemoved,
     backlogRowRemoved: outcome.backlogRowRemoved,
     indexRegenerated: outcome.indexRegenerated,
-    plan: outcome.plan
-      ? {
-          from: relative(root, outcome.plan.from),
-          to: relative(root, outcome.plan.to),
-        }
-      : null,
+    plans: planMovesFor(outcome.plans, root),
   }
 }

package/src/context/classify/extract.ts

@@ -182,7 +182,7 @@ export function sectionAround(
  * requested canonical doc types.
  *
  * Reads the working tree rather than `HEAD`, matching `listChangedFiles`: a
- * `docs-fold` run checking a session's own edits sees them before they are
+ * `context-fold` run checking a session's own edits sees them before they are
  * committed. A file the range deleted contributes nothing, since there is no
  * current section left to read a hunk's chunk against.
  */

package/src/context/classify/ollama.ts

@@ -14,7 +14,7 @@ export const DEFAULT_OLLAMA_BASE_URL = 'http://localhost:11434'
  * 600s ceiling meant for a batch research run, not a per-call budget for an
  * interactive verb. 30s is chosen here as a deviation, wide enough that a
  * shared GPU under another local session's load (measured coexisting at 12GB)
- * still has room, while short enough that a `docs-fold` run does not hang
+ * still has room, while short enough that a `context-fold` run does not hang
  * indefinitely on a backend that stopped responding mid-call.
  */
 export const OLLAMA_TIMEOUT_MS = 30_000

package/src/context/classify/run.ts

@@ -165,7 +165,7 @@ interface ModelLayerPlan {
  * Decides whether the model layer runs, probing reachability before any real
  * call. A configured-but-unreachable backend is a plan the caller reports and
  * falls back from, never a refusal: the groundwork decision reads "warn and
- * continue," and a refused run here would fail `docs-fold` for a reason that
+ * continue," and a refused run here would fail `context-fold` for a reason that
  * has nothing to do with the branch it is checking.
  */
 async function planModelLayer(

package/src/gate/measures.ts

@@ -1242,7 +1242,7 @@ export const pluginManifests: Measure = async (ctx) => {
     return {
       emissions: [],
       unmeasured:
-        'claude is on PATH and claude --version fails, so the install brought down no platform-native binary and no manifest was read. Raise or lower the pinned version at the Install Plugin CLI step in .github/workflows/verify.yml, and record the move in canon/context/ci.md.',
+        'claude is on PATH and claude --version fails, so the install brought down no platform-native binary and no manifest was read. Raise or lower the pinned version at the Install Plugin CLI step in .github/workflows/verify.yml, and record the move in canon/context/ci/checks.md.',
     }
   }
 

package/src/gate/stages.ts

@@ -107,6 +107,7 @@ const TESTS_SCOPE = new RegExp(
     '^vitest\\.config\\.ts$',
     '^tsconfig\\.json$',
     '^package\\.json$',
+    '^commitlint\\.config\\.(js|test\\.ts)$',
     ...TEST_CORPORA_PATTERNS,
   ].join('|'),
 )