@erclx/canon 4.121.0 → 4.122.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,7 +167,7 @@ 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.
 
@@ -172,7 +175,7 @@ The chain ends at capture, and review is run on its own.
 
 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.
 
-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/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.122.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/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/migrate/skill-names.ts

@@ -21,13 +21,18 @@ import { defineRenameRules, type RenameRules } from '@/migrate/rename'
  * reading in sequence with `draft-screencast` as one three-step pipeline with
  * no prefix forcing that reading.
  *
- * One row renames a skill rather than retiring a prefix. `ui-test` became
+ * Two rows rename a skill rather than retiring a prefix. `ui-test` became
  * `ui-checklist` when the skill stopped writing tests and shrank to the
  * checklist a reviewer reads, so the old name described a job it no longer
  * does. `claude-ui-test` is retargeted onto the same destination rather than
  * left pointing at the retired name, which lands a target on the oldest
  * spelling in one pass instead of two.
  *
+ * `docs-fold` became `context-fold` because the skill folds a session into the
+ * context entries, the canonical records, and the task board, while "docs" in
+ * its name collided with `docs-sync`, which owns `docs/`. `claude-docs` is
+ * retargeted onto `context-fold` for the same reason `claude-ui-test` was.
+ *
  * Every name takes two words. Ten of these would have landed as a bare single
  * word under a plain strip, and a bare word such as `review` or `docs` is a
  * substring of ordinary prose with no token left for a later sweep to find.
@@ -47,7 +52,8 @@ export const SKILL_NAME_MAP: Readonly<Record<string, string>> = {
   'claude-autoship': 'auto-ship',
   'claude-design-extract': 'design-extract',
   'claude-diagram': 'draft-diagram',
-  'claude-docs': 'docs-fold',
+  'claude-docs': 'context-fold',
+  'docs-fold': 'context-fold',
   'claude-feature': 'plan-feature',
   'claude-groundwork': 'plan-groundwork',
   'claude-intake': 'plan-intake',
@@ -105,6 +111,11 @@ export const SKILL_NAME_MAP: Readonly<Record<string, string>> = {
  * what shipped or what a session ran under whatever name was current then, so
  * rewriting one makes it testify to a release or a run that never happened.
  *
+ * The pointer left at `docs-fold` is excluded because it exists to answer under
+ * the old name, so a later run would move it onto the skill it points at. The
+ * exclusion is only safe once the real body has moved, since excluding the path
+ * ahead of the first sweep leaves that body behind.
+ *
  * The record archives need no entry here. They are gitignored, so the tracked
  * listing every sweep reads never reaches them.
  */
@@ -117,5 +128,7 @@ export const SKILL_NAME_RULES: RenameRules = defineRenameRules({
     'CHANGELOG.md',
     'src/migrate/skill-names.ts',
     'src/migrate/skill-names.test.ts',
+    'claude/skills/docs-fold/SKILL.md',
+    'claude/skills/docs-fold/REQUIREMENT.md',
   ],
 })