@erclx/canon 5.67.0 → 5.69.0

package/src/commands/take.ts

@@ -5,6 +5,7 @@ import { INSTALL_BROWSER, isEngineMissing } from '@/browser/engine'
 import { readTakePlan } from '@/take/plan'
 import type { TakePlanRefusal } from '@/take/plan'
 import type { TakeRefusal } from '@/take/film'
+import { renderReel } from '@/take/reel'
 import {
   intro,
   logError,
@@ -24,6 +25,7 @@ type Take = typeof import('@/take/film')
 
 interface RunOptions {
   readonly out: string
+  readonly reel?: string
   readonly json?: boolean
 }
 
@@ -60,14 +62,19 @@ export function register(program: Command): void {
     .argument('<plan>', 'JSON file naming the beats and their steps')
     .requiredOption('--out <dir>', 'Folder the clips, logs, and tracks land in')
     .helpOption('-h, --help', 'Show this help message')
+    .option(
+      '--reel <file>',
+      'Also join the beats into one animated WebP with the pointer drawn',
+    )
     .option('--json', 'Add a machine-readable record on stdout')
     .addHelpText(
       'after',
       [
         '',
         'Films each beat from a fresh load of the page into its own folder under',
-        '--out, numbered in plan order: clip.mp4, log.json, and camera.json.',
-        'take.json beside them lists every beat and the route that filmed it.',
+        '--out, numbered in plan order: clip.mp4, log.json, camera.json, and',
+        "still.jpg, the clip's closing frame. take.json beside them lists every",
+        'beat and the route that filmed it.',
         '',
         'A step beat is filmed by frame stepping in chrome-headless-shell, at',
         '3840x2160 and exactly 60 fps, with the page clock advancing one frame',
@@ -77,7 +84,13 @@ export function register(program: Command): void {
         '',
         'No cursor is drawn in a clip. The edit draws it from the log at a',
         'constant size, and the camera track carries the cursor and click ring',
-        'per frame beside the view. Canon renders nothing past the clip.',
+        'per frame beside the view. Canon renders nothing past the clip, save',
+        'the reel below.',
+        '',
+        '--reel <file> joins every beat in plan order into one looping animated',
+        'WebP at 960 wide and 20 fps, keeping every third frame, with the cursor',
+        'and click ring drawn from each camera track. It carries no zoom, so a',
+        "reviewer sees the whole page. clip.mp4 stays each beat's raw take.",
         '',
         '  {',
         '    "beats": [',
@@ -118,14 +131,16 @@ export function register(program: Command): void {
         '  server-unreachable  nothing answered at the URL',
         '  target-missing      a step names a target the page does not carry',
         '  take-failed         the take failed against a reachable page',
+        '  reel-failed         every beat was filmed and the reel did not encode',
         '',
         'Exit codes:',
-        '  0  every beat was filmed',
+        '  0  every beat was filmed, and the reel written when asked for',
         '  1  refused, with the reason on stderr or in the JSON record',
         '',
         'Examples:',
         '  canon take http://localhost:4173 plan.json --out .canon/tmp/demo/takes',
         '  canon take http://localhost:4173 plan.json --out takes --json',
+        '  canon take http://localhost:4173 plan.json --out takes --reel takes/reel.webp',
         '',
       ].join('\n'),
     )
@@ -222,16 +237,37 @@ async function runTake(
     )
     if (beat.fallback) logWarn(`  filmed by screencast: ${beat.fallback}`)
   }
-  outro()
 
-  emit(emitJson, {
+  const filmed = {
     url,
     plan: path,
     out: result.out,
     beats: result.beats,
     durationMs: result.durationMs,
-  })
-  return 0
+  }
+  if (!opts.reel) {
+    outro()
+    emit(emitJson, filmed)
+    return 0
+  }
+
+  logStep('Reel')
+  try {
+    const reel = await renderReel(result.out, result.beats, resolve(opts.reel))
+    logInfo(
+      `${reel.file}  ${plural(reel.frames, 'frame')}  ${reel.seconds} s  ${(reel.bytes / 1e6).toFixed(1)} MB`,
+    )
+    outro()
+    emit(emitJson, { ...filmed, reel })
+    return 0
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    logWarn('Every beat was filmed, and the reel did not encode.')
+    logWarn(message.split('\n')[0] ?? '')
+    outro()
+    emit(emitJson, { ...filmed, reason: 'reel-failed', message })
+    return 1
+  }
 }
 
 /**

package/src/commands/tasks.ts

@@ -3,6 +3,13 @@ import type { Command } from 'commander'
 import { execa } from 'execa'
 import { gitEnv } from '@/git/env'
 import { type AnswersOutcome, planAnswers } from '@/tasks/answers'
+import {
+  DEFAULT_LAUNCH_WAIT_SECONDS,
+  type LaunchOutcome,
+  type LaunchWait,
+  readLaunchable,
+  waitForLaunchable,
+} from '@/tasks/launch-wait'
 import {
   type BoardOutcome,
   type BoardRefused,
@@ -112,6 +119,12 @@ interface AnswersCommandOptions {
   readonly root?: string
 }
 
+interface LaunchableCommandOptions {
+  readonly json?: boolean
+  readonly root?: string
+  readonly wait?: string | true
+}
+
 interface BranchCommandOptions {
   readonly json?: boolean
   readonly root?: string
@@ -414,6 +427,72 @@ export function register(program: Command): void {
       process.exitCode = await runAnswers(plan, opts)
     })
 
+  tasks
+    .command('launchable')
+    .description(
+      'Report whether a row has a linked plan the dispatch may launch',
+    )
+    .argument('<task>', 'Task filename stem, as in v28.1-trigger-escalation')
+    .helpOption('-h, --help', 'Show this help message')
+    .option('--json', 'Emit a machine-readable record on stdout')
+    .option('--root <path>', 'Board root, defaulting to the main worktree')
+    .option(
+      '--wait [seconds]',
+      `Hold until the row is launchable, default ${DEFAULT_LAUNCH_WAIT_SECONDS}`,
+    )
+    .addHelpText(
+      'after',
+      [
+        '',
+        "Resolves the task's Plan: line and runs the plan-answers gate on the",
+        'plan it names, in one read. It keys on the line rather than on the',
+        'plan file, since a planner links a plan only after it validates, so a',
+        'plan still being written never reads as landed. It answers planning',
+        'alone: the branch and claim checks stay in the dispatch runbook.',
+        '',
+        'The record carries task, plan, launchable, and open, the last three',
+        'named as plan-answers names them. Read `reason`:',
+        '  unlinked    the task carries no Plan: line yet',
+        '  open        the plan still holds a question for the operator',
+        '  launchable  the plan waits on nobody',
+        '',
+        '`--wait [seconds]` re-reads every 30 seconds until the row is',
+        'launchable or the deadline passes. `reason` then reads `launchable`',
+        'or `timeout`, the record carries the last reading, and',
+        '`waitedSeconds` is added. A refusal ends the wait at once. A wait',
+        'past 600 seconds outlasts a foreground shell call, so run it in the',
+        'background and act on the wake.',
+        '',
+        'Refusals, read off `reason`:',
+        '  no-board       the project carries no .canon/tasks/',
+        '  no-match       no task carries that stem exactly',
+        '  ambiguous      several tasks start with the name, so pass one in full',
+        '  several-plans  the Plan: line links more than one plan',
+        '  no-plan        the Plan: line names no file',
+        '  archived       the Plan: line points into the plans archive',
+        '  bad-input      the Plan: line carries an empty target',
+        '  bad-wait       --wait takes a whole number of seconds above zero',
+        '',
+        'Exit codes:',
+        '  0  the row is launchable',
+        '  1  refused, with the reason on stderr or in the JSON record',
+        '  2  the row is unlinked or open, or the wait reached its deadline',
+        '',
+        'It reports and never writes. Branch on `reason` rather than on the',
+        'exit code, which a shell function wrapping canon can flatten to zero.',
+        '',
+        'Examples:',
+        '  canon tasks launchable v28.1-trigger-escalation',
+        '  canon tasks launchable v28.1-trigger-escalation --json',
+        '  canon tasks launchable v28.1-trigger-escalation --wait --json',
+        '  canon tasks launchable v28.1-trigger-escalation --wait 900 --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (task: string, opts: LaunchableCommandOptions) => {
+      process.exitCode = await runLaunchable(task, opts)
+    })
+
   tasks
     .command('plan-branch')
     .description('Derive the branch name a dispatch and a worker both take')
@@ -1827,6 +1906,110 @@ function reportAnswers(
   return EXIT_FINDINGS
 }
 
+const BAD_WAIT = '--wait takes a whole number of seconds above zero.'
+
+interface BadWait {
+  readonly ok: false
+  readonly reason: 'bad-wait'
+  readonly message: string
+}
+
+async function runLaunchable(
+  task: string,
+  opts: LaunchableCommandOptions,
+): Promise<number> {
+  const emitJson = opts.json ?? false
+  const root = opts.root ?? (await mainWorktreeRoot())
+
+  let waitSeconds: number | undefined
+  if (opts.wait === true) {
+    waitSeconds = DEFAULT_LAUNCH_WAIT_SECONDS
+  } else if (opts.wait !== undefined) {
+    if (!/^\d+$/.test(opts.wait) || Number(opts.wait) === 0) {
+      const refused: BadWait = {
+        ok: false,
+        reason: 'bad-wait',
+        message: BAD_WAIT,
+      }
+      return reportLaunchable(refused, emitJson, root)
+    }
+    waitSeconds = Number(opts.wait)
+  }
+
+  const outcome =
+    waitSeconds === undefined
+      ? await readLaunchable(root, task)
+      : await waitForLaunchable(root, task, {
+          waitSeconds,
+          clock: {
+            now: () => Date.now(),
+            sleep: (ms) => new Promise((done) => setTimeout(done, ms)),
+          },
+        })
+
+  return reportLaunchable(outcome, emitJson, root)
+}
+
+function reportLaunchable(
+  outcome: LaunchOutcome | LaunchWait | BadWait,
+  emitJson: boolean,
+  root: string,
+): number {
+  if (!outcome.ok) {
+    intro('canon tasks launchable')
+    logStep('Refused')
+    logError(outcome.message)
+    outro()
+
+    if (emitJson) {
+      process.stdout.write(
+        `${JSON.stringify({
+          ok: false,
+          reason: outcome.reason,
+          message: outcome.message,
+          ...('waitedSeconds' in outcome && {
+            waitedSeconds: outcome.waitedSeconds,
+          }),
+          root,
+        })}\n`,
+      )
+    }
+    return 1
+  }
+
+  const code = outcome.launchable ? 0 : EXIT_FINDINGS
+
+  if (emitJson) {
+    process.stdout.write(`${JSON.stringify({ ...outcome, root })}\n`)
+    return code
+  }
+
+  intro('canon tasks launchable')
+  logStep(outcome.task)
+
+  if (outcome.plan === undefined) {
+    logWarn('carries no Plan: line yet, so no plan has landed.')
+  } else if (outcome.launchable) {
+    logInfo(`${outcome.plan} waits on nobody, so the dispatch may launch it.`)
+  } else {
+    for (const question of outcome.open) {
+      logWarn(`${question.label} ${question.why}`)
+    }
+    logError(`${outcome.plan} still waits on the operator.`)
+  }
+
+  if ('waitedSeconds' in outcome) {
+    logInfo(
+      outcome.reason === 'timeout'
+        ? `not launchable within ${outcome.waitedSeconds}s`
+        : `launchable after ${outcome.waitedSeconds}s`,
+    )
+  }
+
+  outro()
+  return code
+}
+
 async function runBranch(
   plan: string,
   opts: BranchCommandOptions,

package/src/gate/stages.ts

@@ -402,9 +402,9 @@ export const STAGES: readonly Stage[] = [
     checks: [
       {
         kind: 'cli',
-        argv: ['gov', 'audit', '--gate'],
+        argv: ['gov', 'audit', '--gate', '--touched'],
         failure:
-          'A rule in a gated folder is past a shape limit or short of its ledger. Run bun src/cli.ts gov audit.',
+          'A rule in a gated folder is past a shape limit or short of its ledger. Run bun src/cli.ts gov audit --touched.',
       },
     ],
   },

package/src/gov/audit.ts

@@ -1,6 +1,6 @@
 import { existsSync, statSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { join, relative, resolve, sep } from 'node:path'
+import { join, normalize, relative, resolve, sep } from 'node:path'
 import { listRuleFiles } from '@/gov/payload'
 
 /**
@@ -57,6 +57,19 @@ export const PRACTICE_FOLDERS: readonly string[] = [
   'tooling',
 ]
 
+/**
+ * The folders whose rules record house decisions. Their ledger is checked
+ * wherever one exists and owed only by a rule the branch touched, since the
+ * reasoning behind an older bullet was never written down and no backfill
+ * recovers it.
+ */
+export const CORE_FOLDERS: readonly string[] = [
+  'canon',
+  'claude',
+  'code',
+  'writing',
+]
+
 const SHIPPED_RULES = join('governance', 'rules')
 const LEDGERS = join('governance', 'ledger')
 
@@ -316,29 +329,41 @@ export function compareLedger(
     .filter((entry) => entry.bullets !== entry.rows)
 }
 
-/** Where a rule's ledger lives, or nothing when its folder carries none. */
-function ledgerPath(file: string): string | undefined {
+/**
+ * Where a rule's ledger lives and whether its absence is a finding, or nothing
+ * when its folder carries none.
+ */
+function ledgerFor(
+  file: string,
+  touched: ReadonlySet<string>,
+): { path: string; owed: boolean } | undefined {
   const prefix = `${SHIPPED_RULES}${sep}`
   if (!file.startsWith(prefix)) return undefined
   const rest = file.slice(prefix.length)
   const folder = rest.split(sep)[0]
-  if (!PRACTICE_FOLDERS.includes(folder)) return undefined
-  return join(LEDGERS, rest)
+  const path = join(LEDGERS, rest)
+  if (PRACTICE_FOLDERS.includes(folder)) return { path, owed: true }
+  if (CORE_FOLDERS.includes(folder)) return { path, owed: touched.has(file) }
+  return undefined
 }
 
 async function readLedger(
   root: string,
   file: string,
   groups: readonly HeadingCount[],
+  touched: ReadonlySet<string>,
 ): Promise<LedgerReading> {
-  const path = ledgerPath(file)
-  if (path === undefined) return { status: 'not-required' }
+  const ledger = ledgerFor(file, touched)
+  if (ledger === undefined) return { status: 'not-required' }
+  const { path } = ledger
 
   let text: string
   try {
     text = await readFile(resolve(root, path), 'utf8')
   } catch {
-    return { status: 'missing', path }
+    return ledger.owed
+      ? { status: 'missing', path }
+      : { status: 'not-required' }
   }
 
   return {
@@ -352,14 +377,22 @@ async function readLedger(
  * Measures every rule this tree authors, or the files named.
  *
  * A tree holding `governance/rules/` is a canon checkout, read across both
- * authored corpora with a ledger asked of each outside-practice rule. Any
- * other tree is a target, read at `.claude/rules/project/` alone with no
+ * authored corpora with a ledger asked of each outside-practice rule and of
+ * each core rule in `touched`, and checked for any core rule carrying one.
+ * Any other tree is a target, read at `.claude/rules/project/` alone with no
  * ledger asked, since ledgers never ship.
+ *
+ * `touched` holds paths relative to the root, and leaving it out reads no core
+ * rule as touched.
  */
 export async function readRuleAudit(
   root: string,
   paths: readonly string[] = [],
+  options: { readonly touched?: readonly string[] } = {},
 ): Promise<RuleAuditReport> {
+  const touched = new Set(
+    (options.touched ?? []).map((path) => normalize(path)),
+  )
   const scope = existsSync(resolve(root, SHIPPED_RULES)) ? 'canon' : 'target'
   const corpus = scope === 'canon' ? CANON_CORPUS : TARGET_CORPUS
 
@@ -421,7 +454,11 @@ export async function readRuleAudit(
   for (const abs of files) {
     const file = relative(root, abs)
     const { groups, ...shape } = measureRule(await readFile(abs, 'utf8'))
-    rules.push({ file, ...shape, ledger: await readLedger(root, file, groups) })
+    rules.push({
+      file,
+      ...shape,
+      ledger: await readLedger(root, file, groups, touched),
+    })
   }
 
   return { kind: 'measured', scope, corpus, rules }

package/src/gov/detect.ts

@@ -253,7 +253,7 @@ function isLiteral(pattern: string): boolean {
 
 /**
  * A literal pattern is also tested on disk, since evidence such as
- * `.canon/canvas` sits in a folder a target's own `.gitignore` excludes, and
+ * `.canon/board` sits in a folder a target's own `.gitignore` excludes, and
  * the git listing never carries it.
  */
 function matchEntry(

package/src/markdown/scope.ts

@@ -136,8 +136,6 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/build-in-slices/references/adopted.md',
   'claude/skills/canon-cli/REQUIREMENT.md',
   'claude/skills/canon-cli/SKILL.md',
-  'claude/skills/canon-feedback-triage/REQUIREMENT.md',
-  'claude/skills/canon-feedback-triage/SKILL.md',
   'claude/skills/canon-feedback/REQUIREMENT.md',
   'claude/skills/canon-feedback/SKILL.md',
   'claude/skills/canon-feedback/references/template.md',
@@ -202,10 +200,10 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/document-repair/REQUIREMENT.md',
   'claude/skills/document-repair/SKILL.md',
   'claude/skills/document-repair/references/batches.md',
-  'claude/skills/pick-by-eye/REQUIREMENT.md',
-  'claude/skills/pick-by-eye/SKILL.md',
-  'claude/skills/pick-by-eye/references/board.md',
-  'claude/skills/pick-by-eye/references/live-arms.md',
+  'claude/skills/design-pick/REQUIREMENT.md',
+  'claude/skills/design-pick/SKILL.md',
+  'claude/skills/design-pick/references/board.md',
+  'claude/skills/design-pick/references/live-arms.md',
   'claude/skills/write-doc/REQUIREMENT.md',
   'claude/skills/write-doc/SKILL.md',
   'claude/skills/write-doc/references/context.md',
@@ -229,10 +227,6 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/design-identity/REQUIREMENT.md',
   'claude/skills/design-identity/SKILL.md',
   'claude/skills/design-identity/references/card-route.md',
-  'claude/skills/plan-ready/REQUIREMENT.md',
-  'claude/skills/plan-ready/SKILL.md',
-  'claude/skills/plan-ready/references/assembly.md',
-  'claude/skills/plan-ready/references/ready.md',
   'claude/skills/git-branch/REQUIREMENT.md',
   'claude/skills/git-branch/SKILL.md',
   'claude/skills/git-branch/references/branch.md',
@@ -391,10 +385,10 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/test-first/references/adopted.md',
   'claude/skills/ui-checklist/REQUIREMENT.md',
   'claude/skills/ui-checklist/SKILL.md',
-  'claude/skills/ux-audit/REQUIREMENT.md',
-  'claude/skills/ux-audit/SKILL.md',
-  'claude/skills/ux-measure/REQUIREMENT.md',
-  'claude/skills/ux-measure/SKILL.md',
+  'claude/skills/ui-audit/REQUIREMENT.md',
+  'claude/skills/ui-audit/SKILL.md',
+  'claude/skills/ui-measure/REQUIREMENT.md',
+  'claude/skills/ui-measure/SKILL.md',
   'claude/skills/write-human/REQUIREMENT.md',
   'claude/skills/write-human/SKILL.md',
   'claude/skills/write-human/references/adopted.md',
@@ -404,6 +398,7 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/youtube-transcripts/SKILL.md',
   '.claude/skills/internal-claude/REQUIREMENT.md',
   '.claude/skills/internal-docs/REQUIREMENT.md',
+  '.claude/skills/internal-feedback-triage/REQUIREMENT.md',
   '.claude/skills/internal-governance/REQUIREMENT.md',
   '.claude/skills/internal-rule-audit/REQUIREMENT.md',
   '.claude/skills/internal-sandbox-check/REQUIREMENT.md',

package/src/migrate/record-layout.ts

@@ -88,8 +88,9 @@ const RENDER = [SCRATCH, 'render'] as const
  * Every move this migration makes, as record-relative paths.
  *
  * The first two rows are batch 2's. The rest are batch 3's, in the order the
- * intake's review-folder pass listed them. A later batch appends here rather
- * than adding a second table.
+ * intake's review-folder pass listed them, then the design board, moved to
+ * the `.canon/board` folder Frameboard names. A later batch appends here
+ * rather than adding a second table.
  */
 export const RECORD_LAYOUT_MOVES: readonly RecordLayoutMove[] = [
   { kind: 'folder', from: ['review', 'memory'], to: ['memory', 'review'] },
@@ -130,6 +131,7 @@ export const RECORD_LAYOUT_MOVES: readonly RecordLayoutMove[] = [
     picks: ['picks'],
     evidence: ['evidence'],
   },
+  { kind: 'folder', from: ['canvas'], to: ['board'] },
 ]
 
 function resolveRecord(root: string, segments: readonly string[]): string {
@@ -346,7 +348,7 @@ function entriesOf(dir: string, isDirectory: boolean): string[] {
 }
 
 /**
- * What `pick-by-eye` Step 6 writes into the folder it archives a choice to:
+ * What `design-pick` Step 6 writes into the folder it archives a choice to:
  * a capture per canvas frame, named `arm-<id>`. A design handoff marks a pick
  * folder an earlier skill wrote. A folder carrying neither is evidence.
  */

package/src/migrate/skill-names.ts

@@ -54,6 +54,15 @@ import { defineRenameRules, type RenameRules } from '@/migrate/rename'
  * target on the oldest spelling lands in one pass rather than two.
  * `draft-ready` alone keys on its namespaced forms below rather than here.
  *
+ * Four skills then moved into the family their job belongs to. `pick-by-eye`
+ * was the one step of the design flow without the `design-` prefix, so it
+ * became `design-pick`. `ui-record` filmed footage while "record" already
+ * named the design record, so it became `ui-film`. `ux-audit` and
+ * `ux-measure` were the only `ux-` skills beside the `ui-` ones, so they
+ * became `ui-audit` and `ui-measure`. `draft-and-pick`, `claude-ux-audit`,
+ * and `claude-ux-measure` are retargeted onto the new names for the same
+ * reason `claude-ui-test` was.
+ *
  * Every name takes two words. Ten of these would have landed as a bare single
  * word under a plain strip, and a bare word such as `review` or `docs` is a
  * substring of ordinary prose with no token left for a later sweep to find.
@@ -92,8 +101,10 @@ export const SKILL_NAME_MAP: Readonly<Record<string, string>> = {
   'claude-teach': 'teach-workspace',
   'claude-ui-test': 'ui-checklist',
   'ui-test': 'ui-checklist',
-  'claude-ux-audit': 'ux-audit',
-  'claude-ux-measure': 'ux-measure',
+  'claude-ux-audit': 'ui-audit',
+  'claude-ux-measure': 'ui-measure',
+  'ux-audit': 'ui-audit',
+  'ux-measure': 'ui-measure',
   'claude-worker': 'role-worker',
   'claude-worktree': 'session-worktree',
   'canon-screencast': 'script-screencast',
@@ -110,8 +121,10 @@ export const SKILL_NAME_MAP: Readonly<Record<string, string>> = {
   'draft-figure': 'draw-figure',
   'draft-identity': 'design-identity',
   'draft-slides': 'make-deck',
-  'draft-and-pick': 'pick-by-eye',
+  'draft-and-pick': 'design-pick',
   'draft-screencast': 'script-screencast',
+  'pick-by-eye': 'design-pick',
+  'ui-record': 'ui-film',
 }
 
 /**
@@ -190,6 +203,10 @@ export const RENAMED_DRAFT_POINTERS: readonly string[] = [
  * what shipped or what a session ran under whatever name was current then, so
  * rewriting one makes it testify to a release or a run that never happened.
  *
+ * A replay fixture is excluded on the same argument. It records a real
+ * project's tree as that project held it, so a rewrite changes what the replay
+ * proves.
+ *
  * The record archives need no entry here. They are gitignored, so the tracked
  * listing every sweep reads never reaches them.
  */
@@ -197,7 +214,7 @@ export const SKILL_NAME_RULES: RenameRules = defineRenameRules({
   replacements: { ...SKILL_NAME_MAP, ...SKILL_CITATION_MAP },
   keepMarker: 'canon-keep-retired',
   wholeToken: true,
-  excludedPrefixes: ['scripts/eval/result-'],
+  excludedPrefixes: ['scripts/eval/result-', 'sandbox/fixtures/replay/'],
   excludedPaths: [
     'CHANGELOG.md',
     'src/migrate/skill-names.ts',