@erclx/canon 4.79.0 → 4.81.0

package/src/commands/design.ts

@@ -11,12 +11,17 @@ import { buildDesignCss } from '@/design/css'
 import { HAND_DRAWN_FONT_FACES } from '@/design/fonts'
 import { renderDesignDoc } from '@/design/render'
 import { DESIGN_BASE_CSS, DESIGN_DOCUMENT, regenDesign } from '@/design/regen'
-import { checkoutMismatchWarning, PROJECT_ROOT } from '@/project-root'
+import {
+  checkoutMismatchWarning,
+  isOwnCheckout,
+  PROJECT_ROOT,
+} from '@/project-root'
 import { creationRel } from '@/record-root'
 import { surfaceDir } from '@/surface-root'
 import { recordStamp, runDomainSync } from '@/sync/engine'
 import { resolveTarget } from '@/target'
 import { intro, logAdd, logError, logInfo, logWarn, outro, palette } from '@/ui'
+import { mainWorktreeRoot } from '@/worktree'
 
 export function register(program: Command): void {
   const design = program
@@ -133,33 +138,44 @@ export function register(program: Command): void {
   design
     .command('board')
     .description(
-      'Generate the design board, an index over this repository’s own design surfaces',
+      'Generate the design board, an index over a project’s design surfaces',
     )
     .option(
       '-o, --out <path>',
       'Output directory',
       creationRel(process.cwd(), 'review', 'board'),
     )
+    .option('--root <path>', 'Project root, defaulting to the main worktree')
     .addHelpText(
       'after',
       [
         '',
-        'Like regen, this runs against the toolkit checkout rather than a',
-        'target: it reads five sources already on disk relative to the',
-        'project root and writes a static page set, never installed or',
-        'synced. Open it with canon serve <out>.',
+        'Reads its sources from --root, defaulting to the main worktree of',
+        'whatever project the caller stands in, and writes a static page',
+        'set, never installed or synced. The surfaces panel’s landing-page',
+        'half and the whole components panel render only when that root is',
+        'this toolkit’s own checkout. Open the result with canon serve <out>.',
         '',
       ].join('\n'),
     )
-    .action((opts: { out: string }) => {
+    .action(async (opts: { out: string; root?: string }) => {
       const outDir = resolve(process.cwd(), opts.out)
+      const root = opts.root
+        ? resolve(process.cwd(), opts.root)
+        : await mainWorktreeRoot()
+      const isToolkitCheckout = isOwnCheckout(root)
       const { GREEN, GREY, NC, RED, WHITE } = palette(process.stderr)
       const mismatch = checkoutMismatchWarning(process.cwd())
       process.stderr.write(
         `${GREY}┌${NC}\n${GREY}│${NC} ${WHITE}Generate design board${NC}\n`,
       )
       if (mismatch !== undefined) logWarn(mismatch)
-      const result = generateBoard(PROJECT_ROOT, outDir, process.cwd())
+      const result = generateBoard(
+        root,
+        outDir,
+        process.cwd(),
+        isToolkitCheckout,
+      )
       if (!result.ok) {
         process.stderr.write(
           `${GREY}│${NC} ${RED}✗${NC} ${result.detail}\n${GREY}└${NC}\n`,

package/src/commands/sync.ts

@@ -101,7 +101,7 @@ function renderCheck(report: CheckReport): void {
 
   if (report.stampAtLegacyPath) {
     logWarn(
-      'Stamp found at a retired path. Move it to .claude/canon/config.json.',
+      'Stamp found at a retired path. Move it to canon/config/config.json.',
     )
   }
 

package/src/commands/teach.ts

@@ -2,6 +2,7 @@ import { relative } from 'node:path'
 import type { Command } from 'commander'
 import { type LessonOutcome, planLesson } from '@/teach/lesson'
 import { type NavOutcome, generateNav } from '@/teach/nav'
+import { type RenderOutcome, renderLessonBody } from '@/teach/render'
 import {
   defineTerms,
   type ListOutcome,
@@ -81,6 +82,10 @@ interface NavCommandOptions {
   readonly root?: string
 }
 
+interface RenderCommandOptions {
+  readonly json?: boolean
+}
+
 export function register(program: Command): void {
   const teach = program
     .command('teach')
@@ -357,6 +362,36 @@ export function register(program: Command): void {
     .action(async (topic: string | undefined, opts: NavCommandOptions) => {
       process.exitCode = await runNav(topic, opts)
     })
+
+  teach
+    .command('render')
+    .description('Render a lesson body block list to HTML')
+    .helpOption('-h, --help', 'Show this help message')
+    .option('--json', 'Emit a machine-readable record on stdout')
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Exit codes:',
+        '  0  the block list rendered',
+        '  1  refused, with the reason on stderr or in the JSON record',
+        '',
+        'Reads a JSON array of blocks from stdin, each a heading, paragraph,',
+        'list, or raw block, and renders it through the same components the',
+        'fixture lesson is generated from. Content the three cannot express',
+        'takes type raw, carrying its own html verbatim, unescaped.',
+        '',
+        'Takes no topic and no --root: the verb is a stateless transform,',
+        'reading nothing off a workspace on disk.',
+        '',
+        'Examples:',
+        '  echo \'[{"type":"heading","level":1,"text":"Compass bearings"}]\' | canon teach render --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (opts: RenderCommandOptions) => {
+      process.exitCode = await runRender(opts)
+    })
 }
 
 interface StylesheetCommandOptions {
@@ -403,6 +438,17 @@ function collect(value: string, previous: string[]): string[] {
   return [...previous, value]
 }
 
+function readStdin(): Promise<string> {
+  return new Promise((resolveStream, rejectStream) => {
+    const chunks: Buffer[] = []
+    process.stdin.on('data', (chunk: Buffer) => chunks.push(chunk))
+    process.stdin.on('end', () =>
+      resolveStream(Buffer.concat(chunks).toString('utf8')),
+    )
+    process.stdin.on('error', rejectStream)
+  })
+}
+
 /**
  * Splits every pair or reports the ones that carry no separator. Both halves
  * are reported together, so a caller passing four pairs learns about all the
@@ -648,6 +694,78 @@ async function runNav(
   return reportNav(await generateNav(root, topic), emitJson, root)
 }
 
+async function runRender(opts: RenderCommandOptions): Promise<number> {
+  const emitJson = opts.json ?? false
+
+  if (process.stdin.isTTY) {
+    return reportRenderRefusal(
+      badInput(
+        "No blocks on stdin. Pipe a JSON array: echo '[...]' | canon teach render",
+      ),
+      emitJson,
+    )
+  }
+
+  const body = (await readStdin()).trim()
+
+  if (!body) {
+    return reportRenderRefusal(
+      badInput('Empty stdin. Pipe a JSON array of blocks.'),
+      emitJson,
+    )
+  }
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(body)
+  } catch {
+    return reportRenderRefusal(badInput('Malformed JSON on stdin.'), emitJson)
+  }
+
+  if (!Array.isArray(parsed)) {
+    return reportRenderRefusal(
+      badInput('Stdin must be a JSON array of blocks.'),
+      emitJson,
+    )
+  }
+
+  return reportRender(renderLessonBody(parsed), emitJson)
+}
+
+function reportRenderRefusal(refused: TeachRefused, emitJson: boolean): number {
+  if (emitJson) {
+    process.stderr.write(`${refused.message}\n`)
+    process.stdout.write(
+      `${JSON.stringify({
+        ok: false,
+        reason: refused.reason,
+        message: refused.message,
+      })}\n`,
+    )
+    return 1
+  }
+
+  intro('canon teach render')
+  logStep('Refused')
+  logError(refused.message)
+  outro()
+  return 1
+}
+
+function reportRender(outcome: RenderOutcome, emitJson: boolean): number {
+  if (!outcome.ok) return reportRenderRefusal(outcome, emitJson)
+
+  if (emitJson) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, html: outcome.html })}\n`,
+    )
+    return 0
+  }
+
+  process.stdout.write(`${outcome.html}\n`)
+  return 0
+}
+
 function reportNav(
   outcome: NavOutcome,
   emitJson: boolean,

package/src/design/board.ts

@@ -11,13 +11,17 @@ import { join, relative, sep } from 'node:path'
 import { DESIGN_DOCUMENT } from '@/design/regen'
 import { renderDesignDoc } from '@/design/render'
 import { colorValue } from '@/design/tokens'
+import { parseFrontmatter, readField } from '@/indexes/frontmatter'
 import { recordDir } from '@/record-root'
+import { surfaceDir } from '@/surface-root'
 
 /**
- * The one named site for this repository's wireframe corpus, so the surface
- * move retargets a single constant rather than a literal repeated per panel.
- * The board reads this checkout alone, which has moved, so the new root is
- * spelled directly rather than resolved.
+ * The wireframes panel's creation-root spelling, used in its own empty-state
+ * message and by this module's tests to seed a fixture. The panel itself
+ * resolves its actual read path through `surfaceDir`, which also reads
+ * `.claude/wireframes/` for a target that has not run the surface-roots
+ * migration, so this constant names where a fresh file lands rather than
+ * where every root's corpus necessarily sits.
  */
 export const WIREFRAME_DIR = join('canon', 'wireframes')
 
@@ -34,26 +38,6 @@ const WEB_DIST_ENTRY = 'index.html'
 const WEB_GALLERY_DIST = join('web', 'gallery-dist')
 const WEB_GALLERY_DIST_ENTRY = 'index.html'
 
-interface WireframeEntry {
-  readonly path: string
-  readonly describes: string
-}
-
-/**
- * The six files the wireframes panel renders, each beside the surface it
- * describes. `index.md` at either level is a catalog rather than a wireframe
- * and is excluded, which is why this list holds six rather than the eight
- * files the corpus carries today.
- */
-const WIREFRAMES: readonly WireframeEntry[] = [
-  { path: 'landing-page.md', describes: 'The canon.erclx.dev landing page' },
-  { path: 'slides.md', describes: 'The SLIDES.md render' },
-  { path: 'teach/root.md', describes: 'A teach workspace root listing' },
-  { path: 'teach/contents.md', describes: 'A workspace contents page' },
-  { path: 'teach/lesson.md', describes: 'A lesson page and quiz stepper' },
-  { path: 'teach/chrome.md', describes: 'The shared teach chrome' },
-]
-
 const IMAGE_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.svg', '.webp']
 
 export interface BoardPanel {
@@ -233,7 +217,8 @@ iframe { width: 100%; height: 480px; border: 1px solid var(--board-border); bord
 <body>
 <header>
 <h1>Design board</h1>
-<p class="meta">Generated by <code>canon design board</code>. Repository-local, never installed into a target.</p>
+<p class="meta">Generated by <code>canon design board</code>. Reads from a caller-resolved root, never installed or synced.</p>
+<p class="meta">Drafting a new candidate: <code>canon:draft-and-pick</code>. Auditing a rendered surface: <code>canon:ux-audit</code>.</p>
 </header>
 <nav>${navLinks}${THEME_TOGGLE_BUTTON}</nav>
 <main>
@@ -282,7 +267,7 @@ ${body}
 }
 
 function writeTokensPanel(root: string, outDir: string): void {
-  const sourcePath = join(root, DESIGN_DOCUMENT)
+  const sourcePath = surfaceDir(root, 'DESIGN.md')
   const dir = join(outDir, 'tokens')
 
   if (!existsSync(sourcePath)) {
@@ -300,18 +285,56 @@ function writeTokensPanel(root: string, outDir: string): void {
   renderDesignDoc(sourcePath, dir)
 }
 
+interface WireframeFile {
+  readonly relPath: string
+  readonly text: string
+  readonly description: string | undefined
+}
+
+/**
+ * Every wireframe under whichever root the corpus resolves at, sorted for a
+ * stable render order across runs. `surfaceDir` reads `.claude/wireframes/`
+ * for a target that has not run the surface-roots migration, the same
+ * fallback `recordDir` already gives the surfaces panel's teach half.
+ * `index.md` at any depth is a catalog rather than a wireframe and is
+ * excluded. A glob emits OS-native separators, and the corpus nests one
+ * level deep, so the label always reads with forward slashes regardless of
+ * platform.
+ */
+function listWireframes(root: string): readonly WireframeFile[] {
+  const dir = surfaceDir(root, 'wireframes')
+  if (!existsSync(dir)) return []
+
+  const glob = new Bun.Glob('**/*.md')
+  const relPaths = [...glob.scanSync({ cwd: dir })]
+    .filter((relPath) => relPath.split(sep).pop() !== 'index.md')
+    .map((relPath) => relPath.split(sep).join('/'))
+    .sort()
+
+  return relPaths.map((relPath) => {
+    const text = readFileSync(join(dir, relPath), 'utf8')
+    return {
+      relPath,
+      text,
+      description: readField(parseFrontmatter(text), 'description'),
+    }
+  })
+}
+
 function writeWireframesPanel(root: string, outDir: string): void {
   const dir = join(outDir, 'wireframes')
   mkdirSync(dir, { recursive: true })
 
-  const sections = WIREFRAMES.map((entry) => {
-    const sourcePath = join(root, WIREFRAME_DIR, entry.path)
-    if (!existsSync(sourcePath)) {
-      return `<h2>${escapeHtml(entry.path)}</h2>\n<p class="empty">Missing from ${WIREFRAME_DIR}/.</p>`
-    }
-    const text = readFileSync(sourcePath, 'utf8')
-    return `<h2>${escapeHtml(entry.path)}</h2>\n<p>${escapeHtml(entry.describes)}</p>\n<pre>${escapeHtml(text)}</pre>`
-  }).join('\n')
+  const files = listWireframes(root)
+  const sections =
+    files.length === 0
+      ? `<p class="empty">No wireframe files under ${WIREFRAME_DIR}/.</p>`
+      : files
+          .map((file) => {
+            const description = file.description ?? file.relPath
+            return `<h2>${escapeHtml(file.relPath)}</h2>\n<p>${escapeHtml(description)}</p>\n<pre>${escapeHtml(file.text)}</pre>`
+          })
+          .join('\n')
 
   writeFileSync(join(dir, 'index.html'), panelPage('Wireframes', sections))
 }
@@ -322,15 +345,21 @@ function copyBuilt(source: string, dest: string): void {
   cpSync(source, dest, { recursive: true })
 }
 
-function writeSurfacesPanel(root: string, outDir: string): void {
+function writeSurfacesPanel(
+  root: string,
+  outDir: string,
+  isToolkitCheckout: boolean,
+): void {
   const dir = join(outDir, 'surfaces')
   mkdirSync(dir, { recursive: true })
 
   const distSource = join(root, WEB_DIST)
-  const landingBody = existsSync(join(distSource, WEB_DIST_ENTRY))
-    ? (copyBuilt(distSource, join(dir, 'landing')),
-      '<iframe src="landing/index.html" loading="lazy"></iframe>')
-    : `<p class="empty">No ${WEB_DIST}/ build. Run bun run web:build, then regenerate the board.</p>`
+  const landingBody = !isToolkitCheckout
+    ? `<p class="empty">The landing page panel only renders in this toolkit's own checkout.</p>`
+    : existsSync(join(distSource, WEB_DIST_ENTRY))
+      ? (copyBuilt(distSource, join(dir, 'landing')),
+        '<iframe src="landing/index.html" loading="lazy"></iframe>')
+      : `<p class="empty">No ${WEB_DIST}/ build. Run bun run web:build, then regenerate the board.</p>`
 
   const teachSource = recordDir(root, 'teach')
   const teachBody = existsSync(join(teachSource, 'index.html'))
@@ -347,15 +376,21 @@ function writeSurfacesPanel(root: string, outDir: string): void {
   )
 }
 
-function writeComponentsPanel(root: string, outDir: string): void {
+function writeComponentsPanel(
+  root: string,
+  outDir: string,
+  isToolkitCheckout: boolean,
+): void {
   const dir = join(outDir, 'components')
   mkdirSync(dir, { recursive: true })
 
   const gallerySource = join(root, WEB_GALLERY_DIST)
-  const body = existsSync(join(gallerySource, WEB_GALLERY_DIST_ENTRY))
-    ? (copyBuilt(gallerySource, join(dir, 'gallery')),
-      '<iframe src="gallery/index.html" loading="lazy"></iframe>')
-    : `<p class="empty">No ${WEB_GALLERY_DIST}/ build. Run bun run web:gallery, then regenerate the board.</p>`
+  const body = !isToolkitCheckout
+    ? `<p class="empty">The components panel only renders in this toolkit's own checkout.</p>`
+    : existsSync(join(gallerySource, WEB_GALLERY_DIST_ENTRY))
+      ? (copyBuilt(gallerySource, join(dir, 'gallery')),
+        '<iframe src="gallery/index.html" loading="lazy"></iframe>')
+      : `<p class="empty">No ${WEB_GALLERY_DIST}/ build. Run bun run web:gallery, then regenerate the board.</p>`
 
   writeFileSync(join(dir, 'index.html'), panelPage('Components', body))
 }
@@ -416,13 +451,54 @@ function writeCandidatesPanel(root: string, outDir: string): void {
   const sections = found
     .map(
       ({ folder, images }) =>
-        `<h2>${escapeHtml(folder)}</h2>\n${images.map((image) => `<img src="${folder}/${image}" alt="${escapeHtml(image)}">`).join('\n')}`,
+        `<h2>${escapeHtml(folder)}</h2>\n${images.map((image) => `<img src="${escapeHtml(`${folder}/${image}`)}" alt="${escapeHtml(image)}">`).join('\n')}`,
     )
     .join('\n')
 
   writeFileSync(join(dir, 'index.html'), panelPage('Past candidates', sections))
 }
 
+function writeReferencesPanel(root: string, outDir: string): void {
+  const dir = join(outDir, 'references')
+  mkdirSync(dir, { recursive: true })
+
+  const referencesDir = recordDir(root, 'review', 'references')
+  if (!existsSync(referencesDir)) {
+    writeFileSync(
+      join(dir, 'index.html'),
+      panelPage(
+        'References',
+        `<p class="empty">No ${relative(root, referencesDir)} folder yet.</p>`,
+      ),
+    )
+    return
+  }
+
+  const images = imagesIn(referencesDir)
+  if (images.length === 0) {
+    writeFileSync(
+      join(dir, 'index.html'),
+      panelPage(
+        'References',
+        `<p class="empty">${relative(root, referencesDir)} exists but carries no image yet.</p>`,
+      ),
+    )
+    return
+  }
+
+  for (const image of images) {
+    cpSync(join(referencesDir, image), join(dir, image))
+  }
+
+  const sections = images
+    .map(
+      (image) => `<img src="${escapeHtml(image)}" alt="${escapeHtml(image)}">`,
+    )
+    .join('\n')
+
+  writeFileSync(join(dir, 'index.html'), panelPage('References', sections))
+}
+
 /**
  * Generates the board's page set into `outDir`, clearing whatever was there.
  *
@@ -433,11 +509,16 @@ function writeCandidatesPanel(root: string, outDir: string): void {
  * `cwd` is the caller's own working directory, resolved and passed in
  * explicitly rather than read here, so a test can exercise the checkout-
  * mismatch case without touching the process's real cwd.
+ *
+ * `isToolkitCheckout` gates the surfaces panel's landing-page half and the
+ * whole components panel, both of which read this repository's own build
+ * output rather than anything a target project produces.
  */
 export function generateBoard(
   root: string,
   outDir: string,
   cwd: string,
+  isToolkitCheckout: boolean,
 ): BoardOutcome {
   if (wouldDeleteRoot([root, cwd], outDir)) {
     return {
@@ -460,13 +541,15 @@ export function generateBoard(
       path: 'candidates/index.html',
     },
     { id: 'components', title: 'Components', path: 'components/index.html' },
+    { id: 'references', title: 'References', path: 'references/index.html' },
   ]
 
   writeTokensPanel(root, outDir)
-  writeSurfacesPanel(root, outDir)
+  writeSurfacesPanel(root, outDir, isToolkitCheckout)
   writeWireframesPanel(root, outDir)
   writeCandidatesPanel(root, outDir)
-  writeComponentsPanel(root, outDir)
+  writeComponentsPanel(root, outDir, isToolkitCheckout)
+  writeReferencesPanel(root, outDir)
 
   const indexPath = join(outDir, 'index.html')
   writeFileSync(indexPath, shellHtml(panels))

package/src/gate/measures.ts

@@ -126,11 +126,11 @@ export const SANDBOX_ASSERTED_FLOOR = 26
  * Where the retained counts the audit stage compares each run against are
  * read, relative to `root`.
  *
- * A function rather than a spelled constant, since the read now resolves at
+ * A function rather than a spelled constant, since the read resolves at
  * either surface root and a constant naming one of them would be believed of
- * a project that has moved. `canon audits run` owns writing it, and the write
- * stays at the creation default for this batch, so the two can disagree for
- * exactly the release window `src/surface-root.ts` documents.
+ * a project that has moved. `canon audits run` owns writing it, at
+ * `canon/config/baseline.json` now that the write has flipped, falling back to
+ * `.claude/canon/baseline.json` for a target that has not moved.
  */
 export function auditsBaselineRel(root: string): string {
   return relative(root, surfaceDir(root, 'canon', 'baseline.json'))

package/src/labels/map.ts

@@ -1,14 +1,23 @@
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
+import { resolveExisting } from '@/legacy-path'
 
 /**
- * Where a project declares its pull request label map, spelled once.
+ * Where a project declares its pull request label map.
  *
  * The file has already moved once, and that relocation rewrote every mention
- * across four surfaces. Nothing in code spells it anywhere else, so the next
- * move is one edit here rather than a sweep.
+ * across four surfaces. `LEGACY_MAP_REL` below is the one other place code
+ * spells it, kept only as a read fallback, so the next move is still one edit
+ * to the write path rather than a sweep.
  */
-export const MAP_REL = join('.claude', 'canon', 'pr-labels.toml')
+export const MAP_REL = join('canon', 'config', 'pr-labels.toml')
+
+/**
+ * Where the map lived before this move, `.claude/canon/pr-labels.toml`.
+ * `readLabelMap` falls back to it so a project that has not moved still reads
+ * its declared map.
+ */
+const LEGACY_MAP_REL = join('.claude', 'canon', 'pr-labels.toml')
 
 /** A label name and the path prefixes that earn it, in the map's own order. */
 export interface DomainRow {
@@ -90,9 +99,14 @@ export function parseLabelMap(source: string): LabelMap {
 
 /** Reads the map a project declares at `root`, or says why it could not. */
 export function readLabelMap(root: string): LabelMap {
+  const path = resolveExisting([
+    join(root, MAP_REL),
+    join(root, LEGACY_MAP_REL),
+  ])
+
   let source: string
   try {
-    source = readFileSync(join(root, MAP_REL), 'utf8')
+    source = readFileSync(path, 'utf8')
   } catch {
     return { kind: 'refused', reason: 'no-map' }
   }

package/src/legacy-path.ts

@@ -0,0 +1,15 @@
+import { existsSync } from 'node:fs'
+
+/**
+ * Where a fallback chain resolves for reading: the first path that exists,
+ * current first, or the first candidate when none exists yet, which is
+ * always the write target.
+ *
+ * `src/audits/baseline.ts`, `src/labels/map.ts`, and `src/sync/stamp.ts` each
+ * trail a file that moved, and each used to reason about its own chain
+ * separately. The tuple type keeps a caller from passing an empty list, since
+ * every chain here has a write target to fall back to.
+ */
+export function resolveExisting(paths: readonly [string, ...string[]]): string {
+  return paths.find((path) => existsSync(path)) ?? paths[0]
+}

package/src/migrate/plan.ts

@@ -44,6 +44,7 @@ export interface RenamePlan {
 const TOOLKIT_OWNED: readonly string[] = [
   '.claude/aitk/',
   '.claude/canon/',
+  'canon/config/',
   '.claude/hooks/',
   '.claude/rules/',
   '.claude/tooling/',

package/src/migrate/surface-roots.ts

@@ -20,13 +20,12 @@ const TO_ROOT: SurfaceRoot = 'canon'
 /**
  * Every entry this move relocates, at the name `.claude/` gives it.
  *
- * Read from `SURFACE_ENTRIES` rather than restated, less the one entry that
- * stays: `canon` names the install stamp folder, which batch 3 owns and which
- * `.claude/canon/` continues to hold until that batch lands.
+ * Read from `SURFACE_ENTRIES` rather than restated. `canon` names the install
+ * stamp folder and is the one entry whose name differs by root, which
+ * `sourcePrefix` and `destinationPrefix` already resolve through `spell`
+ * rather than restating the variant here.
  */
-export const MOVED_ENTRIES: readonly string[] = SURFACE_ENTRIES.filter(
-  (entry) => entry !== 'canon',
-)
+export const MOVED_ENTRIES: readonly string[] = SURFACE_ENTRIES
 
 function sourcePrefix(entry: string): string {
   return join(FROM_ROOT, spell(FROM_ROOT, entry))

package/src/project-root.ts

@@ -28,6 +28,22 @@ const readPackageName = (root: string): string | undefined => {
   }
 }
 
+/**
+ * Whether `root` is a checkout of this same package, judged by package name
+ * rather than by path equality against `PROJECT_ROOT`.
+ *
+ * A linked worktree tracks the identical `package.json` the main worktree
+ * does, so this reads true for either. Comparing `root` against `PROJECT_ROOT`
+ * directly reads true only for the one directory this process happened to
+ * load its own source from, which is wrong for a caller whose CLI runs out of
+ * a linked worktree while `root` correctly points at the main one, or at
+ * another worktree of the same repository.
+ */
+export function isOwnCheckout(root: string): boolean {
+  const ownName = readPackageName(PROJECT_ROOT)
+  return ownName !== undefined && readPackageName(root) === ownName
+}
+
 /**
  * Walks upward from `startDir` for the nearest ancestor `package.json`
  * sharing this package's own `name`, and reports its path when that ancestor