@erclx/aitk 0.62.1 → 0.63.1

package/README.md

@@ -6,7 +6,7 @@
 
 One source for your repos' AI conventions. Install once, sync everywhere.
 
-![The aitk catalog, listing skills, governance rules, and standards with the count each ships and a sample of their names](assets/hero.png)
+![The aitk catalog, listing skills, governance rules, and standards with the count each ships, the workflow skills named, and a sample of the rule and standard names](assets/hero.png)
 
 If you work across more than one repository and your AI setup has started to drift between them, this is for you. The counts above are read from the catalogs when the image is built, so they're what the repo actually ships today.
 

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

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

package/docs/ai-workflow.md

@@ -77,7 +77,7 @@ Run one orchestrator at a time. The board is gitignored, so a second session rea
 
 Before a handoff, the orchestrator checks the plan against the tree rather than reading it: grep each construct it names and count the sites, confirm every phase label it cites is still open, and open each file it describes. A plan goes stale from whatever merged after it was written, and reading cannot catch that.
 
-`.claude/plans/`, `.claude/review/`, and `.claude/memory/` all resolve at the main worktree root, so artifacts created in any session are visible from any sibling worktree. See [Claude Code and git worktrees](../wiki/claude/claude-worktrees.md) for the full rule and the domain-level fan-out guidance.
+`.claude/plans/`, `.claude/review/`, and `.claude/memory/` all resolve at the main worktree root, so artifacts created in any session are visible from any sibling worktree. A session inside a worktree reads them directly and writes them through the shell, since the file-editing tools refuse a main-root path. See [Claude Code and git worktrees](../wiki/claude/claude-worktrees.md) for the full rule and the domain-level fan-out guidance.
 
 The plan's shape is fixed by `.claude/standards/plan.md`: the section list, the filename, the lifecycle, and the contract its questions keep. Every question carries a `- Suggested:` line and an empty `- Answer:` slot, and a blank answer accepts the suggestion at execution time. That default is what makes a plan decision-ready in one pass, and it is the opposite of the contract an intake folder keeps, where an empty slot means nobody reached the item.
 

package/package.json

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

package/scripts/core/regen-hero.sh

@@ -19,6 +19,7 @@ PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
 
 TEMPLATE="$PROJECT_ROOT/assets/hero.html.tmpl"
 OUTPUT="$PROJECT_ROOT/assets/hero.html"
+CLI_ENTRY="$PROJECT_ROOT/src/cli.ts"
 LISTED=10
 
 # `bun src/cli.ts` rather than `aitk`, since a globally linked binary resolves to
@@ -32,6 +33,20 @@ if [ ! -f "$TEMPLATE" ]; then
   exit 1
 fi
 
+# The commands have no `--json` catalog to read, so the count comes from the
+# registration block in the CLI entry point, which is the one place a command is
+# added. `--help` is hand-authored ASCII and would drift from what is registered.
+if [ ! -f "$CLI_ENTRY" ]; then
+  echo "regen-hero: missing CLI entry point at $CLI_ENTRY" >&2
+  exit 1
+fi
+
+COMMAND_COUNT="$(grep -c '^import { register as ' "$CLI_ENTRY" || true)"
+if [ "${COMMAND_COUNT:-0}" -eq 0 ]; then
+  echo "regen-hero: no command registrations found in $CLI_ENTRY, refusing to write a zeroed hero" >&2
+  exit 1
+fi
+
 SKILLS_JSON="$(catalog claude skills list)"
 GOV_JSON="$(catalog gov list)"
 STANDARDS_JSON="$(catalog standards list)"
@@ -59,12 +74,12 @@ printf '%s' "$SNIPPETS_JSON" >"$PAYLOAD_DIR/snippets.json"
 printf '%s' "$TOOLING_JSON" >"$PAYLOAD_DIR/tooling.json"
 
 export PAYLOAD_DIR
-export TEMPLATE OUTPUT LISTED PROJECT_ROOT
+export TEMPLATE OUTPUT LISTED PROJECT_ROOT COMMAND_COUNT
 
 bun --eval '
 const { readFileSync } = require("node:fs")
 
-const { PAYLOAD_DIR, TEMPLATE, OUTPUT, LISTED, PROJECT_ROOT } = process.env
+const { PAYLOAD_DIR, TEMPLATE, OUTPUT, LISTED, PROJECT_ROOT, COMMAND_COUNT } = process.env
 
 const payload = (name) => readFileSync(PAYLOAD_DIR + "/" + name + ".json", "utf8")
 
@@ -79,7 +94,13 @@ const skills = JSON.parse(SKILLS_JSON).skills.map((entry) => entry.name)
 const gov = JSON.parse(GOV_JSON)
 // Rule names carry a numeric prefix that orders the load, not the identity a
 // reader knows them by, so the frame shows the slug alone.
-const rules = gov.rules.map((entry) => entry.name.replace(/^\d+-/, ""))
+const slug = (entry) => entry.name.replace(/^\d+-/, "")
+const rules = gov.rules.map(slug)
+// A rule no stack names is opt-in behind `--add`, so featuring one advertises
+// an entry no ordinary `aitk gov install` delivers. The column samples the
+// stack-reached subset while its count and remainder describe the whole catalog.
+const stacked = new Set(gov.stacks.flatMap((stack) => stack.rules))
+const deliveredRules = gov.rules.filter((entry) => stacked.has(entry.name)).map(slug)
 const standards = JSON.parse(STANDARDS_JSON).standards.map((entry) => entry.name)
 const snippets = new Set(
   JSON.parse(SNIPPETS_JSON).categories.flatMap((category) => category.entries),
@@ -89,20 +110,62 @@ const toolingStacks = JSON.parse(TOOLING_JSON).stacks
 const escape = (value) =>
   value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
 
-// Even spacing across the sorted catalog rather than its first N. The skill
-// names are prefixed by domain, so an alphabetical head returns eight
-// `claude-*` entries and reads as a narrower catalog than the one that ships.
+// Even spacing across the sorted catalog rather than its first N, so a column
+// whose names share a prefix does not read as a narrower catalog than the one
+// that ships. Rules and standards sample. Skills do not, because the even step
+// lands on the entries closest to commodity and on none of the workflow the
+// toolkit exists to carry.
 const sample = (names) => {
   if (names.length <= listed) return names
   const step = names.length / listed
   return Array.from({ length: listed }, (_, i) => names[Math.floor(i * step)])
 }
 
-const entries = (names) =>
-  sample(names)
+// The first seven are the method and exist nowhere else. The last three are
+// recognizable on sight and are what keeps a column of chosen names from
+// reading as an all-`claude-` catalog, which is the failure the sampler above
+// was written against.
+const FEATURED_SKILLS = [
+  "claude-feature",
+  "claude-groundwork",
+  "claude-intake",
+  "claude-orchestrate",
+  "claude-autoship",
+  "claude-pr-review",
+  "claude-tasks",
+  "git-ship",
+  "setup-init",
+  "systematic-debugging",
+]
+
+// A chosen name is maintained by hand where a sample never goes stale, so a
+// rename has to fail the run rather than quietly shrink the column. This is
+// what makes the trade acceptable.
+//
+// The length is asserted because the `+N more` figure below counts down from
+// `listed` rather than from what this returns, so a list of any other length
+// renders a remainder that is wrong by the difference.
+const featured = (names, chosen) => {
+  if (chosen.length !== listed) {
+    console.error(`regen-hero: ${chosen.length} featured skills, expected ${listed}`)
+    process.exit(1)
+  }
+  const catalog = new Set(names)
+  const missing = chosen.filter((name) => !catalog.has(name))
+  if (missing.length > 0) {
+    console.error(`regen-hero: featured skills missing from the catalog: ${missing.join(", ")}`)
+    process.exit(1)
+  }
+  return chosen
+}
+
+const markup = (names) =>
+  names
     .map((name) => `            <div class="entry">${escape(name)}</div>`)
     .join("\n")
 
+const entries = (names) => markup(sample(names))
+
 const remaining = (names) => String(Math.max(0, names.length - listed))
 
 // An empty array is well-formed JSON, so the shell guard on an empty payload
@@ -111,6 +174,7 @@ const remaining = (names) => String(Math.max(0, names.length - listed))
 for (const [label, list] of [
   ["skills", skills], ["rules", rules], ["standards", standards],
   ["snippets", [...snippets]], ["tooling stacks", toolingStacks], ["gov stacks", gov.stacks],
+  ["stack-delivered rules", deliveredRules],
 ]) {
   if (list.length === 0) {
     console.error(`regen-hero: the ${label} catalog is empty, refusing to write a zeroed hero`)
@@ -125,8 +189,9 @@ const values = {
   SNIPPET_COUNT: String(snippets.size),
   GOV_STACK_COUNT: String(gov.stacks.length),
   TOOLING_STACK_COUNT: String(toolingStacks.length),
-  SKILL_ENTRIES: entries(skills),
-  RULE_ENTRIES: entries(rules),
+  COMMAND_COUNT: String(Number(COMMAND_COUNT)),
+  SKILL_ENTRIES: markup(featured(skills, FEATURED_SKILLS)),
+  RULE_ENTRIES: entries(deliveredRules),
   STANDARD_ENTRIES: entries(standards),
   SKILL_MORE: remaining(skills),
   RULE_MORE: remaining(rules),

package/tooling/claude/seeds/CLAUDE.md

@@ -84,4 +84,6 @@
 
 - Implementation work runs in a linked worktree. From the main worktree, enter one with `/claude-worktree` before editing tracked files for a feature.
 - Shared session scratch (`.claude/plans/`, `.claude/review/`, `.claude/memory/`, `.claude/tasks/`) lives at the main worktree root, not inside a linked worktree. From a linked worktree, resolve these paths against the main root via `git worktree list --porcelain | grep -m 1 '^worktree ' | cut -d' ' -f2-`. Fall back to `pwd` if not a git repo.
-- From a linked worktree, every `Edit` or `Write` to a tracked file (source, docs) must use a path starting with `pwd`. Only shared session scratch (`.claude/plans/`, `.claude/review/`, `.claude/memory/`, `.claude/tasks/`) resolves to the main worktree root.
+- 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.