@erclx/canon 4.120.0 → 4.122.0

package/src/gate/measures.ts

@@ -438,8 +438,8 @@ export const recordIdempotence: Measure = async (ctx) => {
 }
 
 /**
- * A banned character, word, or spelling is a fact rather than a threshold, so
- * it fails the push while bullet, paragraph, and depth weight stay advisory.
+ * A banned character is a fact rather than a threshold, so it fails the push
+ * while bullet, paragraph, and depth weight stay advisory.
  *
  * The whole corpus is measured rather than the changed files, because a
  * `Do not use` bullet added to a standard bans a token retroactively and no
@@ -453,7 +453,7 @@ export const markdownBans: Measure = async (ctx) => {
   const { exitCode } = await ctx.cli(['markdown', 'audit', '--json'])
 
   if (exitCode === 0) {
-    return { emissions: [info('No banned character, word, or spelling')] }
+    return { emissions: [info('No banned character')] }
   }
 
   if (exitCode === 1) {
@@ -476,7 +476,7 @@ export const markdownBans: Measure = async (ctx) => {
     return {
       emissions: [output(frame.all)],
       failure:
-        'Markdown prose carries a banned character, word, or spelling, or a relative link resolves to nothing on disk. Rewrite the sentence or fix the link, and reach for a code span only where the token is genuinely an identifier under discussion.',
+        'Markdown prose carries a banned character, or a relative link resolves to nothing on disk. Rewrite the sentence or fix the link, and reach for a code span only where the token is genuinely an identifier under discussion.',
     }
   }
 
@@ -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

@@ -97,7 +97,6 @@ export const TEST_CORPORA_PATTERNS = [
   '^standards/markdown\\.md$',
   '^tooling/base/reference\\.md$',
   '^tooling/web/configs/scripts/worktree-port\\.sh$',
-  '^\\.cspell/banned-spellings\\.txt$',
   '^scripts/lib/worktree\\.sh$',
   '^scripts/core/check-ignore-parity\\.sh$',
 ]

package/src/markdown/bans.ts

@@ -10,85 +10,28 @@ import type { BanSets } from '@/markdown/scan'
 const CHARACTERS = ['—', ';'] as const
 
 /**
- * Single lowercase words `markdown.md` bans under `## Language`.
+ * The one closed set the audit measures, owned here rather than harvested
+ * from the standard stating it.
  *
- * A multi-word ban is absent by the same test the character set applies. The
- * standard bans a pattern like `It's not X, it's Y` with a placeholder standing
- * in for the rest of the sentence, so no literal match reaches it and the
- * phrase bans stay a reader's judgment.
- */
-const WORDS = [
-  'seamless',
-  'robust',
-  'powerful',
-  'revolutionary',
-  'enhanced',
-  'allows',
-  'leverage',
-  'simply',
-  'just',
-  'easily',
-  'quickly',
-  'very',
-  'really',
-] as const
-
-/**
- * British spellings of the American examples `markdown.md` lists.
- *
- * The set is carried whole rather than derived from a suffix rule, because a
- * suffix pattern run over prose produced 46 of the 58 false positives measured
- * during intake: `exercises`, `promises`, and `revised` all end in `-ise` and
- * none is a British spelling. Matching whole words reaches none of them.
- *
- * `analyse` is absent because the standard's example is `analyze`, which ends
- * in `-yze` rather than the `-ize` its rule states. The set records what the
- * standard reaches rather than what a reader would extend it to, so adding the
- * spelling here would widen the check past the prose it answers to.
- */
-const SPELLINGS = [
-  'organise',
-  'summarise',
-  'recognise',
-  'behaviour',
-  'colour',
-  'centre',
-] as const
-
-/**
- * The three closed sets the audit measures, owned here rather than harvested
- * from the standards stating them.
- *
- * Parsing the prose was the alternative and it put a parser contract on two
- * documents authored for people, which the prose standard had to carry a
- * paragraph of its own to protect. The sets are a prior an author already
- * knows rather than a filter: measured at `60fc97bf` on 2026-08-19, these 21
- * terms ran across 483 markdown files for a clean exit, and every one of the
- * 70 occurrences of a banned word sat inside the ban list itself or inside an
- * example demonstrating the ban.
- *
- * The set is closed rather than extensible. Enumeration cannot close the gap
- * it aims at, and each addition costs a false-positive class, since `just`,
- * `allows`, and `very` have honest uses no literal match separates. A project
- * wanting its own vocabulary is asking for a different feature than this one.
+ * Parsing the prose was the alternative and it put a parser contract on a
+ * document authored for people. The set is closed rather than extensible,
+ * since a character is the one class a literal match settles. A word is left
+ * to `write-human` as guidance and a spelling to cspell, because a word ban
+ * catches the token and misses the habit behind it.
  */
 export const BAN_SETS: BanSets = {
   characters: CHARACTERS,
-  words: WORDS,
-  spellings: SPELLINGS,
 }
 
 /**
- * Names any set that arrived empty, so a run measuring nothing says so.
+ * Names the set when it arrived empty, so a run measuring nothing says so.
  *
  * Empty is not the same state as finding no hit. A scan with no terms reports
  * a clean file having looked for nothing, which is the silence the audit
- * refused to ship back when a standard could go missing. The sets ship with
- * the package now, so the only way one empties is an edit to this file, and
+ * refused to ship back when a standard could go missing. The set ships with
+ * the package now, so the only way it empties is an edit to this file, and
  * the guard is what keeps that edit loud rather than quiet.
  */
 export function emptyBanSets(sets: BanSets = BAN_SETS): string[] {
-  return (['characters', 'words', 'spellings'] as const).filter(
-    (name) => sets[name].length === 0,
-  )
+  return (['characters'] as const).filter((name) => sets[name].length === 0)
 }

package/src/markdown/gate.ts

@@ -21,7 +21,7 @@ export interface GateInput {
 /**
  * Whether the audit found something that should fail the caller.
  *
- * A banned character, word, or spelling and a relative link resolving to
+ * A banned character and a relative link resolving to
  * nothing on disk are both facts rather than a threshold, so either gates
  * unconditionally and there is no widened mode to reach for. The standards
  * decide what counts as banned, which keeps this answering how many rather

package/src/markdown/scan.ts

@@ -55,20 +55,9 @@ export interface BodyLine {
   readonly text: string
   /** True on a fence delimiter and on every line between one pair. */
   readonly fenced: boolean
-  /**
-   * Which fenced block the line sits in, counted from one, and undefined
-   * outside one. Two blocks written with nothing between them are one
-   * contiguous run of fenced lines, so this is the only field telling them
-   * apart. Counting from one keeps the outside answer from reading as a block.
-   *
-   * The name carries the fence because `block` alone already names a run of
-   * `BodyLine` values in `src/markdown/structure.ts`, and one word meaning both
-   * an aggregate of lines and an index on each line reads as a bug.
-   */
-  readonly fenceBlock: number | undefined
 }
 
-export type BanKind = 'character' | 'word' | 'spelling'
+export type BanKind = 'character'
 
 export interface BanFinding {
   readonly line: number
@@ -80,30 +69,20 @@ export interface BanFinding {
 
 export interface BanSets {
   readonly characters: readonly string[]
-  readonly words: readonly string[]
-  readonly spellings: readonly string[]
 }
 
 /**
- * Marks which lines sit inside a fence without dropping them, and which block
- * each of those lines belongs to.
+ * Marks which lines sit inside a fence without dropping them.
  *
  * Each measure excludes a fence for its own reason and needs a different
  * response. The depth measure skips a fenced line so an example cannot break
  * the run around it, bullet folding treats one as a break so a bullet does not
  * absorb the block below it, and the ban scan ignores it outright. Returning
  * the mark rather than a filtered list is what lets one walk serve all three.
- *
- * The block index answers the consumer that has to decide per block rather
- * than per contiguous run, since two adjacent blocks are indistinguishable
- * through the mark alone. It is counted here because the walk already holds
- * the opening delimiter, and a consumer parsing its own would be the second
- * fence walker this repository consolidated away.
  */
 function markFences(texts: readonly string[], offset: number): BodyLine[] {
   const lines: BodyLine[] = []
   let fence: string | undefined
-  let fenceBlock = 0
 
   for (const [index, text] of texts.entries()) {
     const match = FENCE.exec(text.trim())
@@ -117,15 +96,9 @@ function markFences(texts: readonly string[], offset: number): BodyLine[] {
     } else if (match) {
       fenced = true
       fence = match[1]
-      fenceBlock += 1
     }
 
-    lines.push({
-      number: offset + index + 1,
-      text,
-      fenced,
-      fenceBlock: fenced ? fenceBlock : undefined,
-    })
+    lines.push({ number: offset + index + 1, text, fenced })
   }
 
   return lines
@@ -227,47 +200,12 @@ export function visibleText(text: string): string {
   return visible + drop(text.slice(read))
 }
 
-function escape(term: string): string {
-  return term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-/**
- * Bounds a banned word on a word character or a hyphen either side.
- *
- * `\b` sits after a hyphen, so a banned word ending a hyphenated compound
- * reports from inside it: `allows` came back out of `auto-allows`. A compound
- * is one word to a reader, and the ban is on the word rather than on a morpheme
- * of it. Stripping hyphens before matching was the alternative and it joins the
- * compound into a token neither half reaches.
- *
- * A spelling ban takes `wordBoundary` instead. This is not that rule with a
- * wider fence, since the two bans target different things.
- */
-function bannedWord(term: string): RegExp {
-  return new RegExp(`(?<![\\w-])${escape(term)}(?![\\w-])`, 'gi')
-}
-
 /**
- * Bounds a banned spelling on a word character alone, hyphens included.
+ * Finds every banned character outside a fence, a code span, and a link.
  *
- * A word ban targets the word, so a compound reading as one word is correct.
- * A spelling ban targets the orthography inside it, and a compound is exactly
- * where the orthography still sits: `behaviour-driven` carries the banned
- * spelling as plainly as `behaviour` does, and rejecting a hyphen here would
- * leave the usual spelling of that phrase unreported.
- */
-function bannedSpelling(term: string): RegExp {
-  return new RegExp(`\\b${escape(term)}\\b`, 'gi')
-}
-
-/**
- * Finds every banned term outside a fence, a code span, and a link.
- *
- * A word ban matches in either casing, since the standard states each in
- * lowercase and bans the word rather than a spelling of it. A closed set of
- * whole words separates the check from the pattern that produced most of the
- * intake's false positives: `exercises` and `promises` end in the banned
- * suffix and are not the banned words, and a closed set never reaches them.
+ * Characters are the whole set because a character is the one class a literal
+ * match settles. A word carries honest uses no match separates, which is why
+ * word choice is guidance a reader applies rather than a finding this reports.
  */
 export function scanBans(
   lines: readonly BodyLine[],
@@ -275,19 +213,6 @@ export function scanBans(
 ): BanFinding[] {
   const found: BanFinding[] = []
 
-  const patterns: { kind: BanKind; term: string; pattern: RegExp }[] = [
-    ...bans.words.map((term) => ({
-      kind: 'word' as const,
-      term,
-      pattern: bannedWord(term),
-    })),
-    ...bans.spellings.map((term) => ({
-      kind: 'spelling' as const,
-      term,
-      pattern: bannedSpelling(term),
-    })),
-  ]
-
   for (const line of lines) {
     if (line.fenced) continue
     const text = maskDisplayed(line.text)
@@ -299,12 +224,6 @@ export function scanBans(
         column = text.indexOf(term, column + term.length)
       }
     }
-
-    for (const { kind, term, pattern } of patterns) {
-      for (const match of text.matchAll(pattern)) {
-        found.push({ line: line.number, column: match.index, kind, term })
-      }
-    }
   }
 
   return found.sort((a, b) => a.line - b.line || a.column - b.column)

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',
   ],
 })

package/src/records/stale.ts

@@ -0,0 +1,243 @@
+import { existsSync } from 'node:fs'
+import { readdir, readFile } from 'node:fs/promises'
+import { join, relative } from 'node:path'
+import { parseFrontmatter, readField } from '@/indexes/frontmatter'
+import {
+  CREATION_ROOT,
+  RECORD_ROOTS,
+  recordDir,
+  SCRATCH,
+  spell,
+} from '@/record-root'
+
+/** The window after which a reviewed entry is due again, in days. */
+export const DEFAULT_REVIEW_DAYS = 30
+
+const DAY_MS = 24 * 60 * 60 * 1000
+
+const MEMORY_INDEX = 'index.md'
+
+export interface StaleEntry {
+  /** The filename stem, which is what a review names an entry by. */
+  readonly name: string
+  readonly category: string | null
+  /** `YYYY-MM-DD`, or null when the entry carries no readable review date. */
+  readonly reviewed: string | null
+  /** The raw value of a `reviewed` field that is not a date, present only then. */
+  readonly invalidReviewed?: string
+  readonly due: boolean
+  /** Backticked paths the entry cites that the project root does not hold. */
+  readonly unresolved: readonly string[]
+}
+
+export interface StaleReport {
+  readonly ok: true
+  readonly root: string
+  /** The pen read, relative to the root. */
+  readonly folder: string
+  readonly days: number
+  readonly total: number
+  readonly due: number
+  readonly entries: readonly StaleEntry[]
+}
+
+export const STALE_REFUSALS = ['no-folder'] as const
+
+export type StaleRefusal = (typeof STALE_REFUSALS)[number]
+
+export interface StaleRefused {
+  readonly ok: false
+  readonly reason: StaleRefusal
+  readonly message: string
+}
+
+export type StaleOutcome = StaleReport | StaleRefused
+
+const REVIEWED_FIELD = /^reviewed:[ \t]*(.*?)[ \t]*$/m
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/
+const RAW_FRONTMATTER = /^---\n([\s\S]*?)\n---/
+
+/**
+ * Reads `reviewed` off the raw block rather than the parsed fields, for the
+ * reason `hasOpeningDate` in the validator gives: a YAML parser resolves a
+ * bare `YYYY-MM-DD` to a date on one schema and a string on another.
+ *
+ * A value that is not a calendar date reads as never reviewed and is carried
+ * back so the review can see it, rather than throwing over one hand edit.
+ */
+function readReviewed(
+  text: string,
+): Pick<StaleEntry, 'reviewed' | 'invalidReviewed'> {
+  const block = RAW_FRONTMATTER.exec(text)?.[1]
+  const match = block ? REVIEWED_FIELD.exec(block) : null
+  if (!match) return { reviewed: null }
+
+  const value = match[1].replace(/^(['"])(.*)\1$/, '$2')
+  const parsed = Date.parse(`${value}T00:00:00Z`)
+  const isDate =
+    ISO_DATE.test(value) &&
+    Number.isFinite(parsed) &&
+    new Date(parsed).toISOString().slice(0, 10) === value
+
+  return isDate
+    ? { reviewed: value }
+    : { reviewed: null, invalidReviewed: value }
+}
+
+/**
+ * Tokens that name a session record, scratch at either root, or a checkout,
+ * none of which a tree commits. The scratch spellings come from `spell` so the
+ * legacy root's variant is stated in one place.
+ */
+const UNTRACKED_PREFIXES = [
+  ...RECORD_ROOTS.map((at) => `${at}/${spell(at, SCRATCH)}/`),
+  `${CREATION_ROOT}/`,
+  '.claude/worktrees/',
+]
+
+const INLINE_CODE = /`([^`\n]+)`/g
+const LINE_ANCHOR = /:\d+(?:[-:]\d+)*$/
+const FILE_EXTENSION = /\.[A-Za-z0-9]+$/
+
+/**
+ * Reduces one backticked token to the repository path it cites, or undefined
+ * when it cites none.
+ *
+ * A path is a token carrying a `/` and ending in a file extension once any
+ * line or heading anchor is stripped. A placeholder, an elided path, a glob, a
+ * variable, a URL, and a path outside the project all look like paths and
+ * resolve against nothing in the tree, so each is dropped rather than reported.
+ */
+function toCitedPath(token: string): string | undefined {
+  if (/\s/.test(token) || token.includes('://')) return undefined
+  if (/[<*{$]/.test(token) || token.includes('...')) return undefined
+  if (/^(?:\/|~|\.\.\/)/.test(token)) return undefined
+
+  const path = token
+    .replace(/#.*$/, '')
+    .replace(LINE_ANCHOR, '')
+    .replace(/^\.\//, '')
+
+  if (!path.includes('/') || !FILE_EXTENSION.test(path)) return undefined
+  if (UNTRACKED_PREFIXES.some((prefix) => path.startsWith(prefix)))
+    return undefined
+
+  return path
+}
+
+/** Every distinct repository path a body cites in inline code, in order. */
+export function citedPaths(body: string): string[] {
+  const paths = new Set<string>()
+
+  for (const match of body.matchAll(INLINE_CODE)) {
+    const path = toCitedPath(match[1])
+    if (path) paths.add(path)
+  }
+
+  return [...paths]
+}
+
+function isDue(reviewed: string | null, days: number, now: number): boolean {
+  if (reviewed === null) return true
+  return now - Date.parse(`${reviewed}T00:00:00`) > days * DAY_MS
+}
+
+async function readEntry(
+  root: string,
+  dir: string,
+  file: string,
+  days: number,
+  now: number,
+): Promise<StaleEntry> {
+  const text = (await readFile(join(dir, file), 'utf8')).replaceAll(
+    '\r\n',
+    '\n',
+  )
+  const frontmatter = parseFrontmatter(text)
+  const review = readReviewed(text)
+  const body = text.slice(RAW_FRONTMATTER.exec(text)?.[0].length ?? 0)
+
+  return {
+    name: file.replace(/\.md$/, ''),
+    category: readField(frontmatter, 'category') ?? null,
+    ...review,
+    due: isDue(review.reviewed, days, now),
+    unresolved: citedPaths(body).filter(
+      (path) => !existsSync(join(root, path)),
+    ),
+  }
+}
+
+/**
+ * The order a review takes a batch in: due entries first, and among them the
+ * ones citing a tree that moved, then the longest unreviewed, then by name so
+ * two runs over one pen agree.
+ */
+function compareEntries(left: StaleEntry, right: StaleEntry): number {
+  if (left.due !== right.due) return left.due ? -1 : 1
+
+  const leftMoved = left.unresolved.length > 0
+  const rightMoved = right.unresolved.length > 0
+  if (leftMoved !== rightMoved) return leftMoved ? -1 : 1
+
+  if (left.reviewed !== right.reviewed) {
+    if (left.reviewed === null) return -1
+    if (right.reviewed === null) return 1
+    return left.reviewed < right.reviewed ? -1 : 1
+  }
+
+  return left.name.localeCompare(right.name)
+}
+
+/**
+ * Reports each memory entry's review state and the paths it cites that the
+ * project no longer holds, ordered so a caller takes the first N as a batch.
+ *
+ * It reads the top level of the pen alone. `review/` holds receipts and
+ * `archive/` holds retirements, and neither is an entry a review would queue.
+ * Paths resolve against the project root rather than the entry's folder, since
+ * an entry cites the tree it was written about. It reports and never writes.
+ *
+ * `now` is a parameter so a test can pin the window against fixture dates.
+ */
+export async function staleMemory(
+  root: string,
+  days: number = DEFAULT_REVIEW_DAYS,
+  now: number = Date.now(),
+): Promise<StaleOutcome> {
+  const dir = recordDir(root, 'memory')
+
+  if (!existsSync(dir)) {
+    return {
+      ok: false,
+      reason: 'no-folder',
+      message: `No memory folder at ${dir}, so there are no entries to read.`,
+    }
+  }
+
+  const listed = await readdir(dir, { withFileTypes: true })
+  const files = listed
+    .filter(
+      (entry) =>
+        entry.isFile() &&
+        entry.name.endsWith('.md') &&
+        entry.name !== MEMORY_INDEX,
+    )
+    .map((entry) => entry.name)
+
+  const entries = (
+    await Promise.all(
+      files.map((file) => readEntry(root, dir, file, days, now)),
+    )
+  ).toSorted(compareEntries)
+
+  return {
+    ok: true,
+    root,
+    folder: relative(root, dir),
+    days,
+    total: entries.length,
+    due: entries.filter((entry) => entry.due).length,
+    entries,
+  }
+}

package/src/sandbox/expect.ts

@@ -178,7 +178,7 @@ function contentArray(value: unknown): ContentAssertion[] {
     // A bare key written below a `[[content]]` header belongs to that table in
     // TOML, not to the document, so a declaration listing `manual` or
     // `max_turns` after its content blocks parses clean and silently asserts
-    // neither. The arm then named `claude/ui-test`, now
+    // neither. The arm then named `claude/ui-test` (canon-keep-retired), now
     // `claude/ui-checklist`, shipped that way: a turn ceiling that
     // never ran and five manual entries that never reached the unchecked count,
     // while `canon sandbox coverage` counted the arm as armed. Nothing at the

package/src/tasks/archive.ts

@@ -269,6 +269,30 @@ export function readPlanTarget(text: string): string | undefined {
   return match[1] ?? match[2]
 }
 
+/**
+ * Reads every target the first `Plan:` line outside a fenced sample carries,
+ * falling back to the bare-path form. `readPlanTarget` answers only a line
+ * holding exactly one pointer, so this is how a caller tells a line linking
+ * several plans apart from no line at all.
+ */
+export function readPlanTargets(text: string): readonly string[] {
+  const lines = text.split('\n')
+  const fenced = fenceMask(lines)
+  const line = lines.find(
+    (candidate, index) => !fenced[index] && candidate.startsWith('Plan:'),
+  )
+  if (line === undefined) return []
+
+  const rest = line.slice('Plan:'.length)
+  const links = [...rest.matchAll(/\[[^\]]*\]\(([^)]+)\)/g)].map(
+    (match) => match[1],
+  )
+  if (links.length > 0) return links
+
+  const bare = /^[ \t]*(\S+)/.exec(rest)
+  return bare ? [bare[1]] : []
+}
+
 /**
  * Builds a `Plan:` line as a markdown link whose text and target stay in step,
  * the label taken from the target's filename with its extension dropped.
@@ -431,7 +455,7 @@ function isBulletFor(line: string, target: string): boolean {
 
 /**
  * Resolves the `Plan:` target against the board and against the project root
- * both, which is how `docs-fold` reads the same line. It accepts `../plans/x.md`
+ * both, which is how `context-fold` reads the same line. It accepts `../plans/x.md`
  * and `.canon/plans/x.md` as one file, so a gate reading only the first form
  * would pass the second and strand the plan this exists to protect.
  *
@@ -485,7 +509,7 @@ function atOneRoot(path: string, plans: string[], root: string): string {
 
 /**
  * Names the other live tasks whose `Plan:` line lands on the same file. This is
- * the rule `docs-fold` applies before it archives a plan, held here so one
+ * the rule `context-fold` applies before it archives a plan, held here so one
  * question has one implementation: a plan another live task still cites is a
  * plan the sweep is correct to leave, and a guard that read the folder instead
  * refused every task sharing one plan and deadlocked the board against the
@@ -542,7 +566,7 @@ export type CitationOutcome = PlanCitations | ArchiveRefused
 
 /**
  * Answers where one task's plan sits and who else holds it, which is the whole
- * of the last-live-citation rule. `docs-fold` reads this rather than scanning
+ * of the last-live-citation rule. `context-fold` reads this rather than scanning
  * the board itself, so the sweep that moves a plan and the gate that refuses a
  * task archive cannot drift into disagreeing about which plan is free.
  *
@@ -758,7 +782,7 @@ 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
+  // `context-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)