@erclx/aitk 0.65.1 → 0.66.1

package/README.md

@@ -63,7 +63,7 @@ Each domain has a canonical source in this repo and a thin install or sync CLI o
 
 - [Claude Code plugin](.claude/context/claude-plugin/index.md): skills for planning, review, docs sync, and the git ship chain
 - [Governance rules](.claude/context/governance.md): Cursor rules and stacks, installable per project
-- [Standards](.claude/context/standards.md): shared authoring conventions, synced to projects
+- [Standards](.claude/context/standards/index.md): shared authoring conventions, synced to projects
 - [Snippets](.claude/context/snippets.md): reusable prompts for Claude and Gemini chat
 - [Tooling stacks](.claude/context/tooling.md): golden configs, seeds, and references per framework
 - [Design system](.claude/context/design.md): `DESIGN.md` token shape, extract skill and its two paths, render command

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

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

package/claude/skills/claude-standards-audit/REQUIREMENT.md

@@ -7,7 +7,7 @@ description: What the standards audit is for, the gaps it closes, and the fixing
 
 ## Gap
 
-Without this skill, markdown ships unchecked against the authoring standards it was written under. A session that just wrote prose does not reopen the standard it was meant to follow, banned punctuation survives because it reads fine, and the mapping from a file to the standards governing it gets re-derived by guess on every pass.
+Without this skill, markdown ships unchecked against the authoring standards it was written under. A session fresh from writing prose does not reopen the standard it was meant to follow, banned punctuation survives because it reads fine, and the mapping from a file to the standards governing it gets re-derived by guess on every pass.
 
 ## Must
 

package/claude/skills/create-standard/SKILL.md

@@ -28,5 +28,5 @@ Read a standard from `${CLAUDE_SKILL_DIR}/../../standards/` instead when the pro
 
 Emit the full path on its own line.
 
-- Root surface: this is the toolkit's authoring source. Remind the user to run `bun run check` to regenerate the consumed copy under `.claude/`. That pass also regenerates the `standards/index.md` entry, and the user adds a row to the standards table in `.claude/context/standards.md`.
+- Root surface: this is the toolkit's authoring source. Remind the user to run `bun run check` to regenerate the consumed copy under `.claude/`. That pass also regenerates the `standards/index.md` entry, and the user adds a row to the standards table in `.claude/context/standards/overview.md`.
 - `.claude/` surface: the file is project-local. `aitk standards sync` leaves it alone, since sync only updates filenames it recognizes from the toolkit. Remind the user to copy it to the toolkit repo, under `standards/<slug>.md`, if it should ship to every project.

package/claude/skills/git-split/SKILL.md

@@ -56,7 +56,7 @@ Run these commands in parallel to gather git context:
 
 **All <total> commits accounted for.**
 
-- For the primary concern (the current branch), show `<current_branch> → <new_name>` only when renaming. Show just `<current_branch>` if the existing name already matches the concern.
+- For the primary concern (the current branch), show `<current_branch> → <new_name>` only when renaming. Show `<current_branch>` alone if the existing name already matches the concern.
 - For stacked mode, list rows in merge order: branches based on `main` first, then each layer above. For independent mode, list the primary concern first.
 
 If Mode is Stacked, append this line to the preview:

package/claude/skills/systematic-debugging/SKILL.md

@@ -51,7 +51,7 @@ When this happens, stop fixing and ask the user whether the underlying pattern s
 ## Red flags that mean "return to phase 1"
 
 - "Quick fix for now, investigate later"
-- "Just try X and see if it works"
+- "Try X and see if it works"
 - "It's probably Y, let me change that"
 - Proposing a fix before tracing data flow
 - Adding multiple changes and running tests to see what sticks

package/docs/agents/markdown-audit.md

@@ -86,7 +86,11 @@ Exit codes are `0` for a completed run and `1` for a refusal. Every finding repo
 
 A banned character is a fact rather than a judgment, which is the test that would ordinarily make it gate. What holds it back is that gating on day one against a corpus never checked mechanically fails loudly on work nobody has had a chance to fix. The order is to land the verb reporting, measure the corpus once, fix what it finds, and turn the gate on as its own change. Bullet, paragraph, and depth weight are judgments and stay advisory under any later gate.
 
-Measured across 444 files with the paragraph checkpoint at 600: 8 word hits, no character or spelling hits, 119 heavy bullets, 221 heavy paragraphs across 86 files, and 41 files carrying a run past the depth checkpoint. Of the paragraphs, 88 fire on weight alone. This is the baseline the corpus sweep tracks its work against. The ban count is what a gate would have to hold at zero, and it is the only one of the five a gate should ever read.
+Measured at `4b7b13a2` across 444 files with the paragraph checkpoint at 600: 8 word hits, no character or spelling hits, 119 heavy bullets, 221 heavy paragraphs across 86 files, and 41 files carrying a run past the depth checkpoint. Of the paragraphs, 88 fire on weight alone. This is the baseline the corpus sweep tracks its work against. The ban count is what a gate would have to hold at zero, and it is the only one of the five a gate should ever read.
+
+The ban half of that baseline now reports no character, word, or spelling hit, which is the precondition the gate was waiting on. The other four moved with the corpus rather than with any decision, so read them from a run rather than from this paragraph.
+
+### Why a recorded count goes stale
 
 A count written into prose goes stale against the corpus it describes, and nothing compares the two. The paragraph figure recorded when the masking fix shipped was already wrong by twelve one release later, which is why the standard states the rule and this page carries the numbers.
 
@@ -94,6 +98,20 @@ A standard sits inside the corpus this verb measures, so rewriting a rule can br
 
 Masking took 7 of the weight-only paragraphs the checkpoint reported at 400 and 4 of the 44 files under their checkpoints, and no bullet at all. The first corpus triage put those at 31 paragraphs and 2 bullets, and neither reproduces: a code span is walked around, so a backticked path holding an angle-bracket placeholder keeps the width the page gives it, and both bullets the triage counted were that shape.
 
+### How the ban count reached zero
+
+Eight word hits stood between the baseline and a gate, and only three carried the sense `prose.md` bans. `leverage` sat in the requirements worldview, `allows` in the claude stack reference, and one `just` was the vague qualifier in a skill body. Those three lost the qualifier rather than the word.
+
+The other five were correct prose the closed set cannot separate from a violation. Four were the temporal `just`, meaning a moment ago, in phrases like the implementation `just` completed and the field the user `just` edited. The fifth quoted an anti-pattern a skill exists to forbid. `prose.md` bans vague qualifiers and lists the tokens those qualifiers happen to spell, so the rule as written reaches none of the five while the scan reaches all of them.
+
+### Why they were rewritten rather than exempted
+
+Rewriting all five is what settled them, over building an exemption path. An exemption has three consumers, `src/markdown/scan.ts` for the patterns, `src/markdown/bans.ts` for the sets, and `.claude/hooks/standards-audit.sh`, which greps its own copy of the word bans in awk. A mechanism landing in the verb and not the hook leaves an exempted line still failing on edit, which is the surface an author actually meets. Five sentences lost a small amount of naturalness and the count now means what it says.
+
+A code span was the first answer for the quoted anti-pattern and it was the wrong one. The ban scan walks around a code span, so backticking a quotation clears the report, and `## Code and identifiers` reserves the span for commands, API names, file paths, and identifiers, which a quoted utterance is none of. Spending one rule to satisfy another leaves the corpus no cleaner than dropping the qualifier does.
+
+The collision is structural rather than a property of five legacy sentences. Writing the task and the plan behind this change each reproduced it, because a fresh file discussing the ban quotes the tokens it discusses. A later author writing about vague qualifiers meets the same thing, and the answer is to name the token in a code span where it is genuinely an identifier being discussed, and to rewrite the sentence where it is not.
+
 ## What it does not cover
 
 The verb reads the two attribute standards and nothing else. The five standards declaring `appliesTo: ["*"]` also include `publish.md`, `slug.md`, and `versioning.md`, none of which this implements.

package/docs/target-projects.md

@@ -185,5 +185,5 @@ Sync also refuses a target whose working tree is dirty, so commit or stash befor
 
 - [agents](agents/index.md): CLI flags, exit codes, and JSON output shapes
 - [AI workflow](ai-workflow.md): feature-development loop inside a toolkit-managed project
-- [tooling](../.claude/context/tooling.md), [governance](../.claude/context/governance.md), [claude plugin](../.claude/context/claude-plugin/index.md), [indexes](../.claude/context/indexes.md), [snippets](../.claude/context/snippets.md), [standards](../.claude/context/standards.md): per-domain mechanics
+- [tooling](../.claude/context/tooling.md), [governance](../.claude/context/governance.md), [claude plugin](../.claude/context/claude-plugin/index.md), [indexes](../.claude/context/indexes.md), [snippets](../.claude/context/snippets.md), [standards](../.claude/context/standards/index.md): per-domain mechanics
 - [sandbox](../.claude/context/sandbox/index.md): scenario catalog for verifying domain flows

package/governance/rules/ui/420-forms.md

@@ -22,7 +22,7 @@ paths:
 ## Error placement
 
 - Show the error directly under the field that caused it, not under an unrelated field.
-- When a change to field A causes a conflict involving field B, show the error under field A (the field the user just edited), not under field B.
+- When a change to field A causes a conflict involving field B, show the error under field A (the field the user edited), not under field B.
 
 ## Input sanitization
 

package/package.json

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

package/scripts/core/check-seed-independence.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+set -e
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
+
+source "$PROJECT_ROOT/scripts/lib/tooling.sh"
+
+TOOLKIT_TOKEN="aitk"
+TOOLING_ROOT="$PROJECT_ROOT/tooling"
+
+# `find` writes to stderr and returns non-zero for a missing root, inside a
+# process substitution whose status nothing reads. Without this the walk covers
+# nothing and the check reports the seeds independent having never read one.
+if [ ! -d "$TOOLING_ROOT" ]; then
+  echo "No tooling root at ${TOOLING_ROOT#"$PROJECT_ROOT/"}, seed independence unverifiable." >&2
+  exit 1
+fi
+
+# An empty discovery is a real state rather than a broken walk, and the Seed
+# standards stage already reports it as a skip. Failing here would have the two
+# stages disagree about what the same condition means.
+seed_roots=$(collect_seed_roots)
+if [ -z "$seed_roots" ]; then
+  echo "No seed root carries .claude/, nothing to check." >&2
+  exit 0
+fi
+
+# Markdown alone. The seed tree also ships hooks that call the toolkit CLI on
+# purpose, each reporting a named stale-index warning when the binary is absent,
+# and scoping by extension leaves them outside this walk without an exemption
+# list that would have to be maintained against them.
+cited=""
+measured=0
+while IFS= read -r seed_root; do
+  while IFS= read -r file; do
+    measured=$((measured + 1))
+    while IFS= read -r hit; do
+      cited="$cited  ${file#"$PROJECT_ROOT/"}:$hit"$'\n'
+    done < <(grep -n "$TOOLKIT_TOKEN" "$file" || true)
+  done < <(find "$PROJECT_ROOT/$seed_root" -type f -name '*.md')
+done <<<"$seed_roots"
+
+# Roots resolved and no markdown under any of them is a walk that covered
+# nothing, which is the verdict-without-a-measurement the guards above refuse for
+# a missing tree. Reporting a pass here would say the seeds cite no CLI on the
+# strength of having read no prose.
+if [ "$measured" -eq 0 ]; then
+  echo "Seed roots resolved but carry no markdown, seed independence unverifiable." >&2
+  exit 1
+fi
+
+if [ -n "$cited" ]; then
+  echo "Seed prose cites the toolkit CLI:" >&2
+  printf '%s' "$cited" >&2
+  echo "A scaffolded project may not have $TOOLKIT_TOKEN installed. State the capability the line needs rather than the binary that supplies it." >&2
+  exit 1
+fi

package/scripts/core/verify.sh

@@ -7,6 +7,7 @@ PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
 
 source "$PROJECT_ROOT/scripts/lib/ui.sh"
 source "$PROJECT_ROOT/scripts/lib/worktree.sh"
+source "$PROJECT_ROOT/scripts/lib/tooling.sh"
 
 NESTED="${VERIFY_NESTED:-false}"
 WRITE="${VERIFY_WRITE:-true}"
@@ -127,16 +128,6 @@ assert_hero_pair() {
   [ "$html_commit" = "$png_commit" ]
 }
 
-# Whatever stacks the repo currently carries, so a new one is covered without an
-# edit here. A seed root holding no `.claude/` seeds nothing a standard governs.
-collect_seed_roots() {
-  local dir
-  for dir in "$PROJECT_ROOT"/tooling/*/seeds; do
-    [ -d "$dir/.claude" ] || continue
-    printf '%s\n' "${dir#"$PROJECT_ROOT"/}"
-  done
-}
-
 # Entries the audit actually measured, summed across the folders it resolved.
 # `--json` carries one `"entries":<n>` per folder object, and the top-level key
 # of that name holds an array, so the numeric match reaches folders alone.
@@ -214,6 +205,15 @@ main() {
   run_check "bash $PROJECT_ROOT/scripts/core/check-plugin-boundary.sh" "Plugin ships toolkit-internal content."
   log_info "Plugin boundary clean"
 
+  # Seed prose is installed into every scaffolded project and read there as
+  # instruction about that project, so a line naming this repository's CLI hands
+  # a target a verb it may not be able to run. This gates for the reason the
+  # Seed standards stage below gates: a defect authored once propagates into
+  # every project scaffolded after it.
+  log_step "Seed independence"
+  run_check "bash $PROJECT_ROOT/scripts/core/check-seed-independence.sh" "Seed prose cites the toolkit CLI."
+  log_info "Seed prose cites no toolkit CLI"
+
   # A stack entry naming a rule folder takes every rule in it, which is what
   # stops a new rule from needing a second edit to reach a target. The failure
   # it leaves open is a rule authored into a folder no stack names, which

package/scripts/lib/tooling.sh

@@ -22,3 +22,14 @@ list_tooling_stacks() {
     echo "$name"
   done < <(find "$tooling_dir" -mindepth 1 -maxdepth 1 -type d | sort)
 }
+
+# Seed roots that carry a `.claude/`, emitted relative to `PROJECT_ROOT`. Every
+# stage measuring seed content discovers through this rather than naming a stack,
+# so a stack seeding `.claude/` later arrives covered with no edit to any caller.
+collect_seed_roots() {
+  local dir
+  for dir in "$PROJECT_ROOT"/tooling/*/seeds; do
+    [ -d "$dir/.claude" ] || continue
+    printf '%s\n' "${dir#"$PROJECT_ROOT"/}"
+  done
+}

package/snippets/claude/feature-recap.md

@@ -1,4 +1,4 @@
-Recap the implementation just completed. Read the plan file referenced in the session (usually `.claude/plans/feature-<slug>.md`) and produce a verification block.
+Recap the implementation this session completed. Read the plan file referenced in the session (usually `.claude/plans/feature-<slug>.md`) and produce a verification block.
 
 Output this shape, nothing else:
 

package/tooling/claude/reference.md

@@ -53,11 +53,11 @@ A project installed before the diagram surface became a folder still holds `.cla
 
 ## CLI
 
-| Command             | What it does                                                                                                                |
-| ------------------- | --------------------------------------------------------------------------------------------------------------------------- |
-| `aitk claude init`  | Seeds `.claude/` workflow docs, updates `.gitignore`                                                                        |
-| `aitk claude sync`  | Reconciles `.gitignore` against the manifest. Reports seeded file status.                                                   |
-| `aitk claude setup` | Installs user-level config to `~/.claude/`: statusline, attribution, and permission allows or denies. Run once per machine. |
+| Command             | What it does                                                                                                                                         |
+| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `aitk claude init`  | Seeds `.claude/` workflow docs, updates `.gitignore`                                                                                                 |
+| `aitk claude sync`  | Reconciles `.gitignore` against the manifest. Reports seeded file status.                                                                            |
+| `aitk claude setup` | Installs user-level config to `~/.claude/`: statusline, attribution, and the `permissions.allow` and `permissions.deny` lists. Run once per machine. |
 
 ## CLAUDE.md
 

package/tooling/claude/seeds/CLAUDE.md

@@ -74,7 +74,7 @@
 - Write all memory files to `.claude/memory/`, not `~/.claude/projects/`
 - A fact about a domain goes to that domain's `.claude/context/` entry, not to memory. `claude-memory-capture` routes it there and `claude-docs` folds it in. Memory keeps only what no context entry owns.
 - Never delete a memory entry. Retire one by moving it to `.claude/.tmp/memory-archive/`. A bulk retire runs through the shell, where no file edit fires a path-scoped rule, and the folder is gitignored with nothing to recover from.
-- Follow `.claude/standards/memory.md` for the filename and type prefix, the frontmatter, the body shape each type carries, and the lifecycle. Run `aitk records validate memory` to check the pen against it.
+- Follow `.claude/standards/memory.md` for the filename and type prefix, the frontmatter, the body shape each type carries, and the lifecycle. Check every entry in the pen against that standard and fix what breaks it, since nothing keeps the folder conforming on its own.
 
 ## Scratch
 
@@ -87,4 +87,4 @@
 - From a linked worktree, every `Edit` or `Write` to a tracked file (source, docs) must use a path starting with `pwd`.
 - From a linked worktree, `Edit` and `Write` are refused for every main-root path, session scratch included. The refusal names session isolation and points at the worktree copy, which is a second gitignored file no later session reads, so never take that redirect.
 - `Read` resolves against the main root normally from a linked worktree. A main-root write reaches it only through `Bash`, as one plain command rather than a compound one, which is refused for complexity.
-- Route a main-root write by what it does to the file. Creating a whole file goes out as one plain `Bash` command carrying a heredoc. Changing a line inside a file that already exists goes through an `aitk` verb, which resolves the main root in-process, because the shell route for that case is the stream editor this file bans.
+- Route a main-root write by what it does to the file. Creating a whole file goes out as one plain `Bash` command carrying a heredoc. Changing a line inside a file that already exists goes through a command that resolves the main root in-process, because the shell route for that case is the stream editor this file bans.