@erclx/canon 4.116.0 → 4.117.0

package/scripts/core/check-capability-seeding.sh

@@ -60,7 +60,8 @@ check_capability "Hooks" "$PROJECT_ROOT/.claude/hooks" \
   "$PROJECT_ROOT"/tooling/claude/seeds/.claude/hooks/*
 
 check_capability "Workflows" "$PROJECT_ROOT/.github/workflows" \
-  "$PROJECT_ROOT"/tooling/*/configs/.github/workflows/*
+  "$PROJECT_ROOT"/tooling/*/configs/.github/workflows/* \
+  "$PROJECT_ROOT"/tooling/*/seeds/.github/workflows/*
 
 check_capability "Husky" "$PROJECT_ROOT/.husky" \
   "$PROJECT_ROOT"/tooling/base/configs/.husky/*
@@ -90,7 +91,8 @@ check_orphans() {
 check_orphans "Hooks" "$PROJECT_ROOT/.claude/hooks" \
   "$PROJECT_ROOT/tooling/claude/seeds/.claude/hooks"
 
-for dir in "$PROJECT_ROOT"/tooling/*/configs/.github/workflows; do
+for dir in "$PROJECT_ROOT"/tooling/*/configs/.github/workflows \
+  "$PROJECT_ROOT"/tooling/*/seeds/.github/workflows; do
   check_orphans "Workflows" "$PROJECT_ROOT/.github/workflows" "$dir"
 done
 

package/src/claude/cases/misc.ts

@@ -36,6 +36,11 @@ export const MISC_CASES: readonly SkillCase[] = [
       "We're about to hit the context limit, write the handoff before we lose state.",
     expect: 'session-compact',
   },
+  {
+    prompt:
+      "I'm moving this session to another machine, write the handoff before I pack it up.",
+    expect: 'session-compact',
+  },
   {
     prompt:
       'I am the orchestrating session and about to compact, so write the board handoff as a session map on the task board.',

package/src/claude/skills-audit.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { parseFrontmatter, readField } from '@/indexes/frontmatter'
+import { bodyLines, maskDisplayed } from '@/markdown/scan'
 
 /** Returned when a skill folder carries no `REQUIREMENT.md`, the gating check. */
 export const EXIT_MISSING_REQUIREMENT = 2
@@ -33,6 +34,14 @@ const KEBAB_CASE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
 
 const HEADING = /^#{1,6}\s+(.+?)\s*$/
 
+/**
+ * An ISO date, read as provenance wherever a reader is told it. The context
+ * audit's detector clears a date after "measured" or "verified", and a skill
+ * body keeps no such carve-out, since the standard sends every incident and its
+ * date to the requirement's Gap or to git.
+ */
+const ISO_DATE = /\b\d{4}-\d{2}-\d{2}\b/g
+
 export interface SkillFinding {
   readonly rel: string
   readonly detail: string
@@ -59,6 +68,7 @@ export interface SkillsAudit {
   readonly nameMismatch: readonly SkillFinding[]
   readonly longDescription: readonly SkillFinding[]
   readonly requirementSections: readonly SkillFinding[]
+  readonly datedProvenance: readonly SkillFinding[]
 }
 
 interface SkillSource {
@@ -69,6 +79,17 @@ interface SkillSource {
   readonly description: string | undefined
   /** Undefined when the folder carries no `REQUIREMENT.md` at all. */
   readonly requirementHeadings: readonly string[] | undefined
+  /**
+   * `SKILL.md` and every reference below the folder, keyed by the path a
+   * finding names. `REQUIREMENT.md` and `EVAL.md` are left out, since the
+   * requirement is where the standard sends a date.
+   */
+  readonly bodies: readonly SkillText[]
+}
+
+interface SkillText {
+  readonly rel: string
+  readonly text: string
 }
 
 /**
@@ -110,6 +131,9 @@ export async function auditSkills(root: string): Promise<SkillsAudit> {
     nameMismatch: sources.flatMap(nameFindings),
     longDescription: sources.flatMap(lengthFindings),
     requirementSections: sources.flatMap(sectionFindings),
+    datedProvenance: sources.flatMap((source) =>
+      source.bodies.flatMap(dateFindings),
+    ),
   }
 }
 
@@ -138,23 +162,41 @@ async function readSkill(
   const skillDir = join(dir, folder)
   const requirementPath = join(skillDir, 'REQUIREMENT.md')
 
-  const [body, requirement] = await Promise.all([
+  const references = [
+    ...new Bun.Glob('references/**/*.md').scanSync({
+      cwd: skillDir,
+      onlyFiles: true,
+    }),
+  ].sort()
+
+  const [body, requirement, referenceTexts] = await Promise.all([
     Bun.file(join(skillDir, 'SKILL.md')).text(),
     existsSync(requirementPath)
       ? Bun.file(requirementPath).text()
       : Promise.resolve(undefined),
+    Promise.all(
+      references.map((path) => Bun.file(join(skillDir, path)).text()),
+    ),
   ])
 
   const fields = parseFrontmatter(body)
+  const skillRel = join(rel, folder)
 
   return {
-    rel: join(rel, folder),
+    rel: skillRel,
     folder,
     hasReadme: existsSync(join(skillDir, 'README.md')),
     name: declared(readField(fields, 'name')),
     description: declared(readField(fields, 'description')),
     requirementHeadings:
       requirement === undefined ? undefined : headings(requirement),
+    bodies: [
+      { rel: join(skillRel, 'SKILL.md'), text: body },
+      ...references.map((path, index) => ({
+        rel: join(skillRel, path),
+        text: referenceTexts[index] ?? '',
+      })),
+    ],
   }
 }
 
@@ -209,3 +251,18 @@ function sectionFindings(source: SkillSource): SkillFinding[] {
     },
   ]
 }
+
+/**
+ * A date inside a fence or a code span is example data a reader is shown, such
+ * as a sample frontmatter block, so only prose outside both is read.
+ */
+function dateFindings(source: SkillText): SkillFinding[] {
+  return bodyLines(source.text)
+    .filter((line) => !line.fenced)
+    .flatMap((line) =>
+      [...maskDisplayed(line.text).matchAll(ISO_DATE)].map((match) => ({
+        rel: source.rel,
+        detail: `line ${line.number}: ${match[0]}`,
+      })),
+    )
+}

package/src/commands/claude.ts

@@ -1397,6 +1397,7 @@ async function runSkillsAudit(
     reportFrontmatter(report)
     reportFolder(report)
     reportRequirementShape(report)
+    reportProvenance(report)
     reportUnmeasured()
     outro()
   }
@@ -1418,6 +1419,7 @@ async function runSkillsAudit(
           readme: report.readme,
           folderName: report.folderName,
           requirementSections: report.requirementSections,
+          datedProvenance: report.datedProvenance,
         },
         checkpoints: {
           descriptionLimit: DESCRIPTION_LIMIT,
@@ -1588,6 +1590,31 @@ function reportRequirementShape(report: SkillsAudit): void {
   reportFindings(report.requirementSections)
 }
 
+/**
+ * Names where the date belongs, since the finding is a date to move rather
+ * than one to delete, and reports without failing the run for the same reason
+ * the frontmatter measures do.
+ */
+function reportProvenance(report: SkillsAudit): void {
+  logStep('Provenance')
+  logInfo(
+    'A SKILL.md and its references state the current rule, with no ISO date outside a fence or code span.',
+  )
+  logInfo(
+    'The incident and date that earned a rule go in REQUIREMENT.md under Gap, or stay in git.',
+  )
+
+  if (report.datedProvenance.length === 0) {
+    logInfo('No body or reference carries a date.')
+    return
+  }
+
+  logWarn(
+    `${plural(report.datedProvenance.length, 'date')} in a body or reference`,
+  )
+  reportFindings(report.datedProvenance)
+}
+
 /**
  * Stated on every run, including the run where everything above passed. A
  * report that lists only what it measured reads as a verdict on the standard
@@ -1604,4 +1631,7 @@ function reportUnmeasured(): void {
   logInfo(
     'The 150-line body checkpoint is mechanical and still absent here, and it would print a count rather than a defect.',
   )
+  logInfo(
+    'Undated provenance, such as "a pull request dropped...", and a date written in words or without its day are not read.',
+  )
 }

package/src/commands/markdown.ts

@@ -3,6 +3,7 @@ import { readFile } from 'node:fs/promises'
 import { dirname, relative, resolve } from 'node:path'
 import type { Command } from 'commander'
 import { BAN_SETS, emptyBanSets } from '@/markdown/bans'
+import { lengthExemption } from '@/markdown/ceiling'
 import { type MarkdownAuditRefusal, resolveMarkdown } from '@/markdown/files'
 import { isGating } from '@/markdown/gate'
 import { decodePath, findBrokenLinks, type LinkFinding } from '@/markdown/links'
@@ -16,6 +17,7 @@ import {
   BASELINE,
   CHECKPOINTS,
   type Checkpoints,
+  documentHeight,
   measureStructure,
   type StructureReport,
 } from '@/markdown/structure'
@@ -51,6 +53,9 @@ interface FileReport {
   readonly bans: readonly BanFinding[]
   readonly links: readonly LinkFinding[]
   readonly structure: StructureReport
+  readonly renderedLines: number
+  /** The stated reason, or null where the document is not exempt. */
+  readonly exempt: string | null
 }
 
 export function register(program: Command): void {
@@ -62,7 +67,7 @@ export function register(program: Command): void {
   markdown
     .command('audit')
     .description(
-      'Fail on a banned character, word, or spelling, and report bullet, paragraph, cadence, and depth',
+      'Fail on a banned character, word, or spelling, and report bullet, paragraph, cadence, depth, and length',
     )
     .argument(
       '[path...]',
@@ -85,6 +90,11 @@ export function register(program: Command): void {
         'Bullet, paragraph, and depth weight are judgments a reader settles,',
         'so all three report and none of them fails a run.',
         '',
+        'Length reports a whole document past the ceiling and never exits 2.',
+        'The Document ceiling gate stage owns that verdict, since this audit also',
+        'runs on a record kept out of version control, where a long plan is not',
+        'a defect.',
+        '',
         'Cadence reports the same way and carries one more caveat. Its range is',
         'drawn from prose a person reads, so terse reference prose sits below',
         'it correctly and a flat paragraph there is not a defect.',
@@ -148,7 +158,8 @@ async function runAudit(
   const reports: FileReport[] = await Promise.all(
     scope.files.map(async (rel) => {
       const abs = resolve(root, rel)
-      const lines = bodyLines(await readFile(abs, 'utf8'))
+      const source = await readFile(abs, 'utf8')
+      const lines = bodyLines(source)
       return {
         rel,
         bans: scanBans(lines, bans),
@@ -156,6 +167,8 @@ async function runAudit(
           existsSync(resolve(dirname(abs), path)),
         ),
         structure: measureStructure(rel, lines, checkpoints),
+        renderedLines: documentHeight(source, checkpoints.renderWidth),
+        exempt: lengthExemption(rel, source),
       }
     }),
   )
@@ -168,6 +181,7 @@ async function runAudit(
   reportParagraphs(reports, checkpoints)
   reportCadence(reports, checkpoints)
   reportDepth(reports, checkpoints)
+  reportLength(reports, checkpoints)
   outro()
 
   if (opts.json) {
@@ -192,6 +206,7 @@ async function runAudit(
           cadence: checkpoints.cadence,
           spread: checkpoints.spread,
           opener: checkpoints.opener,
+          ceiling: checkpoints.ceiling,
         },
         entries: reports.map((report) => ({
           path: report.rel,
@@ -202,6 +217,8 @@ async function runAudit(
           heavyBullets: report.structure.heavyBullets,
           heavyParagraphs: report.structure.heavyParagraphs,
           cadence: report.structure.cadence,
+          renderedLines: report.renderedLines,
+          exempt: report.exempt,
         })),
       })}\n`,
     )
@@ -606,3 +623,47 @@ function reportDepth(
       .join('\n'),
   )
 }
+
+/**
+ * Lists every document past the ceiling and counts the exempt ones rather than
+ * naming them, since an exemption is settled where its marker sits.
+ */
+function reportLength(
+  reports: readonly FileReport[],
+  checkpoints: Checkpoints,
+): void {
+  logStep('Length')
+  logInfo(
+    `Whole documents measure rendered lines at ${checkpoints.renderWidth} columns, frontmatter and fenced blocks included.`,
+  )
+  logInfo(
+    'A changelog is exempt by name, and so is a document carrying a canon-length-exempt marker that names a reason.',
+  )
+
+  const past = reports.filter(
+    (report) => report.renderedLines > checkpoints.ceiling,
+  )
+  const over = past
+    .filter((report) => report.exempt === null)
+    .sort((a, b) => b.renderedLines - a.renderedLines)
+  const exempt = past.length - over.length
+
+  if (over.length === 0) {
+    logInfo(`No document past the ${checkpoints.ceiling}-line ceiling.`)
+  } else {
+    logWarn(
+      `${plural(over.length, 'document')} past the ${checkpoints.ceiling}-line ceiling`,
+    )
+    pipeOutput(
+      over
+        .map(
+          (report) => `${report.rel}  ${report.renderedLines} rendered lines`,
+        )
+        .join('\n'),
+    )
+  }
+
+  if (exempt > 0) {
+    logInfo(`${plural(exempt, 'exempt document')} past the ceiling.`)
+  }
+}

package/src/context/audit.ts

@@ -4,7 +4,7 @@ import { BARE_NAME, IGNORE_MARKER } from '@/context/citations'
 import type { AuditedFolder } from '@/context/folders'
 import type { NarrationTerms } from '@/context/narration'
 import { type BodyLine, bodyLines, maskDisplayed } from '@/markdown/scan'
-import { renderedHeight } from '@/markdown/structure'
+import { documentHeight } from '@/markdown/structure'
 import { isStubSeed } from '@/seed-marker'
 
 /**
@@ -214,9 +214,10 @@ export interface EntryReport {
   readonly rel: string
   /**
    * Rendered lines across the whole file, counting frontmatter and fenced
-   * blocks. It shares `renderedHeight` with the depth checkpoint in
-   * `src/markdown/structure.ts`, since the two sit in one section of the
-   * standard and a reader compares them.
+   * blocks. It counts through `documentHeight` in `src/markdown/structure.ts`,
+   * which shares `renderedHeight` with the depth checkpoint and with the
+   * document ceiling, since all three sit beside each other in the standard
+   * and a reader compares them.
    *
    * Fences are counted here and excluded there. The depth measure skips one so
    * an example cannot break the run around it, and a file measure has no run to
@@ -646,10 +647,7 @@ export function measureEntry(
 
   return {
     rel,
-    lines: source
-      .replace(/\n$/, '')
-      .split('\n')
-      .reduce((sum, text) => sum + renderedHeight(text), 0),
+    lines: documentHeight(source),
     catalogTables: catalogTables(lines),
     provenance: governsContent ? provenance(lines) : [],
     narration: governsContent && terms ? narration(lines, terms) : [],

package/src/gate/measures.ts

@@ -13,6 +13,9 @@ import {
   measureArchitecture,
 } from '@/context/architecture'
 import { listRepositoryFiles } from '@/git-files'
+import { ceilingFindings } from '@/markdown/ceiling'
+import { resolveMarkdown } from '@/markdown/files'
+import { CHECKPOINTS } from '@/markdown/structure'
 import {
   isShippedCorpus,
   REFERENCE_MARKER,
@@ -21,6 +24,7 @@ import {
   type ShippedReference,
 } from '@/shipped/references'
 import { surfaceDir } from '@/surface-root'
+import { plural } from '@/ui'
 import {
   README_PARAPHRASE_MARKER,
   readmeCitationsIn,
@@ -273,6 +277,62 @@ export const architectureRecord: Measure = async (ctx) => {
   }
 }
 
+/**
+ * Every tracked markdown document against the whole-document ceiling.
+ *
+ * Report-only for now: a document past the ceiling warns and the stage still
+ * passes, since the corpus carried dozens past it when the stage landed. The
+ * flip to a failure is a separate change once the count reads zero, and it
+ * replaces the warn path rather than sitting beside it.
+ *
+ * Read in-process rather than through `canon markdown audit`, whose exit code
+ * stays bans and dead links only. The plan and groundwork skills run that audit
+ * on a gitignored record, and a gating length there would fail every long plan.
+ */
+export const documentCeiling: Measure = async (ctx) => {
+  const scope = await resolveMarkdown(ctx.root, [])
+  if (scope.kind === 'unavailable') {
+    return {
+      emissions: [],
+      unmeasured: 'git could not list the tree, so no document was measured.',
+    }
+  }
+
+  const documents = scope.files.flatMap((rel) => {
+    try {
+      return [{ rel, source: readFileSync(join(ctx.root, rel), 'utf8') }]
+    } catch {
+      return []
+    }
+  })
+  const findings = ceilingFindings(documents)
+  const over = findings.filter((finding) => finding.exempt === null)
+  const exempt = findings.length - over.length
+  const ceiling = CHECKPOINTS.ceiling
+
+  if (over.length === 0) {
+    const exemptNote = exempt > 0 ? `, ${exempt} exempt` : ''
+    return {
+      emissions: [
+        info(
+          `No document past the ${ceiling}-line ceiling across ${plural(documents.length, 'markdown file')}${exemptNote}`,
+        ),
+      ],
+    }
+  }
+
+  return {
+    emissions: [
+      ...over.map((finding) =>
+        warn(`${finding.rel}  ${finding.renderedLines} rendered lines`),
+      ),
+      info(
+        `${plural(over.length, 'document')} past the ${ceiling}-line ceiling, ${exempt} exempt. Reported only, so the push is not held.`,
+      ),
+    ],
+  }
+}
+
 /**
  * A second run of the records move should rewrite nothing, and the count is
  * only knowable once the folders themselves have landed.

package/src/gate/stages.ts

@@ -3,6 +3,7 @@ import {
   auditSet,
   captureStamps,
   clientCommandCitations,
+  documentCeiling,
   markdownBans,
   type Measure,
   pluginManifests,
@@ -333,9 +334,11 @@ export const STAGES: readonly Stage[] = [
     checks: [{ kind: 'measure', measure: unreferencedRules }],
   },
   {
-    // Only the citation half of the audit gates. Length, depth, table, and
+    // Only the citation half of the audit gates. Its length, depth, table, and
     // index findings are judgment thresholds, and failing a push on one would
-    // make the stage something to route around.
+    // make the stage something to route around. The one length reading that
+    // will gate is the whole-document ceiling, which the Document ceiling stage
+    // below owns rather than this audit.
     id: 'context-citations',
     label: 'Context citations',
     checks: [
@@ -355,6 +358,13 @@ export const STAGES: readonly Stage[] = [
     label: 'Architecture record',
     checks: [{ kind: 'measure', measure: architectureRecord }],
   },
+  {
+    // Unscoped, since any branch can grow any document. It warns and passes
+    // until the corpus sits under the ceiling, then flips to a failure.
+    id: 'document-ceiling',
+    label: 'Document ceiling',
+    checks: [{ kind: 'measure', measure: documentCeiling }],
+  },
   {
     // A rule citing a file that moved fails silently. The consumed-copy drift
     // stage passes an authored rule and its copy that are wrong together, and

package/src/markdown/ceiling.ts

@@ -0,0 +1,70 @@
+import { basename } from 'node:path'
+import { bodyLines } from '@/markdown/scan'
+import { CHECKPOINTS, documentHeight } from '@/markdown/structure'
+
+/**
+ * The marker exempting one document from the ceiling, written as a whole line
+ * outside a fence and naming a reason.
+ *
+ * The whole line rather than anywhere on it, so a standard quoting the marker
+ * inside a code span to document it does not exempt itself. A marker with no
+ * reason does not count, for the reason `isMarked` in `src/exempt-marker.ts`
+ * gives: a bare token reads as a line that meant to say something and did not.
+ */
+const EXEMPT_MARKER = /^<!--\s*canon-length-exempt:[ \t]*(\S.*?)\s*-->$/
+
+/**
+ * A changelog is exempt by name because the release tool rewrites it and would
+ * not keep a marker in place. A committed list of exempt paths was the
+ * alternative, and it turns every rename into a second edit with nothing to
+ * check the list against the tree.
+ */
+const CHANGELOG = 'CHANGELOG.md'
+const CHANGELOG_REASON = 'CHANGELOG.md is written by the release tool'
+
+export interface CeilingDocument {
+  readonly rel: string
+  readonly source: string
+}
+
+export interface CeilingFinding {
+  readonly rel: string
+  readonly renderedLines: number
+  /** The stated reason, or null where the document is not exempt. */
+  readonly exempt: string | null
+}
+
+/** The reason a document is exempt from the ceiling, or null where it is not. */
+export function lengthExemption(rel: string, source: string): string | null {
+  if (basename(rel) === CHANGELOG) return CHANGELOG_REASON
+
+  for (const line of bodyLines(source)) {
+    if (line.fenced) continue
+    const match = EXEMPT_MARKER.exec(line.text.trim())
+    if (match) return match[1]
+  }
+
+  return null
+}
+
+/**
+ * Every document past the ceiling, longest first, exempt ones included with
+ * their reason so a report can count them rather than hide them.
+ */
+export function ceilingFindings(
+  documents: readonly CeilingDocument[],
+): CeilingFinding[] {
+  return documents
+    .map(({ rel, source }) => ({
+      rel,
+      renderedLines: documentHeight(source),
+      source,
+    }))
+    .filter(({ renderedLines }) => renderedLines > CHECKPOINTS.ceiling)
+    .map(({ rel, renderedLines, source }) => ({
+      rel,
+      renderedLines,
+      exempt: lengthExemption(rel, source),
+    }))
+    .sort((a, b) => b.renderedLines - a.renderedLines)
+}

package/src/markdown/structure.ts

@@ -116,6 +116,7 @@ export const CHECKPOINTS = {
   cadence: 3,
   spread: 5,
   opener: 2,
+  ceiling: 300,
 } as const
 
 /**
@@ -167,6 +168,11 @@ export interface Checkpoints {
   readonly spread: number
   /** Times one opening word may open a sentence in a paragraph before it is a pattern. */
   readonly opener: number
+  /**
+   * Rendered lines a whole document may reach, read by the Document ceiling
+   * gate stage rather than by any exit code of the audit.
+   */
+  readonly ceiling: number
 }
 
 export interface BulletFinding {
@@ -247,6 +253,22 @@ export function renderedHeight(text: string, width = RENDER_WIDTH): number {
   return Math.max(1, Math.ceil(visibleText(text).length / width))
 }
 
+/**
+ * Height a whole source occupies once wrapped, frontmatter and fenced blocks
+ * included.
+ *
+ * Nothing is excluded because a session pays for every line it loads, which is
+ * what separates this from the depth measure. The context audit's length
+ * reading and the document ceiling both count through here, so the two report
+ * one unit.
+ */
+export function documentHeight(source: string, width = RENDER_WIDTH): number {
+  return source
+    .replace(/\n$/, '')
+    .split('\n')
+    .reduce((sum, text) => sum + renderedHeight(text, width), 0)
+}
+
 /**
  * Reports whether a run is the peer list the standard exempts.
  *

package/src/tooling/inject.ts

@@ -6,7 +6,12 @@ import { copyPreservingMode } from '@/copy'
 import { rewritesOnInstall, stripSeedMarker } from '@/seed-marker'
 import { resolveSurfacePath } from '@/surface-root'
 import { mergeSections, pruneSections } from '@/tooling/gitignore'
-import { ancestorsFirst, listFiles, type Manifest } from '@/tooling/manifest'
+import {
+  ancestorsFirst,
+  configPaths,
+  listFiles,
+  type Manifest,
+} from '@/tooling/manifest'
 import {
   applyScripts,
   collectDeps,
@@ -97,9 +102,14 @@ export async function injectSeeds(
   target: string,
 ): Promise<string[]> {
   const applied: string[] = []
+  const isSubfolder = isSubfolderTarget(target)
+  const shadowed = configPaths(chain)
 
   for (const manifest of ancestorsFirst(chain)) {
-    const files = listFiles(manifest.seedsDir)
+    const files = listFiles(manifest.seedsDir).filter(
+      (rel) =>
+        !shadowed.has(rel) && !(isSubfolder && isWithheldInSubfolder(rel)),
+    )
     if (files.length === 0) continue
 
     logStep(`Applying ${manifest.name} seeds`)
@@ -111,9 +121,7 @@ export async function injectSeeds(
     }
   }
 
-  const spellConfig = isSubfolderTarget(target)
-    ? subfolderSpellConfig(chain)
-    : undefined
+  const spellConfig = isSubfolder ? subfolderSpellConfig(chain) : undefined
   if (spellConfig !== undefined && !hasSpellConfig(target)) {
     logStep('Applying subfolder spell config')
     await writeFile(join(target, SUBFOLDER_SPELL_CONFIG), spellConfig)

package/src/tooling/manifest.ts

@@ -44,6 +44,15 @@ export function listFiles(dir: string): string[] {
   ].sort()
 }
 
+/**
+ * Every path any stack in the chain ships as a config. A seed at one of these
+ * paths is shadowed, since the config overwrites it on every sync. `scan` and
+ * `injectSeeds` both read this, so the report and the write cannot disagree.
+ */
+export function configPaths(chain: readonly Manifest[]): Set<string> {
+  return new Set(chain.flatMap((manifest) => listFiles(manifest.configsDir)))
+}
+
 /**
  * Reverses a chain so the furthest ancestor is applied first and nearer
  * stacks overwrite it.