@erclx/canon 5.20.0 → 5.22.0

package/src/slides/package/motion.ts

@@ -0,0 +1,316 @@
+import type JSZip from 'jszip'
+
+/**
+ * Slide transitions and entrance animations, written into a slide's XML after
+ * pptxgenjs has written it, since pptxgenjs declares neither. A slide states
+ * them in its HTML, `walk.ts` reads the attributes, and the converter resolves
+ * each animated element to the object names `planSlide` gave its shapes. This
+ * module turns those names into the shape ids the written XML assigned.
+ */
+
+export interface TransitionSpec {
+  readonly effect: string
+  readonly duration?: string
+}
+
+export interface EntranceSpec {
+  /** The element that declared it, which every notice names. */
+  readonly selector: string
+  readonly effect: string
+  readonly order?: string
+  readonly duration?: string
+  /** Every shape drawn from the element and the elements inside it. */
+  readonly shapes: readonly string[]
+}
+
+export interface SlideMotion {
+  readonly transition?: TransitionSpec
+  readonly entrances: readonly EntranceSpec[]
+}
+
+export interface MotionResult {
+  readonly xml: string
+  readonly notices: readonly string[]
+}
+
+/** A slide's motion, numbered as the package numbers its slide parts. */
+export interface SlideMotionEdit {
+  readonly slide: number
+  readonly motion: SlideMotion
+}
+
+export interface MotionNotice {
+  readonly slide: number
+  readonly message: string
+}
+
+/** The child element `<p:transition>` holds, each in its default direction. */
+const TRANSITIONS: Readonly<Record<string, string>> = {
+  fade: '<p:fade/>',
+  push: '<p:push/>',
+  wipe: '<p:wipe/>',
+  cover: '<p:cover/>',
+}
+
+/**
+ * The strict schema states a transition's length only as one of three speeds,
+ * 0.5, 0.75, and 1 second. A length in milliseconds needs the PowerPoint 2010
+ * extension namespace, so a declared duration rounds to the nearest speed.
+ */
+function speedOf(duration: number | undefined): 'fast' | 'med' | 'slow' {
+  if (duration === undefined) return 'med'
+  if (duration < 625) return 'fast'
+  return duration < 875 ? 'med' : 'slow'
+}
+
+type Behaviors = (spid: string, duration: number, next: () => number) => string
+
+const target = (spid: string): string =>
+  `<p:tgtEl><p:spTgt spid="${spid}"/></p:tgtEl>`
+
+const animEffect =
+  (filter: string): Behaviors =>
+  (spid, duration, next) =>
+    `<p:animEffect transition="in" filter="${filter}"><p:cBhvr><p:cTn id="${next()}" dur="${duration}"/>${target(spid)}</p:cBhvr></p:animEffect>`
+
+function anim(
+  spid: string,
+  duration: number,
+  id: number,
+  attribute: string,
+  from: string,
+  to: string,
+): string {
+  return `<p:anim calcmode="lin" valueType="num"><p:cBhvr additive="base"><p:cTn id="${id}" dur="${duration}" fill="hold"/>${target(spid)}<p:attrNameLst><p:attrName>${attribute}</p:attrName></p:attrNameLst></p:cBhvr><p:tavLst><p:tav tm="0"><p:val><p:strVal val="${from}"/></p:val></p:tav><p:tav tm="100000"><p:val><p:strVal val="${to}"/></p:val></p:tav></p:tavLst></p:anim>`
+}
+
+interface Preset {
+  readonly id: number
+  readonly subtype: number
+  readonly behaviors: Behaviors
+}
+
+/**
+ * PowerPoint's own preset ids, so the effect shows by name in its animation
+ * pane. Fly comes in from the bottom and wipe from the left, the directions
+ * PowerPoint picks when none is chosen. A wipe filter names the edge the
+ * reveal starts from, so from the left pairs with `wipe(left)`.
+ */
+const ENTRANCES: Readonly<Record<string, Preset>> = {
+  fade: { id: 10, subtype: 0, behaviors: animEffect('fade') },
+  fly: {
+    id: 2,
+    subtype: 4,
+    behaviors: (spid, duration, next) =>
+      anim(spid, duration, next(), 'ppt_x', '#ppt_x', '#ppt_x') +
+      anim(spid, duration, next(), 'ppt_y', '1+#ppt_h/2', '#ppt_y'),
+  },
+  wipe: { id: 22, subtype: 8, behaviors: animEffect('wipe(left)') },
+  zoom: {
+    id: 53,
+    subtype: 16,
+    behaviors: (spid, duration, next) =>
+      anim(spid, duration, next(), 'ppt_w', '0', '#ppt_w') +
+      anim(spid, duration, next(), 'ppt_h', '0', '#ppt_h') +
+      animEffect('fade')(spid, duration, next),
+  },
+}
+
+const DEFAULT_ENTRANCE_MS = 500
+
+const ANCHOR = '</p:clrMapOvr>'
+
+const list = (names: readonly string[]): string =>
+  `${names.slice(0, -1).join(', ')}, or ${names.at(-1)}`
+
+/**
+ * The object names an entrance on `root` brings in: every shape drawn from it
+ * and from the elements inside it, so a card's box and its text arrive on one
+ * click. A descendant in `roots` declares its own entrance and keeps its
+ * subtree for that click. A record follows its parent in document order, which
+ * lets one pass collect the subtree.
+ */
+export function entranceShapes(
+  root: number | null,
+  records: readonly { readonly id: number; readonly parent: number | null }[],
+  names: readonly { readonly record: number; readonly name: string }[],
+  roots: ReadonlySet<number>,
+): string[] {
+  if (root === null) return []
+  const subtree = new Set([root])
+  for (const record of records) {
+    const isOwnEntrance = roots.has(record.id)
+    if (
+      record.parent !== null &&
+      subtree.has(record.parent) &&
+      !isOwnEntrance
+    ) {
+      subtree.add(record.id)
+    }
+  }
+  return names
+    .filter((named) => subtree.has(named.record))
+    .map((named) => named.name)
+}
+
+/** Milliseconds from `500`, `500ms`, or `0.5s`, or undefined when unreadable. */
+export function millisecondsOf(value: string | undefined): number | undefined {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*(ms|s)?\s*$/.exec(value ?? '')
+  if (!match?.[1]) return undefined
+  const amount = Number(match[1])
+  return Math.round(match[2] === 's' ? amount * 1000 : amount)
+}
+
+/**
+ * pptxgenjs numbers a table `n * slideNumber + 1` and every other shape by its
+ * index plus two, so a table can share an id with a shape beside it. A timing
+ * target has to name one shape, so each repeat after the first takes a fresh id.
+ */
+function uniqueIds(xml: string): string {
+  const pattern = /<p:cNvPr id="(\d+)"/g
+  let highest = Math.max(
+    0,
+    ...[...xml.matchAll(pattern)].map((match) => Number(match[1])),
+  )
+  const seen = new Set<string>()
+  return xml.replace(pattern, (whole, id: string) => {
+    if (!seen.has(id)) {
+      seen.add(id)
+      return whole
+    }
+    highest += 1
+    return `<p:cNvPr id="${highest}"`
+  })
+}
+
+function shapeIds(xml: string): Map<string, string> {
+  const ids = new Map<string, string>()
+  for (const [, id, name] of xml.matchAll(
+    /<p:cNvPr id="(\d+)" name="([^"]*)"/g,
+  )) {
+    if (id && name && !ids.has(name)) ids.set(name, id)
+  }
+  return ids
+}
+
+interface Click {
+  readonly preset: Preset
+  readonly duration: number
+  readonly spids: readonly string[]
+}
+
+function timingXml(clicks: readonly Click[]): string {
+  let counter = 2
+  const next = (): number => {
+    counter += 1
+    return counter
+  }
+  const pars = clicks.map((click) => {
+    const outer = next()
+    const inner = next()
+    const effects = click.spids.map((spid, index) => {
+      const nodeType = index === 0 ? 'clickEffect' : 'withEffect'
+      const effect = next()
+      const visible = `<p:set><p:cBhvr><p:cTn id="${next()}" dur="1" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst></p:cTn>${target(spid)}<p:attrNameLst><p:attrName>style.visibility</p:attrName></p:attrNameLst></p:cBhvr><p:to><p:strVal val="visible"/></p:to></p:set>`
+      const behaviors = click.preset.behaviors(spid, click.duration, next)
+      return `<p:par><p:cTn id="${effect}" presetID="${click.preset.id}" presetClass="entr" presetSubtype="${click.preset.subtype}" fill="hold" nodeType="${nodeType}"><p:stCondLst><p:cond delay="0"/></p:stCondLst><p:childTnLst>${visible}${behaviors}</p:childTnLst></p:cTn></p:par>`
+    })
+    return `<p:par><p:cTn id="${outer}" fill="hold"><p:stCondLst><p:cond delay="indefinite"/></p:stCondLst><p:childTnLst><p:par><p:cTn id="${inner}" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst><p:childTnLst>${effects.join('')}</p:childTnLst></p:cTn></p:par></p:childTnLst></p:cTn></p:par>`
+  })
+  return `<p:timing><p:tnLst><p:par><p:cTn id="1" dur="indefinite" restart="never" nodeType="tmRoot"><p:childTnLst><p:seq concurrent="1" nextAc="seek"><p:cTn id="2" dur="indefinite" nodeType="mainSeq"><p:childTnLst>${pars.join('')}</p:childTnLst></p:cTn><p:prevCondLst><p:cond evt="onPrev" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:prevCondLst><p:nextCondLst><p:cond evt="onNext" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:nextCondLst></p:seq></p:childTnLst></p:cTn></p:par></p:tnLst></p:timing>`
+}
+
+/** Declared order first, then document order for ties and for no order. */
+function ordered(entrances: readonly EntranceSpec[]): EntranceSpec[] {
+  const rank = (entrance: EntranceSpec): number => {
+    const order = Number.parseFloat(entrance.order ?? '')
+    return Number.isFinite(order) ? order : Number.POSITIVE_INFINITY
+  }
+  return entrances.toSorted((a, b) => rank(a) - rank(b))
+}
+
+/**
+ * Inserts the transition and an on-click main sequence after the slide's color
+ * map override, where the schema orders them. Each entrance is one click, and
+ * every shape drawn from its element comes in on that click together. A slide
+ * missing the anchor is returned unchanged rather than patched elsewhere.
+ */
+export function addMotion(xml: string, motion: SlideMotion): MotionResult {
+  const notices: string[] = []
+  let transition = ''
+  if (motion.transition) {
+    const element = TRANSITIONS[motion.transition.effect]
+    if (element) {
+      const speed = speedOf(millisecondsOf(motion.transition.duration))
+      transition = `<p:transition spd="${speed}">${element}</p:transition>`
+    } else {
+      notices.push(
+        `unknown transition ${motion.transition.effect}. Use ${list(Object.keys(TRANSITIONS))}`,
+      )
+    }
+  }
+
+  const numbered = uniqueIds(xml)
+  const ids = shapeIds(numbered)
+  const clicks: Click[] = []
+  for (const entrance of ordered(motion.entrances)) {
+    const preset = ENTRANCES[entrance.effect]
+    if (!preset) {
+      notices.push(
+        `${entrance.selector}: unknown entrance ${entrance.effect}. Use ${list(Object.keys(ENTRANCES))}`,
+      )
+      continue
+    }
+    const spids = entrance.shapes.flatMap((name) => {
+      const id = ids.get(name)
+      return id ? [id] : []
+    })
+    if (spids.length === 0) {
+      notices.push(
+        `${entrance.selector}: draws no shape, so its entrance has nothing to animate`,
+      )
+      continue
+    }
+    const duration = millisecondsOf(entrance.duration) ?? DEFAULT_ENTRANCE_MS
+    clicks.push({ preset, duration, spids })
+  }
+
+  const timing = clicks.length > 0 ? timingXml(clicks) : ''
+  if (!transition && !timing) return { xml, notices }
+  if (!xml.includes(ANCHOR)) {
+    return {
+      xml,
+      notices: [
+        ...notices,
+        `no ${ANCHOR} to anchor motion after, so none was written`,
+      ],
+    }
+  }
+  return {
+    xml: (timing ? numbered : xml).replace(
+      ANCHOR,
+      `${ANCHOR}${transition}${timing}`,
+    ),
+    notices,
+  }
+}
+
+/** Writes each slide's motion into the opened package and returns its notices. */
+export async function writeMotion(
+  zip: JSZip,
+  edits: readonly SlideMotionEdit[],
+): Promise<MotionNotice[]> {
+  const notices: MotionNotice[] = []
+  for (const { slide, motion } of edits) {
+    const path = `ppt/slides/slide${slide}.xml`
+    const xml = await zip.file(path)?.async('string')
+    if (xml === undefined) {
+      notices.push({ slide, message: `no ${path} in the written deck` })
+      continue
+    }
+    const result = addMotion(xml, motion)
+    if (result.xml !== xml) zip.file(path, result.xml)
+    notices.push(...result.notices.map((message) => ({ slide, message })))
+  }
+  return notices
+}

package/src/slides/package/test-face.ts

@@ -0,0 +1,113 @@
+/**
+ * Builds the smallest sfnt the font step reads, holding only the `OS/2`,
+ * `head`, and `name` tables an EOT header is built from, plus `fvar` when the
+ * face should read as variable. It carries no glyphs, so it embeds and never
+ * renders. Tests use it in place of a real face, whose license the repository
+ * would then have to carry.
+ */
+
+export interface TestFaceOptions {
+  readonly family?: string
+  readonly subfamily?: string
+  readonly weight?: number
+  readonly isItalic?: boolean
+  readonly fsType?: number
+  readonly isVariable?: boolean
+  /** The first four bytes, `0x00010000` for TrueType. */
+  readonly version?: number
+}
+
+/** Values distinct enough that a header copying the wrong field shows it. */
+export const TEST_FACE = {
+  panose: [2, 11, 5, 3, 3, 4, 3, 2, 2, 4],
+  unicodeRanges: [0xe0000aff, 0x5000e5ff, 0x00000009, 0x00000001],
+  codePages: [0x0000019f, 0x01020000],
+  checkSumAdjustment: 0x1234abcd,
+} as const
+
+function os2(options: TestFaceOptions): Buffer {
+  const table = Buffer.alloc(96)
+  table.writeUInt16BE(4, 0)
+  table.writeUInt16BE(options.weight ?? 400, 4)
+  table.writeUInt16BE(options.fsType ?? 0, 8)
+  Buffer.from(TEST_FACE.panose).copy(table, 32)
+  TEST_FACE.unicodeRanges.forEach((range, index) => {
+    table.writeUInt32BE(range, 42 + index * 4)
+  })
+  table.write('TEST', 58, 'latin1')
+  table.writeUInt16BE(options.isItalic ? 0x0001 : 0x0040, 62)
+  TEST_FACE.codePages.forEach((page, index) => {
+    table.writeUInt32BE(page, 78 + index * 4)
+  })
+  return table
+}
+
+function head(): Buffer {
+  const table = Buffer.alloc(54)
+  table.writeUInt32BE(0x00010000, 0)
+  table.writeUInt32BE(TEST_FACE.checkSumAdjustment, 8)
+  table.writeUInt32BE(0x5f0f3cf5, 12)
+  return table
+}
+
+function name(strings: ReadonlyMap<number, string>): Buffer {
+  const encoded = [...strings].map(([id, text]) => ({
+    id,
+    bytes: Buffer.from(text, 'utf16le').swap16(),
+  }))
+  const header = Buffer.alloc(6 + encoded.length * 12)
+  header.writeUInt16BE(0, 0)
+  header.writeUInt16BE(encoded.length, 2)
+  header.writeUInt16BE(header.length, 4)
+  let offset = 0
+  encoded.forEach(({ id, bytes }, index) => {
+    const at = 6 + index * 12
+    header.writeUInt16BE(3, at)
+    header.writeUInt16BE(1, at + 2)
+    header.writeUInt16BE(0x0409, at + 4)
+    header.writeUInt16BE(id, at + 6)
+    header.writeUInt16BE(bytes.length, at + 8)
+    header.writeUInt16BE(offset, at + 10)
+    offset += bytes.length
+  })
+  return Buffer.concat([header, ...encoded.map(({ bytes }) => bytes)])
+}
+
+export function testFace(options: TestFaceOptions = {}): Buffer {
+  const family = options.family ?? 'Fixture Sans'
+  const subfamily = options.subfamily ?? 'Regular'
+  const tables = new Map<string, Buffer>([
+    ['OS/2', os2(options)],
+    ['head', head()],
+    [
+      'name',
+      name(
+        new Map([
+          [1, family],
+          [2, subfamily],
+          [4, `${family} ${subfamily}`],
+          [5, 'Version 1.000'],
+        ]),
+      ),
+    ],
+  ])
+  if (options.isVariable) tables.set('fvar', Buffer.alloc(16))
+
+  const entries = [...tables].sort(([a], [b]) => a.localeCompare(b))
+  const directory = Buffer.alloc(12 + entries.length * 16)
+  directory.writeUInt32BE(options.version ?? 0x00010000, 0)
+  directory.writeUInt16BE(entries.length, 4)
+  let offset = directory.length
+  const bodies: Buffer[] = []
+  entries.forEach(([tag, table], index) => {
+    const at = 12 + index * 16
+    directory.write(tag, at, 'latin1')
+    directory.writeUInt32BE(offset, at + 8)
+    directory.writeUInt32BE(table.length, at + 12)
+    const padded = Buffer.alloc(Math.ceil(table.length / 4) * 4)
+    table.copy(padded)
+    bodies.push(padded)
+    offset += padded.length
+  })
+  return Buffer.concat([directory, ...bodies])
+}

package/src/sync/check.ts

@@ -10,8 +10,10 @@ import { planSync, type ScanEntry, type SyncAdapter } from '@/sync/engine'
 import {
   collectSuperseded,
   detectUnmigrated,
+  detectUnmovedSurfaces,
   type SupersededEntry,
   type UnmigratedDomain,
+  type UnmovedSurface,
 } from '@/sync/layout'
 import {
   buildReverseReport,
@@ -178,6 +180,11 @@ export interface CheckReport {
   readonly seeds: SeedsReport
   readonly superseded: readonly SupersededEntry[]
   readonly unmigrated: readonly UnmigratedDomain[]
+  /**
+   * Report-only like `superseded`, since a target's CI gating on `--exit-code`
+   * would otherwise start failing on a layout nobody asked it to move yet.
+   */
+  readonly unmovedSurfaces: readonly UnmovedSurface[]
   readonly newSkills: readonly string[]
   /**
    * Rules the toolkit authored after this target's governance anchor, filtered
@@ -440,6 +447,7 @@ export async function buildCheckReport(
       seeds: { entries: [], historyUnavailable: false },
       superseded: [],
       unmigrated: [],
+      unmovedSurfaces: [],
       newSkills: [],
       newRules: [],
       reverse: emptyReverseReport(),
@@ -456,6 +464,7 @@ export async function buildCheckReport(
     seeds: buildSeedsReport(toolkitRoot, target),
     superseded: collectSuperseded(target),
     unmigrated,
+    unmovedSurfaces: detectUnmovedSurfaces(target),
     newSkills: await readNewSkills(toolkitRoot, anchors),
     newRules: await readNewRules(toolkitRoot, target, stamp),
     reverse: buildReverseReport(toolkitRoot, target),

package/src/sync/layout.ts

@@ -2,7 +2,7 @@ import { existsSync, statSync } from 'node:fs'
 import { basename, join, relative } from 'node:path'
 import { SUBDIRS } from '@/claude/seeds'
 import { creationRel, isRecordEntry } from '@/record-root'
-import { SURFACE_ENTRIES, surfaceDir } from '@/surface-root'
+import { SURFACE_ENTRIES, spell, surfaceDir } from '@/surface-root'
 import type { StampDomain } from '@/sync/stamp'
 
 const CLAUDE_DIR = '.claude'
@@ -122,6 +122,32 @@ export function detectUnmigrated(
   return found
 }
 
+/**
+ * A tracked surface the target still reads at its `.claude/` spelling, with
+ * nothing at the `canon/` one, and where `canon migrate surface-roots` moves it.
+ */
+export interface UnmovedSurface {
+  readonly rel: string
+  readonly movesTo: string
+}
+
+/**
+ * Surfaces a target holds only at the root the surface move retired. Kept
+ * apart from `detectUnmigrated`, which models a domain stranded at the project
+ * root under a stamp domain, while a surface carries neither. A rule names the
+ * current layout only, so a target here stops loading the rules scoped to these
+ * files, and this report is what points it at the verb.
+ */
+export function detectUnmovedSurfaces(target: string): UnmovedSurface[] {
+  return SURFACE_ENTRIES.filter(
+    (entry) =>
+      relative(target, surfaceDir(target, entry)) === join(CLAUDE_DIR, entry),
+  ).map((entry) => ({
+    rel: join(CLAUDE_DIR, entry),
+    movesTo: join('canon', spell('canon', entry)),
+  }))
+}
+
 /**
  * Root files whose basename matches something the toolkit ships for this domain.
  * Basenames rather than relative paths, because the root layout an older toolkit

package/src/tasks/record.ts

@@ -512,12 +512,18 @@ export async function recordPlan(
  * line, so the merge of an earlier slice cannot archive the task in the window
  * before this branch's own number is recorded. A rerun that ticks nothing adds
  * no marker, since its branch has already recorded or is already listed.
+ *
+ * `branchPulls` holds the pull request numbers the branch's own head carries.
+ * One already on the task's `Pull request:` line means the branch recorded its
+ * number, so a marker would outlive the branch with nothing left to clear it.
+ * An absent or empty list keeps the marker, which is the first slice's case.
  */
 export async function closeOutcomes(
   root: string,
   selector: RecordSelector,
   positions: readonly number[],
   branch?: string,
+  branchPulls: readonly number[] = [],
 ): Promise<CloseOutcome> {
   const opened = await openTask(root, selector)
   if ('ok' in opened) return opened
@@ -541,8 +547,12 @@ export async function closeOutcomes(
     )
   }
 
+  const recorded = readPullRequest(result.text).some((number) =>
+    branchPulls.includes(number),
+  )
+
   const text =
-    result.closed.length > 0 && branch
+    result.closed.length > 0 && branch && !recorded
       ? writePendingBranch(result.text, branch).text
       : result.text
 

package/src/tasks/validate.ts

@@ -6,6 +6,7 @@ import {
   declinedDir,
   isReservedStem,
   readOutcomes,
+  readPendingBranches,
   readPlanTargets,
   readPullRequest,
   resolveLivePlan,
@@ -1065,6 +1066,10 @@ function nothing(): CitedResult {
  * about, and a task naming none leaves the row untested rather than settled,
  * because the only local signal left is the checkbox that produced the defect.
  *
+ * A task still carrying a pending branch is untested whatever its recorded
+ * pull request says, since a slice is in flight that has recorded no number yet
+ * and the landed one may belong to an earlier slice.
+ *
  * The outcome list comes off `readOutcomes` rather than a pattern of its own,
  * so this check cannot disagree with the archive and outcome verbs about which
  * checkboxes are outcomes and which sit inside a block a task displays.
@@ -1114,6 +1119,15 @@ async function checkCitedTask(
   const { open, closed } = readOutcomes(text)
   if (open.length > 0 || closed.length === 0) return nothing()
 
+  const pending = readPendingBranches(text)
+  if (pending.length > 0) {
+    return untestedRow(
+      group,
+      subject,
+      `waits on ${cited}, which closed every outcome but holds a pending branch (${pending.join(', ')}) that has yet to record its pull request.`,
+    )
+  }
+
   // The last number is the newest slice, and an earlier one closed without
   // merging never lands, so only the last says whether the work reached trunk.
   const pullRequest = readPullRequest(text).at(-1)

package/standards/architecture.md

@@ -3,7 +3,6 @@ title: Architecture reference
 description: Shape and content rules for canon/ARCHITECTURE.md
 paths:
   - 'canon/ARCHITECTURE.md'
-  - '.claude/ARCHITECTURE.md'
 rule:
   - "Add a decision here only when it fills one of the standard's slots, and write any other decision into the context entry for the domain it constrains. At the record's stated cap, merge or retire an entry before adding one."
 ---

package/standards/context.md

@@ -3,7 +3,6 @@ title: Context entry reference
 description: Shape and content rules for canon/context/<domain>.md entries
 paths:
   - 'canon/context/**'
-  - '.claude/context/**'
 rule:
   - 'Before non-trivial work in a domain, read its `canon/context/<domain>.md` entry. Use `canon/context/index.md` to find it.'
   - 'Leave the entry conforming when work in its domain changes what it describes.'

package/standards/design.md

@@ -3,7 +3,6 @@ title: Design reference
 description: Shape and content rules for canon/DESIGN.md
 paths:
   - 'canon/DESIGN.md'
-  - '.claude/DESIGN.md'
 ---
 
 # Design reference

package/standards/diagrams.md

@@ -3,12 +3,9 @@ title: Diagram reference
 description: Shape and content rules for .canon/diagrams/<kind>.md files
 paths:
   - '.canon/diagrams/**'
-  - '.claude/DIAGRAMS.md'
 rule:
   - 'Layout, budgets, accessibility, labels, and render verification inside the fence are a separate topic. The mermaid standard routes them.'
   - 'A diagram entry carries structure and flow, not implementation. Read the standard before adding or revising a kind.'
-  - 'Write a new diagram to `.canon/diagrams/<kind>.md`, never to `.claude/DIAGRAMS.md`'
-  - 'Convert a `.claude/DIAGRAMS.md` left by an older install into per-kind entries before editing it'
 ---
 
 # Diagram reference

package/standards/requirements.md

@@ -3,7 +3,6 @@ title: Requirements reference
 description: Shape and content rules for canon/REQUIREMENTS.md
 paths:
   - 'canon/REQUIREMENTS.md'
-  - '.claude/REQUIREMENTS.md'
 ---
 
 # Requirements reference

package/standards/rule.md

@@ -89,6 +89,7 @@ paths:
 - Cut any rule that resists crisp one-line phrasing. Vague guidance is worse than none.
 - Keep the file to one topic. A second topic is a second rule file.
 - Do not restate a rule that a sibling rule or `CLAUDE.md` already owns. Point once, never duplicate.
+- Name the current layout only, in a glob and in the body alike. A layout change ships a migration verb, as `canon migrate surface-roots` and `canon migrate records` did, rather than a rule line or a glob that keeps the old spelling loading.
 
 ## Examples
 

package/standards/tasks.md

@@ -141,7 +141,7 @@ One plan per task, or one per slice, which the board check reads as distinct pla
 
 `Pull request:` records which pull requests carry the task's work, each as a bare `#NNN` the way `Issue:` does. It lists every pull request that shipped part of the task, oldest first and separated by commas, as in `Pull request: #NNN, #NNN`, and a task shipped whole lists one. It is not an origin, so a task without one is well-formed. `git-pr` appends to it when a pull request opens.
 
-The line is what lets a merge close its own task. `canon tasks archive --pull-request <n>` finds the task by any number the line lists and archives it only on the last. One pull request, one task: two tasks naming the same number refuse to archive rather than both moving. `Pending branch: <branch>` holds that merge back while a branch that ticked an outcome waits on its own number, since `canon tasks outcome` writes it and `canon tasks pull-request` clears it.
+The line is what lets a merge close its own task. `canon tasks archive --pull-request <n>` finds the task by any number the line lists and archives it only on the last. One pull request, one task: two tasks naming the same number refuse to archive rather than both moving. `Pending branch: <branch>` holds that merge back while a branch that ticked an outcome waits on its own number, since `canon tasks outcome` writes it and `canon tasks pull-request` clears it. `canon tasks outcome` skips the write when the branch's own pull request is already on the line.
 
 ## What goes in
 

package/standards/wireframes.md

@@ -3,7 +3,6 @@ title: Wireframe reference
 description: Shape and content rules for canon/wireframes/<surface>.md files
 paths:
   - 'canon/wireframes/**'
-  - '.claude/wireframes/**'
 rule:
   - 'Read it before adding or revising a surface.'
 ---

package/tooling/astro/configs/card-src/pages/og-card.astro

@@ -20,12 +20,12 @@
  * `scripts/check-card-exclusion.sh` fails a build that carries the marker
  * below, which is what keeps the route out of the published site.
  */
-import '@/styles/global.css'
 
-// Retarget the import above when this project keeps its global stylesheet
+// Point the import below at this project's global stylesheet when it lives
 // somewhere else. An unresolved path refuses the card server by name, which is
 // the loud direction: a card captured against no stylesheet renders as an
 // unstyled box and reports success.
+import '@/styles/global.css'
 ---
 
 <html lang="en">