@erclx/canon 4.79.0 → 4.80.0

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "canon",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "4.79.0",
+  "version": "4.80.0",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/canon-rollout/SKILL.md

@@ -36,7 +36,7 @@ Every target in every wave takes the same branch and the same title, written fro
 - Title: `chore(agents): <what changed in that target>`.
 - Body: the sections `${CLAUDE_SKILL_DIR}/../../standards/pr.md` fixes, describing what that target received.
 - Body, one line: name this toolkit as the source of the changed files and where to change the content upstream. A reader in that repository months later has no other route to the fact that these files are toolkit-managed and that a local edit is lost at the next wave.
-- Body, no version number anywhere in it. `${CLAUDE_SKILL_DIR}/../../standards/versioning.md` permits a semver tag only where the pull request cuts a release, and `.claude/canon/config.json` in the target already records `syncedAt` and a sha256 per synced file. A version in the body is a second copy of a fact the target holds canonically, and it is the copy that goes stale while the pull request sits open.
+- Body, no version number anywhere in it. `${CLAUDE_SKILL_DIR}/../../standards/versioning.md` permits a semver tag only where the pull request cuts a release, and `canon/config/config.json` in the target already records `syncedAt` and a sha256 per synced file. A version in the body is a second copy of a fact the target holds canonically, and it is the copy that goes stale while the pull request sits open.
 
 The title withholds the source and the body supplies it, because the two have different audiences. `agents` says what changed without saying where it came from, which is what a target's own history wants, and the source line is for a reader inside that repository rather than for whoever merges.
 

package/claude/skills/git-pr/SKILL.md

@@ -11,7 +11,7 @@ Read these files in parallel:
 
 - `${CLAUDE_SKILL_DIR}/../../standards/branch.md`: branch format, valid types, and constraints
 - `${CLAUDE_SKILL_DIR}/../../standards/pr.md`: structure, rules, and banned phrases
-- `${CLAUDE_SKILL_DIR}/references/labels.md`: label map format, matching, and the missing-label warning. Skip when the project has no `.claude/canon/pr-labels.toml`.
+- `${CLAUDE_SKILL_DIR}/references/labels.md`: label map format, matching, and the missing-label warning. Skip when the project has no `canon/config/pr-labels.toml` and no `.claude/canon/pr-labels.toml`.
 - `${CLAUDE_SKILL_DIR}/../../standards/markdown.md`: banned words, punctuation, and formatting for all generated text
 - The `write-human` skill: voice, rhythm, and sentence construction for all generated text
 - `${CLAUDE_SKILL_DIR}/../../standards/versioning.md`: phase label vs semver discipline
@@ -119,7 +119,7 @@ A `reason` of `no-map` is the answer that the project declared no map, which ear
 
 Every other `reason` is a map or a range the verb could not read, which is `unreadable-map`, `no-domains`, `no-base`, and `unreadable-changes`, plus `bad-base` for a ref this skill resolved wrongly. Take the fallback below and warn beside the result line, naming the reason. A map with a typo in it still has rows a prefix match can reach, and reading the refusal as an absence would open the pull request with no labels and nothing said, which is the surface merging bare that the verb exists to name.
 
-The fallback is reading `.claude/canon/pr-labels.toml` and matching it against the name-only diff per `${CLAUDE_SKILL_DIR}/references/labels.md`. It also covers no record coming back at all, which is an installed `canon` predating the verb, since a skill reaches a target the moment it merges while the CLI reaches one only when a release publishes. The fallback labels correctly and reports no uncovered path, which is the half only the verb carries.
+The fallback is reading `canon/config/pr-labels.toml`, or `.claude/canon/pr-labels.toml` when the project has not moved, and matching it against the name-only diff per `${CLAUDE_SKILL_DIR}/references/labels.md`. It also covers no record coming back at all, which is an installed `canon` predating the verb, since a skill reaches a target the moment it merges while the CLI reaches one only when a release publishes. Naming both spellings matters exactly here: the binary old enough to need this fallback is the same binary that may predate the move, so the project's map can still sit at the older path. The fallback labels correctly and reports no uncovered path, which is the half only the verb carries.
 
 Leave `pr_labels` empty when no map resolves or no prefix matches, which skips the labelling command rather than running it against nothing.
 
@@ -223,7 +223,7 @@ Respond with one line, using the `url` the final command printed:
 
 Add a line for each `uncovered` path the labels step reported, naming the path and the map it belongs in:
 
-`⚠️ No label covers <path>. Add a row to .claude/canon/pr-labels.toml or a [declined] entry.`
+`⚠️ No label covers <path>. Add a row to canon/config/pr-labels.toml or a [declined] entry.`
 
 Add a further line only when the labelling command printed its warning, quoting the label `gh` refused:
 

package/claude/skills/git-pr/references/labels.md

@@ -17,7 +17,7 @@ Does not govern:
 
 ## Map format
 
-The map lives at `.claude/canon/pr-labels.toml` in the project root. Each key under `[domains]` is a label name and its value is the list of path prefixes that earn it.
+The map lives at `canon/config/pr-labels.toml` in the project root, or `.claude/canon/pr-labels.toml` for a project that has not moved. Each key under `[domains]` is a label name and its value is the list of path prefixes that earn it.
 
 ```toml
 [domains]

package/docs/agents/audits.md

@@ -19,7 +19,7 @@ canon audits list --json
 | ----------------- | ---------------------------------------------------------------------------------------------------------- |
 | `--json`          | Add a machine-readable record on stdout, keeping the frame                                                 |
 | `--root <path>`   | Measure this tree instead of the current worktree                                                          |
-| `--record`        | Write this run's tracked counts to `.claude/canon/baseline.json`                                           |
+| `--record`        | Write this run's tracked counts to `canon/config/baseline.json`                                            |
 | `--corpus <name>` | Limit the run to one corpus (`tracked`, `per-machine`, `upstream`), repeatable, defaulting to every corpus |
 
 ## What it runs
@@ -75,7 +75,7 @@ Every run states how many corpora it measured against how many it skipped, inclu
 
 ## The retained baseline
 
-`.claude/canon/baseline.json` holds the counts from the last run recorded with `--record`, alongside the day it was taken and the commit it was read at. Each later run reports which counts moved and by how much.
+`canon/config/baseline.json` holds the counts from the last run recorded with `--record`, alongside the day it was taken and the commit it was read at, falling back to `.claude/canon/baseline.json` for a project that has not moved. Each later run reports which counts moved and by how much.
 
 The file is committed. A per-machine record cannot answer the question this half exists for, which is whether a number grew since anyone last looked, and a fresh checkout has to inherit that answer rather than start over. The cost is that a branch moving a count either fixes it or re-records it and says why, which is the shape the consumed-copy assertion already carries.
 

package/docs/agents/commands.md

@@ -56,7 +56,7 @@ Full help: `canon <command> --help`. Behavior notes for the install and sync ver
 | `canon migrate rename`           | Rewrite every unprotected `aitk` token to `canon` and move the paths that carry the name, reporting the plan without `--write` (`--scope`, `--json`)                                                                                                                                                                   |
 | `canon migrate skill-names`      | Move the prefixed skill folders onto their two-word names and rewrite every citation, reporting the plan without `--write` (`--root`, `--json`)                                                                                                                                                                        |
 | `canon migrate records`          | Move the gitignored session records to `.canon/` and repoint every tracked citation, reporting the plan without `--write` (`--root`, `--json`)                                                                                                                                                                         |
-| `canon migrate surface-roots`    | Move the tracked surfaces (`context/`, `wireframes/`, and the three loose documents) from `.claude/` to `canon/` with `git mv` and repoint every tracked citation, reporting the plan without `--write` (`--root`, `--json`)                                                                                           |
+| `canon migrate surface-roots`    | Move the tracked surfaces (`context/`, `wireframes/`, the three loose documents, and the install stamp folder) from `.claude/` to `canon/` with `git mv` and repoint every tracked citation, reporting the plan without `--write` (`--root`, `--json`)                                                                 |
 | `canon migrate record-tree`      | Repoint the old-root citations inside the records themselves, scoped to the live folders and reporting every line without `--write` (`--root`, `--json`)                                                                                                                                                               |
 | `canon migrate rule-layout`      | Move a target's installed rules from the flat `.claude/rules/<subdir>/` layout to `.claude/rules/canon/<subdir>/`, reporting the plan without `--write` (`--root`, `--json`)                                                                                                                                           |
 | `canon migrate scratch-evidence` | Move a folder under `.tmp/` that a durable record cites as evidence to `.canon/review/evidence/`, repointing every citation live or archived, reporting the plan without `--write` (`--root`, `--json`)                                                                                                                |
@@ -167,7 +167,7 @@ Common patterns:
 
 A record folder already present at the destination is a refusal rather than a merge, and a line carrying `canon-keep-record-root`, or the nearest non-blank line below it, keeps the old spelling for prose that dates a decision. The records themselves are never swept: everything under `.canon/` and every `.claude/` record folder is passed over and reported as a count on its own line, which is what keeps the run that follows the ignore collapse touching the same files as one before it. Running it twice rewrites nothing, which is the check that the exclusions, the markers, and that skip all fired.
 
-`migrate surface-roots` moves the tracked surfaces from `.claude/` to `canon/`: `context/`, `wireframes/`, `ARCHITECTURE.md`, `REQUIREMENTS.md`, and `DESIGN.md`. Every path is tracked, so each file moves with `git mv` and its history follows it, and every tracked citation of one is rewritten in the same run. `.claude/canon/`, `rules/`, `skills/`, `hooks/`, and `settings.json` stay where Claude Code reads them. It reports until `--write` is passed, and a destination already present under `canon/` refuses the whole plan rather than splitting a surface across both roots.
+`migrate surface-roots` moves the tracked surfaces from `.claude/` to `canon/`: `context/`, `wireframes/`, `ARCHITECTURE.md`, `REQUIREMENTS.md`, `DESIGN.md`, and the install stamp folder, respelled `canon/config/` since a project under `canon/` reserves the bare `canon` name for the CLI's own install. Every path is tracked, so each file moves with `git mv` and its history follows it, and every tracked citation of one is rewritten in the same run. `rules/`, `skills/`, `hooks/`, and `settings.json` stay where Claude Code reads them. It reports until `--write` is passed, and a destination already present under `canon/` refuses the whole plan rather than splitting a surface across both roots.
 
 A line carrying `canon-keep-surface-root`, or the nearest non-blank line above it, keeps the old spelling. A rule's frontmatter `paths:` glob, a citation shaped like a path into another repository, and one inside a dated paragraph are reported by file and line and left alone. Running it twice rewrites nothing, which is the idempotence check. A project that never runs it keeps resolving each surface under `.claude/`, since every reader takes whichever root holds the entry.
 

package/docs/agents/install-and-sync.md

@@ -158,9 +158,9 @@ Use `--json` for the machine-readable report and `--exit-code` to fail a CI job.
 and missing files are both excluded from that exit code: a project-authored
 rule never converges, and a sync that added a missing one silently changes
 what the project is governed by, which stays a separate command an operator
-chooses to run. Attribution reads `canon/config/config.json` first and falls
-back to `.claude/canon/config.json`, which every install and sync still writes
-in this release.
+chooses to run. Attribution reads `canon/config/config.json` first, which every
+install and sync now writes, and falls back to `.claude/canon/config.json` for
+a target that has not moved.
 
 A target installed before stamping shipped has no such file, and neither does
 that fallback do anything to migrate it. A target stamped before the file

package/docs/agents/label-coverage.md

@@ -28,7 +28,7 @@ Under `--json` the record holds stdout alone and the frame still renders on stde
 
 ## The map it reads
 
-The map sits at `.claude/canon/pr-labels.toml` and carries two tables. `[domains]` keys a label name to the path prefixes that earn it, and `[declined]` keys a reason to the prefixes that earn no label on purpose.
+The map sits at `canon/config/pr-labels.toml`, falling back to `.claude/canon/pr-labels.toml` for a project that has not moved, and carries two tables. `[domains]` keys a label name to the path prefixes that earn it, and `[declined]` keys a reason to the prefixes that earn no label on purpose.
 
 ```toml
 [domains]

package/docs/target-projects.md

@@ -208,7 +208,7 @@ The report opens by naming the binary running it. The installed version reads ag
 
 A `stale` file still matches what the toolkit installed, so the update is mechanical. A `customized` file carries local edits, so taking the upstream version is a decision and `canon:seed-sync` is the tool for it. A `stranded` file sits where an older toolkit installed it and the toolkit has since moved, which is a relocation the report names but no command runs.
 
-That attribution comes from `canon/config/config.json` when a project carries it, falling back to `.claude/canon/config.json`, a stamp every install and sync still writes in this release. A target stamped before that path shipped is read from the retired `.claude/canon.json` instead, reported rather than migrated. Governance records a hash per installed file, plus the stack `canon gov install` was given, and tooling records the stack chain it resolved instead of any file hash, since its install runs no per-file walk to attribute.
+That attribution comes from `canon/config/config.json`, which every install and sync now writes, falling back to `.claude/canon/config.json` for a target stamped before that move. A target stamped before that path shipped is read from the retired `.claude/canon.json` instead, reported rather than migrated. Governance records a hash per installed file, plus the stack `canon gov install` was given, and tooling records the stack chain it resolved instead of any file hash, since its install runs no per-file walk to attribute.
 
 Each domain holds its own toolkit commit, so syncing governance today does not move the revision tooling measures against, and each domain reports the upstream commits touching its own source path. Running any sync stamps that domain, and the report names the ones still unstamped.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "4.79.0",
+  "version": "4.80.0",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/audits/baseline.ts

@@ -1,6 +1,7 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
+import { dirname, join, relative } from 'node:path'
 import type { AuditResult } from '@/audits/catalog'
+import { resolveExisting } from '@/legacy-path'
 
 /**
  * Where the retained counts live, relative to the project root.
@@ -15,7 +16,14 @@ import type { AuditResult } from '@/audits/catalog'
  * that installs the CLI. A baseline in the package would hand a target this
  * repository's counts to measure its own tree against.
  */
-export const BASELINE_REL = join('.claude', 'canon', 'baseline.json')
+export const BASELINE_REL = join('canon', 'config', 'baseline.json')
+
+/**
+ * Where the baseline wrote before this move, `.claude/canon/baseline.json`.
+ * `readBaseline` falls back to it so a target that has not moved still reads
+ * its recorded floor, and the write no longer lands there.
+ */
+const LEGACY_BASELINE_REL = join('.claude', 'canon', 'baseline.json')
 
 export interface Baseline {
   /** The day the record was taken, as `YYYY-MM-DD`. */
@@ -165,7 +173,11 @@ function isBaseline(value: unknown): value is Baseline {
 export async function readBaseline(
   root: string,
 ): Promise<Baseline | undefined> {
-  const path = join(root, BASELINE_REL)
+  const path = resolveExisting([
+    join(root, BASELINE_REL),
+    join(root, LEGACY_BASELINE_REL),
+  ])
+  const rel = relative(root, path)
 
   let raw: string
   try {
@@ -178,12 +190,12 @@ export async function readBaseline(
   try {
     parsed = JSON.parse(raw)
   } catch {
-    throw new Error(`${BASELINE_REL} does not parse as JSON. Fix or delete it.`)
+    throw new Error(`${rel} does not parse as JSON. Fix or delete it.`)
   }
 
   if (!isBaseline(parsed)) {
     throw new Error(
-      `${BASELINE_REL} carries no recordedAt, commit, and checks. Fix or delete it.`,
+      `${rel} carries no recordedAt, commit, and checks. Fix or delete it.`,
     )
   }
 

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/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/surface-root.ts

@@ -56,26 +56,19 @@ export function spell(root: SurfaceRoot, entry: string): string {
 }
 
 /**
- * The creation default for one entry.
+ * The root a surface resolves at: the first that carries it, and
+ * `CREATION_ROOT` when neither does.
  *
- * The stamp folder keeps creating under `.claude/` until its own move lands,
- * since the install stamp and the audits baseline still write there by a
- * fixed path. A read resolving to `canon/config/` in a fresh project would
- * answer from a folder nothing writes.
- */
-function creationRootFor(entry: string): SurfaceRoot {
-  return entry === 'canon' ? '.claude' : CREATION_ROOT
-}
-
-/**
- * The root a surface resolves at: the first that carries it, and the creation
- * default when neither does.
+ * The stamp folder used to take a carve-out here, staying at `.claude/` while
+ * the install stamp and the audits baseline still wrote there by a fixed path
+ * of their own. Both moved to `canon/config/` by a fixed path of their own, so
+ * every entry now shares the one default.
  */
 function rootOf(root: string, entry: string): SurfaceRoot {
   return (
     SURFACE_ROOTS.find((candidate) =>
       existsSync(join(root, candidate, spell(candidate, entry))),
-    ) ?? creationRootFor(entry)
+    ) ?? CREATION_ROOT
   )
 }
 

package/src/sync/stamp.ts

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import { mkdir, writeFile } from 'node:fs/promises'
 import { dirname, join, sep } from 'node:path'
 import { execa } from 'execa'
+import { resolveExisting } from '@/legacy-path'
 import { recordTarget } from '@/targets/registry'
 
 /**
@@ -56,7 +57,21 @@ export interface Stamp {
   readonly domains: Readonly<Partial<Record<StampDomain, DomainStamp>>>
 }
 
+/**
+ * Where a stamp is written today, `canon/config/config.json`. Named
+ * `stampPath` rather than `surfaceStampPath` because the write side has only
+ * one current path, unlike the read side's fallback chain below.
+ */
 export function stampPath(target: string): string {
+  return join(target, 'canon', 'config', 'config.json')
+}
+
+/**
+ * Where the stamp wrote before this move, `.claude/canon/config.json`. Kept
+ * for the same reason as the two spellings below: a target stamped under it
+ * still carries its config here, and `readStamp` falls back to it.
+ */
+export function claudeCanonStampPath(target: string): string {
   return join(target, '.claude', 'canon', 'config.json')
 }
 
@@ -84,18 +99,6 @@ export function retiredNameStampPath(target: string): string {
   return join(target, '.claude', 'aitk', 'config.json')
 }
 
-/**
- * The stamp path under the new surface root, `canon/config/config.json`.
- *
- * Read ahead of `stampPath`, extending the same mechanism rather than adding a
- * new one: a target that has moved reads its config from the root it moved
- * to, and one that has not falls through to the spellings below unchanged.
- * The write destination does not move to it in this batch.
- */
-function surfaceStampPath(target: string): string {
-  return join(target, 'canon', 'config', 'config.json')
-}
-
 /**
  * Every spelling a stamp has been written under, current first. The order is
  * the read order, so a target carrying more than one resolves to the newest.
@@ -105,10 +108,10 @@ function surfaceStampPath(target: string): string {
  * second breaking change aimed at exactly the targets that were slowest to
  * migrate the first time.
  */
-export function stampPaths(target: string): readonly string[] {
+export function stampPaths(target: string): readonly [string, ...string[]] {
   return [
-    surfaceStampPath(target),
     stampPath(target),
+    claudeCanonStampPath(target),
     retiredNameStampPath(target),
     legacyStampPath(target),
   ]
@@ -120,7 +123,10 @@ export function stampPaths(target: string): readonly string[] {
  * there is nothing to migrate off of.
  */
 export function isLegacyStamped(target: string): boolean {
-  if (existsSync(surfaceStampPath(target)) || existsSync(stampPath(target))) {
+  if (
+    existsSync(stampPath(target)) ||
+    existsSync(claudeCanonStampPath(target))
+  ) {
     return false
   }
   return (
@@ -158,8 +164,7 @@ export function toStampKey(rel: string): string {
  * was read from.
  */
 export function readStamp(target: string): Stamp | undefined {
-  const found = stampPaths(target).find((path) => existsSync(path))
-  return found === undefined ? undefined : readStampFile(found)
+  return readStampFile(resolveExisting(stampPaths(target)))
 }
 
 function readStampFile(path: string): Stamp | undefined {

package/src/targets/sweep.ts

@@ -3,6 +3,7 @@ import { join, resolve } from 'node:path'
 import { $ } from 'bun'
 import { gitEnv } from '@/git-env'
 import {
+  claudeCanonStampPath,
   isLegacyStamped,
   legacyStampPath,
   retiredNameStampPath,
@@ -91,15 +92,18 @@ export interface SweepOptions {
 }
 
 /**
- * Whether a folder carries an install stamp at the current path or either
+ * Whether a folder carries an install stamp at the current path or any
  * retired one. `aitk@3.57.0` still writes the folder form,
  * `retiredNameStampPath`, as its current path, so a target a pre-rename
  * binary syncs after this check drops the folder form would otherwise vanish
- * from the walk with nothing saying so.
+ * from the walk with nothing saying so. `claudeCanonStampPath` is the spelling
+ * every target carried before the stamp moved to `canon/config/`, which a
+ * target this batch has not reached still writes to.
  */
 function isStamped(path: string): boolean {
   return (
     Bun.file(stampPath(path)).size > 0 ||
+    Bun.file(claudeCanonStampPath(path)).size > 0 ||
     Bun.file(retiredNameStampPath(path)).size > 0 ||
     Bun.file(legacyStampPath(path)).size > 0
   )