@erclx/canon 5.33.0 → 5.35.0

package/src/records/validate.ts

@@ -7,7 +7,6 @@ import {
   recordDir as resolveRecordDir,
   recordDirs as resolveRecordDirs,
 } from '@/roots/record'
-import { ATTRIBUTE_MARKER, governedPaths, readScope } from '@/standards/scope'
 import {
   TEACH_GLOSSARY,
   TEACH_MISSION,
@@ -18,34 +17,10 @@ import {
   WORKSPACE_NAME,
 } from '@/teach/workspace'
 
-export const RECORD_KINDS = [
-  'plans',
-  'groundwork',
-  'intake',
-  'standards',
-  'teach',
-] as const
+export const RECORD_KINDS = ['plans', 'groundwork', 'intake', 'teach'] as const
 
 export type RecordKind = (typeof RECORD_KINDS)[number]
 
-/**
- * The folders standards reads, in precedence order.
- *
- * It carries two because the corpus authors at the project root and installs
- * under `.claude/`. The authoring root wins where both exist, since the
- * installed tree is a generated copy here and a finding fixed there is
- * overwritten by the next regen. A project that consumed the corpus holds only
- * the second, so one order serves both.
- *
- * Every other kind is a session record and takes the record roots instead,
- * resolved by `@/roots/record`. Standards is the one kind that is tracked, so it
- * does not move and spells its own two candidates here.
- */
-const STANDARDS_FOLDERS: readonly string[] = [
-  'standards',
-  join('.claude', 'standards'),
-]
-
 /**
  * `unknown-kind` is raised at the argument boundary rather than by the walk, and
  * it sits here because both reach a caller through the same `reason` field. A
@@ -60,7 +35,6 @@ export const FINDING_KINDS = [
   'name-malformed',
   'title-missing',
   'section-missing',
-  'scope-unanchored',
   'entry-unreasoned',
   'suggestion-missing',
   'question-unanswerable',
@@ -103,10 +77,6 @@ export type ValidateOutcome = ValidateReport | ValidateRefused
 
 /** Every folder a kind would accept, whether or not it is on disk. */
 export function recordDirs(root: string, kind: RecordKind): string[] {
-  if (kind === 'standards') {
-    return STANDARDS_FOLDERS.map((folder) => join(root, folder))
-  }
-
   return resolveRecordDirs(root, kind)
 }
 
@@ -114,19 +84,8 @@ export function recordDirs(root: string, kind: RecordKind): string[] {
  * The folder a kind reads. The first candidate on disk wins, and the creation
  * default stands in when none exists, so a refusal and a test fixture both name
  * the location the kind would be written to.
- *
- * The default is where this parts company with `dirs[0]`, which the record
- * kinds can no longer take: their first candidate is the root the move lands at
- * and nothing creates there yet, so a fallback reading it would name a folder no
- * verb would ever write. Standards has no such split, since it is tracked and
- * its first candidate is where it is authored.
  */
 export function recordsDir(root: string, kind: RecordKind): string {
-  if (kind === 'standards') {
-    const dirs = recordDirs(root, kind)
-    return dirs.find((dir) => existsSync(dir)) ?? dirs[0]
-  }
-
   return resolveRecordDir(root, kind)
 }
 
@@ -134,18 +93,6 @@ export function isRecordKind(value: string): value is RecordKind {
   return (RECORD_KINDS as readonly string[]).includes(value)
 }
 
-/**
- * Whether a kind's folder is shared session scratch at the main worktree root.
- *
- * The five record folders are, so every session validates the records every
- * other session reads. The corpus is tracked instead, so a linked worktree holds
- * its own edited copy, and defaulting that kind to the main root would report on
- * a tree the session never touched and say nothing about which one it read.
- */
-export function isSharedScratch(kind: RecordKind): boolean {
-  return kind !== 'standards'
-}
-
 const NONE_IDENTIFIED = 'None identified.'
 const NUMBERED_FILE = /^\d{2}-[a-z0-9]+(-[a-z0-9]+)*\.md$/
 
@@ -920,127 +867,6 @@ async function checkWorkspace(dir: string, slug: string): Promise<Finding[]> {
   ]
 }
 
-const STANDARD_INDEX = 'index.md'
-const STANDARD_FIELDS = ['title', 'description'] as const
-
-const DOES_NOT_GOVERN = 'Does not govern:'
-
-/**
- * The words a governed path offers a filename. Each segment gives its own word
- * and, where it carries a prefix or a placeholder, the parts either side of a
- * hyphen, so `.canon/tasks/session-<slug>.md` offers `tasks` and `session`.
- *
- * A dotted segment gives nothing. It names the folder holding the artifact
- * rather than the artifact, and a standard named for it would pass this check
- * while naming the container every sibling shares.
- */
-export function pathWords(path: string): string[] {
-  const words: string[] = []
-
-  for (const segment of path.split('/')) {
-    if (segment.startsWith('.')) continue
-
-    const stem = segment.replace(/\.[a-z]+$/i, '').toLowerCase()
-    words.push(stem)
-    if (stem.includes('-')) words.push(...stem.split('-'))
-  }
-
-  return words.filter((word) => /^[a-z]+$/.test(word))
-}
-
-/**
- * Accepts the singular and the plural of one word. A standard over a single
- * document is named for the document and one over a folder of them is named for
- * either, and picking a side would report a conforming half of the corpus.
- */
-function namesWord(stem: string, word: string): boolean {
-  return stem === word || `${stem}s` === word || stem === `${word}s`
-}
-
-function checkStandardName(name: string, statement: string): Finding[] {
-  const paths = governedPaths(statement)
-
-  // The marker is read only where the first sentence backticks nothing, which
-  // is the catalog's own rule. A statement naming a path publishes that path
-  // however the rest of the statement describes itself.
-  if (paths.length === 0) {
-    if (statement.includes(ATTRIBUTE_MARKER)) return []
-
-    return [
-      finding(
-        'scope-unanchored',
-        name,
-        name,
-        'backticks no path in its first scope sentence and does not call itself an attribute standard, so it names no artifact to be named for.',
-      ),
-    ]
-  }
-
-  const stem = name.replace(/\.md$/, '')
-  const words = paths.flatMap(pathWords)
-
-  if (words.some((word) => namesWord(stem, word))) return []
-
-  return [
-    finding(
-      'name-malformed',
-      name,
-      name,
-      `names no part of ${paths.join(', ')}, which is what it governs. A rename reaches every target that installed the corpus and every surface citing it by bare filename.`,
-    ),
-  ]
-}
-
-export function checkStandard(name: string, text: string): Finding[] {
-  const findings: Finding[] = []
-  const frontmatter = parseFrontmatter(text)
-
-  const missing = STANDARD_FIELDS.filter(
-    (field) => !readField(frontmatter, field),
-  )
-
-  if (missing.length > 0) {
-    findings.push(
-      finding(
-        'frontmatter-incomplete',
-        name,
-        name,
-        `carries no ${missing.join(' and no ')}.`,
-      ),
-    )
-  }
-
-  const scope = readScope(text)
-
-  // The name derives from the scope statement, so an absent section leaves
-  // nothing to derive against. Reporting the name as well would name one defect
-  // twice and point the fix at the wrong file.
-  if (!scope) {
-    return [
-      ...findings,
-      finding(
-        'section-missing',
-        name,
-        '## Scope',
-        'is absent, so the standard claims no jurisdiction and can refuse no rule.',
-      ),
-    ]
-  }
-
-  if (!scope.lines.some((line) => line.trim().startsWith(DOES_NOT_GOVERN))) {
-    findings.push(
-      finding(
-        'section-missing',
-        name,
-        DOES_NOT_GOVERN,
-        'is absent from the scope section, so no boundary names the owner it hands off to.',
-      ),
-    )
-  }
-
-  return [...findings, ...checkStandardName(name, scope.statement)]
-}
-
 /**
  * The three kinds whose records are folders rather than files. Keyed by kind so
  * a seventh arrives as an entry here and the compiler names the walk it owes,
@@ -1048,7 +874,7 @@ export function checkStandard(name: string, text: string): Finding[] {
  */
 const FOLDER_CHECK: Readonly<
   Record<
-    Exclude<RecordKind, 'plans' | 'standards'>,
+    Exclude<RecordKind, 'plans'>,
     (dir: string, slug: string) => Promise<Finding[]>
   >
 > = {
@@ -1066,9 +892,8 @@ async function validateFiles(
   dir: string,
   kind: RecordKind,
   check: (name: string, text: string) => Finding[],
-  skip: (file: string) => boolean = () => false,
 ): Promise<ValidateReport> {
-  const files = (await listMarkdown(dir)).filter((file) => !skip(file))
+  const files = await listMarkdown(dir)
 
   const perFile = await Promise.all(
     files.map(async (file) =>
@@ -1080,12 +905,9 @@ async function validateFiles(
 }
 
 /**
- * Reports what every record in one folder claims against the shape its standard
- * fixes. It writes nothing whichever kind runs, and the reason differs by kind.
- * A session record is per-machine scratch with no history behind it, so a repair
- * that guessed wrong could not be undone. A standard installs into every target
- * and is cited by bare filename, so a rename costs more than the file move it
- * looks like.
+ * Reports what every record in one folder claims against the shape its reference
+ * fixes. It writes nothing, since a session record is per-machine scratch with
+ * no history behind it, so a repair that guessed wrong could not be undone.
  */
 export async function validateRecords(
   root: string,
@@ -1102,16 +924,6 @@ export async function validateRecords(
 
   if (kind === 'plans') return validateFiles(dir, kind, checkPlan)
 
-  // The walk stays flat, matching install and the catalog.
-  if (kind === 'standards') {
-    return validateFiles(
-      dir,
-      kind,
-      checkStandard,
-      (file) => file === STANDARD_INDEX,
-    )
-  }
-
   const folders = await listFolders(dir)
   const check = FOLDER_CHECK[kind]
   const perFolder = await Promise.all(

package/src/sandbox/equivalence.ts

@@ -701,13 +701,16 @@ function canonVersion(): string {
 }
 
 /**
- * Adds the baseline as a detached worktree of the base ref, so it carries full
- * history for the scenarios that read it, and returns a remover that is safe to
- * call twice. `node_modules` is linked from the working checkout, since the
- * baseline runs the same CLI and carries no install of its own.
+ * Adds a detached worktree of `ref` at `path`, so it carries full history for
+ * the scenarios that read it, and returns a remover that is safe to call twice.
+ * `node_modules` is linked from the working checkout, since the copy runs the
+ * same CLI and carries no install of its own.
  */
-function addBaseline(root: string, workDir: string, ref: string): () => void {
-  const path = join(workDir, 'base')
+export function addDetachedWorktree(
+  root: string,
+  path: string,
+  ref: string,
+): () => void {
   execFileSync('git', ['worktree', 'add', '--detach', path, ref], {
     cwd: root,
     stdio: ['ignore', 'ignore', 'pipe'],
@@ -761,7 +764,11 @@ export async function runEquivalence(
 
   let removeBaseline: () => void
   try {
-    removeBaseline = addBaseline(options.root, workDir, options.base)
+    removeBaseline = addDetachedWorktree(
+      options.root,
+      join(workDir, 'base'),
+      options.base,
+    )
   } catch (error) {
     // An unknown ref must not leave an empty scratch folder behind.
     if (options.out === undefined)

package/src/sandbox/provision.ts

@@ -220,11 +220,6 @@ function install(
   fail(`Could not install ${label} into the sandbox.`)
 }
 
-/**
- * No standards install. The corpus installs into no target, so a scenario
- * driving a skill that reads one takes the `canon standards <name>` path a real
- * project takes.
- */
 function setupAssets(
   root: string,
   sandbox: string,

package/src/secrets/shipped.ts

@@ -13,8 +13,7 @@ import { join } from 'node:path'
  *
  * What it does not cover is the plugin, which a marketplace install reads live
  * from `claude/` rather than from a tarball. That folder is a `files` entry
- * too, and its `standards` symlink resolves into a tree the field lists in its
- * own right, so both routes land inside the same corpus.
+ * too, so both routes land inside the same corpus.
  */
 export type ShipEntries =
   /** The field declares a corpus, which is what this check reads. */

package/src/serve/static.ts

@@ -200,8 +200,7 @@ export function resolveWithin(
 /**
  * Re-tests containment after following symlinks. `resolveWithin` is lexical
  * and `resolve` does not follow a link, so a link inside the root clears that
- * test while the file it points at sits outside. This repository is a live
- * instance, since `claude/standards` is a link out of `claude/`.
+ * test while the file it points at sits outside.
  *
  * Only a path that exists is checked, because a link can be followed only once
  * there is something on the other end, and a path that resolves to nothing is

package/src/shipped/references.ts

@@ -10,8 +10,7 @@ import { isMarked } from '@/sweep/exempt-marker'
  * on purpose rather than by omission. What decides membership here is whether
  * anything serves the file to a reader who does not hold this repository: a
  * skill body loads into a session, a docs page is read through `canon docs`, a
- * standard through `canon standards`, a rule through a glob match, and a seed
- * through an install. A `src/` doc comment
+ * rule through a glob match, and a seed through an install. A `src/` doc comment
  * is read by someone working on the toolkit, in this checkout, where every
  * number resolves.
  *
@@ -19,18 +18,12 @@ import { isMarked } from '@/sweep/exempt-marker'
  * `src/design/base.css` and `src/design/tokens.ts` carry sixteen values shaped
  * `#191512`, which no width or boundary rule separates from a pull request
  * number, so telling them apart would need the line's syntactic position.
- *
- * `claude/standards` is a symlink into one of the roots below, and a walk that
- * followed it would read that corpus twice and report every finding in it
- * under two paths. Nothing is lost by not following, since it is a corpus here
- * in its own right.
  */
 export const SHIPPED_CORPORA = [
   'claude',
   'docs',
   'governance',
   'scripts',
-  'standards',
   'tooling',
 ] as const
 
@@ -146,37 +139,15 @@ const SAME_REPOSITORY =
 const DOCS_PATH = /(?<![\w./-])docs\/[^\s`)\]]*\.md\b/g
 
 /**
- * A bare `standards/<name>.md` citation from a body under `claude/skills/`,
- * which `598-authoring-layout.md` fixes as the broken form there:
- * `${CLAUDE_SKILL_DIR}` is what resolves off the `claude/standards` symlink
- * in every plugin cache, and a raw path has nothing to expand it.
- *
- * Scoped to that one corpus rather than every `isShippedCorpus` reads,
- * because `docs/agents/` and `docs/workflow/` carry the identical
- * `standards/<name>.md` shape correctly: a docs page resolves from this
- * checkout's own root rather than through a skill's `${CLAUDE_SKILL_DIR}`,
- * so the same string is the fix in one corpus and the defect in the other.
- * Widening the pattern to every corpus turns it into a mass false-positive
- * over the dozens of correct citations those two folders carry.
- *
- * The same leading-boundary discipline as `DOCS_PATH` excludes the already
- * correct form: a `/` sits ahead of `standards` in
- * `${CLAUDE_SKILL_DIR}/../../standards/<name>.md`, which the negative
- * lookbehind rejects, so a citation already rewritten to the resolving form
- * does not fail this check a second time.
+ * A call to `canon standards`, a verb no installed CLI carries any more. A
+ * shipped body naming it sends a target reader to an unknown-command error,
+ * so every corpus reports it, `docs/` included. A page saying the verb is gone
+ * carries the reference marker on that line.
  *
- * Reported unless `isStandardsPathReportable` reads the match as a
- * deliberate placeholder rather than a real citation. A body illustrating
- * the shape a project's own `standards/<name>.md` takes writes a bracketed
- * token this pattern also matches, such as `standards/<slug>.md`
- * in a skill that drafts one, which names no real file. A bare,
- * non-bracketed match now reports whether or not the file exists, unlike
- * `DOCS_PATH`, which still gates on existence: a same-repository citation
- * under this corpus names no target project's own tree the way a `docs/`
- * path can, so shape alone separates a placeholder from a broken citation
- * here with no false-positive class existence was catching.
+ * The trailing lookahead keeps a hyphenated token such as a `standards-audit`
+ * page name from matching, since that names a file rather than a call.
  */
-const STANDARDS_PATH = /(?<![\w./-])standards\/[^\s`)\]]*\.md\b/g
+const STANDARDS_CALL = /\bcanon standards(?![\w-])/g
 
 /**
  * A phase-label-shaped token: exactly two numeric groups, with a negative
@@ -223,7 +194,7 @@ export interface ShippedReference {
     | 'pull-request'
     | 'commit'
     | 'docs-path'
-    | 'standards-path'
+    | 'retired-verb'
     | 'phase-label'
     | 'rule-path'
   /** The reference as written, so a report names the token to qualify. */
@@ -272,50 +243,31 @@ function isDocsPathReportable(
 }
 
 /**
- * Whether `file` sits in the one corpus `STANDARDS_PATH` and `RULE_PATH`
- * both gate: a shipped skill body, minus its own `REQUIREMENT.md`.
+ * Whether `file` sits in the one corpus `RULE_PATH` gates: a shipped skill
+ * body, minus its own `REQUIREMENT.md`.
  *
- * Both patterns share this scope because both bans live in
- * `598-authoring-layout.md`, stated for the same reader: a session loading
- * the `SKILL.md` body a target actually receives. `REQUIREMENT.md` is
- * excluded for the reason that file states there, since a maintainer or an
- * audit command reads it rather than a session loading it, so neither
- * resolver rule this pair enforces ever applies to it. One predicate serves
- * both call sites rather than two copies drifting apart with nothing
- * comparing them.
+ * The ban lives in `598-authoring-layout.md`, stated for one reader: a
+ * session loading the `SKILL.md` body a target actually receives.
+ * `REQUIREMENT.md` is excluded for the reason that file states there, since a
+ * maintainer or an audit command reads it rather than a session loading it,
+ * so the resolver rule never applies to it.
  */
 function isSkillBodyScope(file: string): boolean {
   return file.startsWith('claude/skills/') && !file.endsWith('/REQUIREMENT.md')
 }
 
-/**
- * Whether a `STANDARDS_PATH` match should be reported: every match that is
- * not a placeholder, whether or not the named file exists.
- *
- * Existence used to gate this the same way `isDocsPathReportable` gates its
- * corpus, which conflated a deliberate placeholder with a genuinely broken,
- * real-looking citation: both fail existence and both passed muted. A bare
- * `standards/<name>.md` names no target-project tree the way a `docs/` path
- * can, so shape alone separates the two classes here with no false-positive
- * class existence was catching.
- */
-function isStandardsPathReportable(path: string): boolean {
-  return !isPlaceholderPath(path)
-}
-
 /**
  * Every reference in one shipped file that no marker mutes.
  *
  * The corpus walk is deliberately absent, which lets most of the shape be
  * tested against a string rather than against a fixture. That is the seam
  * `headingCitationsIn` draws in `src/claude/skills-headings.ts` and `citationsIn`
- * draws in `skills-reach.ts`. `DOCS_PATH` and `STANDARDS_PATH` are the two
- * patterns that still need a filesystem, since resolving against this
- * checkout is the only thing that separates a real citation from an
- * illustration for either, so `referencesIn` takes `root` as the one
- * caller-supplied exception to that rule. `root` is required rather than
- * defaulted, since a caller that dropped it silently would report zero
- * findings for both rather than raising, which is the wrong failure
+ * draws in `skills-reach.ts`. `DOCS_PATH` is the one pattern that still
+ * needs a filesystem, since resolving against this checkout is the only thing
+ * that separates a real citation from an illustration, so `referencesIn`
+ * takes `root` as the one caller-supplied exception to that rule. `root` is
+ * required rather than defaulted, since a caller that dropped it silently
+ * would report zero findings rather than raising, which is the wrong failure
  * direction for a gate.
  *
  * The unit is the match rather than the line, unlike those two, because one
@@ -375,16 +327,13 @@ export function referencesIn(
       })
     }
 
-    if (isSkillBodyScope(file)) {
-      for (const match of line.matchAll(STANDARDS_PATH)) {
-        if (!isStandardsPathReportable(match[0])) continue
-        references.push({
-          file,
-          line: index + 1,
-          kind: 'standards-path',
-          text: match[0],
-        })
-      }
+    for (const match of line.matchAll(STANDARDS_CALL)) {
+      references.push({
+        file,
+        line: index + 1,
+        kind: 'retired-verb',
+        text: match[0],
+      })
     }
 
     for (const match of line.matchAll(PHASE_LABEL)) {

package/src/sync/check.ts

@@ -3,9 +3,10 @@ import { basename, join, sep } from 'node:path'
 import { execa } from 'execa'
 import { gitEnv } from '@/git/env'
 import { createDesignAdapter, DESIGN_INSTALL_DIR } from '@/design/adapter'
-import { createGovAdapter, rulesSourceDir } from '@/gov/adapter'
+import { createGovAdapter } from '@/gov/adapter'
 import { successorResolver } from '@/gov/renames'
-import { loadGovStack, resolveMissingRules, resolveRules } from '@/gov/stacks'
+import { lookupRules } from '@/gov/install'
+import { resolveMissingRules, resolveRules } from '@/gov/stacks'
 import { planSync, type ScanEntry, type SyncAdapter } from '@/sync/engine'
 import {
   collectSuperseded,
@@ -576,7 +577,8 @@ export function readInstalledRules(
  * not already hold.
  *
  * The band test is the entitlement filter, and `bands` carries two sources: the
- * folders the target already holds, and the folders the base stack takes whole.
+ * folders the target already holds, and the folders holding a rule the base
+ * stack resolves to.
  * A rule authored under `lang/` or `ui/` is named by an individual stack, so it
  * belongs to some targets and not others, and listing every added file would
  * tell a base consumer about rules it was never entitled to. The test
@@ -615,27 +617,29 @@ export function selectNewRules(
 }
 
 /**
- * Band folders the base stack takes whole. Every governance stack extends base,
- * so a rule authored under one of these is entitled to every target.
+ * Band folders holding a rule the base stack resolves to. Every governance
+ * stack extends base, so a new rule authored beside one of base's rules is
+ * reported to every target the fallback below reads.
  *
  * This is what covers a band no target can carry yet. Entitlement is otherwise
- * read off folders the target already holds, and a folder added to base later
+ * read off folders the target already holds, and a band base reaches later
  * exists in no installed tree, so without this the rules inside it would reach
- * nobody. Read from the stack file rather than fixed, so that addition needs no
- * code change here.
+ * nobody. Read through `resolveRules` rather than off the stack's entries,
+ * since base names its rules one by one and an entry is a slug rather than a
+ * folder.
  *
- * A folder only a leaf stack names is deliberately absent. It is entitled to
+ * A folder only a leaf stack reaches is deliberately absent. It is entitled to
  * some targets and not others, which is the distinction the band test makes and
  * the installed tree is the only evidence of.
  */
 export function baseBands(root: string): Set<string> {
-  const stack = loadGovStack(root, 'base')
-  if (stack === undefined) return new Set()
+  const resolution = resolveRules(root, 'base')
+  if (!resolution.ok) return new Set()
 
   return new Set(
-    stack.rules.filter((entry) =>
-      isDirectory(join(rulesSourceDir(root), entry)),
-    ),
+    lookupRules(root, resolution.rules)
+      .found.map((source) => source.subdir.split(sep)[0] ?? '')
+      .filter((band) => band !== ''),
   )
 }
 

package/src/tooling/inject.ts

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

package/src/tooling/read.ts

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