@erclx/aitk 1.7.1 → 2.1.0

package/src/commands/sync.ts

@@ -34,7 +34,6 @@ import {
 import { describeSkew } from '@/version/skew'
 
 const SYNC_ARGS: Record<SyncDomain, readonly string[]> = {
-  standards: ['standards', 'sync'],
   snippets: ['snippets', 'sync'],
   governance: ['gov', 'sync'],
   claude: ['claude', 'sync'],
@@ -379,7 +378,7 @@ async function runSync(target: string): Promise<number> {
 
   if (existsSync(join(resolved, '.claude'))) {
     process.stderr.write(
-      `${GREY}Tip: run \`/claude-seed-sync\` to audit seed and standards drift per section, preserving local customizations.${NC}\n`,
+      `${GREY}Tip: run \`/claude-seed-sync\` to audit seed drift per section, preserving local customizations.${NC}\n`,
     )
   }
 

package/src/gov/install.ts

@@ -109,12 +109,3 @@ export async function installRules(
 
   return installed
 }
-
-/**
- * The bash checked `<target>/standards`, but `aitk standards install` writes
- * `.claude/standards/`, which is also the path the rules reference and the
- * path the warning names. The guard therefore fired on every modern install.
- */
-export function hasStandards(target: string): boolean {
-  return existsSync(join(target, '.claude', 'standards'))
-}

package/src/init/flags.ts

@@ -1,6 +1,5 @@
 import type { Command } from 'commander'
 import { DEFAULT_STACK, SKIPPABLE_DOMAINS } from '@/init/plan'
-import { ALL_SELECTION } from '@/standards/closure'
 
 interface InitOptionSpec {
   /** The option value key commander stores the parsed value under. */
@@ -33,12 +32,6 @@ export const INIT_OPTIONS: readonly InitOptionSpec[] = [
     description: "Snippets preset, category, or 'all'",
     defaultValue: 'essentials',
   },
-  {
-    key: 'standards',
-    flags: '--standards <selection>',
-    description: "Comma-separated standard names, or 'all'",
-    defaultValue: ALL_SELECTION,
-  },
   {
     key: 'skip',
     flags: '--skip <list>',
@@ -62,9 +55,9 @@ export function applyInitOptions(command: Command): Command {
 
 /**
  * Whether the operator passed any flag, which is what makes the command
- * scriptable by suppressing the confirmation prompt. `--stack`, `--snippets`,
- * and `--standards` all carry defaults, so presence has to be read from where
- * the value came from rather than from the value itself.
+ * scriptable by suppressing the confirmation prompt. `--stack` and `--snippets`
+ * both carry defaults, so presence has to be read from where the value came
+ * from rather than from the value itself.
  */
 export function flagsProvided(cmd: Command): boolean {
   return INIT_OPTIONS.some(

package/src/init/plan.ts

@@ -1,13 +1,11 @@
-import { ALL_SELECTION } from '@/standards/closure'
-
-export const SKIPPABLE_DOMAINS = ['wiki', 'standards', 'governance'] as const
+export const SKIPPABLE_DOMAINS = ['wiki', 'governance'] as const
 
 export type SkippableDomain = (typeof SKIPPABLE_DOMAINS)[number]
 
 /**
  * The stack a caller gets without asking. Governance installs on every init so
- * the standards that install alongside it arrive with the rules that route to
- * them, and `--skip governance` is the one spelling for declining.
+ * a scaffolded project arrives with the rules that route it, and
+ * `--skip governance` is the one spelling for declining.
  */
 export const DEFAULT_STACK = 'base'
 
@@ -33,7 +31,6 @@ export interface InitFlags {
   readonly stack?: string
   readonly add?: string
   readonly snippets: string
-  readonly standards: string
   readonly skip: SkipPlan
 }
 
@@ -73,11 +70,7 @@ export function parseSkip(csv: string | undefined): SkipPlan {
  * prints nothing at all and declined governance prints a warning, so neither
  * reaches the total.
  *
- * Governance is the one skip that costs another domain something, so its
- * warning names the consequence rather than only the action. Declining
- * standards too removes that consequence, and the warning drops it.
- *
- * The skip also drops `--add`, which names rules the caller asked for. Input
+ * The skip drops `--add`, which names rules the caller asked for. Input
  * that goes nowhere is reported for the same reason `parseSkip` reports an
  * unrecognized value, so the warning names the flag rather than dropping it
  * without a word.
@@ -91,13 +84,10 @@ export function planInit(flags: InitFlags): InitPlan {
   const stack = resolveStack(flags.stack)
 
   if (flags.skip.skipped.has('governance')) {
-    const notes: string[] = []
-    if (flags.add !== undefined && flags.add !== '')
-      notes.push(`--add ${flags.add} not installed`)
-    if (!flags.skip.skipped.has('standards'))
-      notes.push('standards land without the rules that route to them')
-
-    const detail = notes.length === 0 ? '' : `, ${notes.join(', ')}`
+    const detail =
+      flags.add === undefined || flags.add === ''
+        ? ''
+        : `, --add ${flags.add} not installed`
     preview.push({ level: 'warn', text: `governance (skipped${detail})` })
   } else if (flags.add === undefined || flags.add === '') {
     preview.push({ level: 'info', text: `governance (stack: ${stack})` })
@@ -108,14 +98,6 @@ export function planInit(flags: InitFlags): InitPlan {
     })
   }
 
-  if (!flags.skip.skipped.has('standards')) {
-    const detail =
-      flags.standards === ALL_SELECTION
-        ? 'authoring conventions'
-        : `${flags.standards}, plus what they cite`
-    preview.push({ level: 'info', text: `standards (${detail})` })
-  }
-
   preview.push({ level: 'info', text: `snippets (${flags.snippets})` })
 
   if (!flags.skip.skipped.has('wiki')) {

package/src/init/steps.ts

@@ -1,6 +1,5 @@
 import { type InitFlags, resolveStack } from '@/init/plan'
 import type { DomainStep } from '@/init/run'
-import { ALL_SELECTION } from '@/standards/closure'
 
 /** Builds the child-process invocation for one domain. */
 export type RunFactory = (args: readonly string[]) => () => Promise<boolean>
@@ -49,14 +48,6 @@ export function buildSteps(
     })
   }
 
-  if (!flags.skip.skipped.has('standards')) {
-    steps.push({
-      kind: 'run',
-      label: 'Standards',
-      run: child(standardsArgs(flags.standards, resolved)),
-    })
-  }
-
   steps.push({
     kind: 'run',
     label: 'Snippets',
@@ -74,21 +65,6 @@ export function buildSteps(
   return steps
 }
 
-/**
- * Builds the `standards install` argv. `all` is left off rather than spelled
- * out, so the default init runs the same command it ran before the flag
- * existed.
- */
-function standardsArgs(selection: string, path: string): string[] {
-  const args = ['standards', 'install']
-  if (selection !== '' && selection !== ALL_SELECTION) {
-    args.push('--only', selection)
-  }
-  args.push(path)
-
-  return args
-}
-
 /**
  * Builds the `gov install` argv. The run and the recovery command a skip prints
  * come from here both, so the command a caller is told to paste installs what

package/src/standards/read.ts

@@ -2,8 +2,13 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { basename, join } from 'node:path'
 import { stripFrontmatter } from '@/frontmatter'
 import { PROJECT_ROOT } from '@/project-root'
-import { standardsSourceDir } from '@/standards/adapter'
-import { INDEX_FILE } from '@/standards/index-refresh'
+
+export const INDEX_FILE = 'index.md'
+
+/** The folder a repository authors standards in, toolkit or project alike. */
+export function standardsSourceDir(root: string): string {
+  return join(root, 'standards')
+}
 
 /**
  * Spells the package root in a report where every other root spells a
@@ -27,22 +32,19 @@ export interface ResolvedStandard {
 }
 
 /**
- * The three roots a standard resolves against, in precedence order.
+ * The roots a standard resolves against. No toolkit standard installs into a
+ * project any more, so `.claude/standards/` is gone from the list and a target
+ * carries neither entry below: the package corpus is the only root that
+ * answers there, which is what leaves no precedence to reason about.
  *
- * A project copy wins wherever one exists. An installed standard is a seed a
- * project edits, so a package copy overriding it would discard that edit with
- * nothing said, and the fallback answers absence rather than staleness. The
- * package root is what lets a project that installed no standards still be
- * measured against one, since `package.json` ships the corpus beside the code
- * doing the reading.
+ * The authoring root stays ahead of the package corpus for the repository that
+ * writes standards, where an edit in progress has to win over the copy
+ * `package.json` shipped. A project that authors standards of its own is the
+ * same case under the same folder.
  */
 export function standardRoots(root: string): StandardRoot[] {
   return [
-    {
-      dir: join(root, '.claude', 'standards'),
-      label: join('.claude', 'standards'),
-    },
-    { dir: join(root, 'standards'), label: 'standards' },
+    { dir: standardsSourceDir(root), label: 'standards' },
     {
       dir: standardsSourceDir(PROJECT_ROOT),
       label: join(PACKAGE_LABEL, 'standards'),

package/src/sync/check.ts

@@ -23,7 +23,6 @@ import {
   stampedCommit,
   type StampDomain,
 } from '@/sync/stamp'
-import { createStandardsAdapter } from '@/standards/adapter'
 import { isDirectory } from '@/target'
 import { loadManifest } from '@/tooling/manifest'
 import { scan } from '@/tooling/scan'
@@ -32,10 +31,11 @@ import { readSkew, type SkewReport } from '@/version/skew'
 /**
  * Domains the sync engine walks file by file. Tooling is a stamp domain without
  * being one of these, because `src/tooling/` never calls `planSync`, so the
- * three lookups below have no entry to offer it.
+ * three lookups below have no entry to offer it. Standards left the list with
+ * the install channel: nothing writes the corpus into a target, so there is no
+ * installed copy to attribute.
  */
 export const SCANNED_DOMAINS = [
-  'standards',
   'snippets',
   'governance',
 ] as const satisfies readonly StampDomain[]
@@ -48,19 +48,16 @@ export type ScannedDomain = (typeof SCANNED_DOMAINS)[number]
  * never go stale and belong in the read-only section instead.
  */
 const SYNCED_SOURCES: Record<ScannedDomain, string> = {
-  standards: 'standards/',
   snippets: 'snippets/',
   governance: 'governance/rules/',
 }
 
 const ADAPTERS: Record<ScannedDomain, (root: string) => SyncAdapter> = {
-  standards: createStandardsAdapter,
   snippets: createSnippetsAdapter,
   governance: createGovAdapter,
 }
 
 const INSTALL_MARKERS: Record<ScannedDomain, readonly string[]> = {
-  standards: ['.claude', 'standards'],
   snippets: ['.claude', 'snippets'],
   governance: ['.claude', 'rules'],
 }
@@ -304,7 +301,7 @@ export function hasDrift(report: CheckReport): boolean {
 /**
  * Bounds each domain's upstream read by that domain's own anchor and its own
  * source path. A shared anchor would let a gov sync advance the revision
- * standards measures from, silently dropping a standards change out of the read.
+ * snippets measures from, silently dropping a snippets change out of the read.
  */
 export async function buildCheckReport(
   toolkitRoot: string,

package/src/sync/layout.ts

@@ -2,7 +2,6 @@ import { existsSync, statSync } from 'node:fs'
 import { basename, join } from 'node:path'
 import { SUBDIRS } from '@/claude/seeds'
 import { snippetsSourceDir } from '@/snippets/categories'
-import { standardsSourceDir } from '@/standards/adapter'
 import type { StampDomain } from '@/sync/stamp'
 
 const CLAUDE_DIR = '.claude'
@@ -11,7 +10,9 @@ const CLAUDE_DIR = '.claude'
  * Domains an older toolkit installed at the project root, each with the source
  * folder naming what it owns. Governance is absent because its rules have always
  * landed under `.claude/rules/`, so there is no earlier location to be stranded
- * at.
+ * at. Standards is absent because no copy installs into a target at all now, so
+ * a root `standards/` folder there is the project's own authoring surface and
+ * reporting it as unmigrated would propose moving files nothing installed.
  *
  * A tuple array rather than a partial record, so the domain key stays typed
  * without asserting an `Object.entries` result back into the union.
@@ -20,10 +21,7 @@ const ROOT_LAYOUTS: readonly (readonly [
   StampDomain,
   string,
   (root: string) => string,
-])[] = [
-  ['standards', 'standards', standardsSourceDir],
-  ['snippets', 'snippets', snippetsSourceDir],
-]
+])[] = [['snippets', 'snippets', snippetsSourceDir]]
 
 /**
  * A target file that a shipped seed folder replaced. Carries no source and
@@ -79,7 +77,7 @@ export function collectSuperseded(target: string): SupersededEntry[] {
  *
  * A root folder is claimed only when it holds a file the toolkit ships under
  * that domain. Presence of the folder alone is not evidence: a project can
- * carry its own `standards/` of project docs and never have installed the
+ * carry its own `snippets/` of prompts it wrote and never have installed the
  * domain, and calling that unmigrated would fail `--exit-code` with no action
  * that clears it.
  */
@@ -107,9 +105,9 @@ export function detectUnmigrated(
 
 /**
  * Root files whose basename matches something the toolkit ships for this domain.
- * Basenames rather than relative paths, because standards install flat while
- * snippets nest by category, and the question here is only whether any file is
- * toolkit-owned rather than which source each one came from.
+ * Basenames rather than relative paths, because the root layout an older toolkit
+ * wrote is flat while the source nests by category, and the question here is only
+ * whether any file is toolkit-owned rather than which source each one came from.
  */
 function countToolkitOwned(dir: string, sourceDir: string): number {
   const owned = new Set(listMarkdown(sourceDir).map((rel) => basename(rel)))

package/src/sync/stamp.ts

@@ -5,16 +5,16 @@ import { dirname, join, sep } from 'node:path'
 import { execa } from 'execa'
 
 /**
- * Domains the stamp can record. The first three attribute file by file through
+ * Domains the stamp can record. The first two attribute file by file through
  * the sync engine. Tooling runs its own inject and manifest machinery, so it
  * records the stack chain it resolved instead and carries no file hashes.
+ *
+ * A stamp written before the standards install channel closed still carries a
+ * `standards` record. `isStamp` ignores the key and `sortDomains` drops it on
+ * the next write, so the target loses a domain nothing can refresh rather than
+ * losing the whole file.
  */
-export const STAMP_DOMAINS = [
-  'standards',
-  'snippets',
-  'governance',
-  'tooling',
-] as const
+export const STAMP_DOMAINS = ['snippets', 'governance', 'tooling'] as const
 
 export type StampDomain = (typeof STAMP_DOMAINS)[number]
 
@@ -223,18 +223,21 @@ function sortDomains(
 }
 
 /**
- * Validates every domain record rather than only the container. A stamp whose
- * domain value is the wrong shape would otherwise reach `attribute`, where a
- * bad hash lookup silently reads as a customization.
+ * Validates every recognized domain record rather than only the container. A
+ * stamp whose domain value is the wrong shape would otherwise reach
+ * `attribute`, where a bad hash lookup silently reads as a customization.
+ *
+ * A key naming no current domain is ignored rather than failing the parse. A
+ * target stamped before the standards install channel closed carries one, and
+ * rejecting the file would read as unstamped and then drop the three records it
+ * does carry on the next write. `sortDomains` retires the key at that write.
  */
 function isStamp(value: unknown): value is Stamp {
   if (!isRecord(value) || !isRecord(value.domains)) return false
 
-  return Object.entries(value.domains).every(
-    ([domain, record]) =>
-      (STAMP_DOMAINS as readonly string[]).includes(domain) &&
-      isDomainStamp(record),
-  )
+  return Object.entries(value.domains)
+    .filter(([domain]) => (STAMP_DOMAINS as readonly string[]).includes(domain))
+    .every(([, record]) => isDomainStamp(record))
 }
 
 /**

package/src/sync/target.ts

@@ -2,12 +2,7 @@ import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { isDirectory } from '@/target'
 
-export const SYNC_DOMAINS = [
-  'standards',
-  'snippets',
-  'governance',
-  'claude',
-] as const
+export const SYNC_DOMAINS = ['snippets', 'governance', 'claude'] as const
 
 export type SyncDomain = (typeof SYNC_DOMAINS)[number]
 
@@ -17,7 +12,6 @@ export interface DomainState {
 }
 
 const DOMAIN_MARKERS: Record<SyncDomain, string> = {
-  standards: join('.claude', 'standards'),
   snippets: join('.claude', 'snippets'),
   governance: join('.claude', 'rules'),
   claude: '.claude',
@@ -30,7 +24,6 @@ const DOMAIN_MARKERS: Record<SyncDomain, string> = {
  * because that is the only file `aitk claude sync` writes.
  */
 const DOMAIN_PATHS: Record<SyncDomain, readonly string[]> = {
-  standards: ['.claude/standards/'],
   snippets: ['.claude/snippets/'],
   governance: ['.claude/rules/', '.claude/GOV.md'],
   claude: ['.gitignore'],

package/standards/skill.md

@@ -231,13 +231,13 @@ A skill reads from two roots. Know which one a file lives under before referenci
 
 ### Citing a standard
 
-A standard reaches a skill by two routes, and a body that names only the first breaks in a project that installed the plugin without running `aitk standards install`.
+No standard installs into a project, so a body cites one place rather than choosing between two.
 
-- Cite `.claude/standards/X.md` first, then name `${CLAUDE_SKILL_DIR}/../../standards/X.md` as the fallback. The plugin ships the whole standards folder beside `skills/`, so the second path resolves in every install.
-- The project copy wins when it exists, which keeps a target's local edits authoritative. The fallback only covers the case where the project lacks that file.
-- Condition the fallback on the standard, never on the `.claude/standards/` directory. `aitk standards sync` updates only filenames it already finds and never adds one, so a project that installed before a standard existed keeps the directory and never receives that file. A directory test passes there, no fallback engages, and the standard reads as absent.
-- State the fallback once per body, at the site that reads the standard. A later mention of a standard the body already read stays bare, since repeating the fallback at every mention is noise rather than instruction.
-- A guard on a standard's presence names the file and tests both paths before it stops. A guard that tests only `.claude/standards/` refuses to run in a plugin-only project that has the file, and a guard that tests the directory passes in the partial-install case it exists to catch.
+- Cite `${CLAUDE_SKILL_DIR}/../../standards/X.md`. The plugin ships the whole standards folder beside `skills/`, so the path resolves in every install and needs no fallback behind it.
+- Never cite `.claude/standards/X.md` from a shipped body. A target holds no such folder, and one left behind by an older toolkit is a stale copy no resolver reads.
+- Name `aitk standards X` instead where the body wants the document rather than a path to open, such as a value it captures or reports. That verb resolves `standards/` at the project root and then the corpus inside the package.
+- State the path once per body, at the site that reads the standard. A later mention of a standard the body already read stays bare, since repeating the path at every mention is noise rather than instruction.
+- A guard on a standard's presence names the file rather than the folder holding it, since a folder test answers for a sibling that happens to be there.
 - Use `${CLAUDE_SKILL_DIR}`, never a bare `../../` and never `${CLAUDE_PLUGIN_ROOT}`. Only `${CLAUDE_SKILL_DIR}` is expanded before the body reaches the model. The other two leave the model to infer a base path, which it may resolve against the session cwd instead.
 - Cite a shared procedure, never restate it. A procedure two or more skills execute gets one definition in a standard and a citation in each body. Nothing catches a restatement that drifts, because the drift assertion covers generated copies and a hand-written one is not generated, so the guarantee is only that a single definition exists to correct.
 - Keep the trigger in the body and the procedure in the standard. The citing skill states when the procedure runs and what it runs against, since that varies per skill and the standard cannot know it.

package/standards/standard.md

@@ -38,7 +38,7 @@ A standard failing these questions is non-conforming even when it satisfies ever
 
 - Govern one document type per standard, or one attribute across every document. Split unrelated conventions into separate files.
 - Open with a `## Scope` section stating what the standard governs and what it does not, placed above the shape rules. A standard that specifies shape exhaustively and jurisdiction nowhere cannot refuse a rule, so the rule with no obvious owner lands in whichever standard sits nearest.
-- Write it as one line naming the artifact or attribute and where it applies, then a `Does not govern:` list. Give each entry the excluded concern and the owner it goes to. Name a sibling standard by bare filename, since standards install as siblings, and name the surface instead where the owner is one, such as a coding rule, a project policy, or the code.
+- Write it as one line naming the artifact or attribute and where it applies, then a `Does not govern:` list. Give each entry the excluded concern and the owner it goes to. Name a sibling standard by bare filename, since the corpus is one flat folder, and name the surface instead where the owner is one, such as a coding rule, a project policy, or the code.
 - Put the governed path in backticks inside the first sentence of that line, anchored deep enough to resolve from a project root. A bare folder name matches a same-named folder elsewhere in the tree, and a path held back until a later sentence sits beside every other path the statement mentions, including the ones it excludes.
 - Say in that same sentence when the standard governs an attribute rather than a document type. An attribute is written across every document and has no path to name, so the silence reads as an omission unless the sentence claims it.
 - Cut an entry that names no owner at all. It is either excluding something nothing was going to claim, or it is a content exclusion, which the rule below sends to the shape rules instead.

package/tooling/claude/seeds/.claude/ARCHITECTURE.md

@@ -1,6 +1,6 @@
 # Architecture
 
-Authoring guidance: `.claude/standards/architecture.md`.
+Authoring guidance: the architecture standard.
 
 ## Overview
 

package/tooling/claude/seeds/.claude/DESIGN.md

@@ -1,6 +1,6 @@
 # Design
 
-Authoring guidance: `.claude/standards/design.md`.
+Authoring guidance: the design standard.
 
 ## Personality
 

package/tooling/claude/seeds/.claude/REQUIREMENTS.md

@@ -1,6 +1,6 @@
 # Requirements
 
-Authoring guidance: `.claude/standards/requirements.md`.
+Authoring guidance: the requirements standard.
 
 ## Problem
 

package/tooling/claude/seeds/CLAUDE.md

@@ -40,7 +40,7 @@
 - Read `CLAUDE_CODE_ENTRYPOINT` once, at the first response that emits a path, and reuse it for the rest of the session. The surface cannot change mid-session, so a second read only confirms the first.
 - When it reads `claude-desktop`, emit each path as a markdown link carrying the path as its text and an absolute `file://` URI as its target, resolving a relative path against the main project root to build that target. The desktop file tree hides dotted folders, so a bare path into one names a file the reader cannot reach.
 - On every other value, including unset, emit the path bare. A terminal emulator makes it clickable through its own path detection, and link markup defeats that.
-- Both forms govern a path emitted in a response. A path written into a markdown file follows `.claude/standards/markdown.md` instead, which backticks a file reference and never repeats it as a link label.
+- Both forms govern a path emitted in a response. A path written into a markdown file follows the markdown standard instead, which your toolkit resolves by name, and which backticks a file reference and never repeats it as a link label.
 - Use the path the user's editor can resolve. The editor is rooted at the main project root.
 - In the main worktree: relative from `pwd` works because `pwd` equals the editor root.
 - In a linked worktree (under `.claude/worktrees/<name>/`): use absolute paths. Relative paths from worktree `pwd` would not resolve against the editor's project root.
@@ -78,7 +78,7 @@
 - Write all memory files to `.claude/memory/`, not `~/.claude/projects/`
 - A fact about a domain goes to that domain's `.claude/context/` entry, not to memory. `claude-memory-capture` routes it there and `claude-docs` folds it in. Memory keeps only what no context entry owns.
 - Never delete a memory entry. Retire one by moving it to `.claude/.tmp/memory-archive/`. A bulk retire runs through the shell, where no file edit fires a path-scoped rule, and the folder is gitignored with nothing to recover from.
-- Follow `.claude/standards/memory.md` for the filename and type prefix, the frontmatter, the body shape each type carries, and the lifecycle. Check every entry in the pen against that standard and fix what breaks it, since nothing keeps the folder conforming on its own.
+- Follow the memory standard, which your toolkit resolves by name, for the filename and type prefix, the frontmatter, the body shape each type carries, and the lifecycle. Check every entry in the pen against that standard and fix what breaks it, since nothing keeps the folder conforming on its own.
 
 ## Scratch
 

package/src/standards/adapter.ts

@@ -1,51 +0,0 @@
-import { existsSync } from 'node:fs'
-import { basename, join } from 'node:path'
-import {
-  INDEX_FILE,
-  refreshIndex,
-  standardsInstallDir,
-} from '@/standards/index-refresh'
-import type { InstalledFile, SyncAdapter } from '@/sync/engine'
-
-export function standardsSourceDir(root: string): string {
-  return join(root, 'standards')
-}
-
-/**
- * Matches installed standards to sources by filename against the flat
- * `standards/` root. A standard that lives in a source subfolder, such as
- * `bundled/`, has no flat sibling and so reads as project-authored, which is
- * what keeps `install` and `sync` agreeing on the same set.
- *
- * Standards are seeds a project is expected to edit, unlike gov rules and
- * snippets, so a headless run refuses to overwrite drift rather than applying
- * it. That refusal is the reason the engine grew a per-adapter policy.
- */
-export function createStandardsAdapter(root: string): SyncAdapter {
-  const sourceDir = standardsSourceDir(root)
-
-  return {
-    banner: 'aitk standards sync',
-    label: 'standards',
-    missingMessage:
-      "No .claude/standards/ found in target. Run 'aitk standards install' first.",
-    unit: 'standards',
-    installedRoot: standardsInstallDir,
-    isExcluded: (file: InstalledFile) => basename(file.path) === INDEX_FILE,
-    locateSource: (file: InstalledFile) =>
-      locateSource(sourceDir, basename(file.path)),
-    nonInteractive: {
-      kind: 'refuse',
-      message:
-        'Drifts detected. Refusing to auto-apply in non-interactive mode.',
-      hint: 'Run interactively, or use /claude-seed-sync for per-section audit that preserves customizations.',
-    },
-    onComplete: (target: string) => refreshIndex(sourceDir, target),
-    stamp: { domain: 'standards', toolkitRoot: root },
-  }
-}
-
-function locateSource(sourceDir: string, name: string): string | undefined {
-  const source = join(sourceDir, name)
-  return existsSync(source) ? source : undefined
-}