@erclx/canon 5.31.0 → 5.32.0

package/src/context/requirements.ts

@@ -1,17 +1,26 @@
 import { readFile } from 'node:fs/promises'
 import { join, relative } from 'node:path'
-import { wordCount } from '@/context/architecture'
 import { bodyLines } from '@/markdown/scan'
 import { surfaceDir } from '@/roots/surface'
 
 /**
  * The record this measures, relative to `root`, resolved at either surface
- * root for the reason `architectureRel` gives.
+ * root, since a project that has moved holds it under either.
  */
 export function requirementsRel(root: string): string {
   return relative(root, surfaceDir(root, 'REQUIREMENTS.md'))
 }
 
+/**
+ * Counts whitespace-delimited tokens, the unit the record's word cap is stated
+ * in. A code span counts as the tokens it holds, so a line citing a long path
+ * pays for it the way a reader does. A caller gating on the count hands in
+ * prose with fenced lines already dropped.
+ */
+export function wordCount(text: string): number {
+  return text.match(/\S+/g)?.length ?? 0
+}
+
 export interface RequirementsReport {
   readonly rel: string
   /** The whole record's word count, frontmatter left out. */
@@ -43,8 +52,8 @@ function isMissing(error: unknown): boolean {
 /**
  * Measures the record, or reports nothing when the project carries none.
  *
- * Absent rather than zeroed, for the reason `measureArchitecture` gives, and a
- * record present and unreadable propagates the same way.
+ * Absent rather than zeroed, so a project with no record is never told it holds an
+ * empty one, and a record present and unreadable propagates.
  */
 export async function measureRequirements(
   root: string,

package/src/counts/scan.ts

@@ -35,8 +35,8 @@ export type CountsReport =
 
 /**
  * A calendar date, which reads a sentence as a historical record rather than
- * a live claim about the tree. `canon/ARCHITECTURE.md` and the context
- * entries carry a figure this way deliberately, and every one of them stays
+ * a live claim about the tree. The context entries
+ * carry a figure this way deliberately, and every one of them stays
  * correct forever, so a sentence carrying one is read past rather than
  * matched.
  */
@@ -142,7 +142,7 @@ const QUANTIFIERS = ['all']
  * match at all. No syntactic rule tells a qualifier that narrows a catalog
  * from one that only restates it, and the sentence was true when written, so
  * the fix was not a narrower matcher: the clause was dated as a past state,
- * the way `canon/ARCHITECTURE.md` dates its own figures, which is the class
+ * the way a context entry dates its own figures, which is the class
  * the date exclusion below already reads past.
  */
 const ARTICLES = ['the', 'a', 'an']

package/src/design/components.ts

@@ -250,8 +250,8 @@ const TEACH_CHROME: Component = {
     'navigation shared by every teach page. Recovered from two gitignored',
     'course.css files that predate a regression that dropped this layer from the',
     "generator, and rewritten onto this module's tokens rather than the",
-    'incompatible palette they carried. See canon/wireframes/teach/chrome.md for',
-    'the shape.',
+    'incompatible palette they carried. See canon/context/features/teach/chrome.md',
+    'for the shape.',
   ].join('\n   '),
   reads: [
     '--color-background',

package/src/feedback/body.ts

@@ -1,5 +1,3 @@
-const SLUG_FALLBACK = 'general'
-const SLUG_MAX_LENGTH = 40
 const TITLE_MAX_LENGTH = 72
 
 /**
@@ -79,16 +77,6 @@ function surfaceField(body: string): string | undefined {
   return readField(body, 'Surface')?.split('\n')[0]?.trim()
 }
 
-export function deriveSlug(body: string): string {
-  const slug = (surfaceField(body) ?? '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, SLUG_MAX_LENGTH)
-    .replace(/-+$/g, '')
-  return slug || SLUG_FALLBACK
-}
-
 /**
  * Each label must exist on the toolkit repository, because `gh issue create`
  * refuses the whole issue on an unknown label rather than dropping it.

package/src/gate/measures.ts

@@ -7,14 +7,6 @@ import {
   type ClientCommand,
   clientCommandCitationsIn,
 } from '@/gate/client-commands'
-import {
-  isOverCount,
-  isOverLength,
-  isOverRisks,
-  measureArchitecture,
-  missingRevisit,
-  overWords,
-} from '@/context/architecture'
 import { isOverWordCap, measureRequirements } from '@/context/requirements'
 import {
   auditSkills,
@@ -253,62 +245,19 @@ function citedPaths(record: { paths?: unknown } | undefined): string[] {
 }
 
 /**
- * The canonical records against the caps each states for itself. The
- * architecture record carries five: the line ceiling its allowances derive,
- * the entry cap, the revisit sentence closing each decision, the words a
- * decision may hold, and the bullets its Risks section may hold. The
- * requirements record carries one, its own word count.
+ * The requirements record against the word cap it states for itself.
  *
  * Read in-process rather than through `context audit`, whose one gating stage
- * here runs `--citations-only` and never opens either record, which is why
- * the line ceiling went unenforced by `bun run check` until this stage. A
- * project carrying neither record, or records stating none of the caps,
- * passes, since each rule belongs to the record rather than to the toolkit.
+ * here runs `--citations-only` and never opens the record. A project carrying
+ * no record, or a record stating no cap, passes, since the rule belongs to the
+ * record rather than to the toolkit.
  */
 export const canonicalRecords: Measure = async (ctx) => {
-  const [report, requirements] = await Promise.all([
-    measureArchitecture(ctx.root),
-    measureRequirements(ctx.root),
-  ])
+  const requirements = await measureRequirements(ctx.root)
 
   const failures: string[] = []
   const emissions: Emission[] = []
 
-  if (report === undefined) {
-    emissions.push(info('No architecture record to measure'))
-  } else {
-    const decisions = report.decisions.length
-    const lackingRevisit = missingRevisit(report)
-    const longDecisions = overWords(report)
-    failures.push(
-      ...[
-        isOverCount(report) &&
-          `${decisions} decisions against a cap of ${report.entryCap}. Merge two or retire one in ${report.rel}, never compress.`,
-        isOverLength(report) &&
-          `${report.lines} lines against a ceiling of ${report.ceiling} in ${report.rel}.`,
-        lackingRevisit.length > 0 &&
-          `No revisit sentence in ${lackingRevisit.map((heading) => `"${heading}"`).join(', ')}. Close each with one opening "Revisit when" in ${report.rel}.`,
-        longDecisions.length > 0 &&
-          `${longDecisions.map((entry) => `"${entry.heading}" (${entry.words})`).join(', ')} past ${report.wordCap} words a decision in ${report.rel}. Cut the reasoning to the trade, never split one decision across two headings.`,
-        isOverRisks(report) &&
-          `${report.risksBullets} risk bullets against a cap of ${report.riskCap} in ${report.rel}. Drop what is no longer open.`,
-      ].filter((failure): failure is string => typeof failure === 'string'),
-    )
-
-    const cap =
-      report.entryCap === undefined
-        ? 'no entry cap stated'
-        : `a cap of ${report.entryCap}`
-    emissions.push(info(`${decisions} decisions against ${cap}`))
-    if (report.riskCap !== undefined && report.risksBullets === undefined) {
-      emissions.push(
-        info(
-          `No Risks section to count against a cap of ${report.riskCap} in ${report.rel}`,
-        ),
-      )
-    }
-  }
-
   if (requirements === undefined) {
     emissions.push(info('No requirements record to measure'))
   } else if (isOverWordCap(requirements)) {
@@ -415,7 +364,7 @@ export const skillProvenance: Measure = async (ctx) => {
 /**
  * Every listed practice skill against the closing sections, and every skill on
  * the wider ledger list against the ledger, both of which
- * `standards/skill-practice.md` requires.
+ * `claude/skills/create-skill/references/skill-practice.md` requires.
  *
  * Read in-process for the reason `skillProvenance` is, so the verb keeps its
  * missing-requirement-only exit. The list names shipped folders alone, so a

package/src/gov/citations.ts

@@ -6,6 +6,7 @@ import { isMarked } from '@/sweep/exempt-marker'
 import { gitEnv } from '@/git/env'
 import { listRuleFiles } from '@/gov/payload'
 import { parseFrontmatter } from '@/indexes/frontmatter'
+import { movedStandardPath } from '@/standards/read'
 import { findBacktickSpans } from '@/markdown/backticks'
 
 /**
@@ -177,8 +178,9 @@ export function classifySpan(span: string): CitationForm | undefined {
  *
  * A standard name takes the authoring root alone, matching `standardRoots` in
  * `@/standards/read`, which reads `standards/` at the working root and then the
- * package corpus. This verb refuses a tree holding no rule corpus, so it runs
- * only where those two roots are one directory. `internal/standards/` is
+ * package corpus, plus the skill reference a retired name moved to. This verb
+ * refuses a tree holding no rule corpus, so it runs only where those two roots
+ * are one directory. `internal/standards/` is
  * deliberately absent: `canon standards <name>` never reaches it, so admitting it
  * here would pass a citation that refuses for the session opening it, which is a
  * gate failing open.
@@ -191,7 +193,11 @@ function candidatesFor(
   cited: string,
   ruleFile: string,
 ): string[] {
-  if (form === 'standard') return [join('standards', `${cited}.md`)]
+  if (form === 'standard') {
+    const moved = movedStandardPath(cited)
+
+    return [join('standards', `${cited}.md`), ...(moved ? [moved] : [])]
+  }
   if (form === 'sibling') return [join(dirname(ruleFile), cited)]
   return [cited]
 }

package/src/gov/restated.ts

@@ -36,8 +36,8 @@ const SKILL_ROOTS: readonly string[] = [SHIPPED_SKILLS_REL, PROJECT_SKILLS_REL]
 /**
  * Path pairs whose duplication is deliberate and already recorded.
  *
- * The seed is authored from the always-loaded file and `seed-sync`
- * exists to reconcile the two, so a bullet appearing in both is the design
+ * The seed is authored from the always-loaded file and a hand merge
+ * reconciles the two, so a bullet appearing in both is the design
  * rather than a defect. Excluding by pair rather than by content is what the
  * plan settled on: the duplication is a location fact this repository already
  * records, and a content test would have to rediscover it on every run.
@@ -611,7 +611,7 @@ function authorityFor(
   if (candidate.kind === 'seed') {
     return {
       authority: 'claude-md',
-      reason: `${INSTRUCTIONS_REL} is authored first and the seed carries it to a target, so an edit starts there and reaches the seed through seed-sync`,
+      reason: `${INSTRUCTIONS_REL} is authored first and the seed carries it to a target, so an edit starts there and reaches the seed through a hand merge`,
     }
   }
 

package/src/markdown/structure.ts

@@ -6,7 +6,7 @@ const HEADING = /^#{1,6}\s/
  * A section marker holding its line alone, which is the signpost a document
  * uses where its own template asks for bold rather than a heading.
  *
- * `standards/plan.md` gives `## Summary` a heading and marks the four sections
+ * `claude/skills/plan-feature/references/plan.md` gives `## Summary` a heading and marks the four sections
  * below it this way, so a conforming plan read as one run from its first line
  * to its last and all seven live plans reported past the depth checkpoint, at
  * 106 to 166 rendered lines. A measure firing on a whole corpus says nothing
@@ -659,7 +659,7 @@ function measureParagraph(block: readonly BodyLine[]): CadenceFinding {
  *
  * `compromise` reported 2 percent. It tags a fronted past participle as a
  * finite past-tense verb, so all twelve of those sentences in
- * `.claude/ARCHITECTURE.md` read as carrying one, eleven opening `Measured at`
+ * the repository's architecture record at that commit read as carrying one, eleven opening `Measured at`
  * and one `Overturned by`, which is the exact shape the measure exists to
  * catch. It is not even consistent with itself there: `Measured at` tags a verb
  * and `Measured against` tags an adjective.

package/src/migrate/record-layout.ts

@@ -346,9 +346,9 @@ function entriesOf(dir: string, isDirectory: boolean): string[] {
 }
 
 /**
- * What `draft-and-pick` Step 6 and `sketch-design` write into the folder they
- * archive a choice to: a capture per arm, named `arm-<id>`, and a design
- * handoff. A folder carrying neither is evidence.
+ * What `draft-and-pick` Step 6 writes into the folder it archives a choice to:
+ * a capture per canvas frame, named `arm-<id>`. A design handoff marks a pick
+ * folder an earlier skill wrote. A folder carrying neither is evidence.
  */
 const PICK_FILE = /^(?:arm-[^.]+\..+|design-handoff\.md)$/
 

package/src/records/ordinal.ts

@@ -4,7 +4,7 @@ import { recordDir } from '@/roots/record'
 
 /**
  * The two record folders that share one ordinal sequence, per
- * `standards/intake.md` and `standards/groundwork.md`. A folder opened as
+ * `claude/skills/plan-intake/references/intake.md` and `claude/skills/plan-groundwork/references/groundwork.md`. A folder opened as
  * either kind blocks the same number for the other, so the two read together
  * rather than each keeping a count of its own.
  */

package/src/records/prune.ts

@@ -35,7 +35,8 @@ const LEGACY_MOVES: ReadonlyMap<string, string> = new Map([
  * Scratch-root names a different migration moves out of scratch for good,
  * derived from that migration's own table rather than duplicated in a second
  * hand-kept list. `RECORD_LAYOUT_MOVES` names `memory-archive`, the
- * retired-entry archive `603-memory` says never to delete, and `PROMOTED_FOLDERS`
+ * retired-entry archive of the memory kind, which is never offered for deletion,
+ * and `PROMOTED_FOLDERS`
  * names an evidence folder a durable record cites by name. A project that has
  * not run either migration still carries these at the scratch root, where an
  * ordinary slug's own age test would eventually offer them.

package/src/records/stale-canonical.ts

@@ -6,8 +6,8 @@ import { gitEnv } from '@/git/env'
 import { readReviewed } from '@/records/stale'
 import { surfaceDir } from '@/roots/surface'
 
-/** The two records whose drift is identity rather than a stale path. */
-const CANONICAL_DOCS = ['REQUIREMENTS.md', 'ARCHITECTURE.md'] as const
+/** The record whose drift is identity rather than a stale path. */
+const CANONICAL_DOCS = ['REQUIREMENTS.md'] as const
 
 export interface CanonicalDoc {
   /** Relative to the root, at whichever surface root carries the doc. */

package/src/roots/record.ts

@@ -56,7 +56,7 @@ const CANON_SCRATCH = 'tmp'
  * Everything absent from this list is committed and never lands under the
  * record root, which is the rule the move ran on. `rules`, `skills`, and
  * `hooks` stay under `.claude/` because the vendor reads them there, while
- * `context`, `wireframes`, and the loose documents are tracked surfaces that
+ * `context` and the loose documents are tracked surfaces that
  * `surface.ts` resolves under `canon/` instead. A seed and a
  * superseded-layout report each ask this rather than assuming a root.
  */

package/src/sandbox/scenario.ts

@@ -8,10 +8,19 @@ import {
   readFileSync,
   statSync,
   writeFileSync,
+  writeSync,
 } from 'node:fs'
 import { createRequire } from 'node:module'
 import { dirname, join, relative } from 'node:path'
-import { logError, logInfo, logStep, logWarn, palette, select } from '@/cli/ui'
+import {
+  logError,
+  logInfo,
+  logStep,
+  logWarn,
+  palette,
+  pipeOutput,
+  select,
+} from '@/cli/ui'
 
 /**
  * The TypeScript form of a sandbox scenario: `sandbox/<category>/<command>.ts`,
@@ -33,7 +42,7 @@ export const FIXTURE_SUFFIX = '.fixture'
 /** A scenario whose only arm carries this name routes none, as a bash file with no picker did. */
 export const DEFAULT_ARM_NAME = 'default'
 
-/** Every bash scenario passed this prompt to `select_or_route_scenario`. */
+/** What a bash scenario passed to `select_or_route_scenario` unless it named another. */
 const ROUTE_PROMPT = 'Which scenario?'
 
 /** Every scenario that sets the anchor pushes to this one throwaway repository. */
@@ -50,6 +59,14 @@ export interface ScenarioDefinition {
   readonly config?: Readonly<Record<string, string>>
   /** Stages the tree from the anchor fixture and names the throwaway remote. */
   readonly anchor?: boolean
+  /**
+   * Stages and narrates what the bash form did ahead of `select_or_route_scenario`,
+   * so the picker's echo lands after it on the frame. Runs before the arm is
+   * routed, which leaves `ctx.arm` undefined.
+   */
+  readonly prepare?: ArmSetup
+  /** The picker's message, for a bash scenario that passed something other than the default. */
+  readonly prompt?: string
   /** In routing order, so the first arm is the one a headless caller gets. */
   readonly arms: Readonly<Record<string, ArmSetup>>
 }
@@ -144,7 +161,7 @@ export function loadScenario(file: string): ScenarioDefinition {
   if (!isRecord(definition))
     throw new Error(`${file} has no default export from scenario()`)
 
-  const { arms, config, anchor } = definition
+  const { arms, config, anchor, prepare, prompt } = definition
   if (!isRecord(arms) || Object.keys(arms).length === 0)
     throw new Error(`${file} declares no arms`)
   for (const [name, setup] of Object.entries(arms))
@@ -158,6 +175,10 @@ export function loadScenario(file: string): ScenarioDefinition {
     throw new Error(`${file} config holds a value that is not a string`)
   if (anchor !== undefined && typeof anchor !== 'boolean')
     throw new Error(`${file} anchor is not a boolean`)
+  if (prepare !== undefined && typeof prepare !== 'function')
+    throw new Error(`${file} prepare is not a function`)
+  if (prompt !== undefined && typeof prompt !== 'string')
+    throw new Error(`${file} prompt is not a string`)
 
   return definition as unknown as ScenarioDefinition
 }
@@ -225,6 +246,24 @@ export interface RunOptions {
   readonly stderr?: 'inherit' | 'ignore'
   /** Returns a failing status rather than stopping the arm, the `|| true` of the bash form. */
   readonly allowFailure?: boolean
+  /** Set for this command alone, the `NAME=value command` prefix of the bash form. */
+  readonly env?: Readonly<Record<string, string>>
+}
+
+export interface CaptureOptions {
+  /** Relative to the tree, the `cd` of a bash subshell. */
+  readonly cwd?: string
+  /** Fed to the command's stdin, the `<file` or `<<<` of the bash form. */
+  readonly input?: string
+  readonly env?: Readonly<Record<string, string>>
+  /** `inherit` leaves the stream on the terminal, where `pipe` hands it back for a file. */
+  readonly stderr?: 'pipe' | 'inherit' | 'ignore'
+}
+
+export interface Captured {
+  readonly status: number
+  readonly stdout: string
+  readonly stderr: string
 }
 
 export interface StageContext {
@@ -240,6 +279,8 @@ export interface StageContext {
     warn(message: string): void
     /** A bare frame line, the `echo -e "${GREY}│${NC}"` of the bash form. */
     bar(): void
+    /** Indents borrowed output inside the frame, the `pipe_output` of the bash form. */
+    pipe(text: string): void
   }
   fixtures(category: string, command: string, arm: string, stage: string): void
   git(...args: string[]): void
@@ -248,6 +289,18 @@ export interface StageContext {
   run(command: string, args: readonly string[], options?: RunOptions): number
   /** Runs a command and returns its stdout, stopping the arm on a failure. */
   read(command: string, args: readonly string[], options?: RunOptions): string
+  /**
+   * Runs a command and returns both streams with its status, never stopping the
+   * arm. For the `>file 2>file || status=$?` shape, where the outcome is the
+   * record the arm exists to hold.
+   */
+  capture(
+    command: string,
+    args: readonly string[],
+    options?: CaptureOptions,
+  ): Captured
+  /** Writes to a stream the way a bare `cat` or `echo` did, in order with the commands around it. */
+  print(text: string, stream?: 'stdout' | 'stderr'): void
   write(path: string, content: string): void
   append(path: string, content: string): void
   mkdir(path: string): void
@@ -291,14 +344,24 @@ export function createStageContext(options: ContextOptions): StageContext {
     args: readonly string[],
     stdout: 'inherit' | 'ignore' | 'pipe',
     stderr: 'inherit' | 'ignore' | 'pipe',
+    extra: {
+      cwd?: string
+      input?: string
+      env?: Readonly<Record<string, string>>
+    } = {},
   ) => {
-    const stdio: StdioOptions = ['ignore', stdout, stderr]
+    const stdio: StdioOptions = [
+      extra.input === undefined ? 'ignore' : 'pipe',
+      stdout,
+      stderr,
+    ]
 
     return spawnSync(command, [...args], {
-      cwd: dir,
-      env,
+      cwd: extra.cwd === undefined ? dir : join(dir, extra.cwd),
+      env: extra.env === undefined ? env : { ...env, ...extra.env },
       encoding: 'utf8',
       stdio,
+      input: extra.input,
     })
   }
 
@@ -312,6 +375,7 @@ export function createStageContext(options: ContextOptions): StageContext {
       args,
       runOptions.stdout ?? 'inherit',
       runOptions.stderr ?? 'inherit',
+      { env: runOptions.env },
     )
     const status = result.status ?? 1
     if (status !== 0 && runOptions.allowFailure !== true)
@@ -325,7 +389,13 @@ export function createStageContext(options: ContextOptions): StageContext {
     args: readonly string[],
     runOptions: RunOptions = {},
   ): string => {
-    const result = spawn(command, args, 'pipe', runOptions.stderr ?? 'inherit')
+    const result = spawn(
+      command,
+      args,
+      'pipe',
+      runOptions.stderr ?? 'inherit',
+      { env: runOptions.env },
+    )
     const status = result.status ?? 1
     if (status !== 0 && runOptions.allowFailure !== true)
       throw new ScenarioStop(status, 'exited')
@@ -333,6 +403,26 @@ export function createStageContext(options: ContextOptions): StageContext {
     return status === 0 ? result.stdout : ''
   }
 
+  const capture = (
+    command: string,
+    args: readonly string[],
+    captureOptions: CaptureOptions = {},
+  ): Captured => {
+    const result = spawn(
+      command,
+      args,
+      'pipe',
+      captureOptions.stderr ?? 'pipe',
+      captureOptions,
+    )
+
+    return {
+      status: result.status ?? 1,
+      stdout: result.stdout ?? '',
+      stderr: result.stderr ?? '',
+    }
+  }
+
   const git = (...args: string[]): void => {
     run('git', args)
   }
@@ -476,12 +566,20 @@ export function createStageContext(options: ContextOptions): StageContext {
         const { GREY, NC } = palette(process.stderr)
         process.stderr.write(`${GREY}│${NC}\n`)
       },
+      // `pipe_output` read lines, so an empty body printed nothing at all.
+      pipe: (text) => {
+        if (text !== '') pipeOutput(text)
+      },
     },
     fixtures,
     git,
     commit: (subject) => git('commit', '-m', subject, '--no-verify', '-q'),
     run,
     read,
+    capture,
+    print: (text, stream = 'stdout') => {
+      writeSync(stream === 'stdout' ? 1 : 2, text)
+    },
     write: (path, content) => {
       mkdirSync(dirname(inTree(path)), { recursive: true })
       writeFileSync(inTree(path), content)
@@ -510,11 +608,12 @@ export function createStageContext(options: ContextOptions): StageContext {
 async function routeArm(
   names: readonly string[],
   env: NodeJS.ProcessEnv,
+  prompt: string,
 ): Promise<string> {
   const echo = (name: string): string => {
     const { GREY, NC, WHITE } = palette(process.stderr)
     process.stderr.write(
-      `${GREY}│${NC}\n${GREY}◇${NC} ${ROUTE_PROMPT} ${WHITE}${name}${NC}\n`,
+      `${GREY}│${NC}\n${GREY}◇${NC} ${prompt} ${WHITE}${name}${NC}\n`,
     )
 
     return name
@@ -533,13 +632,13 @@ async function routeArm(
 
   if (!process.stdin.isTTY) {
     logError(
-      `${ROUTE_PROMPT} requires a TTY. Pass an argument or set CANON_NON_INTERACTIVE=1.`,
+      `${prompt} requires a TTY. Pass an argument or set CANON_NON_INTERACTIVE=1.`,
     )
     throw new ScenarioStop(1, 'exited')
   }
 
   return select({
-    message: ROUTE_PROMPT,
+    message: prompt,
     options: names.map((name) => ({ value: name, label: name })),
   })
 }
@@ -560,8 +659,13 @@ export async function stageScenarioInProcess(
 ): Promise<StageOutcome> {
   try {
     const names = armNames(definition)
+    await definition.prepare?.(
+      createStageContext({ ...options, arm: undefined }),
+    )
     const name =
-      names.length === 0 ? DEFAULT_ARM_NAME : await routeArm(names, options.env)
+      names.length === 0
+        ? DEFAULT_ARM_NAME
+        : await routeArm(names, options.env, definition.prompt ?? ROUTE_PROMPT)
     const setup = Object.hasOwn(definition.arms, name)
       ? definition.arms[name]
       : undefined

package/src/shipped/references.ts

@@ -168,8 +168,8 @@ const DOCS_PATH = /(?<![\w./-])docs\/[^\s`)\]]*\.md\b/g
  * Reported unless `isStandardsPathReportable` reads the match as a
  * deliberate placeholder rather than a real citation. A body illustrating
  * the shape a project's own `standards/<name>.md` takes writes a bracketed
- * token this pattern also matches, such as `standards/<slug>.md` in
- * `create-standard/SKILL.md`, which names no real file. A bare,
+ * token this pattern also matches, such as `standards/<slug>.md`
+ * in a skill that drafts one, which names no real file. A bare,
  * non-bracketed match now reports whether or not the file exists, unlike
  * `DOCS_PATH`, which still gates on existence: a same-repository citation
  * under this corpus names no target project's own tree the way a `docs/`
@@ -206,7 +206,7 @@ const PHASE_LABEL = /\bv\d+\.\d+(?!\.\d)\b/g
  *
  * Anchored on the trailing `\d{3}-[\w-]+\.md` rather than on the bare
  * `.claude/rules/` prefix, which is what keeps a folder mention carrying no
- * number, such as `create-rule`, `memory-review`, and `target-setup` already
+ * number, such as `create-rule`, `target-check`, and `target-setup` already
  * write correctly, from matching. The segment group between `rules/` and the
  * numbered file admits both a governance-namespace path
  * (`canon/canon/604-scratch.md`) and a project-namespace one

package/src/standards/read.ts

@@ -59,7 +59,38 @@ export function standardRoots(root: string): StandardRoot[] {
  * map goes with the verb in the last slice of the retirement.
  */
 const MOVED_STANDARDS: Readonly<Record<string, string>> = {
+  board: 'claude/skills/task-board/references/board.md',
   markdown: 'claude/skills/markdown-craft/references/markdown.md',
+  canvas: 'claude/skills/canvas/references/canvas.md',
+  glossary: 'claude/skills/teach-workspace/references/glossary.md',
+  groundwork: 'claude/skills/plan-groundwork/references/groundwork.md',
+  'groundwork-spikes':
+    'claude/skills/plan-groundwork/references/groundwork-spikes.md',
+  intake: 'claude/skills/plan-intake/references/intake.md',
+  mermaid: 'claude/skills/draft-figure/references/mermaid.md',
+  plan: 'claude/skills/plan-feature/references/plan.md',
+  'plan-lifecycle': 'claude/skills/plan-feature/references/plan-lifecycle.md',
+  ready: 'claude/skills/draft-ready/references/ready.md',
+  requirements: 'claude/skills/draft-doc/references/requirements.md',
+  'skill-paths': 'claude/skills/create-skill/references/skill-paths.md',
+  'skill-practice': 'claude/skills/create-skill/references/skill-practice.md',
+  session: 'claude/skills/session-map/references/session.md',
+  'skill-requirement':
+    'claude/skills/create-skill/references/skill-requirement.md',
+  tasks: 'claude/skills/task-board/references/tasks.md',
+  'tasks-decline': 'claude/skills/task-board/references/tasks-decline.md',
+  teach: 'claude/skills/teach-workspace/references/teach.md',
+  wiki: 'claude/skills/draft-doc/references/wiki.md',
+}
+
+/**
+ * The package-relative path a retired standard now lives at, so a caller that
+ * resolves against a root of its own tests the same map the verb reads.
+ */
+export function movedStandardPath(name: string): string | undefined {
+  if (!Object.hasOwn(MOVED_STANDARDS, name)) return undefined
+
+  return MOVED_STANDARDS[name]
 }
 
 function filename(name: string): string {

package/src/sync/seeds-report.ts

@@ -34,7 +34,7 @@ export interface SeedsReport {
  * Classifies every seed the toolkit ships against the target's copy, and never
  * returns a change. Seeds are copy-once files a project is expected to edit, so
  * the engine's copy path would overwrite `CLAUDE.md` wholesale. Reporting alone
- * is what lets `seed-sync` merge one section at a time instead.
+ * is what lets an operator merge one section at a time by hand instead.
  *
  * Attribution reuses the history reader rather than the engine's own recovery
  * pass, which is private and takes a `SyncAdapter` seeds have no way to supply.