@erclx/canon 4.6.1 → 4.8.0

package/scripts/core/check-ignore-parity.sh

@@ -9,22 +9,22 @@ GITIGNORE="$PROJECT_ROOT/.gitignore"
 MANIFEST="$PROJECT_ROOT/tooling/claude/manifest.toml"
 SECTION="# Claude"
 
-# Divergences this repository has decided to keep, one `<entry>|<reason>` per
-# line, matched after the trailing slash is stripped. Each names a path the
-# enclosing repository ignores and the claude manifest deliberately does not
-# ship, so a target keeps tracking it.
+# Parity is exact, with no exception list behind it, and the move to `.canon/`
+# is what removed the one there was. Its two members each named a path inside
+# `.claude/` that this repository ignored and the manifest withheld, so a target
+# kept tracking it. A single root entry can withhold nothing inside itself: git
+# does not descend into an excluded directory, so a re-inclusion like
+# `!.canon/diagrams/` matches nothing. Retiring both is what buys the one line.
 #
-# This is the canonical list. `.gitignore` and the manifest carry a pointer
-# beside their own entries rather than a second copy of the reason, and
-# `.claude/context/tooling.md` carries the narrative behind both.
+# The diagrams divergence is the one that cost something. A target used to track
+# its diagrams and keep the context audit's default coverage of them, and it now
+# ignores them with the rest of its records, so that coverage is gone unless the
+# project names the folder itself. `.claude/context/tooling.md` carries the
+# narrative.
 #
-# A sanction that no longer describes a divergence fails the same as an
-# unsanctioned one. An exception outliving its reason is what teaches the next
-# reader to widen the list rather than to read it.
-SANCTIONED=(
-  ".claude/diagrams|a target that tracks its diagrams keeps the context audit's default coverage of them, which ignoring the folder for every target would take away. This repository backs the folder through its records remote instead."
-  ".claude/README.md|the landing page a records pull writes back into a repository that set up a records remote. A target has not, so it never receives the file."
-)
+# An exception mechanism is not kept against a future divergence, because an
+# empty one cannot be exercised and a check nobody can test is a check nobody
+# should trust. It comes back with its first real member or not at all.
 
 if [ ! -f "$GITIGNORE" ]; then
   echo "No .gitignore at ${GITIGNORE#"$PROJECT_ROOT/"}, ignore parity unverifiable." >&2
@@ -38,15 +38,15 @@ fi
 
 # A gitignore pattern and a manifest entry describe the same folder whether or
 # not either spells the trailing slash, so presence is compared with it dropped.
-# `.claude/.tmp` and `.claude/.tmp/` are the live instance of that pair.
+# No live pair differs that way now that both lists carry the same two entries,
+# and the normalization stays because either side may be written without one.
 normalize() {
   printf '%s\n' "${1%/}"
 }
 
 # Every pattern the file carries, comments and blank lines dropped. The whole
-# file rather than one header, because `.claude/teach/` sits under a header of
-# its own and reading the `# Claude` header alone would report it missing from a
-# list that carries it.
+# file rather than one header, since a claude-scoped entry filed under a header
+# of its own would otherwise read as missing from a list that carries it.
 gitignore_patterns() {
   awk '{ sub(/[[:space:]]+$/, "") } $0 ~ /^[[:space:]]*#/ || $0 == "" { next } { print }' "$GITIGNORE"
 }
@@ -106,7 +106,6 @@ if [ ${#shipped[@]} -eq 0 ]; then
 fi
 
 failures=""
-sanction_notes=""
 
 # Entries the manifest ships that this repository does not ignore. A target is
 # told to ignore a folder the toolkit itself tracks, which no decision sanctions,
@@ -121,48 +120,22 @@ done
 # and says nothing about `node_modules/` or `.env`.
 #
 # `.canon` is read as a bare root as well as a prefix, since it is one line
-# covering a whole tree where `.claude/` is thirteen lines naming folders inside
-# a root that also holds tracked content. Leaving it out is what would let a new
-# entry sit outside the only stage comparing the two lists, which is the
-# direction that goes silently blind.
+# covering a whole tree where `.claude/` names a folder inside a root that also
+# holds tracked content. Leaving it out is what would let a new entry sit outside
+# the only stage comparing the two lists, which is the direction that goes
+# silently blind.
 for pattern in "${ignored[@]}"; do
   case "$pattern" in
   .claude/* | .canon | .canon/*) ;;
   *) continue ;;
   esac
   contains "$pattern" "${shipped[@]}" && continue
-
-  matched=false
-  for sanction in "${SANCTIONED[@]}"; do
-    [ "${sanction%%|*}" = "$pattern" ] || continue
-    matched=true
-    sanction_notes="$sanction_notes  $pattern stays out of the manifest: ${sanction#*|}"$'\n'
-    break
-  done
-
-  if [ "$matched" = false ]; then
-    failures="$failures  $pattern is ignored here and absent from the manifest"$'\n'
-  fi
-done
-
-# A sanction naming a path that is no longer divergent, either because the
-# manifest took it or because .gitignore dropped it.
-for sanction in "${SANCTIONED[@]}"; do
-  entry="${sanction%%|*}"
-  if contains "$entry" "${ignored[@]}" && ! contains "$entry" "${shipped[@]}"; then
-    continue
-  fi
-  failures="$failures  $entry is sanctioned as a divergence and is no longer one"$'\n'
+  failures="$failures  $pattern is ignored here and absent from the manifest"$'\n'
 done
 
 if [ -n "$failures" ]; then
   echo "The ignore set a target receives disagrees with this repository's own:" >&2
   printf '%s' "$failures" >&2
-  echo "Add the entry to the \"$SECTION\" array in ${MANIFEST#"$PROJECT_ROOT/"} and to .gitignore, or record it in SANCTIONED in scripts/core/check-ignore-parity.sh with the reason it stays apart." >&2
+  echo "Add the entry to the \"$SECTION\" array in ${MANIFEST#"$PROJECT_ROOT/"} and to .gitignore. The two lists are compared exactly, and nothing here records an exception." >&2
   exit 1
 fi
-
-if [ -n "$sanction_notes" ]; then
-  echo "Sanctioned divergences from the ignore set a target receives:"
-  printf '%s' "$sanction_notes"
-fi

package/scripts/core/install-check.sh

@@ -7,7 +7,7 @@ PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
 
 source "$PROJECT_ROOT/scripts/lib/ui.sh"
 
-TMP_ROOT="$PROJECT_ROOT/.claude/.tmp/install-check"
+TMP_ROOT="$PROJECT_ROOT/.canon/tmp/install-check"
 CLONE_DIR="$TMP_ROOT/clone"
 TARGET_DIR="$TMP_ROOT/target"
 KEEP=0
@@ -20,10 +20,10 @@ for arg in "$@"; do
 Usage: scripts/core/install-check.sh [--keep]
 
 Verifies the README install path end to end:
-  1. Clones this repo into .claude/.tmp/install-check/clone
+  1. Clones this repo into .canon/tmp/install-check/clone
   2. Runs bun install in the clone
   3. Runs the CLI with --help to confirm it executes
-  4. Scaffolds a fresh project in .claude/.tmp/install-check/target
+  4. Scaffolds a fresh project in .canon/tmp/install-check/target
   5. Runs canon init and asserts a scaffold landed
 
 Flags:
@@ -83,7 +83,7 @@ log_step "Assert scaffold"
 # `@`-reference convention rule is the one snippets-domain file that still
 # installs, since `base` carries `governance/rules/snippets/` as a
 # folder-whole entry the same way it does `core` and `claude`.
-for path in "CLAUDE.md" ".claude/wiki/index.md" ".claude" ".claude/context/index.md" ".claude/wireframes/index.md" ".claude/diagrams/index.md" \
+for path in "CLAUDE.md" ".claude/wiki/index.md" ".claude" ".claude/context/index.md" ".claude/wireframes/index.md" ".canon/diagrams/index.md" \
   ".prettierrc" ".editorconfig" ".lintstagedrc" ".husky/pre-commit" ".github/workflows/verify.yml" "scripts/verify.sh" \
   ".claude/rules/core/000-constitution.md" ".claude/rules/snippets/505-at-references.md"; do
   if [ ! -e "$TARGET_DIR/$path" ]; then

package/scripts/core/regen-hero.sh

@@ -4,15 +4,18 @@
 # Only the HTML regenerates here. The PNG beside it is a chromium render whose
 # bytes move with the browser version, so asserting it in verify.sh would fail
 # on a machine whose chromium differs rather than on a stale count. Rebuild the
-# image with `canon capture assets/hero.html` after this script reports a change.
+# image with `canon capture assets/hero.html --selector .window` after this
+# script reports a change. The selector has no default, since the element a
+# capture crops to belongs to the page rather than to the command, and `.window`
+# is the class this repository's own two sources declare.
 # That capture also writes assets/hero.stamp, which records the digest of the
 # markup it rendered and is what the Hero stage compares, so all three files
 # commit together. The frame carries no version. `package.json` is bumped on main by the release
 # tooling, so embedding it drifts every open branch on the next release and the
 # stage then fails for work that touched nothing.
 #
-# Clone-only. `src/capture` is excluded from the published tarball, and this
-# script reads the repository's own catalogs, so a registry install has neither.
+# Clone-only. `canon capture` ships now, but this script reads the repository's
+# own catalogs, which a registry install does not carry.
 set -e
 set -o pipefail
 

package/scripts/core/snapshot.sh

@@ -10,7 +10,7 @@ source "$PROJECT_ROOT/scripts/lib/ui.sh"
 
 NESTED="${VERIFY_NESTED:-false}"
 
-OUTPUT_FILE=".claude/.tmp/project/PROJECT-SNAPSHOT.md"
+OUTPUT_FILE=".canon/tmp/project/PROJECT-SNAPSHOT.md"
 
 check_dependencies() {
   command -v find >/dev/null 2>&1 || log_error "find not installed"

package/scripts/manage-sandbox.sh

@@ -163,7 +163,7 @@ init_empty_sandbox() {
   mkdir -p "$SANDBOX"
 
   cat <<EOF >"$SANDBOX/.gitignore"
-.claude/.tmp/
+.canon/tmp/
 node_modules
 EOF
   (

package/scripts/tooling/verify.sh

@@ -16,7 +16,7 @@ show_help() {
   echo -e "${GREY}│${NC}    --keep       ${GREY}# Keep tmp dir after run for inspection${NC}"
   echo -e "${GREY}│${NC}    -h, --help   ${GREY}# Show this help message${NC}"
   echo -e "${GREY}│${NC}"
-  echo -e "${GREY}│${NC}  Scaffolds <stack> into .claude/.tmp/verify-<stack>/, syncs the full"
+  echo -e "${GREY}│${NC}  Scaffolds <stack> into .canon/tmp/verify-<stack>/, syncs the full"
   echo -e "${GREY}│${NC}  layer chain, and runs check + test:e2e + screenshot."
   echo -e "${GREY}└${NC}"
   exit 0
@@ -100,7 +100,7 @@ main() {
   open_timeline "canon tooling verify $stack"
   trap close_timeline EXIT
 
-  local tmp_root="$PROJECT_ROOT/.claude/.tmp"
+  local tmp_root="$PROJECT_ROOT/.canon/tmp"
   local tmp_dir="$tmp_root/verify-$stack"
 
   mkdir -p "$tmp_root"

package/snippets/claude/decision-memo.md

@@ -1,4 +1,4 @@
-Produce a decision memo for a research or should-we question. This is the decision-heavy counterpart to `claude-feature`, which plans a build. Write one file per independent concern under `.claude/plans/feature-<slug>.md`, or answer inline when the plan is small. Use the same plans folder as `claude-feature`.
+Produce a decision memo for a research or should-we question. This is the decision-heavy counterpart to `claude-feature`, which plans a build. Write one file per independent concern under `.canon/plans/feature-<slug>.md`, or answer inline when the plan is small. Use the same plans folder as `claude-feature`.
 
 Read the current state from the code and docs before recommending. Do not assume it.
 

package/snippets/claude/feature-recap.md

@@ -1,4 +1,4 @@
-Recap the implementation this session completed. Read the plan file referenced in the session (usually `.claude/plans/feature-<slug>.md`) and produce a verification block.
+Recap the implementation this session completed. Read the plan file referenced in the session (usually `.canon/plans/feature-<slug>.md`) and produce a verification block.
 
 Output this shape, nothing else:
 

package/src/audits/catalog.ts

@@ -488,7 +488,7 @@ export const AUDITS: readonly AuditSpec[] = [
     corpus: 'tracked',
     // The one reason this verb refuses for that is an absence rather than a
     // break, on the same test the reach check and the skill audit take: no
-    // target adopts `.claude/context/`, `.claude/diagrams/`, and
+    // target adopts `.claude/context/`, `.canon/diagrams/`, and
     // `.claude/wireframes/` all at once, so without the allowance every such
     // project reports the verb unmeasured on every run and never changes.
     absentReasons: ['no-folders'] satisfies ContextAuditRefusal[],

package/src/capture/render.ts

@@ -0,0 +1,166 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { basename, dirname } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { chromium } from 'playwright-core'
+import type { Browser, Page } from 'playwright-core'
+import type { CaptureSource } from '@/capture/sources'
+import { primaryFontFamily, resolveCaptureSources } from '@/capture/sources'
+import { formatStamp, hashSource, stampPath } from '@/capture/stamp'
+
+/**
+ * Every browser reference the capture command makes lives in this module, and
+ * `src/commands/capture.ts` reaches it through a dynamic import so `src/cli.ts`
+ * never resolves the engine at startup.
+ *
+ * It ships, like `@/demo/drive`, `@/inventory/walk`, and `@/driver/drive`.
+ * Regenerating this repository's own committed images was the reason it stayed
+ * behind, and it was a reason about one caller rather than about the mechanism:
+ * a target renders its own generated pages and proves its own fonts resolved,
+ * which is the whole of what this module does.
+ *
+ * It imports `playwright-core` rather than `@playwright/test` for the same
+ * reason the three siblings do. The test runner is a development dependency the
+ * published tarball never carries, so the earlier import resolved here and
+ * threw `ERR_MODULE_NOT_FOUND` in every target install.
+ */
+
+const DEVICE_SCALE_FACTOR = 2
+const FONT_PROBE_SIZE = 72
+const FONT_PROBE_TEXT = 'canon capture 0123456789'
+const ABSENT_FAMILY = '__canon_absent_family__'
+
+export interface CaptureOptions {
+  selector: string
+  outDir?: string
+}
+
+export type CaptureResult =
+  | {
+      status: 'rendered'
+      htmlPath: string
+      pngPath: string
+      width: number
+      height: number
+    }
+  | { status: 'failed'; htmlPath: string; reason: string }
+
+export async function captureSources(
+  sourcePath: string,
+  options: CaptureOptions,
+): Promise<CaptureResult[]> {
+  const sources = resolveCaptureSources(sourcePath, options.outDir)
+  if (!sources.length) return []
+
+  const browser = await chromium.launch()
+  try {
+    return await Promise.all(
+      sources.map((source) => captureOne(browser, source, options.selector)),
+    )
+  } finally {
+    await browser.close()
+  }
+}
+
+/**
+ * Resolves to a failed result rather than throwing, so one source that cannot
+ * render does not drop the rest of the batch.
+ */
+async function captureOne(
+  browser: Browser,
+  source: CaptureSource,
+  selector: string,
+): Promise<CaptureResult> {
+  const page = await browser.newPage({
+    deviceScaleFactor: DEVICE_SCALE_FACTOR,
+  })
+  try {
+    await page.goto(pathToFileURL(source.htmlPath).href)
+    const element = page.locator(selector).first()
+    if ((await element.count()) === 0) {
+      return failed(source, `no element matched ${selector}`)
+    }
+
+    await page.evaluate(() => document.fonts.ready.then(() => undefined))
+    const family = primaryFontFamily(
+      await element.evaluate((node) => getComputedStyle(node).fontFamily),
+    )
+    if (family && !(await resolvesFont(page, family))) {
+      return failed(
+        source,
+        `${family} is not installed, so the capture would rewrap against a fallback`,
+      )
+    }
+
+    mkdirSync(dirname(source.pngPath), { recursive: true })
+    const png = await element.screenshot({ omitBackground: true })
+    writeFileSync(source.pngPath, png)
+    writeStamp(source, png)
+    return {
+      status: 'rendered',
+      htmlPath: source.htmlPath,
+      pngPath: source.pngPath,
+      width: png.readUInt32BE(16),
+      height: png.readUInt32BE(20),
+    }
+  } catch (error) {
+    return failed(
+      source,
+      error instanceof Error ? error.message : String(error),
+    )
+  } finally {
+    await page.close()
+  }
+}
+
+/**
+ * Runs inside the render rather than in a wrapper around it, so a capture
+ * cannot succeed and leave the provenance unrecorded. A throw here reaches the
+ * caller's catch and reports the source as failed, which is correct: a PNG
+ * whose stamp never landed is the state the verify stage exists to reject.
+ *
+ * The source is stored as a bare filename. An absolute path would record the
+ * machine that ran the capture into a tracked file and differ per checkout.
+ *
+ * The image digest is taken over the buffer the screenshot returned rather than
+ * by reading the file back, so the stamp describes the bytes this run wrote.
+ */
+function writeStamp(source: CaptureSource, png: Uint8Array): void {
+  writeFileSync(
+    stampPath(source.pngPath),
+    formatStamp({
+      source: basename(source.htmlPath),
+      sourceSha256: hashSource(readFileSync(source.htmlPath)),
+      imageSha256: hashSource(png),
+    }),
+  )
+}
+
+function failed(source: CaptureSource, reason: string): CaptureResult {
+  return { status: 'failed', htmlPath: source.htmlPath, reason }
+}
+
+/**
+ * Compares the family's text metrics against a family that cannot exist. Equal
+ * widths mean the browser fell through to its default for both, which is the
+ * only signal available: `document.fonts.check` reports every system family as
+ * present, including invented ones.
+ */
+async function resolvesFont(page: Page, family: string): Promise<boolean> {
+  return page.evaluate(
+    ({ family, absent, size, text }) => {
+      const context = document.createElement('canvas').getContext('2d')
+      if (!context) return false
+      const widthOf = (name: string): number => {
+        context.font = `${size}px "${name}"`
+        return context.measureText(text).width
+      }
+      return widthOf(family) !== widthOf(absent)
+    },
+    {
+      family,
+      absent: ABSENT_FAMILY,
+      size: FONT_PROBE_SIZE,
+      text: FONT_PROBE_TEXT,
+    },
+  )
+}

package/src/capture/sources.ts

@@ -0,0 +1,42 @@
+import { readdirSync, statSync } from 'node:fs'
+import { basename, dirname, extname, join } from 'node:path'
+
+export interface CaptureSource {
+  htmlPath: string
+  pngPath: string
+}
+
+/**
+ * Pairs each HTML source with the PNG it renders to. A directory expands to
+ * every `.html` directly inside it, so adding a capture is a file drop rather
+ * than a flag. Omitting `outDir` writes the PNG beside its source.
+ */
+export function resolveCaptureSources(
+  sourcePath: string,
+  outDir?: string,
+): CaptureSource[] {
+  const htmlPaths = statSync(sourcePath).isDirectory()
+    ? readdirSync(sourcePath)
+        .filter((name) => extname(name) === '.html')
+        .sort()
+        .map((name) => join(sourcePath, name))
+    : [sourcePath]
+
+  return htmlPaths.map((htmlPath) => ({
+    htmlPath,
+    pngPath: join(
+      outDir ?? dirname(htmlPath),
+      `${basename(htmlPath, '.html')}.png`,
+    ),
+  }))
+}
+
+/**
+ * Reads the first family from a computed `font-family` value, which is the font
+ * the source asks for and the one a capture has to prove resolved. Quoting is
+ * the source's choice, so both spellings arrive here.
+ */
+export function primaryFontFamily(declaration: string): string {
+  const first = declaration.split(',')[0]?.trim() ?? ''
+  return first.replace(/^['"]|['"]$/g, '')
+}

package/src/capture/stamp.ts

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto'
+import { basename, dirname, extname, join } from 'node:path'
+
+const HASH_ALGORITHM = 'sha256'
+const STAMP_EXTENSION = '.stamp'
+
+/**
+ * Provenance for one rendered PNG: the markup it came from and a digest over
+ * each side of the pair. `assertStampField` in `src/gate/measures.ts` reads both
+ * digests back off the first whitespace-separated token, so the field names, the
+ * colon, and the space after it are a contract between the writer and the gate
+ * rather than formatting.
+ *
+ * Both sides are recorded because either can move alone. The markup digest
+ * catches an edit committed with no capture, and the image digest catches a PNG
+ * replaced under markup that never changed.
+ */
+export interface CaptureStamp {
+  readonly source: string
+  readonly sourceSha256: string
+  readonly imageSha256: string
+}
+
+/**
+ * A capture writes its stamp beside its PNG rather than beside its HTML,
+ * because `--out` moves the image away from the source and the stamp answers a
+ * question about the image.
+ */
+export function stampPath(pngPath: string): string {
+  return join(
+    dirname(pngPath),
+    `${basename(pngPath, extname(pngPath))}${STAMP_EXTENSION}`,
+  )
+}
+
+/**
+ * Digests the whole file rather than the counts inside it. A template edit
+ * changes what the image shows without moving any count, and the whole point of
+ * the stamp is that it needs no knowledge of what the markup renders.
+ */
+export function hashSource(bytes: Uint8Array): string {
+  return createHash(HASH_ALGORITHM).update(bytes).digest('hex')
+}
+
+export function formatStamp(stamp: CaptureStamp): string {
+  return [
+    `source: ${stamp.source}`,
+    `source-sha256: ${stamp.sourceSha256}`,
+    `image-sha256: ${stamp.imageSha256}`,
+    '',
+  ].join('\n')
+}

package/src/claude/cases/all.ts

@@ -12,7 +12,7 @@ import { SETUP_CASES } from '@/claude/cases/setup'
  * Bootstrapped from each skill's own quoted trigger phrases and then
  * rephrased and supplemented rather than shipped verbatim, since a positive
  * lifted unchanged from a trigger passes by construction and never tests a
- * person's own words. See `.claude/groundwork/42-ai-blueprint/08-spikes.md`
+ * person's own words. See `.canon/groundwork/42-ai-blueprint/08-spikes.md`
  * for the extraction arm this corpus replaces as the shipped measure.
  */
 export const SKILL_CASES: readonly SkillCase[] = [

package/src/claude/seeds.ts

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs'
 import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { copyPreservingMode } from '@/copy'
+import { creationRel, isRecordEntry } from '@/record-root'
 import { rewritesOnInstall, stripSeedMarker } from '@/seed-marker'
 
 const SEEDS_DIR = join('tooling', 'claude', 'seeds')
@@ -81,13 +82,23 @@ export function planSeeds(root: string, target: string): SeedEntry[] {
   }
 
   for (const subdir of SUBDIRS) {
+    // The seed tree authors every subdirectory under `.claude/`, and three of
+    // them are record folders that install under the record root instead. A
+    // target that has not migrated resolves back to `.claude/`, so the same seed
+    // lands beside the records already there rather than opening a second root.
+    // Scaffolding one under `.claude/` now would also land it outside the single
+    // `.canon/` ignore entry a target receives, which tracks the memory pen.
+    const installRel = isRecordEntry(subdir)
+      ? creationRel(target, subdir)
+      : join(CLAUDE_DIR, subdir)
+
     for (const name of listLevel(join(source, subdir))) {
       const rel = `${subdir}/${name}`
       seeds.push({
         src: join(source, subdir, name),
-        dest: join(destDir, subdir, name),
+        dest: join(target, installRel, name),
         scanLabel: rel,
-        applyLabel: join(CLAUDE_DIR, subdir, name),
+        applyLabel: join(installRel, name),
         scope: 'claude',
         executable: subdir === HOOKS,
       })

package/src/claude/skills-rank.ts

@@ -8,7 +8,7 @@ import { listSkillsAt, resolveSkillsCorpus } from '@/claude/skills-list'
  * asks whether the descriptions are separable by the words they use, and
  * Claude Code does not route this way.
  *
- * Ported from `.claude/groundwork/42-ai-blueprint/evidence/rank.ts`, which
+ * Ported from `.canon/groundwork/42-ai-blueprint/evidence/rank.ts`, which
  * ran once against this catalog and named the collisions this measure now
  * tracks on a cadence.
  */

package/src/cli.ts

@@ -72,11 +72,11 @@ function showHelp(): void {
     `${GREY}│${NC}    demo [cmd]         ${GREY}# Record a running app (compile, run)${NC}`,
     `${GREY}│${NC}    inventory [subj]   ${GREY}# Report one computed property across every route${NC}`,
     `${GREY}│${NC}    drive <url> <run>  ${GREY}# Walk a page through named interactions and measure each state${NC}`,
-    `${GREY}│${NC}    feedback           ${GREY}# Write toolkit feedback from stdin to .claude/review/feedback/${NC}`,
+    `${GREY}│${NC}    feedback           ${GREY}# Write toolkit feedback from stdin to .canon/review/feedback/${NC}`,
     `${GREY}│${NC}    transcripts <url>  ${GREY}# Fetch a YouTube transcript with metadata frontmatter${NC}`,
     `${GREY}│${NC}    tasks [cmd]        ${GREY}# Task board commands (archive)${NC}`,
-    `${GREY}│${NC}    intake [cmd]       ${GREY}# Intake folders under .claude/intake/ (list, answer)${NC}`,
-    `${GREY}│${NC}    teach [cmd]        ${GREY}# Learning workspaces under .claude/teach/ (list, open, resource, glossary)${NC}`,
+    `${GREY}│${NC}    intake [cmd]       ${GREY}# Intake folders under .canon/intake/ (list, answer)${NC}`,
+    `${GREY}│${NC}    teach [cmd]        ${GREY}# Learning workspaces under .canon/teach/ (list, open, resource, glossary)${NC}`,
     `${GREY}│${NC}    comments [cmd]     ${GREY}# Measure comment density and trend (scan)${NC}`,
     `${GREY}│${NC}    context [cmd]      ${GREY}# Report context folder health (audit)${NC}`,
     `${GREY}│${NC}    markdown [cmd]     ${GREY}# Report markdown against the attribute standards (audit)${NC}`,
@@ -120,8 +120,8 @@ function showHelp(): void {
     `${GREY}│${NC}    canon design render`,
     `${GREY}│${NC}    canon slides render`,
     `${GREY}│${NC}    canon slides list --json`,
-    `${GREY}│${NC}    canon capture assets/install.html`,
-    `${GREY}│${NC}    canon serve .claude/teach`,
+    `${GREY}│${NC}    canon capture assets/install.html --selector .window`,
+    `${GREY}│${NC}    canon serve .canon/teach`,
     `${GREY}│${NC}    canon inventory focus --json`,
     `${GREY}│${NC}    canon drive http://localhost:4173 run.json --json`,
     `${GREY}│${NC}    pbpaste | canon feedback`,