@erclx/aitk 1.7.1 → 2.1.0

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

@@ -14,14 +14,13 @@ never adds new ones. A rule the toolkit does not ship is left alone, which is
 how project-authored rules survive. It also removes a stale `.claude/GOV.md`
 from the retired build. Use `aitk gov install` to add rules.
 
-`aitk standards sync` matches by filename against `.claude/standards/` and
-regenerates that folder's `index.md` on every completed run. It is the one sync
-that refuses under `AITK_NON_INTERACTIVE=1` when drift exists, logging a warning
-and exiting 0 without writing, because standards are seeds a project edits. Run
-it interactively, or use the `claude-seed-sync` skill for a per-section audit
-that preserves customizations.
-
-`aitk snippets sync` behaves the same way against `.claude/snippets/`. It
+There is no `aitk standards sync` and no `aitk standards install`. The corpus
+installs into no project, so the domain has nothing in a target to reconcile.
+`aitk standards <name>` prints one, resolving `standards/` at the working root
+and then the corpus inside the package, and `aitk standards list --json` carries
+the catalog.
+
+`aitk snippets sync` matches by path relative to `.claude/snippets/`. It
 matches by path relative to that directory, so a snippet the toolkit no longer
 ships, or one authored directly in the target, is reported and skipped rather
 than deleted. It is not preset-aware, so a project that installed `essentials`
@@ -44,33 +43,22 @@ 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
+## Standards resolution
 
-`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.
+`aitk standards <name>` writes the document to stdout and the root it answered
+from to stderr, so a caller capturing with `$(...)` receives the document alone.
 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.
+standard exits 1 after listing the catalog on stderr.
+
+Two roots answer, in order: `standards/` at the working directory, then the
+corpus inside the package. A project that authors standards of its own uses the
+first, and this repository's own authoring root is the same path. `.claude/standards/`
+is not among them. It is this repository's generated mirror, and a copy an older
+toolkit installed into a target resolves nothing.
+
+There is no citation closure to compute, since nothing is copied. A standard
+that hands a concern to a sibling names it in `Does not govern:` and a reader
+runs the verb again for that name.
 
 ## Governance regen
 
@@ -191,10 +179,9 @@ suffixed variant such as `TASKS-ARCHIVE.md` unreported.
 
 Route it to `migration-superseded`. That skill resolves the standard governing
 `replacedBy` from the `appliesTo` the standards catalog declares, reads the
-destination shape from the target's own copy under `.claude/standards/` or at the
-root, and proposes the split without writing. Where a folder has no governing
-standard, or neither root holds the one it has, the entry earns a named refusal
-rather than a shape the project never adopted.
+destination shape with `aitk standards <name>`, and proposes the split without
+writing. Where a folder has no governing standard, the entry earns a named
+refusal rather than a shape nobody stated.
 
 `unmigrated` names a domain sitting at the root layout an older toolkit installed
 to, with nothing at the path the current one reads. It carries `rootPath`,
@@ -275,10 +262,9 @@ 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. `--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.
+still prompts. `--skip` takes `wiki` and `governance`, and warns without aborting
+on any other value. There is no `--standards`, since no run writes a standard
+into the target.
 
 ## Unguarded tooling primitives
 

package/docs/agents/scripting.md

@@ -112,18 +112,11 @@ AITK_NON_INTERACTIVE=1 aitk snippets install essentials /path/to/project
 # Update snippets already installed, leaving project-authored ones alone
 AITK_NON_INTERACTIVE=1 aitk snippets sync /path/to/project
 
-# Report standards drift without applying it, which is what headless does here
-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
+# Print one standard. Nothing installs the corpus, so this is how a target reads one
+AITK_NON_INTERACTIVE=1 aitk standards slug >slug.md
 
 # 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/target-projects.md

@@ -27,7 +27,7 @@ The `aitk` CLI is separate. Twenty skills invoke it in a command position, and a
 bun install --global @erclx/aitk
 ```
 
-The package ships the catalogs the CLI reads, not only `src/`, so `aitk init` resolves standards, snippets, governance, tooling, and the seeds from wherever the package landed.
+The package ships the catalogs the CLI reads, not only `src/`, so `aitk init` resolves snippets, governance, tooling, and the seeds from wherever the package landed, and `aitk standards <name>` reads the corpus from there too.
 
 Pointing Claude Code at a checkout stays the development path, where a local skill edit overrides the installed copy for that session.
 
@@ -84,12 +84,13 @@ Run `aitk tooling list --json` and `aitk gov list --json` to see the current cat
 
 ### Core domains and skips
 
-`aitk init` installs base tooling, Claude workflow, governance, standards, and snippets, and scaffolds `.claude/wiki/`. Governance defaults to the `base` stack, so a bare init carries the rules that route to the standards it installs alongside them. Pass `--stack <name>` to install a framework stack instead.
+`aitk init` installs base tooling, Claude workflow, governance, and snippets, and scaffolds `.claude/wiki/`. Governance defaults to the `base` stack, so a bare init carries the rules that route a project. Pass `--stack <name>` to install a framework stack instead.
 
-`governance`, `standards`, and `wiki` are skippable:
+No standard is written into the project. Each governance rule's authority line names `aitk standards <name>`, which answers from the corpus inside the CLI's own package, and every toolkit skill names the copy in its own plugin root. `aitk markdown audit` needs no standard at all, its ban sets and checkpoints shipping with the package as data.
 
-- `--skip governance`: leave `.claude/rules/` empty, so no coding standard loads on a file match. Standards still install, and the installed copy is the first root `aitk standards <name>` resolves, so it stays the editable seed a project owns. The preview names any `--add` rules the skip drops, and the run prints the `aitk gov install <stack> <path>` command to add rules afterward, carrying those extras so one paste restores what the skip declined.
-- `--skip standards`: leave standards out. The governance rules are unaffected, since each authority line names `aitk standards <name>` and that command answers from the corpus inside the CLI's own package. Toolkit skills are unaffected too, each naming the copy in its own plugin root. `aitk standards <name>` searches the corpus inside the CLI's own package behind both project roots, so it prints a standard in a project that skipped the install, and `aitk markdown audit` needs no standard at all, its ban sets and checkpoints shipping with the package as data. What the skip costs is the editable copy rather than the enforcement.
+`governance` and `wiki` are skippable:
+
+- `--skip governance`: leave `.claude/rules/` empty, so no coding standard loads on a file match. The preview names any `--add` rules the skip drops, and the run prints the `aitk gov install <stack> <path>` command to add rules afterward, carrying those extras so one paste restores what the skip declined.
 - `--skip wiki`: skip the `.claude/wiki/` scaffold. A target that already carries a root `wiki/` keeps it, since the verb reports that folder rather than migrating it.
 
 The plugin corpus carries runtime behavior rather than reference prose alone, because the pre-publish scan and the branch-slug transform each have a standard of their own, `publish.md` and `slug.md`, cited by the skills that run them.
@@ -102,7 +103,8 @@ 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 --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
+
+Standards are not on that list, and there is nothing to add. No standard installs into a project, by default or by flag, so a session that needs one runs `aitk standards <name>` and reads it from the copy inside the package. A project holding a `.claude/standards/` folder from an older toolkit is carrying a stale artifact nothing reads, and deleting it is safe.
 
 Per-domain mechanics live in the corresponding `docs/<domain>.md`. The skill body in `claude/skills/<skill>/SKILL.md` covers detection and preview.
 
@@ -122,15 +124,15 @@ The report opens by naming the binary running it. The installed version reads ag
 
 A `stale` file still matches what the toolkit installed, so the update is mechanical. A `customized` file carries local edits, so taking the upstream version is a decision and `aitk:claude-seed-sync` is the tool for it. A `stranded` file sits where an older toolkit installed it and the toolkit has since moved, which is what `aitk:migration-standards` handles.
 
-That attribution comes from `.claude/aitk.json`, a stamp every install and sync writes. Standards, snippets, and governance record a hash per installed file. Tooling records the stack chain it resolved instead, since its install runs no per-file walk to attribute.
+That attribution comes from `.claude/aitk.json`, a stamp every install and sync writes. Snippets and governance record a hash per installed file. Tooling records the stack chain it resolved instead, since its install runs no per-file walk to attribute.
 
-Each domain holds its own toolkit commit, so syncing governance today does not move the revision standards measures against, and each domain reports the upstream commits touching its own source path. Running any sync stamps that domain, and the report names the ones still unstamped.
+Each domain holds its own toolkit commit, so syncing governance today does not move the revision snippets measures against, and each domain reports the upstream commits touching its own source path. Running any sync stamps that domain, and the report names the ones still unstamped.
 
 A project that has never synced under a toolkit new enough to write a stamp falls back to the toolkit's own git history. Installed content matching any version that history published proves the file untouched, so it reports `stale` naming the commit it came from, and content matching no published version stays `drifted`. That fallback needs the toolkit as a git checkout. Installed from the registry it ships source without history, and the report says attribution was unavailable rather than reading every file as a local edit.
 
 Four further causes sit outside the per-domain scan, each naming something that walk cannot see. A seed the project edited is reported under `seeds` and reconciled with `aitk:claude-seed-sync`, since no sync command touches a seed. A file a newer seed folder replaced is reported under `superseded`, such as `.claude/TASKS.md` against the `.claude/tasks/` that now ships, and nothing moves it because the content is the project's own. A domain sitting at the root layout with nothing under `.claude/` is reported under `unmigrated` and handed to `aitk:migration-standards`.
 
-That third one matters most on an older project. Before it existed, a target holding `standards/` at its root reported zero entries for that domain, so a project that had never migrated was indistinguishable from one that was fully current.
+That third one matters most on an older project. Before it existed, a target holding `snippets/` at its root reported zero entries for that domain, so a project that had never migrated was indistinguishable from one that was fully current. It covers snippets alone, since a root `standards/` folder in a target is the project's own authoring surface and nothing proposes moving it.
 
 #### What the toolkit stopped shipping
 
@@ -158,15 +160,12 @@ Reconcile the configs with `aitk tooling sync <stack> <path> --check` to read wh
 
 It never touches user-owned seed files. Governance rules in `.claude/rules/`, tooling configs, and reference docs refresh in place. Stale `.claude/GOV.md` from earlier installs is removed.
 
-Standards are the exception inside that run, and the stamp narrows it. A standard the project customized is reported and left alone rather than overwritten. A standard still matching what was installed carries no local edits to lose, so a headless run updates it.
-
-An unstamped project reaches the same split through the history fallback, so a headless run updates every standard it can prove untouched and refuses while any file resists attribution. To take the upstream version of a customized file, run `aitk standards sync <path>` interactively, or use `aitk:claude-seed-sync` below to merge section by section.
+Standards take no part in that run. Nothing installed them, so there is no copy to reconcile and no `aitk standards sync` to reach for.
 
 ### Targeted
 
-- Claude seed docs such as `CLAUDE.md` and `.claude/REQUIREMENTS.md`, plus installed standards under `.claude/standards/`: invoke `aitk:claude-seed-sync`. The skill splits each file into a preamble (between the H1 and the first H2) plus one part per `##` section, then diffs part by part across both surfaces and proposes per-part edits. User customizations are preserved.
+- Claude seed docs such as `CLAUDE.md` and `.claude/REQUIREMENTS.md`: invoke `aitk:claude-seed-sync`. The skill splits each file into a preamble (between the H1 and the first H2) plus one part per `##` section, then diffs part by part and proposes per-part edits. User customizations are preserved.
 - Governance rules already installed: `aitk gov sync <path>` diffs and applies, and never adds new rules
-- Standards already installed: `aitk standards sync <path>` diffs and applies whole files, and refuses to apply without a prompt
 - Tooling configs and seeds: `aitk tooling <stack> <path>` overwrites golden configs and merges seeds
 - Reference docs for a stack: `aitk tooling ref <stack> <path>`
 - Index regeneration after markdown edits: `aitk indexes regen`
@@ -186,7 +185,7 @@ cd <your-project>
 claude
 ```
 
-In the session, invoke `aitk:setup-init`. The skill detects no framework, resolves tooling to `base`, governance to `base`, snippets to `all`, and auto-enables `standards` if `docs/` exists. The preview marks both stacks as fallbacks, since neither came from a match, then the chain runs `aitk init`.
+In the session, invoke `aitk:setup-init`. The skill detects no framework and resolves tooling to `base`, governance to `base`, and snippets to `all`. The preview marks both stacks as fallbacks, since neither came from a match, then the chain runs `aitk init`.
 
 Ongoing: run `aitk sync --check .` to see what has drifted, then invoke `aitk:claude-seed-sync` for seed drift or `aitk sync .` for a catch-all refresh.
 

package/package.json

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

package/scripts/core/install-check.sh

@@ -76,10 +76,14 @@ log_step "Assert scaffold"
 # catches a failed domain, and the gate stays green while the target is
 # missing everything that domain provides.
 #
+# Standards name no path because the corpus installs into no target. A scaffold
+# reads a standard through `aitk standards <name>`, which resolves against the
+# copy inside the package.
+#
 # The snippets path has to name a slug the default preset still carries, since
 # init resolves snippets through `essentials`. Editing that preset without
 # editing this line fails the gate on a correct install.
-for path in "CLAUDE.md" ".claude/snippets/decision-help.md" ".claude/standards/skill.md" ".claude/standards/markdown.md" ".claude/wiki/index.md" ".claude" ".claude/context/index.md" ".claude/wireframes/index.md" ".claude/diagrams/index.md" \
+for path in "CLAUDE.md" ".claude/snippets/decision-help.md" ".claude/wiki/index.md" ".claude" ".claude/context/index.md" ".claude/wireframes/index.md" ".claude/diagrams/index.md" \
   ".prettierrc" ".editorconfig" ".lintstagedrc" ".husky/pre-commit" ".github/workflows/verify.yml" "scripts/verify.sh" \
   ".claude/rules/core/000-constitution.md"; do
   if [ ! -e "$TARGET_DIR/$path" ]; then

package/scripts/lib/sandbox-git.sh

@@ -15,8 +15,13 @@ require_sandbox_anchor_config() {
   fi
 }
 
+resolve_sandbox_anchor_repo() {
+  printf '%s\n' "${1:-${ANCHOR_REPO:-}}"
+}
+
 sandbox_anchor_url() {
-  local repo_name="${1:-${ANCHOR_REPO:-}}"
+  local repo_name
+  repo_name="$(resolve_sandbox_anchor_repo "$@")"
 
   if [ -z "$repo_name" ] || [ -z "${GITHUB_ORG:-}" ]; then
     log_error "sandbox_anchor_url needs GITHUB_ORG and a repository name. Call require_sandbox_anchor_config first."
@@ -52,7 +57,7 @@ configure_sandbox_git_identity() {
 
 # Every scenario that needs a remote points at the same throwaway repository, so
 # the name lives here rather than in each one.
-SANDBOX_ANCHOR_REPO="toolkit-sandbox"
+SANDBOX_ANCHOR_REPO="aitk-sandbox"
 
 # A scenario calls this from its own use_anchor hook rather than this file
 # defining the hook. manage-sandbox.sh keys off `type -t use_anchor`, so
@@ -62,11 +67,58 @@ use_sandbox_anchor() {
   export ANCHOR_REPO="${1:-$SANDBOX_ANCHOR_REPO}"
 }
 
+# gh answers an absent repository and an unreachable host with the same exit
+# status, so the 404 is the only thing separating them. Anything else is a
+# network or credential fault, where creating a repository would be the wrong
+# answer and would fail for the same reason the read did.
+ensure_sandbox_anchor_repo() {
+  local repo_name gh_error
+
+  repo_name="$(resolve_sandbox_anchor_repo "$@")"
+
+  if [ -z "$repo_name" ] || [ -z "${GITHUB_ORG:-}" ]; then
+    log_error "ensure_sandbox_anchor_repo needs GITHUB_ORG and a repository name. Call require_sandbox_anchor_config first."
+  fi
+
+  if gh_error="$(gh api "repos/${GITHUB_ORG}/${repo_name}" --silent 2>&1)"; then
+    return 0
+  fi
+
+  case "$gh_error" in
+  *"HTTP 404"*) ;;
+  *) log_error "Cannot reach ${GITHUB_ORG}/${repo_name}: ${gh_error}" ;;
+  esac
+
+  # An absent anchor is nearly always a wrong GITHUB_ORG or a rename nobody
+  # performed, and provisioning stages a fixture rather than cloning while every
+  # scenario force-pushes to main, so a repository created here would carry all
+  # nine to a pass against something that is not the anchor. Refusing is the safe
+  # default and creating is the opt-in, the shape `aitk tooling sync --write`
+  # already sets. `aitk records push` refuses outright for the reason
+  # `.claude/context/development/scratch.md` records, so the two still differ.
+  # The sibling SANDBOX_ flags are presence tests, so any non-empty value turns
+  # them on. This one allowlists instead, because a presence test would have
+  # SANDBOX_ANCHOR_CREATE=false provisioning a repository. Both spellings are
+  # accepted so the `true` those siblings are set to does not land on a refusal.
+  case "${SANDBOX_ANCHOR_CREATE:-}" in
+  1 | true) ;;
+  *) log_error "${GITHUB_ORG}/${repo_name} does not exist. Check GITHUB_ORG and whether a rename is pending, then create it with 'gh repo create ${GITHUB_ORG}/${repo_name} --private' or re-run with SANDBOX_ANCHOR_CREATE=true." ;;
+  esac
+
+  log_warn "${GITHUB_ORG}/${repo_name} does not exist and SANDBOX_ANCHOR_CREATE is set. Creating it as private."
+  if ! gh_error="$(gh repo create "${GITHUB_ORG}/${repo_name}" --private 2>&1)"; then
+    log_error "Could not create ${GITHUB_ORG}/${repo_name}: ${gh_error}"
+  fi
+  log_info "Created ${GITHUB_ORG}/${repo_name} as a private repository."
+}
+
 # A remote is useless without an author, so the scenarios that reach one always
 # configure both. configure_sandbox_git_identity stays callable on its own for
-# the scenarios that never push. The remove keeps this idempotent against a
-# sandbox tree that already carries an origin.
+# the scenarios that never push. The probe runs first so an absent remote is
+# reported before the scenario stages anything. The remove keeps this idempotent
+# against a sandbox tree that already carries an origin.
 configure_sandbox_anchor_remote() {
+  ensure_sandbox_anchor_repo "$@"
   configure_sandbox_git_identity
   git remote remove origin 2>/dev/null || true
   git remote add origin "$(sandbox_anchor_url "$@")"

package/scripts/manage-sandbox.sh

@@ -213,12 +213,6 @@ run_sandbox_install() {
   rm -f "$install_log"
 }
 
-inject_documentation() {
-  [ ! -d "$PROJECT_ROOT/standards" ] && return
-
-  run_sandbox_install "standards" standards install "$SANDBOX"
-}
-
 # The stack decides which rules land. `base` carries the language-agnostic core,
 # which is what a scenario asserting on rule behavior reads. A scenario needing a
 # framework's rules overrides the variable in `use_config`.
@@ -245,9 +239,12 @@ commit_environment_setup() {
   )
 }
 
+# No standards injection. The corpus installs into no target, so a sandbox
+# without one is the shape a scaffolded project has, and a scenario driving a
+# skill that reads a standard exercises the `aitk standards <name>` path a real
+# project takes.
 setup_sandbox_assets() {
   [ -n "$SANDBOX_INJECT_SEEDS" ] && inject_seeds
-  [ -n "$SANDBOX_INJECT_STANDARDS" ] && inject_documentation
   [ -n "$SANDBOX_INJECT_GOV" ] && inject_gov_rules
   commit_environment_setup
 }

package/scripts/standards/list.sh

@@ -59,15 +59,18 @@ list_text() {
   done < <(find "$STANDARDS_DIR" -maxdepth 1 -type f -name "*.md" | sort)
 }
 
+# No `target` field. It named where a standard installed, and nothing installs
+# one now, so every value it could carry is either a path only this repository
+# has or a duplicate of what `aitk standards <name>` reports. `content` already
+# carries the document, which is what a consumer wanted the path for.
 list_json() {
   local first=1
-  local file name title target applies_to
+  local file name title applies_to
   printf '['
   while IFS= read -r file; do
     name=$(basename "$file" .md)
     [ "$name" = "index" ] && continue
     title=$(read_frontmatter_field "$file" "description")
-    target=".claude/standards/$(basename "$file")"
     applies_to=$(read_applies_to "$file")
     if [ "$first" -eq 0 ]; then
       printf ','
@@ -75,10 +78,9 @@ list_json() {
     jq -nc \
       --arg name "$name" \
       --arg description "$title" \
-      --arg target "$target" \
       --argjson appliesTo "$applies_to" \
       --rawfile content "$file" \
-      '{name: $name, description: $description, target: $target, appliesTo: $appliesTo, content: $content}'
+      '{name: $name, description: $description, appliesTo: $appliesTo, content: $content}'
     first=0
   done < <(find "$STANDARDS_DIR" -maxdepth 1 -type f -name "*.md" | sort)
   printf ']'

package/src/cli.ts

@@ -77,7 +77,7 @@ function showHelp(): void {
     `${GREY}│${NC}    aitk sandbox git:commit`,
     `${GREY}│${NC}    aitk gov install react`,
     `${GREY}│${NC}    aitk gov sync ../my-app`,
-    `${GREY}│${NC}    aitk standards sync ../my-app`,
+    `${GREY}│${NC}    aitk standards markdown`,
     `${GREY}│${NC}    aitk snippets install base ../my-app`,
     `${GREY}│${NC}    aitk snippets sync ../my-app`,
     `${GREY}│${NC}    aitk init ../my-app`,

package/src/commands/gov.ts

@@ -5,7 +5,7 @@ import type { Command } from 'commander'
 import { PROJECT_ROOT } from '@/project-root'
 import { createGovAdapter } from '@/gov/adapter'
 import { regenConsumedRules } from '@/gov/consumed'
-import { hasStandards, installRules, lookupRules } from '@/gov/install'
+import { installRules, lookupRules } from '@/gov/install'
 import { buildGovCatalog, describeRule, describeStack } from '@/gov/list'
 import { buildRulesPayload, listRuleFiles } from '@/gov/payload'
 import {
@@ -453,12 +453,6 @@ async function runInstall(
   for (const rel of await installRules(found, resolved)) logAdd(rel)
   await recordStamp(createGovAdapter(PROJECT_ROOT), resolved, new Date())
 
-  if (!hasStandards(resolved)) {
-    logWarn(
-      `Rules reference .claude/standards/. Run 'aitk standards install ${target}' or 'aitk init' so the references resolve.`,
-    )
-  }
-
   const { GREEN, NC } = palette(process.stderr)
   outro()
   process.stderr.write(`${GREEN}✓ Rules installed${NC}\n`)

package/src/commands/init.ts

@@ -13,8 +13,6 @@ 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
 }
 
@@ -37,7 +35,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',
+        '  aitk init --snippets all ../my-app',
         '',
       ].join('\n'),
     )
@@ -65,7 +63,6 @@ async function runInit(
     stack: options.stack,
     add: options.add,
     snippets: options.snippets,
-    standards: options.standards,
     skip,
   }
 

package/src/commands/standards.ts

@@ -1,51 +1,24 @@
-import { join } from 'node:path'
 import type { Command } from 'commander'
 import { registerPassThroughVerbs } from '@/commands/pass-through'
-import { PROJECT_ROOT } from '@/project-root'
-import { createStandardsAdapter, standardsSourceDir } from '@/standards/adapter'
-import { ALL_SELECTION, selectStandards } from '@/standards/closure'
-import {
-  refreshIndex,
-  STANDARDS_REL,
-  standardsInstallDir,
-} from '@/standards/index-refresh'
-import { applyInstall, planInstall } from '@/standards/install'
 import { listStandards, readStandard, resolveStandard } from '@/standards/read'
-import { recordStamp, runDomainSync } from '@/sync/engine'
-import { resolveTarget } from '@/target'
-import {
-  intro,
-  logAdd,
-  logError,
-  logInfo,
-  logStep,
-  logWarn,
-  outro,
-  palette,
-  select,
-} from '@/ui'
-
-interface InstallOptions {
-  /** Always present: the option falls back to `ALL_SELECTION`. */
-  readonly only: string
-}
+import { intro, logError, logInfo, logStep, logWarn, outro } from '@/ui'
 
 export function register(program: Command): void {
   const standards = program
     .command('standards')
-    .description('Standards commands (install, sync, list, <name>)')
+    .description('Standards commands (list, <name>)')
     .argument('[name]', 'Standard to print, by name with or without .md')
     .helpOption('-h, --help', 'Show this help message')
     .addHelpText(
       'after',
       [
         '',
-        'A name resolves under .claude/standards/, then standards/, then the',
-        'corpus inside the aitk package, so a standard prints without a project',
-        'copy on disk. The frame names the copy it read.',
+        'A name resolves under standards/ at the working root, then the corpus',
+        'inside the aitk package. No standard installs into a project, so the',
+        'package corpus is what answers there. The frame names the copy it read.',
         '',
         'Examples:',
-        '  aitk standards prose',
+        '  aitk standards markdown',
         '  aitk standards markdown.md',
         '',
       ].join('\n'),
@@ -63,47 +36,6 @@ export function register(program: Command): void {
       process.exitCode = print(name)
     })
 
-  standards
-    .command('sync')
-    .description('Update standards already installed under .claude/standards/')
-    .argument('[target]', 'Target directory', '.')
-    .helpOption('-h, --help', 'Show this help message')
-    .action(async (target: string) => {
-      process.exitCode = await runDomainSync(
-        createStandardsAdapter(PROJECT_ROOT),
-        target,
-        { protectedRoot: PROJECT_ROOT },
-      )
-    })
-
-  standards
-    .command('install')
-    .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')
-    .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'])
 }
 
@@ -111,9 +43,9 @@ export function register(program: Command): void {
  * Writes the standard to stdout and every frame line to stderr, so a caller
  * capturing the output with `$(...)` receives the document alone.
  *
- * The root is the caller's directory rather than the toolkit's, since a project
- * copy is what governs wherever one exists and the package copy answers only
- * its absence.
+ * The root is the caller's directory rather than the toolkit's, since a
+ * repository that authors standards governs its own copy and the package copy
+ * answers everywhere else.
  */
 function print(name: string): number {
   intro('aitk standards')
@@ -135,67 +67,3 @@ function print(name: string): number {
   outro()
   return 0
 }
-
-async function runInstall(target: string, selection: string): Promise<number> {
-  intro('aitk standards')
-
-  const resolved = resolveTarget(target, PROJECT_ROOT)
-  if (typeof resolved === 'number') return resolved
-
-  const sourceDir = standardsSourceDir(PROJECT_ROOT)
-  const destDir = standardsInstallDir(resolved)
-
-  logStep('Scanning standards')
-  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}?`,
-    options: [
-      { value: true, label: 'Yes' },
-      { value: false, label: 'No' },
-    ],
-    nonInteractiveDefault: true,
-  })
-
-  if (!shouldInstall) {
-    logWarn('Cancelled')
-    outro()
-    return 0
-  }
-
-  logStep('Installing standards')
-  for (const label of await applyInstall(files, destDir)) logAdd(label)
-  await refreshIndex(sourceDir, resolved)
-  await recordStamp(createStandardsAdapter(PROJECT_ROOT), resolved, new Date())
-
-  outro()
-  const { GREEN, GREY, NC } = palette(process.stderr)
-  process.stderr.write(
-    `\n${GREEN}✓ Standards installed${NC} ${GREY}(${files.length} files)${NC}\n`,
-  )
-  return 0
-}