@erclx/canon 5.34.0 → 5.36.0

package/src/tooling/inject.ts

@@ -20,13 +20,7 @@ import {
   readPackage,
   serializePackage,
 } from '@/tooling/package'
-import {
-  hasSpellConfig,
-  isSubfolderTarget,
-  isWithheldInSubfolder,
-  SUBFOLDER_SPELL_CONFIG,
-  subfolderSpellConfig,
-} from '@/tooling/subfolder'
+import { isSubfolderTarget, isWithheldInSubfolder } from '@/tooling/subfolder'
 import { logAdd, logRemove, logStep, logWarn } from '@/cli/ui'
 
 export async function injectConfigs(
@@ -72,30 +66,13 @@ async function writeSeed(src: string, dest: string): Promise<void> {
 }
 
 /**
- * Copies a seed when the target lacks it. When the target already has one and
- * the seed is a `.txt` word list, missing lines are appended and the file is
- * re-sorted. Every other existing file is left untouched.
+ * Copies a seed when the target lacks it and leaves an existing file untouched.
  */
-async function mergeSeedFile(src: string, dest: string): Promise<void> {
+async function copySeedIfMissing(src: string, dest: string): Promise<void> {
   await mkdir(dirname(dest), { recursive: true })
+  if (existsSync(dest)) return
 
-  if (!existsSync(dest)) {
-    await writeSeed(src, dest)
-    return
-  }
-
-  if (!src.endsWith('.txt')) return
-
-  const existing = (await readFile(dest, 'utf8')).split('\n')
-  const incoming = (await readFile(src, 'utf8')).split('\n')
-  const missing = incoming.filter(
-    (word) => word !== '' && !existing.includes(word),
-  )
-
-  if (missing.length === 0) return
-
-  const merged = [...existing.filter((line) => line !== ''), ...missing].sort()
-  await writeFile(dest, `${merged.join('\n')}\n`)
+  await writeSeed(src, dest)
 }
 
 export async function injectSeeds(
@@ -116,20 +93,12 @@ export async function injectSeeds(
     logStep(`Applying ${manifest.name} seeds`)
     for (const rel of files) {
       const dest = resolveSurfacePath(target, rel)
-      await mergeSeedFile(join(manifest.seedsDir, rel), dest)
+      await copySeedIfMissing(join(manifest.seedsDir, rel), dest)
       logAdd(relative(target, dest))
       applied.push(rel)
     }
   }
 
-  const spellConfig = isSubfolder ? subfolderSpellConfig(chain) : undefined
-  if (spellConfig !== undefined && !hasSpellConfig(target)) {
-    logStep('Applying subfolder spell config')
-    await writeFile(join(target, SUBFOLDER_SPELL_CONFIG), spellConfig)
-    logAdd(SUBFOLDER_SPELL_CONFIG)
-    applied.push(SUBFOLDER_SPELL_CONFIG)
-  }
-
   return applied
 }
 

package/src/tooling/read.ts

@@ -28,9 +28,8 @@ function toolingSourceDir(root: string): string {
 }
 
 /**
- * The roots a stack reference resolves against, mirroring `standardRoots` in
- * `src/standards/read.ts`. No stack reference installs into a project any
- * more, so the package corpus is the only root that answers there. The
+ * The roots a stack reference resolves against. No stack reference installs
+ * into a project any more, so the package corpus is the only root that answers there. The
  * authoring root stays ahead of it for the toolkit's own repository, which
  * authors the corpus this reads, and for a project authoring stacks of its
  * own under the same layout.

package/src/tooling/scan.ts

@@ -16,13 +16,7 @@ import {
   readPackage,
   type ScriptState,
 } from '@/tooling/package'
-import {
-  hasSpellConfig,
-  isSubfolderTarget,
-  isWithheldInSubfolder,
-  SUBFOLDER_SPELL_CONFIG,
-  subfolderSpellConfig,
-} from '@/tooling/subfolder'
+import { isSubfolderTarget, isWithheldInSubfolder } from '@/tooling/subfolder'
 
 export interface ConfigState {
   readonly rel: string
@@ -73,9 +67,9 @@ function isIdentical(a: string, b: string): boolean {
  * so the path is reported once.
  *
  * A target below its git toplevel is scanned as a subfolder: a config or seed
- * GitHub reads only at the root moves to `withheld` and counts as no change,
- * and the nested spell config joins the seeds. The scope is read here so every
- * caller of `scan` agrees without passing a flag.
+ * GitHub reads only at the root moves to `withheld` and counts as no change.
+ * The scope is read here so every caller of `scan` agrees without passing a
+ * flag.
  */
 export function scan(chain: readonly Manifest[], target: string): ScanResult {
   const isSubfolder = isSubfolderTarget(target)
@@ -132,13 +126,6 @@ export function scan(chain: readonly Manifest[], target: string): ScanResult {
     }
   }
 
-  if (isSubfolder && subfolderSpellConfig(chain) !== undefined) {
-    seeds.push({
-      rel: SUBFOLDER_SPELL_CONFIG,
-      state: hasSpellConfig(target) ? 'present' : 'missing',
-    })
-  }
-
   const packagePath = join(target, 'package.json')
   const pkg = readPackage(packagePath)
   const scripts = pkg ? collectScripts(chain, pkg) : []

package/src/tooling/subfolder.ts

@@ -1,18 +1,9 @@
-import { existsSync, readdirSync, realpathSync } from 'node:fs'
-import { basename, join, relative } from 'node:path'
+import { realpathSync } from 'node:fs'
+import { relative } from 'node:path'
 import { gitEnv } from '@/git/env'
-import { isWholeStack, type Manifest, seedFiles } from '@/tooling/manifest'
-
-/**
- * The path the generated subfolder spell config is written to. Written
- * copy-once, since a project that already configured cspell here owns it.
- */
-export const SUBFOLDER_SPELL_CONFIG = 'cspell.json'
 
 const WITHHELD_PREFIX = '.github/'
 
-const SPELL_CONFIG_NAMES = ['cspell.json', '.cspell.json']
-
 /**
  * Whether the target sits below the root of the git repository holding it. A
  * target outside any repository, or one git cannot read, counts as a root, so
@@ -57,58 +48,3 @@ export function subfolderPath(target: string): string | undefined {
 export function isWithheldInSubfolder(rel: string): boolean {
   return rel.startsWith(WITHHELD_PREFIX)
 }
-
-/**
- * Whether the target already carries a cspell config of its own, in any of
- * the file names cspell searches for.
- */
-export function hasSpellConfig(target: string): boolean {
-  if (SPELL_CONFIG_NAMES.some((name) => existsSync(join(target, name)))) {
-    return true
-  }
-  if (!existsSync(target)) return false
-  return readdirSync(target).some((name) => name.startsWith('cspell.config.'))
-}
-
-/**
- * Builds the nested cspell config that registers a subfolder's seeded word
- * lists. A root `cspell '**'` merges it with the root config for files under
- * the subfolder. Each dictionary takes a `local-` name, since reusing a root
- * dictionary's name shadows it inside the subfolder and a root word then fails
- * there.
- *
- * Returns nothing when the chain carries `base`, whose own seed already writes
- * a config, or when no stack seeds a word list.
- */
-export function subfolderSpellConfig(
-  chain: readonly Manifest[],
-): string | undefined {
-  if (
-    chain.some((manifest) => manifest.name === 'base' && isWholeStack(manifest))
-  ) {
-    return undefined
-  }
-
-  const lists = new Set<string>()
-  for (const manifest of chain) {
-    for (const rel of seedFiles(manifest)) {
-      if (rel.startsWith('.cspell/') && rel.endsWith('.txt')) lists.add(rel)
-    }
-  }
-  if (lists.size === 0) return undefined
-
-  const definitions = [...lists].sort().map((path) => ({
-    name: `local-${basename(path, '.txt')}`,
-    path,
-    addWords: true,
-  }))
-
-  const config = {
-    version: '0.2',
-    dictionaryDefinitions: definitions,
-    dictionaries: definitions.map((definition) => definition.name),
-    ignorePaths: ['.cspell/**'],
-  }
-
-  return `${JSON.stringify(config, null, 2)}\n`
-}

package/tooling/astro/manifest.toml

@@ -20,7 +20,6 @@ packages = [
 "preview" = "WORKTREE_PORT_OFFSET=$(bash scripts/worktree-port.sh) && export WORKTREE_PORT_OFFSET && astro preview"
 "astro" = "astro"
 "typecheck" = "astro check"
-"setup" = "./scripts/setup.sh"
 "card:dev" = "WORKTREE_PORT_OFFSET=$(bash scripts/worktree-port.sh) && export WORKTREE_PORT_OFFSET && astro dev --config card.config.mjs"
 "card:check" = "bash scripts/check-card-exclusion.sh"
 

package/tooling/astro/reference.md

@@ -34,14 +34,6 @@ Unit-test React island components (`.tsx`) only. Do not test `.astro` files. Pag
 
 Vitest is pinned to `^3` in the web manifest. Vitest `^4` bundles rolldown-vite (vite@8), which ignores the esbuild JSX config in `@vitejs/plugin-react` and breaks `.tsx` tests, plus emits deprecation warnings. Unpin once `@astrojs/react` ships a rolldown-aware plugin (or astro's bundled vite reaches 8).
 
-## Setup script
-
-- File: `scripts/setup.sh`. Destructive: deletes `.git` and self-removes after running. Run once immediately after scaffolding.
-- Prompt for project name, normalize to kebab-case, derive title-cased display name.
-- Update `package.json` name and version, inject verify/clean/update scripts, remove setup.
-- Update `astro.config.mjs`: set `site` if provided.
-- Update `<title>` and `<meta name="description">` in the default layout.
-
 ## Prettier (extend)
 
 Add `prettier-plugin-astro` first in plugins, then `prettier-plugin-tailwindcss` last (per its docs). Add a parser override for `.astro` files.

package/tooling/base/configs/scripts/verify.json

@@ -1,3 +1,3 @@
 {
-  "require": ["format", "check:format", "check:spell", "check:shell"]
+  "require": ["format", "check:format"]
 }

package/tooling/base/configs/scripts/verify.ts

@@ -27,8 +27,12 @@ interface Phase {
   readonly title: string
   readonly failed: string
   readonly passed: string
+  readonly tools?: readonly Tool[]
 }
 
+const SHELL_TOOLS_HINT =
+  "Install it with 'sudo apt-get install shfmt shellcheck' or 'brew install shfmt shellcheck'"
+
 const PHASES: readonly Phase[] = [
   {
     script: 'typecheck',
@@ -54,17 +58,15 @@ const PHASES: readonly Phase[] = [
     failed: 'Format check failed',
     passed: 'Format check passed',
   },
-  {
-    script: 'check:spell',
-    title: 'Spelling',
-    failed: 'Spell check failed',
-    passed: 'Spell check passed',
-  },
   {
     script: 'check:shell',
     title: 'Shell',
     failed: 'Shell check failed',
     passed: 'Shell check passed',
+    tools: [
+      { name: 'shfmt', hint: SHELL_TOOLS_HINT },
+      { name: 'shellcheck', hint: SHELL_TOOLS_HINT },
+    ],
   },
   {
     script: 'test:run',
@@ -83,12 +85,11 @@ const PHASES: readonly Phase[] = [
 // A subfolder synced with --skip base declares none of these, since the
 // repository root owns them, so a list that does not require one runs it only
 // where the folder declares it.
-const BASE_PHASES = new Set([
-  'format',
-  'check:format',
-  'check:spell',
-  'check:shell',
-])
+const BASE_PHASES = new Set(['format', 'check:format'])
+
+// An add-on stack declares these, keyed to the stack that ships each, so a
+// folder that never synced the add-on skips the phase rather than failing it.
+const ADD_ON_PHASES = new Map([['check:shell', 'shell']])
 
 const PHASE_LIST = 'scripts/verify.json'
 const CARD_EXCLUSION = 'scripts/check-card-exclusion.sh'
@@ -237,8 +238,8 @@ function readDeclaredScripts(): Set<string> {
   )
 }
 
-function checkTools(list: PhaseList): void {
-  for (const tool of list.tools) {
+function checkTools(tools: readonly Tool[]): void {
+  for (const tool of tools) {
     if (onPath(tool.name)) continue
     fail(
       tool.hint === undefined
@@ -261,7 +262,8 @@ function runPhase(
   declared: Set<string>,
 ): void {
   const isBase = BASE_PHASES.has(phase.script)
-  if (!required && !isBase) return
+  const addOn = ADD_ON_PHASES.get(phase.script)
+  if (!required && !isBase && addOn === undefined) return
 
   logStep(phase.title)
   if (!declared.has(phase.script)) {
@@ -271,10 +273,13 @@ function runPhase(
       )
     }
     logSkip(
-      `Skipped: ${phase.script} is not declared here, so the repository root runs it`,
+      addOn === undefined
+        ? `Skipped: ${phase.script} is not declared here, so the repository root runs it`
+        : `Skipped: ${phase.script} is not declared here. Run 'canon tooling sync ${addOn} . --write' to add it`,
     )
     return
   }
+  checkTools(phase.tools ?? [])
   runCheck(`bun run ${phase.script}`, phase.failed)
   logInfo(phase.passed)
 }
@@ -343,7 +348,7 @@ function checkMarkdownBans(): void {
 function main(): void {
   const declared = readDeclaredScripts()
   const list = readPhaseList()
-  checkTools(list)
+  checkTools(list.tools)
   checkPreconditions(list)
 
   if (!isNested) print(`${GREY}┌${NC}`)

package/tooling/base/manifest.toml

@@ -6,26 +6,26 @@ scaffold = ""
 
 [sync]
 source = "configs"
-per_root = ["scripts/verify.sh", "scripts/verify.ts", "scripts/verify.json"]
+per_root = ["scripts/verify.ts", "scripts/verify.json"]
 
 [dependencies.dev]
 packages = [
     "prettier",
-    "cspell",
     "husky",
     "@commitlint/cli",
     "@commitlint/config-conventional",
 ]
 
 [scripts]
-"check:spell" = "cspell '**' '.*/**' '.*' --no-progress --color --show-context"
-"check:format" = "prettier --check --log-level warn --ignore-path .gitignore --ignore-path .prettierignore . && find scripts -name '*.sh' -exec shfmt --diff --indent 2 {} +"
-"check:shell" = "find scripts -name '*.sh' -exec shellcheck --severity=warning {} +"
-"format" = "prettier --write --log-level warn --ignore-path .gitignore --ignore-path .prettierignore . && find scripts -name '*.sh' -exec shfmt --write --indent 2 {} +"
+"check:format" = "prettier --check --log-level warn --ignore-path .gitignore --ignore-path .prettierignore ."
+"format" = "prettier --write --log-level warn --ignore-path .gitignore --ignore-path .prettierignore ."
 "prepare" = "husky"
-"check" = "./scripts/verify.sh"
+
+[scripts.override]
+"check" = "bun scripts/verify.ts"
 
 [gitignore]
 "# System" = [".DS_Store"]
 "# Dependencies" = ["node_modules/"]
 "# Secrets" = [".env", ".env.*", "*.local", "!.env.example"]
+"# VSCode" = [".vscode/"]

package/tooling/base/reference.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-The base layer covers every project the toolkit scaffolds, whatever language sits on top. It ships formatting, spelling, shell linting, conventional commits, git hooks, CI, and one maintenance script. Every other stack extends it, so a decision made here is one every stack inherits.
+The base layer covers every project the toolkit scaffolds, whatever language sits on top. It ships formatting, conventional commits, git hooks, CI, and the verify runner. Every other stack extends it, so a decision made here is one every stack inherits. Shell formatting and linting live in the `shell` add-on stack, which a project syncs once it writes shell.
 
 A repository with several language roots layers this stack once at the root and skips it per subtree, since git honors only one `core.hooksPath` and a re-dropped husky silently breaks. `canon docs scenarios` carries the recipe.
 
@@ -11,21 +11,15 @@ A repository with several language roots layers this stack once at the root and
 Golden config files live in `tooling/base/configs/` and are copied into the target on `canon tooling sync base . --write`, replacing whatever sits at those paths. They are the source of truth. The reference covers rationale and tradeoffs. Configs show the concrete setup.
 
 - `.prettierrc`: `semi: false`, `singleQuote: true`, plus a parser override per non-standard extension (`.mdx` to `markdown`).
-- `.shellcheckrc`: `external-sources=true`. Required for shellcheck to follow `source` directives.
-- `.editorconfig`: `root = true`, with an `[*.sh]` block setting `indent_style = space` and `indent_size = 2`.
 - `commitlint.config.js`: ESM default export extending `@commitlint/config-conventional`. Rules are `header-max-length: 72`, `scope-case: lower-case`, `subject-full-stop: never`, `subject-case` disabled, and a local `no-claude-co-author` rule refusing a `Co-authored-by` trailer that names Claude or Anthropic.
 - `.husky/`: `pre-commit`, `commit-msg`, `pre-push`, `post-merge`, `post-rewrite`.
-- `.vscode/extensions.json` and `.vscode/settings.json`: editor wiring for Prettier, cspell, shfmt, and shellcheck.
-- `scripts/verify.sh`: the maintenance entry point behind `check`, a wrapper that hands off to `scripts/verify.ts`.
-- `scripts/verify.ts`: the one verify runner every stack shares. It runs typecheck, lint, format, format check, spelling, shell, unit tests, build, markdown bans, then card exclusion, always in that order, and skips any phase the folder's `scripts/verify.json` leaves out. Node modules only, since a target's own lint and typecheck read it.
-- `scripts/verify.json`: the phases a stack requires, plus any tools and preconditions it probes first. The nearest stack's copy wins. A required phase whose script `package.json` lacks fails the run. A base phase the list leaves out runs only where the folder declares its script. Base requires its four phases, so a base-only target still fails on a missing one. These three files are base's `[sync] per_root` set, which a `--skip base` subfolder still receives.
+- `scripts/verify.ts`: the one verify runner every stack shares, and the command behind `check`. It runs typecheck, lint, format, format check, shell, unit tests, build, markdown bans, then card exclusion, always in that order, and skips any phase the folder's `scripts/verify.json` leaves out. Node modules only, since a target's own lint and typecheck read it.
+- `scripts/verify.json`: the phases a stack requires, plus any tools and preconditions it probes first. The nearest stack's copy wins. A required phase whose script `package.json` lacks fails the run. A base phase the list leaves out runs only where the folder declares its script. Base requires its two phases, so a base-only target still fails on a missing one. The shell phase runs only where `package.json` declares `check:shell`, which the `shell` stack adds, and probes for `shfmt` and `shellcheck` first. These two files are base's `[sync] per_root` set, which a `--skip base` subfolder still receives.
 
 ## What ships as user-owned seeds
 
 Seeds live in `tooling/base/seeds/`. Sync drops each once on first install and never overwrites it, so a project extends them freely.
 
-- `cspell.json`: `version: "0.2"`, `language: "en"`, `useGitignore: true`, `gitignoreRoot: ["."]`, dictionary definitions for `project-terms` and `tech-stack` with `addWords: true` on both, and `ignorePaths: [".cspell/**", ".git/**"]` to skip dictionary self-checks and git object files.
-- `.cspell/project-terms.txt` and `.cspell/tech-stack.txt`: one word per line, sorted alphabetically.
 - `.lintstagedrc`: the glob map below.
 - `.prettierignore`: created empty. Projects add their own entries.
 - `.github/workflows/verify.yml`: runs on pull requests targeting `main` and on `workflow_dispatch`. A project with more than one language root adds its own jobs here.
@@ -35,16 +29,13 @@ Seeds live in `tooling/base/seeds/`. Sync drops each once on first install and n
 ## Tool pairing
 
 - Runtime: `bun` as package manager and script runner, `bunx` over `npx` for a one-off executable.
-- Formatting: Prettier for what it parses, shfmt for shell. Two formatters because Prettier has no shell parser.
-- Spelling: cspell over the whole tree, with project vocabulary split into a project-terms dictionary and a tech-stack one.
-- Shell: shfmt formats and shellcheck lints at warning severity. Both take their files from `find scripts -name '*.sh'`, since `scripts/` can mix shell with TypeScript and shellcheck has no directory mode. A shell script with a shebang and no `.sh` extension is covered by neither, so give it the extension.
+- Formatting: Prettier for what it parses. Prettier has no shell parser, so shell formatting is the `shell` stack's.
 - Commits: commitlint against conventional commits, wired through the husky `commit-msg` hook. Format is `<type>(<scope>): <subject>` in imperative mood with no trailing period.
-- Dev dependencies: `prettier`, `cspell`, `husky`, `@commitlint/cli`, `@commitlint/config-conventional`. Install via `bun add -D`.
+- Dev dependencies: `prettier`, `husky`, `@commitlint/cli`, `@commitlint/config-conventional`. Install via `bun add -D`.
 
 ## File layout
 
-- All shell scripts live in `scripts/`. Do not place a `.sh` file outside it.
-- Dictionaries live in `.cspell/`, hooks in `.husky/`, seeded context docs in `canon/context/`.
+- Hooks live in `.husky/`, seeded context docs in `canon/context/`.
 - The `canon/context/` location matches the three-tier context model: project-wide invariants in `CLAUDE.md` and `canon/REQUIREMENTS.md`, path-scoped rules in `.claude/rules/`, and on-demand domain narrative in `canon/context/`. Indexes stay opt-in.
 
 ## Hooks
@@ -59,13 +50,12 @@ Seeds live in `tooling/base/seeds/`. Sync drops each once on first install and n
 
 Seeded baseline globs:
 
-- `**/*.{json,md,mdc}` runs `prettier --write --ignore-path .gitignore --ignore-path .prettierignore` then `cspell --no-must-find-files`
+- `**/*.{json,md,mdc}` runs `prettier --write --ignore-path .gitignore --ignore-path .prettierignore`
 - `**/*.md` runs `canon indexes regen`
-- `**/*.sh` runs `shfmt --write --indent 2` then `shellcheck --severity=warning`
 
 ## CI
 
-- Steps: checkout, setup Bun at latest, `bun install --frozen-lockfile`, install `shfmt` and `shellcheck` via apt, then `check:format`, `check:spell`, and `check:shell`.
+- Steps: checkout, setup Bun at latest, `bun install --frozen-lockfile`, then `check:format`.
 - CI asserts and never writes. Format must be clean before push.
 
 ## Gitignore
@@ -73,30 +63,27 @@ Seeded baseline globs:
 - `# System`: `.DS_Store`
 - `# Dependencies`: `node_modules/`
 - `# Secrets`: `.env`, `.env.*`, `*.local`, `!.env.example`
+- `# VSCode`: `.vscode/`
 
 ## Anti-patterns
 
 Sticky negative knowledge. Do not relearn.
 
-- Do NOT drop `gitignoreRoot: ["."]` from `cspell.json`. Without it, cspell run from inside a linked worktree under `.claude/worktrees/` walks up into the parent repo's `.gitignore`, resolves every worktree file as living under the ignored worktree path, and checks zero files. New words then pass locally and fail in CI.
-- Do NOT rely on the default `**` glob for spelling. It skips dot-prefixed folders, leaving `.claude/`, `.github/`, and `.husky/` unchecked. Pass `'**' '.*/**' '.*'` explicitly.
 - Do NOT invoke prettier without both `--ignore-path .gitignore --ignore-path .prettierignore`. Passing one drops the other, since the flag replaces the default rather than adding to it.
 - Do NOT omit `--log-level warn` from a prettier invocation. The default prints a line per unchanged file.
 - Do NOT put logic in a husky hook and expect its shebang to hold. Husky runs hooks as `sh -e`, so a hook carrying logic is POSIX sh under errexit whatever the first line says.
-- Do NOT drop the `[*.sh]` block from `.editorconfig` because shfmt already sets indentation. The editor and shfmt then disagree and produce spurious git diffs.
-- Do NOT copy lint-staged's `**/*.sh` glob into a package.json script. lint-staged expands its own globs and passes matched files as arguments, which a bare shell script does not.
 
 ## CLI
 
-| Script                 | What it does                                                                                                                          |
-| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
-| `bun run check`        | Repairs a checkout via `scripts/verify.ts`. Honors `VERIFY_NESTED=true` to suppress timeline boundaries when another script calls it. |
-| `bun run check:format` | Asserts prettier and shfmt formatting without writing                                                                                 |
-| `bun run check:spell`  | Runs cspell across every file, with context on failures                                                                               |
-| `bun run check:shell`  | Runs shellcheck at warning severity                                                                                                   |
-| `bun run format`       | Writes prettier and shfmt formatting in place                                                                                         |
-| `bun run prepare`      | Initializes husky hooks, run automatically on `bun install`                                                                           |
+| Script                 | What it does                                                                                                                              |
+| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `bun run check`        | Repairs a checkout through `scripts/verify.ts`. Honors `VERIFY_NESTED=true` to suppress timeline boundaries when another script calls it. |
+| `bun run check:format` | Asserts prettier formatting without writing                                                                                               |
+| `bun run format`       | Writes prettier formatting in place                                                                                                       |
+| `bun run prepare`      | Initializes husky hooks, run automatically on `bun install`                                                                               |
 
-`bun run check` repairs a checkout rather than gating one. It runs `format` first to auto-fix drifted code, then asserts only what the formatters could not fix. The pull request workflow calls `check:format`, `check:spell`, and `check:shell` directly, and those three are the gate.
+Base writes `check` as a `[scripts.override]`, so a sync replaces whatever `check` a target declared, including one that chained further checks after the runner. Re-add a chained check as its own script after a sync.
 
-`scripts/verify.ts`'s `Markdown bans` stage is the exception: it gates rather than repairs. It runs `canon markdown audit` over every tracked markdown file except `CHANGELOG.md`, since a generated changelog carries commit subjects nobody wrote against the ban set, and exits `2` on a finding or `3` on a shipped-empty ban set, failing `bun run check` and the `pre-push` hook that calls it. A refusal to measure exits `1` and is logged as a skip rather than a failure, as does a corpus with no file left to check once `CHANGELOG.md` is set aside. The stage needs `canon` on PATH. `canon docs projects` names the install command. Without it, the stage is skipped and logged, and coverage falls back to the three checks above.
+`bun run check` repairs a checkout rather than gating one. It runs `format` first to auto-fix drifted code, then asserts only what the formatter could not fix. The pull request workflow calls `check:format` directly, and that is the gate.
+
+`scripts/verify.ts`'s `Markdown bans` stage is the exception: it gates rather than repairs. It runs `canon markdown audit` over every tracked markdown file except `CHANGELOG.md`, since a generated changelog carries commit subjects nobody wrote against the ban set, and exits `2` on a finding or `3` on a shipped-empty ban set, failing `bun run check` and the `pre-push` hook that calls it. A refusal to measure exits `1` and is logged as a skip rather than a failure, as does a corpus with no file left to check once `CHANGELOG.md` is set aside. The stage needs `canon` on PATH. `canon docs projects` names the install command. Without it, the stage is skipped and logged, and coverage falls back to the format check above.

package/tooling/base/seeds/.github/workflows/verify.yml

@@ -22,14 +22,5 @@ jobs:
       - name: Install Dependencies
         run: bun install --frozen-lockfile
 
-      - name: Install Shell Tools
-        run: sudo apt-get install -y shfmt shellcheck
-
       - name: Check Formatting
         run: bun run check:format
-
-      - name: Check Spelling
-        run: bun run check:spell
-
-      - name: Check Shell
-        run: bun run check:shell

package/tooling/base/seeds/.lintstagedrc

@@ -1,8 +1,6 @@
 {
   "**/*.{json,md,mdc}": [
-    "prettier --write --ignore-path .gitignore --ignore-path .prettierignore",
-    "cspell --no-must-find-files"
+    "prettier --write --ignore-path .gitignore --ignore-path .prettierignore"
   ],
-  "**/*.md": ["canon indexes regen"],
-  "**/*.sh": ["shfmt --write --indent 2", "shellcheck --severity=warning"]
+  "**/*.md": ["canon indexes regen"]
 }

package/tooling/base/seeds/canon/context/ci.md

@@ -22,12 +22,10 @@ Owns the GitHub Actions workflow that gates a merge: which events start a run, a
 
 Defined in `.github/workflows/verify.yml`. All jobs must pass before merge.
 
-| Check  | Command                | What it asserts                    |
-| ------ | ---------------------- | ---------------------------------- |
-| Format | `bun run check:format` | prettier and shfmt are clean       |
-| Spell  | `bun run check:spell`  | cspell passes against dictionaries |
-| Shell  | `bun run check:shell`  | shellcheck passes at warning level |
+| Check  | Command                | What it asserts   |
+| ------ | ---------------------- | ----------------- |
+| Format | `bun run check:format` | prettier is clean |
 
 ## Running CI locally
 
-`bun run check` runs the same three asserts plus auto-formats first. If CI fails on format, run `bun run check` locally and commit the diff.
+`bun run check` runs the same assert plus auto-formats first. If CI fails on format, run `bun run check` locally and commit the diff.

package/tooling/base/seeds/canon/context/development.md

@@ -24,7 +24,7 @@ Owns how the project runs on a developer machine: installing the toolchain, the
 | Command          | Purpose                                                                        |
 | ---------------- | ------------------------------------------------------------------------------ |
 | `bun run check`  | Repairs locally. Auto-formats, then asserts what the formatters could not fix. |
-| `bun run format` | Auto-fix prettier and shfmt formatting.                                        |
+| `bun run format` | Auto-fix prettier formatting.                                                  |
 
 ## Shell scripts
 
@@ -32,6 +32,6 @@ All `.sh` files live under `scripts/`. Do not place shell scripts outside `scrip
 
 ## Husky hooks
 
-- `pre-commit` runs `lint-staged` (prettier, cspell, shfmt, shellcheck on staged files).
+- `pre-commit` runs `lint-staged` (prettier on staged files).
 - `commit-msg` runs `commitlint` against the conventional commit format.
 - `pre-push` runs `bun run check`. When a markdown-bans audit tool is on PATH, it also gates on banned characters across every tracked markdown file except `CHANGELOG.md`. After pushing, run `git status`. If files changed, commit the diff as `style(<scope>):` and push again.

package/tooling/claude/reference.md

@@ -42,7 +42,7 @@ A project installed before the board became a folder still holds `.claude/TASKS.
 
 Convert by hand, once per project:
 
-1. Split each `###` block into `.canon/tasks/vXX.Y-<slug>.md`, adding the `title` and `description` frontmatter the tasks standard requires, which `canon standards tasks` prints. Compare each new file against the block it came from rather than checking that every block landed somewhere.
+1. Split each `###` block into `.canon/tasks/vXX.Y-<slug>.md`, adding the `title` and `description` frontmatter the tasks reference in the `task-board` skill requires. Compare each new file against the block it came from rather than checking that every block landed somewhere.
 2. Run `canon indexes regen --no-stage --root . .canon/tasks/<any-task>.md` to build the catalog.
 3. Delete `.claude/TASKS.md`, and swap its `.gitignore` entry for `.canon/tasks/`.
 

package/tooling/claude/seeds/.claude/hooks/review-post-scan.sh

@@ -50,7 +50,19 @@ END {
       while (i <= n && substr(s, i, 1) != "\n") i++
       continue
     }
-    if (c == "<" && substr(s, i, 2) == "<<" && substr(s, i, 3) != "<<<") {
+    if (c == "(" && substr(s, i, 2) == "((") {
+      d = 0
+      while (i <= n) {
+        a = substr(s, i, 1)
+        if (a == "(") d++
+        else if (a == ")") { d--; if (d == 0) { seg = seg a; i++; break } }
+        seg = seg a; i++
+      }
+      continue
+    }
+    if (c == "<" && substr(s, i, 3) == "<<<") { seg = seg "<<<"; i += 3; continue }
+    if (c == "<" && substr(s, i, 2) == "<<" && seg ~ /^[ \t]*let[ \t]/) { seg = seg "<<"; i += 2; continue }
+    if (c == "<" && substr(s, i, 2) == "<<") {
       j = i + 2; dash = 0
       if (substr(s, j, 1) == "-") { dash = 1; j++ }
       while (substr(s, j, 1) ~ /[ \t]/) j++

package/tooling/claude/seeds/.claude/hooks/scratch-guard.sh

@@ -57,5 +57,5 @@ marker="$marker_dir/$key"
 mkdir -p "$marker_dir"
 : >"$marker"
 
-msg='Temporary file write outside the project scratch folder. Write temp files to .canon/tmp/<slug>/ in the project root, not system temp. See the Scratch rule (604-scratch, under canon/ in your installed governance rules).'
+msg='Temporary file write outside the project scratch folder. Write temp files to .canon/tmp/<slug>/ in the project root, not system temp. See the Scratch rule (scratch.md, under canon/ in your installed governance rules).'
 jq -nc --arg msg "$msg" '{hookSpecificOutput:{hookEventName:"PreToolUse",additionalContext:$msg}}'