@erclx/aitk 0.41.0 → 0.41.1

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "aitk",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "0.41.0",
+  "version": "0.41.1",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/claude-autoship/REQUIREMENT.md

@@ -7,13 +7,15 @@ description: What the post-plan pipeline is for, the gaps it closes, and why eve
 
 ## Gap
 
-Without this skill, the run from an approved plan to an open pull request is a conversation. A session implements, then asks what comes next, and the answer varies by session. Review gets skipped on a diff that needed one, or spent on prose already gated by a hook. A run that halts leaves no stated resume point, so the user reconstructs how far it got from the working tree.
+Without this skill, the run from an approved plan to an open pull request is a conversation. A session implements, then asks what comes next, and the answer varies by session. A run that halts leaves no stated resume point, so the user reconstructs how far it got from the working tree.
+
+Review is the step that varies most. It gets skipped on a diff that needed one, or spent on prose already gated by a hook. A file-extension test cannot separate the two, since a skill body and a documentation page are both markdown, so a branch changing what an agent does takes the skip a documentation branch earned.
 
 ## Must
 
 - Take the approved plan for the branch as the scope, and implement only what it describes
 - Give every step a stop condition, and leave the code on the branch and the receipts on disk at each one
-- Classify the changed-file list before review, so a prose-only diff skips a code review with no signal on it
+- Classify the changed-file list by path as well as by extension, so informational prose skips a code review with no signal on it and executable prose still reaches one
 - Stop on any critical or should-fix finding rather than acting on it
 - Open the pull request as a draft, then watch continuous integration to a terminal state
 - Name the recovery for the stop it took, since the value of stopping is that the user knows where to resume
@@ -25,6 +27,7 @@ Without this skill, the run from an approved plan to an open pull request is a c
 - Fix a review finding or a failing check. Both stops are deliberate, since a green pull request reached by auto-fix hides what broke.
 - Run the memory Apply phase. Promoting an entry changes how the agent operates and ships as its own change.
 - Read an empty changed-file list as prose-only. It satisfies that test vacuously and would route the branch past review instead of through it.
+- Read a markdown extension as evidence the change only informs. A skill body, a governance rule, and a standard are behavior written in prose.
 
 ## Guards
 

package/claude/skills/claude-autoship/SKILL.md

@@ -71,13 +71,26 @@ An empty list stops the chain: `❌ No changed files to classify. Re-run when th
 
 The two causes want different responses. A plan that has yet to produce its output is a re-run once it has. A plan whose output is gitignored by design, such as a read pass writing to `.claude/.tmp/`, is work the chain cannot carry at all, since `git-stage` finds nothing to commit six steps later. Never advise removing the output from `.gitignore`, which trades a stopped run for scratch committed into the repository.
 
-If every changed file matches `*.md` or `*.txt`, skip review entirely and continue to Step 7. Prose-only changes are already gated by `docs-sync`, `claude-standards-audit`, and pre-push hooks. Running a code-style review on them burns tokens with no signal.
+The skip needs both tests to pass: every changed file matches `*.md` or `*.txt`, and no changed file sits under a behavior path. On a pass, skip review entirely and continue to Step 7. Otherwise invoke `aitk:claude-review`.
 
-Otherwise invoke `aitk:claude-review`.
+Behavior paths carry two spellings, the one a surface authors at and the one it installs to, so the rule reads the same in a toolkit and in a project that consumed one:
+
+- `claude/skills/` and `.claude/skills/`
+- `governance/rules/` and `.claude/rules/`
+- `standards/` and `.claude/standards/`
+- `snippets/` and `.claude/snippets/`
+- `internal/` and `tooling/`, which hold the stack references and the seed documents a target is handed
+- `CLAUDE.md` at the repository root, named as a file because a path prefix reaches nothing that sits in no folder
+
+Markdown under one of them states what an agent does, so a change there is a behavior change wearing a prose extension. Everything outside them is informational, which keeps `docs/`, `README.md`, and `CHANGELOG.md` skipping without naming them. One behavior file sends the whole branch to review, since documentation shipped beside a behavior change does not cancel it.
+
+Informational prose is already gated by `docs-sync`, `claude-standards-audit`, and pre-push hooks. Running a code-style review on it burns tokens with no signal.
+
+The list covers this toolkit's authoring layout and the layout it installs, which is not every layout. A project keeping executable prose where neither spelling reaches adds the path, and until it does every branch touching it skips review silently.
 
 ## Step 6: evaluate findings
 
-Skip this step if Step 5 was skipped (prose-only diff). Otherwise read `.claude/review/review-<slug>.md` at the main worktree root. Parse the summary line (`X critical, Y should-fix, Z minor`):
+Skip this step when Step 5 skipped review. Otherwise read `.claude/review/review-<slug>.md` at the main worktree root. Parse the summary line (`X critical, Y should-fix, Z minor`):
 
 - Any critical or should-fix count greater than zero, stop: `❌ Review found non-minor issues. See .claude/review/review-<slug>.md. Fix and run /git-ship.`
 - Zero critical and zero should-fix, continue. The minor findings stay in the on-disk review receipt. Fold any a reviewer needs into the PR's `## Technical Context`. Do not add a separate review-notes section to the PR body.

package/docs/agents/install-and-sync.md

@@ -42,6 +42,34 @@ headlessly, so a call that names its stack or category is unchanged.
 `aitk snippets install`. Both resolve the target before anything else, so a path
 that does not exist fails rather than being scaffolded.
 
+## Standards selection
+
+`aitk standards install --only <names>` takes a comma-separated list and
+defaults to `all`, so a call that omits it installs the whole corpus as before.
+A name resolves with or without its `.md` extension, and one that matches no
+standard fails the run with exit 1 rather than being dropped, because a typo
+would otherwise omit a standard silently and compute the closure over the wrong
+set. `aitk init --standards <selection>` passes the same value through.
+
+The selection expands to the standards it depends on, so nothing lands with a
+dangling reference. A citation is a backticked filename in a standard's body,
+resolved case-exactly against the flat `standards/` root, which is what drops a
+citation naming a target's own `.claude/ARCHITECTURE.md` or a bundled standard
+install never copies. Whatever the expansion adds is listed under its own step
+in the output.
+
+A citation inside a standard's `Does not govern:` list is a handoff rather than
+a dependency, and the closure stops at it. That entry names a concern a sibling
+owns and this standard does not, so a caller who did not ask for that concern
+does not need the file. Each one is reported under a `Scope handoffs not
+installed` step, naming what to add to `--only` if the project wants it after
+all.
+
+That split is what keeps a selection to a slice. Nearly all the citation density
+in the corpus sits inside those scope lists, so following them pulls the whole
+corpus in behind any single name. Following dependencies alone, a single name
+lands between one and three of the fifteen.
+
 ## Governance regen
 
 `aitk gov regen` is the one governance verb that runs against the toolkit root,
@@ -97,7 +125,9 @@ exits 1 naming the failures. Passing any flag skips the confirmation prompt,
 which is what makes it scriptable. `--stack` defaults to `base`, and the default
 does not read as a passed flag, so a bare `aitk init` installs governance and
 still prompts. `--skip` takes `wiki`, `standards`, and `governance`, and warns
-without aborting on any other value.
+without aborting on any other value. `--standards` defaults to `all` and reaches
+`aitk standards install` only when it names something narrower, so the default
+run spawns the command it always did.
 
 ## Unguarded tooling primitives
 

package/docs/agents/scripting.md

@@ -101,8 +101,12 @@ AITK_NON_INTERACTIVE=1 aitk standards sync /path/to/project
 # Copy every standard into a target, overwriting what is there
 AITK_NON_INTERACTIVE=1 aitk standards install /path/to/project
 
+# Install a named subset, expanded to the standards it cites
+AITK_NON_INTERACTIVE=1 aitk standards install --only slug /path/to/project
+
 # Bootstrap a project. Any flag suppresses the confirmation prompt
 AITK_NON_INTERACTIVE=1 aitk init --stack astro --skip wiki /path/to/project
+AITK_NON_INTERACTIVE=1 aitk init --standards design,wireframes /path/to/project
 
 # Run every domain sync. The git workflow is refused headlessly, so nothing is pushed
 AITK_NON_INTERACTIVE=1 aitk sync /path/to/project

package/docs/ai-workflow.md

@@ -100,7 +100,7 @@ For features on a mature stack, chain the post-plan pipeline in one session. App
 
 - Use when the plan is tight and the stack has real verify commands and test coverage
 - Autoship stops on: verify failure after one fix attempt, UI manual checklist non-empty, any review finding above minor, no diff baseline resolving against `main`, an empty changed-file list, or hook failure
-- Review is skipped entirely when the diff is prose-only (every changed file matches `*.md` or `*.txt`). Prose changes are gated by `docs-sync`, `claude-standards-audit`, and pre-push hooks.
+- Review is skipped when the diff is prose that only informs: every changed file matches `*.md` or `*.txt`, and none sits under a behavior path. Behavior paths cover skills, rules, standards, snippets, and `tooling/` in both the authoring and the installed spelling, plus root `CLAUDE.md`, so the list matches whether a repository authors those surfaces or consumed them from the toolkit. Markdown under one states what an agent does, so a branch touching it reaches review while `docs/` and `wiki/` still skip and stay gated by `docs-sync`, `claude-standards-audit`, and pre-push hooks.
 - An empty changed-file list stops the chain rather than counting as prose-only. The filename test passes vacuously on an empty set, which routed a branch past review instead of through it.
 - Every stop leaves recoverable state. Fix and resume with `/git-ship`
 - Skip autoship for auth, migrations, security-sensitive changes, or work where the plan itself is uncertain

package/docs/target-projects.md

@@ -88,7 +88,7 @@ When a new need appears after scaffold, install the one domain without re-runnin
 - Project-specific rule the toolkit does not ship: invoke `aitk:create-rule`. It scaffolds a rule into `.claude/rules/` with a non-colliding number, and `aitk gov sync` leaves it untouched.
 - Index.md system for a markdown-heavy folder that emerged: invoke `aitk:setup-indexes`
 - A snippet preset or category: `aitk snippets install <preset|category|all> <path>`. The argument is required, since the picker refuses headlessly rather than choosing for the caller
-- A single standard: `aitk standards install <name> <path>`
+- A single standard: `aitk standards install --only <names> <path>`. The selection expands to the standards it depends on, and stops at a `Does not govern:` handoff, which it reports instead. Omitting the flag installs all of them
 
 Per-domain mechanics live in the corresponding `docs/<domain>.md`. The skill body in `claude/skills/<skill>/SKILL.md` covers detection and preview.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/aitk",
   "type": "module",
-  "version": "0.41.0",
+  "version": "0.41.1",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/commands/init.ts

@@ -17,6 +17,8 @@ interface InitOptions {
   readonly stack: string
   readonly add?: string
   readonly snippets: string
+  /** Always present: the option falls back to `all`. */
+  readonly standards: string
   readonly skip?: string
 }
 
@@ -39,6 +41,7 @@ export function register(program: Command): void {
         '  aitk init ../my-app',
         '  aitk init --stack astro --add 260-shadcn ../my-app',
         '  aitk init --skip governance ../my-app',
+        '  aitk init --standards design,wireframes ../my-app',
         '',
       ].join('\n'),
     )
@@ -66,6 +69,7 @@ async function runInit(
     stack: options.stack,
     add: options.add,
     snippets: options.snippets,
+    standards: options.standards,
     skip,
   }
 

package/src/commands/standards.ts

@@ -3,6 +3,7 @@ import type { Command } from 'commander'
 import { registerPassThroughVerbs } from '@/commands/pass-through'
 import { PROJECT_ROOT } from '@/exec'
 import { createStandardsAdapter, standardsSourceDir } from '@/standards/adapter'
+import { ALL_SELECTION, selectStandards } from '@/standards/closure'
 import {
   refreshIndex,
   STANDARDS_REL,
@@ -11,12 +12,26 @@ import {
 import { applyInstall, planInstall } from '@/standards/install'
 import { recordStamp, runDomainSync } from '@/sync/engine'
 import { resolveTarget } from '@/target'
-import { intro, logAdd, logInfo, logStep, logWarn, outro, select } from '@/ui'
+import {
+  intro,
+  logAdd,
+  logError,
+  logInfo,
+  logStep,
+  logWarn,
+  outro,
+  select,
+} from '@/ui'
 
 const GREEN = '\x1b[0;32m'
 const GREY = '\x1b[0;90m'
 const NC = '\x1b[0m'
 
+interface InstallOptions {
+  /** Always present: the option falls back to `ALL_SELECTION`. */
+  readonly only: string
+}
+
 export function register(program: Command): void {
   const standards = program
     .command('standards')
@@ -38,17 +53,36 @@ export function register(program: Command): void {
 
   standards
     .command('install')
-    .description('Copy all standards into a project (overwrites)')
+    .description('Copy standards into a project (overwrites)')
     .argument('[target]', 'Target directory', '.')
+    .option(
+      '--only <names>',
+      "Comma-separated standard names, or 'all'",
+      ALL_SELECTION,
+    )
     .helpOption('-h, --help', 'Show this help message')
-    .action(async (target: string) => {
-      process.exitCode = await runInstall(target)
+    .addHelpText(
+      'after',
+      [
+        '',
+        'A selection expands to the standards it cites, so nothing lands with',
+        'a dangling reference.',
+        '',
+        'Examples:',
+        '  aitk standards install',
+        '  aitk standards install --only slug ../my-app',
+        '  aitk standards install --only design,wireframes ../my-app',
+        '',
+      ].join('\n'),
+    )
+    .action(async (target: string, options: InstallOptions) => {
+      process.exitCode = await runInstall(target, options.only)
     })
 
   registerPassThroughVerbs(standards, 'standards', ['list'])
 }
 
-async function runInstall(target: string): Promise<number> {
+async function runInstall(target: string, selection: string): Promise<number> {
   intro('aitk standards')
 
   const resolved = resolveTarget(target, PROJECT_ROOT)
@@ -58,8 +92,31 @@ async function runInstall(target: string): Promise<number> {
   const destDir = standardsInstallDir(resolved)
 
   logStep('Scanning standards')
-  const files = planInstall(sourceDir)
-  for (const file of files) logInfo(join(STANDARDS_REL, file.name))
+  const available = planInstall(sourceDir)
+  const result = selectStandards(available, selection)
+
+  if (!result.ok) {
+    logError(
+      `Standard not found: ${result.unknown.join(', ')}. Run 'aitk standards list' for the catalog.`,
+    )
+    outro()
+    return 1
+  }
+
+  const { files, requested, added, unresolved } = result.selection
+  for (const name of requested) logInfo(join(STANDARDS_REL, name))
+
+  if (added.length > 0) {
+    logStep(`Added by citation (${added.length})`)
+    for (const name of added) logInfo(join(STANDARDS_REL, name))
+  }
+
+  if (unresolved.length > 0) {
+    logStep(`Scope handoffs not installed (${unresolved.length})`)
+    for (const name of unresolved) logWarn(name)
+    logInfo('Each names a concern these standards do not govern. Add a name')
+    logInfo('to --only if the project needs that standard as well.')
+  }
 
   const shouldInstall = await select({
     message: `Install ${files.length} standards to ${destDir}?`,

package/src/init/flags.ts

@@ -1,5 +1,6 @@
 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. */
@@ -32,6 +33,12 @@ 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>',
@@ -55,9 +62,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. `--snippets` and `--stack`
- * both 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`, `--snippets`,
+ * and `--standards` all 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,3 +1,5 @@
+import { ALL_SELECTION } from '@/standards/closure'
+
 export const SKIPPABLE_DOMAINS = ['wiki', 'standards', 'governance'] as const
 
 export type SkippableDomain = (typeof SKIPPABLE_DOMAINS)[number]
@@ -31,6 +33,7 @@ export interface InitFlags {
   readonly stack?: string
   readonly add?: string
   readonly snippets: string
+  readonly standards: string
   readonly skip: SkipPlan
 }
 
@@ -106,7 +109,11 @@ export function planInit(flags: InitFlags): InitPlan {
   }
 
   if (!flags.skip.skipped.has('standards')) {
-    preview.push({ level: 'info', text: 'standards (authoring conventions)' })
+    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})` })

package/src/init/steps.ts

@@ -1,5 +1,6 @@
 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>
@@ -52,7 +53,7 @@ export function buildSteps(
     steps.push({
       kind: 'run',
       label: 'Standards',
-      run: child(['standards', 'install', resolved]),
+      run: child(standardsArgs(flags.standards, resolved)),
     })
   }
 
@@ -73,6 +74,21 @@ 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/closure.ts

@@ -0,0 +1,200 @@
+import { readFileSync } from 'node:fs'
+import { basename } from 'node:path'
+import type { StandardsSource } from '@/standards/install'
+
+export const ALL_SELECTION = 'all'
+
+export interface Citations {
+  /** Siblings the body depends on, which the closure follows. */
+  readonly cited: readonly string[]
+  /** Siblings a `Does not govern:` entry hands off to, which it does not. */
+  readonly delegated: readonly string[]
+}
+
+export interface StandardsSelection {
+  readonly files: readonly StandardsSource[]
+  /** What the caller named, in the order the flat root lists it. */
+  readonly requested: readonly string[]
+  /** What a requested standard cites and the caller did not name. */
+  readonly added: readonly string[]
+  /** Handoff targets that did not land, so their pointers will not resolve. */
+  readonly unresolved: readonly string[]
+}
+
+export type SelectionResult =
+  | { readonly ok: true; readonly selection: StandardsSelection }
+  | { readonly ok: false; readonly unknown: readonly string[] }
+
+const CITATION = /`([^`\n]+?\.md)`/g
+const DELEGATION_START = /^Does not govern:/
+const HEADING = /^#{1,6}\s/
+
+/** Accepts `prose` and `prose.md` alike, since the catalog lists both spellings. */
+export function normalizeName(raw: string): string {
+  const name = raw.trim()
+  return name.endsWith('.md') ? name : `${name}.md`
+}
+
+export function parseSelection(csv: string): string[] {
+  return csv
+    .split(',')
+    .map((raw) => raw.trim())
+    .filter((raw) => raw !== '')
+    .map(normalizeName)
+}
+
+/**
+ * Splits a body at the `Does not govern:` list, which runs to the next heading.
+ * Every standard in the flat root carries exactly one, directly under `## Scope`.
+ */
+function splitDelegatedScope(body: string): {
+  governing: string
+  delegated: string
+} {
+  const governing: string[] = []
+  const delegated: string[] = []
+  let inDelegation = false
+
+  for (const line of body.split('\n')) {
+    if (DELEGATION_START.test(line)) inDelegation = true
+    else if (inDelegation && HEADING.test(line)) inDelegation = false
+
+    if (inDelegation) delegated.push(line)
+    else governing.push(line)
+  }
+
+  return { governing: governing.join('\n'), delegated: delegated.join('\n') }
+}
+
+function matchNames(text: string, available: ReadonlySet<string>): string[] {
+  const found = new Set<string>()
+
+  for (const match of text.matchAll(CITATION)) {
+    const token = match[1]
+    if (token === undefined) continue
+
+    const name = basename(token)
+    if (available.has(name)) found.add(name)
+  }
+
+  return [...found]
+}
+
+/**
+ * Reads the sibling standards a body cites, split by whether the citation is a
+ * dependency or a handoff. A citation is a backticked token ending in `.md`,
+ * which is the only place either relationship is written, so the parse is a
+ * heuristic and every candidate is resolved against `available` before it
+ * counts. That resolution is what drops a fenced example, a target project's
+ * `.claude/ARCHITECTURE.md`, and a bundled standard the flat root does not
+ * install, none of which a selection should pull in.
+ *
+ * A citation inside the `Does not govern:` list is `delegated` rather than
+ * `cited`, because that entry says the sibling owns a concern this standard
+ * does not. Expanding on it pulls in a file the caller declined by not naming
+ * it, and nearly all the corpus density sits in those lists, which is what
+ * collapsed every selection into the whole corpus. A name appearing in the list
+ * and also outside it stays `cited`, since a real dependency outranks a handoff.
+ *
+ * Matching is case-exact against the listing rather than a filesystem probe,
+ * because a case-insensitive volume would otherwise resolve `SKILL.md` onto
+ * `skill.md` and expand a selection on a citation that names a target's own
+ * file. The basename is what resolves, so `standards/versioning.md` and a bare
+ * `versioning.md` read as the same dependency.
+ */
+export function citedStandards(
+  body: string,
+  available: ReadonlySet<string>,
+): Citations {
+  const { governing, delegated } = splitDelegatedScope(body)
+  const cited = matchNames(governing, available)
+  const citedSet = new Set(cited)
+
+  return {
+    cited,
+    delegated: matchNames(delegated, available).filter(
+      (name) => !citedSet.has(name),
+    ),
+  }
+}
+
+/**
+ * Expands a selection to the transitive closure of what it cites, so an install
+ * cannot land a standard whose citations dangle. `all` and an empty selection
+ * both mean every standard, which is what keeps the existing callers unchanged.
+ *
+ * The closure follows dependencies alone. A `Does not govern:` handoff names a
+ * concern the caller declined by not selecting it, so the target stays out and
+ * is reported through `unresolved` instead. Following those too pulls the whole
+ * corpus in behind any single name.
+ *
+ * An unrecognized name fails the whole selection rather than being dropped with
+ * a warning, unlike `--skip` on `aitk init`. A typo here silently omits a
+ * standard the caller asked for, and the closure would then be computed over
+ * the wrong set.
+ */
+export function selectStandards(
+  available: readonly StandardsSource[],
+  selection: string,
+): SelectionResult {
+  const byName = new Map(available.map((file) => [file.name, file]))
+
+  if (selection.trim() === '' || selection.trim() === ALL_SELECTION) {
+    return {
+      ok: true,
+      selection: {
+        files: available,
+        requested: available.map((file) => file.name),
+        added: [],
+        unresolved: [],
+      },
+    }
+  }
+
+  const requested = parseSelection(selection)
+  const unknown = requested.filter((name) => !byName.has(name))
+  if (unknown.length > 0) return { ok: false, unknown }
+
+  const names = new Set(byName.keys())
+  const resolved = new Set(requested)
+  const handoffs = new Set<string>()
+  const queue = [...requested]
+
+  for (let index = 0; index < queue.length; index += 1) {
+    const name = queue[index]
+    if (name === undefined) continue
+
+    const file = byName.get(name)
+    if (file === undefined) continue
+
+    const citations = citedStandards(readFileSync(file.path, 'utf8'), names)
+    for (const handoff of citations.delegated) handoffs.add(handoff)
+
+    for (const cited of citations.cited) {
+      if (resolved.has(cited)) continue
+
+      resolved.add(cited)
+      queue.push(cited)
+    }
+  }
+
+  const requestedSet = new Set(requested)
+
+  return {
+    ok: true,
+    selection: {
+      files: available.filter((file) => resolved.has(file.name)),
+      requested: available
+        .filter((file) => requestedSet.has(file.name))
+        .map((file) => file.name),
+      added: available
+        .filter(
+          (file) => resolved.has(file.name) && !requestedSet.has(file.name),
+        )
+        .map((file) => file.name),
+      unresolved: available
+        .filter((file) => handoffs.has(file.name) && !resolved.has(file.name))
+        .map((file) => file.name),
+    },
+  }
+}