@erclx/canon 5.30.0 → 5.32.0

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
@@ -92,7 +92,7 @@ const SENTENCE_END = /[.!?]["'’”)\]]*(?=\s+(?:["'“(\[]*[A-Z]|`)|\s*$)/g
  * Checkpoints the structural measures run against.
  *
  * These are the definition rather than a fallback. Reading each number out of
- * the sentence `standards/markdown.md` states it in was the alternative, and it
+ * the sentence `claude/skills/markdown-craft/references/markdown.md` states it in was the alternative, and it
  * put a parser contract on a document authored for people, where a rewording
  * degraded a number and the report had to carry a legend saying which one. The
  * standard still states every number for a reader, and moving one is an edit to
@@ -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/backup.ts

@@ -47,6 +47,7 @@ export const BACKED_FOLDERS = [
   'tasks',
   'teach',
   'transcripts',
+  'upstream',
   'walkthroughs',
 ] as const
 

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/records/validate.ts

@@ -75,6 +75,8 @@ export const FINDING_KINDS = [
   'category-mismatch',
   'operator-call-phrasing',
   'batch-unsplit',
+  'source-unquoted',
+  'stack-foldable',
 ] as const
 
 export type FindingKind = (typeof FINDING_KINDS)[number]
@@ -276,6 +278,7 @@ const PLAN_SECTIONS = [
   'Risks',
   'Review focus',
   'Questions',
+  'Sources',
 ] as const
 
 type PlanSection = (typeof PLAN_SECTIONS)[number]
@@ -425,6 +428,57 @@ function checkQuestionContract(name: string, lines: string[]): Finding[] {
   return findings
 }
 
+const SOURCE_LINK = /\[[^\]]+\]\(https?:\/\/[^)\s]+\)|https?:\/\/\S+/
+const SOURCE_QUOTE = /["“][^"“”]+["”]/
+const SOURCE_UNVERIFIED = /\bunverified\b/i
+
+/**
+ * A bullet opens an entry only at the section's shallowest indent, so a nested
+ * bullet and a wrapped line both belong to the entry above. Joining them first
+ * lets a passage wrap across lines and still count as quoted.
+ */
+function readSourceEntries(lines: readonly string[]): string[] {
+  const entries: string[] = []
+  let depth: number | undefined
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (trimmed === '') continue
+
+    const indent = line.length - line.trimStart().length
+    const opensEntry =
+      trimmed.startsWith('- ') && (depth === undefined || indent <= depth)
+
+    if (opensEntry) {
+      depth = indent
+      entries.push(trimmed)
+      continue
+    }
+
+    if (entries.length > 0) entries[entries.length - 1] += ` ${trimmed}`
+  }
+
+  return entries
+}
+
+function checkSources(name: string, lines: readonly string[]): Finding[] {
+  return readSourceEntries(lines)
+    .filter((entry) => entry !== `- ${NONE_IDENTIFIED}`)
+    .filter(
+      (entry) =>
+        !SOURCE_LINK.test(entry) ||
+        !(SOURCE_QUOTE.test(entry) || SOURCE_UNVERIFIED.test(entry)),
+    )
+    .map((entry) =>
+      finding(
+        'source-unquoted',
+        name,
+        shorten(entry),
+        'carries no link, or a link with neither a double-quoted passage nor the word unverified.',
+      ),
+    )
+}
+
 export function checkPlan(name: string, text: string): Finding[] {
   const findings: Finding[] = []
 
@@ -480,6 +534,7 @@ export function checkPlan(name: string, text: string): Finding[] {
   }
 
   findings.push(...checkQuestionContract(name, sections.get('Questions') ?? []))
+  findings.push(...checkSources(name, sections.get('Sources') ?? []))
 
   if (hasStagedBatches(text)) {
     const staged = linesOutsideFences(text).find((line) =>

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.
  */
@@ -80,6 +80,7 @@ export const RECORD_ENTRIES: readonly string[] = [
   'tasks',
   'teach',
   'transcripts',
+  'upstream',
   'walkthroughs',
 ]
 

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

@@ -53,6 +53,46 @@ export function standardRoots(root: string): StandardRoot[] {
   ]
 }
 
+/**
+ * Standards retired into the skill reference that took them, keyed by name with
+ * a path relative to the package root. Each retirement adds one line, and the
+ * 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 {
   return name.endsWith('.md') ? name : `${name}.md`
 }
@@ -69,7 +109,16 @@ export function resolveStandard(
     if (existsSync(path)) return { path, source: join(label, file) }
   }
 
-  return undefined
+  const movedName = basename(file, '.md')
+  if (!Object.hasOwn(MOVED_STANDARDS, movedName)) return undefined
+
+  const moved = MOVED_STANDARDS[movedName]
+  if (!moved) return undefined
+
+  const path = join(PROJECT_ROOT, moved)
+  if (!existsSync(path)) return undefined
+
+  return { path, source: join(PACKAGE_LABEL, moved) }
 }
 
 /**
@@ -92,6 +141,8 @@ export function listStandards(root: string): string[] {
     }
   }
 
+  for (const name of Object.keys(MOVED_STANDARDS)) names.add(name)
+
   return [...names].sort()
 }
 

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.

package/src/tasks/answers.ts

@@ -1,7 +1,8 @@
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { isAbsolute, relative, resolve } from 'node:path'
+import { basename, isAbsolute, relative, resolve } from 'node:path'
 import { isUnder } from '@/tasks/paths'
+import { JUDGED_APART_REMEDY, readLivePlans, stackPairs } from '@/tasks/stack'
 import { recordDir, recordDirs } from '@/roots/record'
 import {
   hasStagedBatches,
@@ -231,6 +232,18 @@ export async function planAnswers(
     })
   }
 
+  const stem = basename(resolved.path, '.md')
+  const pairs = stackPairs(await readLivePlans(root))
+
+  for (const { child, parent, shared } of pairs) {
+    if (child !== stem) continue
+
+    open.push({
+      label: 'Stacked sibling',
+      why: `stacks on \`${parent}\` and shares ${shared} declared files with it. ${JUDGED_APART_REMEDY}`,
+    })
+  }
+
   return {
     ok: true,
     plan: resolved.plan,

package/src/tasks/reach.ts

@@ -11,7 +11,7 @@ const PLANS = 'plans'
 const MARKDOWN = '.md'
 const NONE_IDENTIFIED = 'None identified.'
 
-/** The one group a dispatch reads, per `standards/board.md`. */
+/** The one group a dispatch reads, per `claude/skills/task-board/references/board.md`. */
 const DISPATCH_GROUP = 'Run now'
 
 export const REACH_REFUSALS = [
@@ -146,7 +146,7 @@ function namesFile(span: string): boolean {
  * An entry carrying no colon at all is taken whole. The standard requires a
  * reason rather than the punctuation introducing it, so the alternative is
  * reading such an entry as declaring nothing, which reports every path it
- * names as undeclared. `standards/plan.md` fixes the colon form, so the
+ * names as undeclared. `claude/skills/plan-feature/references/plan.md` fixes the colon form, so the
  * conforming entry never reaches this fallback.
  *
  * A rename declares both sides, since both are paths the branch writes and