@erclx/aitk 0.40.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.40.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/claude/skills/claude-orchestrate/REQUIREMENT.md

@@ -11,6 +11,10 @@ Without this skill, the session holding the cross-feature picture starts buildin
 
 The queue fails in both directions. It empties and a free worker waits, or it fills with whatever is oldest rather than with what establishes a mechanism. A plan handed over unverified is the quiet one, since it goes stale from whatever merged after it was written, and a worker that trusts its account of the tree builds against a shape that no longer exists. A second orchestrator makes all of this unrecoverable, because the board is gitignored and neither session can read the other's writes.
 
+The session also writes surfaces it is told only how to read. Refilling the queue promotes and demotes rows in the priority file with no stated method, so a session invents one, and an inline rewrite exits clean when it matches nothing and leaves the board wrong with nothing reporting it. A row carrying prose where a plan pointer belongs costs a worker dispatch, because the ship chain refuses at its guard after the worktree is already open. A plan archived from a worker's own branch strands the pointer the board still carries, and the row reads as correct until someone follows it.
+
+Output drifts everywhere the contract stops. The specified shape covers invocation alone, so a sweep report, a board report, and an analysis each end in a decision the human owns and each buries it under the evidence they would have skipped. A compaction is the same failure one step earlier, since the file that survives it has a stated reader and no stated writer, and the session improvises what to save and loses the reasoning the board never held.
+
 ## Must
 
 - Read the priority file for execution order, since the index sorts by filename and states no order
@@ -20,6 +24,11 @@ The queue fails in both directions. It empties and a free worker waits, or it fi
 - Place every finding a merged pull request produced against the surface that owns it
 - Date the roadmap line from that file's last commit, so an old sequence reads as old
 - Keep one planned, non-conflicting task in reserve beyond what is running
+- Write the priority file with an editing tool that errors on a non-match, since the board is where a silent failure costs a dispatch
+- Carry a plan pointer in the Plan column and a file set in the Touches column, so a row's readiness and disjointness claims stay checkable
+- Re-resolve the board's plan pointers after any archive, since the archiving skill rewrites the task file and knows nothing about the board
+- Lead a sweep report, a board report, and an analysis with the state, the open decisions, and the next action, keeping the evidence below them
+- Write the pre-compact handoff with what no other file carries, and name the snippet that reads it back
 
 ## Must not
 
@@ -29,6 +38,9 @@ The queue fails in both directions. It empties and a free worker waits, or it fi
 - Hand a worker anything but a plan, because scope lives there
 - Run a second orchestrator against the same board
 - Promote a task to fill the queue when nothing qualifies. A thin queue is a real answer.
+- Rewrite the board with a shell stream editor or an inline string replace, both of which exit clean when they match nothing
+- Restate the board, a task file, or a groundwork folder in the pre-compact handoff, which is the padding that makes a handoff stop being read
+- Specify a shape for a correction, since a format for admitting error invites ceremony where plainness is the whole value
 
 ## Guards
 

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

@@ -35,6 +35,10 @@ Then output the state of play so the human knows what to launch, review, and mer
 
 The roadmap is optional and this skill does not require it. It carries why a sequence is what it is, changes only when strategy changes, and is absent in a project whose scope has already shipped. Report what it says and name it as the source. Never assert an active version the file does not state, and say nothing about one when the file is missing.
 
+A compaction is a moment this skill cannot detect, so both sides of it are snippets the human fires. Before one, `@.claude/snippets/claude/orchestrator-handoff.md` writes `.claude/tasks/session.md` with the state of play, the decisions taken under delegated authority, the mistakes worth not repeating, and the standing cautions. After one, `@.claude/snippets/claude/orchestrator-resume.md` reads that file back with the board and the groundwork behind the live work. Write nothing to the handoff that the board, a task file, or a groundwork folder already carries.
+
+Name `${CLAUDE_SKILL_DIR}/../../snippets/claude/<name>.md` as the fallback for any orchestrator snippet the project copy lacks. Snippets install by named bundle rather than wholesale, so a project that installed one bundle has the `.claude/snippets/` directory and none of these files, and the plugin ships the whole snippets folder beside `skills/`.
+
 ## Output
 
 ```plaintext
@@ -68,10 +72,27 @@ Omit the `Roadmap` line when `.claude/ROADMAP.md` is absent. Quote the `Now` row
 
 That command returns nothing for a roadmap that exists but has never been committed, which is the state `claude-roadmap` leaves behind when it writes the file and declines to stage it. Write `uncommitted` as the date in that case. A blank there would read as a formatting slip rather than as the newest possible sequence.
 
+### Every later turn
+
+The block above covers invocation alone. A sweep report, a board report, and an analysis each end in something the human decides, so each opens with the same three slots and puts its evidence underneath:
+
+```plaintext
+State: <what changed since they last looked>
+
+Decisions:
+  1. <one line each, or "none open">
+
+Next: <the single most useful action>
+```
+
+Keep the detail below the block and keep it skippable. A decision reached at the bottom of three paragraphs has been buried, which is the failure this shape exists to prevent. Reuse the vocabulary above rather than inventing a second one, and keep a file set on the row claiming it so the reader can check a disjointness claim instead of taking it.
+
+Write no shape for a correction. A correction is a sentence, and a format for admitting error invites ceremony where plainness is the whole value.
+
 ## The loop
 
 1. Own the roadmap while a scope exists to sequence. Capture a needed draft or resequence of `.claude/ROADMAP.md` in the plan or a task file, naming the MVP list in `.claude/REQUIREMENTS.md` as the source, so a worker runs `claude-roadmap` in its branch and the tracked edit ships in a PR rather than dirtying main. Stop owning it once that list has shipped, since later work then arrives as discrete items rather than as versions.
-2. Plan the next feature. Run `claude-feature` here, with the cross-feature context, to write a plan to `.claude/plans/`. Planning stays in this warm session so the plan front-loads reasoning a cold worker would otherwise re-derive.
+2. Plan the next feature. Run `claude-feature` here, with the cross-feature context, to write a plan to `.claude/plans/`. Planning stays in this warm session so the plan front-loads reasoning a cold worker would otherwise re-derive. A constraint supplied from here that names a surface to leave alone states which of two acts it forbids, and the rule governing that is Step 3 of `claude-feature` under Constraints.
 3. Decide parallelism and merge order. Note which plans touch a shared wiring seam so their PRs merge in sequence, not at once.
 4. Verify the plan against the tree. Reading it is not enough, since a plan goes stale from whatever merged after it was written. Grep for each construct it names and count the sites against the count it claims. Check that every phase label it cites is still open. Open each file it describes rather than trusting its account of the contents. Correct the plan before handing it over.
 5. Hand off. The human opens a worker worktree with `claude-worktree` and runs `claude-autoship` against the plan. The orchestrator does not spawn workers.
@@ -89,7 +110,7 @@ That command returns nothing for a roadmap that exists but has never been commit
 
 ## Refilling the ready queue
 
-Keep enough planned, non-conflicting tasks available that a free worker never waits, and place the findings the last merge produced before promoting anything new. Run this after every merge and whenever the ready list thins.
+Keep enough planned, non-conflicting tasks available that a free worker never waits, and place the findings the last merge produced before promoting anything new. Run this after every merge and whenever the ready list thins. `@.claude/snippets/claude/orchestrator-sweep.md` fires this procedure after a batch of merges and adds the plan re-verification that a merge invalidates.
 
 1. Run `gh pr list --state open` and `git log --oneline -8`. Report any pull request whose review has not been posted and stop for that one first.
 2. For each pull request merged since the last sweep, place every finding it produced. Route a finding that changes a rule to the standard or rule that states it, one that changes another task to that task's Findings, and one that overturns a groundwork lean to that folder marked answered. Never leave a finding in a pull request thread alone.
@@ -107,10 +128,22 @@ Serialized: <task> behind <task>, both write <file>
 Ready now: <tasks with plans, and what each waits on>
 ```
 
+That block is the detail. Lead the reply with the three slots under Every later turn above, so the human reads what they own before the evidence for it.
+
 Treat a task that edits `.claude/context/` entries wholesale as conflicting with every other task, because the root instruction file requires each task to update its own domain entry as it lands.
 
 Do not promote a task to fill the queue when nothing qualifies. A thin queue is a real answer and it beats a plan nobody needed.
 
+### Writing the board
+
+Promoting, demoting, and archiving a row all write `.claude/tasks/priority.md`, and this session is the only writer apart from `aitk tasks archive`.
+
+- Edit the file with the file-editing tool. A shell stream editor and an inline string replace both exit clean on a non-match, so a promotion that matched nothing leaves the board wrong with nothing reporting it, and the file-editing tool errors instead.
+- Put a pointer in the Plan column, never prose. `## Run now` claims a written plan covers every open outcome, and `claude-autoship` refuses at its guard when it follows the column and finds no plan, which spends a worker dispatch to learn what the row should have said.
+- Name the file set in the Touches column. The disjointness call in step 6 is only checkable later when the sets are written down rather than reasoned once and discarded.
+- Re-resolve every Plan pointer after anything archives a plan. `claude-docs` moves a plan to `.claude/.tmp/plans-archive/` and rewrites the citation in the task file alone, so a row for a task still on the board keeps pointing into `.claude/plans/` at a file that has moved. Workers running the ship chain on their own branches archive plans this board still cites, and the board reads as correct until a pointer is followed.
+- Read the file back after writing it, since the row that lands is the row a worker acts on.
+
 ## Parallelism
 
 No fixed number caps worker tracks. Collision between file sets is what binds, so

package/docs/agents/context-audit-checks.md

@@ -19,6 +19,8 @@ It reports rather than gates, the closer call because a missing section reads mo
 
 Length and depth quote their checkpoints from `.claude/standards/context.md`: roughly 150 rendered lines for an entry, roughly 40 for a run no heading breaks. Depth measures the longest such run rather than everything under one `##`, skips fenced blocks so a markdown example does not read as three headings, and exempts a run whose lines are all list items at one indent averaging under 130 characters. The weight condition is what separates a scannable catalog of one-liners from a stack of paragraph-bullets, which reach the same count and read nothing alike.
 
+Depth exempts a second shape, and the two are excused for opposite reasons. A peer list is already navigable, so a subheading dropped into it splits a set that belongs together. A table is exempt because the remedy does not exist: a heading placed inside one splits the table rather than the run, so a catalog renders as an unbroken stretch by construction and no edit short of rewriting it as a list clears the report. The test is whether the run is a table rather than whether it holds one, so a table with prose either side still reports and a heading breaks it at the seam. A run of piped lines carrying no delimiter row is not a table and reports like any other prose. The table finding above is unaffected, so a catalog silenced here still reports as a candidate for a bullet list, which is the measure whose remedy does exist.
+
 Both checks count rendered lines rather than source lines, wrapping each line at 80 columns and summing the heights. Entries here are authored one line per bullet, so a block of fifteen paragraph-bullets occupies fifteen source lines and renders past sixty, which source counting cannot see. Measuring one checkpoint in each unit would put an entry length beside a run length that mean different things. Their exclusions still differ: the file measure counts fenced blocks and frontmatter, while the run measure skips a fence so an example cannot break the run around it. A reference-heavy entry therefore ranks by its examples, which the length legend states on every run. Runs count blank lines, which the standard leaves open, so a hand reader who drops them lands a line or two lower. Both sections state the width on every run, since a number in rendered lines cannot be reproduced without it.
 
 ## Bullet weight and tables

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.40.0",
+  "version": "0.41.1",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/snippets/claude/orchestrator-handoff.md

@@ -0,0 +1,37 @@
+Write the pre-compact handoff as orchestrator. Do this before a compaction, because a compaction keeps conclusions and drops the reasoning that produced them, and no other file in the repository carries that reasoning.
+
+1. Resolve the main worktree root with `git worktree list --porcelain | grep -m 1 '^worktree ' | cut -d' ' -f2-`, falling back to `pwd`. Write `.claude/tasks/session.md` under it.
+2. Write only what a compaction destroys and no other file already carries. The board holds the ordering and what each task waits on, a task file holds its own findings, and a groundwork folder holds its track.
+3. Use this shape:
+
+```markdown
+---
+title: Session map
+description: <what the board cannot show, and the date it was written>
+---
+
+# Session map
+
+<one line marking the file throwaway and naming the board as the real source>
+
+## State
+
+<what is clean, what is running, what is open, and any untracked file that needs committing>
+
+## Decisions taken under delegated authority
+
+<each decision and why it went that way, so nobody re-proposes it>
+
+## Mistakes worth not repeating
+
+<what went wrong and the rule it yields>
+
+## Standing cautions
+
+<commands that lie, tools that measure the wrong tree, and anything unbacked>
+```
+
+4. Cite a commit, a task, or a file and line for every claim, so the next session can tell a read from a recall.
+5. Overwrite the previous handoff rather than appending to it. A stale entry read as current is worse than no handoff.
+
+Add a section only for content that fits none of the four and would otherwise be lost. Do not restate the board, and do not summarize the work that shipped, because git already carries it.

package/src/commands/context.ts

@@ -408,6 +408,9 @@ function reportDepth(entries: readonly EntryReport[]): void {
   logInfo(
     `Fenced blocks are excluded, and so are peer lists averaging under ${PEER_BULLET_CHECKPOINT} characters a bullet.`,
   )
+  logInfo(
+    'A run that is entirely table rows is excluded too, since a heading inside a table splits the table rather than the run.',
+  )
 
   const over = entries
     .filter((entry) => entry.longestRun > RUN_CHECKPOINT)

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/context/audit.ts

@@ -231,6 +231,36 @@ function isScannablePeerList(run: readonly BodyLine[]): boolean {
   return characters / items < PEER_BULLET_CHECKPOINT
 }
 
+/**
+ * Reports whether a run is a table, the second shape the checkpoint cannot fix.
+ *
+ * The peer list above is exempt because it is already navigable. A table is
+ * exempt for the other reason: the remedy does not exist. A heading dropped
+ * inside one splits the table into two tables rather than breaking the run, so
+ * a catalog renders as an unbroken stretch by construction and no edit short of
+ * rewriting it as a list clears the report.
+ *
+ * Every non-blank line has to be a row. A run holding a table between
+ * paragraphs is genuinely mixed, and a heading breaks it at a seam either side,
+ * so testing whether the run holds a table would hide the case the checkpoint
+ * exists for.
+ *
+ * A delimiter is required rather than assumed, matching the table scan below. A
+ * stack of lines opening with a pipe and no delimiter renders as paragraph text
+ * and would otherwise earn the exemption on its punctuation.
+ */
+function isTableRun(run: readonly BodyLine[]): boolean {
+  let separators = 0
+
+  for (const line of run) {
+    if (line.text.trim() === '') continue
+    if (!TABLE_ROW.test(line.text)) return false
+    if (TABLE_SEPARATOR.test(line.text)) separators++
+  }
+
+  return separators > 0
+}
+
 /**
  * Height a source line occupies once wrapped.
  *
@@ -272,7 +302,7 @@ function longestRun(lines: readonly BodyLine[]): {
     // two headings rather than a stretch a reader travels, so it never counts.
     const first = run.find((line) => line.text.trim() !== '')
 
-    if (first && !isScannablePeerList(run)) {
+    if (first && !isScannablePeerList(run) && !isTableRun(run)) {
       const height = run.reduce(
         (sum, line) => sum + renderedHeight(line.text),
         0,

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),
+    },
+  }
+}

package/standards/context.md

@@ -104,6 +104,7 @@ Only the `development` entry carries this section. It is not a general-purpose h
 - Past roughly 40 rendered lines with no heading of any level breaking them, add a subheading at the seam. Measure the longest such run rather than everything under one `##`, and exclude fenced code blocks. The number is a checkpoint like the 150 above, not a cap.
 - Both checkpoints count rendered lines, so wrap each source line at 80 columns and sum the heights. Source lines undercount an entry authored one line per bullet, where a block of fifteen paragraph-bullets occupies fifteen lines and renders past sixty. Counting the two checkpoints in different units would put a file measured one way beside a run measured another.
 - Exempt a block whose lines are all list items at one level averaging under roughly 130 characters. A flat list of short peers is already navigable, and a subheading dropped into it splits a set that belongs together. Bullet count says nothing on its own, since a catalog of one-liners and a stack of paragraphs reach the same count and read nothing alike, so weight is what decides. Mixing prose with the list, or nesting levels inside it, ends the exemption at any weight.
+- Exempt a block whose lines are all table rows, at any length. The peer list above is exempt because it is already navigable, and a table because the remedy does not exist: a subheading dropped inside one splits the table rather than the run, so no edit short of rewriting it as a list clears the checkpoint. Prose either side of the table ends the exemption, since that block has a seam and a heading breaks it there.
 - Past roughly 400 characters in one top-level bullet, counting the lines that continue it and excluding any bullet nested under it, check whether the incident that motivated the decision sits beside the decision itself. Keep the current design and the alternative that lost, and move the incident to the change that introduced it, the issue that tracked it, or the research record behind it. The number is a checkpoint like the two above, and a bullet reading well past it means the number is wrong rather than the rule.
 - Collapse a stack of bullets narrating one subsystem into a single `###` subsection carrying one narrative. Splitting a heavy bullet into three light ones satisfies the checkpoint above and leaves the reader no better off, and subdividing a block does not lighten the bullets inside it, so the two rules answer different defects.
 - Never cut a `## Decisions` or `## Gotchas` entry to shorten a file. Cut a `## Layout` or `## CLI` section instead.