@spardutti/claude-skills 2.62.1 → 2.64.0

package/README.md

@@ -135,7 +135,7 @@ Portable slash commands installed to `.claude/commands/`. Some orchestrate paral
 | `/ship` | Unified delivery pipeline — commit → gate → PR → merge → release. The gate is the one enforcement moment: it checks the diff's file lengths and that new files sit in their kind folder, audits it against the skills installed in the project, mutation-tests the changed lines to prove the tests would catch a break, and runs one `/code-review` round for logic bugs — **fixing what it finds** rather than handing you a list. It runs before the **PR**, not before every commit: its scope is the whole branch, so gating each commit re-mutated every file the branch had ever touched. `--force` skips it. No argument steps through interactively; `/ship pr` runs through PR creation; `/ship release` runs the full pipeline |
 | `/discover` | Find the right problem before deciding what to build — diverges first: generates competing framings through blind subagents under forced constraints, stress-tests the winner with a blind critic, and refuses to converge until every open question is answered or deferred, then drafts scope, non-goals, edge cases and success criteria for you to correct. Run before `/plan-feature` |
 | `/plan-feature` | Integration-first feature planning, then building — one agent scans the repo for reusable code, patterns and touch points, grounded clarifying questions follow, the plan is written as type-checked stubs at the real paths, and on your go it fills them in. It reads every `*.registry.yaml` first and must mark each one reuse or skip |
-| `/registry` | Record the project's reusable systems — aiming methods, a state machine, an effect pipeline — as a small `<name>.registry.yaml` next to their code, so `/plan-feature` extends them instead of rebuilding them. You name the system, it drafts the entry for your yes. `/registry eval` lists existing code that does an entry's job outside its folder |
+| `/registry` | Record the project's reusable systems — aiming methods, a state machine, an effect pipeline — as a small `<name>.registry.yaml` next to their code, so `/plan-feature` extends them instead of rebuilding them. You name the system, it drafts the entry for your yes. `/registry eval` lists existing code that does an entry's job outside its folder, and `/registry update` redrafts every entry against today's code |
 | `/optimize` | Make one measured job faster without changing what it proves — fixes a benchmark and a result that must not move, sends 4 read-only subagents to find suspects, then changes one thing per round with a prediction written first, keeping only what beats the noise. Profiles after every wrong prediction, reruns before judging a result that flipped, and ends by writing the cause as a skill rule for you |
 | `/handoff` | Write a handoff doc so a fresh session picks the work up — captures what auto-compaction loses: decisions made and rejected, dead ends already ruled out, why the tree is dirty, and the one next step |
 | `/lockdown` | Per-repo supply-chain hardening — detects the package managers, Dockerfiles, and CI in use, then guides you through and applies install-time, deploy, and pipeline hardening for npm/pnpm, pip/uv, Docker, and GitHub Actions |

package/hooks/registry-lib.mjs

@@ -62,6 +62,15 @@ export function symbolsOf(extendBy = "") {
   return [...new Set([...ticked, ...shaped])];
 }
 
+export function planMarks(planPath) {
+  const text = existsSync(planPath) ? readFileSync(planPath, "utf8") : null;
+  if (text === null) return null;
+  const section = text.split(/^## /m).find((s) => /^Registry\s*$/m.test(s.split("\n")[0])) ?? "";
+  const marks = new Map();
+  for (const m of section.matchAll(/^[-*]\s*`?([\w.-]+)`?\s*:\s*(reuse|skip)\b/gim)) marks.set(m[1], m[2].toLowerCase());
+  return marks;
+}
+
 export const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 export function triggerHits(entry, text) {
@@ -74,6 +83,8 @@ export function insideLocation(entry, file) {
   return loc !== "" && (file === loc || file.startsWith(loc.replace(/\/?$/, "/")));
 }
 
+export const isAllowed = (entry, file) => entry.allowed.some((a) => (a.endsWith("/") ? file.startsWith(a) : file === a));
+
 // Only what the stub added: an extended file's old code would trip triggers it never wrote.
 export function addedText(root, file) {
   const tracked = spawnSync("git", ["-C", root, "ls-files", "--error-unmatch", file], { encoding: "utf8" });

package/hooks/registry.mjs

@@ -2,7 +2,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import {
-  REGISTRY_SUFFIX, addedText, escape, insideLocation, loadRegistry, projectFiles, projectRoot, symbolsOf, triggerHits,
+  REGISTRY_SUFFIX, addedText, escape, insideLocation, isAllowed, loadRegistry, planMarks, projectFiles, projectRoot, symbolsOf, triggerHits,
 } from "./registry-lib.mjs";
 import { loadEditRules } from "./text-rules.mjs";
 
@@ -26,15 +26,6 @@ function list() {
   stale();
 }
 
-function planMarks(planPath) {
-  const text = existsSync(planPath) ? readFileSync(planPath, "utf8") : null;
-  if (text === null) return null;
-  const section = text.split(/^## /m).find((s) => /^Registry\s*$/m.test(s.split("\n")[0])) ?? "";
-  const marks = new Map();
-  for (const m of section.matchAll(/^[-*]\s*`?([\w.-]+)`?\s*:\s*(reuse|skip)\b/gim)) marks.set(m[1], m[2].toLowerCase());
-  return marks;
-}
-
 function checkPlan(planPath, stubs) {
   if (!entries.length) return console.log("registry ok — no entries");
   const marks = planMarks(planPath);
@@ -59,11 +50,15 @@ function checkPlan(planPath, stubs) {
   if (!asks.length) console.log("registry ok");
 }
 
+function planMissing() {
+  if (entries.length && !planMarks(join(root, "PLAN.md"))?.size) console.log(`registry unplanned — ${entries.length} entries, no marks in PLAN.md`);
+}
+
 function evaluate() {
   if (!entries.length) return console.log(`registry none — no *${REGISTRY_SUFFIX} in this project`);
   for (const e of entries) {
     if (!e.does.length) { console.log(`registry eval ${e.name}: skipped, no does`); continue; }
-    const outside = files.filter((f) => !insideLocation(e, f) && !e.allowed.includes(f) && !f.endsWith(REGISTRY_SUFFIX));
+    const outside = files.filter((f) => !insideLocation(e, f) && !isAllowed(e, f) && !f.endsWith(REGISTRY_SUFFIX));
     const hits = outside.flatMap((f) => readFileSync(join(root, f), "utf8").split("\n").flatMap((line, i) =>
       e.does.filter((code) => calls(line, code)).map((code) => `registry SUSPECT ${e.name} ${f}:${i + 1} ${code}`)));
     console.log(hits.length ? hits.join("\n") : `registry eval ${e.name}: nothing outside ${e.location} does its job`);
@@ -87,24 +82,28 @@ function stale() {
     if (/^\s+-\s/m.test(e.text)) say("write lists on one line, like triggers: [aim, target]");
     if (seen.has(e.name)) say(`name ${e.name} is used twice`);
     seen.add(e.name);
-    const loc = join(root, e.location ?? "");
-    if (!e.location || !existsSync(loc)) { say(`location ${e.location} not found`); continue; }
-    const near = statSync(loc).isDirectory() ? loc : dirname(loc);
-    if (e.example && !existsSync(join(near, e.example)) && !existsSync(join(root, e.example))) say(`example ${e.example} not found`);
-    const syms = symbolsOf(e.extend_by);
-    if (!syms.length) say("extend_by names no symbol — write names like `AimStrategy`");
-    const code = files.filter((f) => insideLocation(e, f) && !f.endsWith(REGISTRY_SUFFIX))
-      .map((f) => readFileSync(join(root, f), "utf8")).join("\n");
-    for (const s of syms) {
-      // A plain word like `first` matches `var first = enemies[0]`; `Aim.first` only matches real use.
-      if (/^[a-z][a-z0-9]*$/.test(s)) say(`\`${s}\` is too common a word to prove use — name its owner, like \`Owner.${s}\``);
-      else if (!s.split(".").every((part) => uses(code, part))) say(`${s} from extend_by is not found in ${e.location}`);
-    }
-    for (const c of e.does) if (!calls(code, c)) say(`does ${c} is not found in ${e.location}`);
+    staleCode(e, say);
   }
   if (problems.length) fail(problems);
 }
 
+function staleCode(e, say) {
+  const loc = join(root, e.location ?? "");
+  if (!e.location || !existsSync(loc)) return say(`location ${e.location} not found`);
+  const near = statSync(loc).isDirectory() ? loc : dirname(loc);
+  if (e.example && !existsSync(join(near, e.example)) && !existsSync(join(root, e.example))) say(`example ${e.example} not found`);
+  const syms = symbolsOf(e.extend_by);
+  if (!syms.length) say("extend_by names no symbol — write names like `AimStrategy`");
+  const code = files.filter((f) => insideLocation(e, f) && !f.endsWith(REGISTRY_SUFFIX))
+    .map((f) => readFileSync(join(root, f), "utf8")).join("\n");
+  for (const s of syms) {
+    // A plain word like `first` matches `var first = enemies[0]`; `Aim.first` only matches real use.
+    if (/^[a-z][a-z0-9]*$/.test(s)) say(`\`${s}\` is too common a word to prove use — name its owner, like \`Owner.${s}\``);
+    else if (!s.split(".").every((part) => uses(code, part))) say(`${s} from extend_by is not found in ${e.location}`);
+  }
+  for (const c of e.does) if (!calls(code, c)) say(`does ${c} is not found in ${e.location}`);
+}
+
 function fail(lines) {
   for (const line of lines) console.log(line);
   process.exitCode = 1;
@@ -113,9 +112,10 @@ function fail(lines) {
 const [mode, ...rest] = process.argv.slice(2);
 if (mode === undefined) list();
 else if (mode === "--plan" && rest[0]) checkPlan(resolve(rest[0]), rest.slice(1));
+else if (mode === "--plan-missing") planMissing();
 else if (mode === "--stale") stale();
 else if (mode === "--eval") evaluate();
 else {
-  console.error("usage: registry.mjs [--plan PLAN.md <stub files…> | --stale | --eval]");
+  console.error("usage: registry.mjs [--plan PLAN.md <stub files…> | --plan-missing | --stale | --eval]");
   process.exit(2);
 }

package/hooks/ship-log-parse.mjs

@@ -1,5 +1,8 @@
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseLine, readLines } from "./diary-lib.mjs";
+import { planMarks } from "./registry-lib.mjs";
 
 const PROJECT = /^ {2}(\S.*?) (stryker|mutmut|config)(?: \((\d+)s\))? — (.*)$/;
 const SURVIVOR = /^ {6}\[(Survived|NoCoverage)\] (\S+)\s+(\S+)$/;
@@ -100,3 +103,15 @@ export function prSize(base, testRe, sourceExt) {
   }
   return size;
 }
+
+export function planRegistry(root) {
+  const marks = planMarks(join(root, "PLAN.md"));
+  return marks && Object.fromEntries(marks);
+}
+
+// Worktrees share one diary, so only this branch's blocks during the ship count.
+export function ruleBlocks(diary, branch, since, until) {
+  return readLines(join(diary, "edit-blocks.jsonl")).map(parseLine)
+    .filter((r) => r?.branch === branch && r.ts >= since && r.ts <= until)
+    .map(({ ts, file, rules }) => ({ ts, file, rules: [].concat(rules) }));
+}

package/hooks/ship-log.mjs

@@ -2,7 +2,8 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { git, parseReport, prSize } from "./ship-log-parse.mjs";
+import { parseLine, readLines } from "./diary-lib.mjs";
+import { git, parseReport, planRegistry, prSize, ruleBlocks } from "./ship-log-parse.mjs";
 import { printReport, tally } from "./ship-log-report.mjs";
 
 const HERE = dirname(resolve(process.argv[1]));
@@ -58,13 +59,14 @@ function settleSurvivors(record) {
   }
 }
 
-function finalize(dir, path, record, tag, status, reason, at) {
+function finalize(c, path, record, tag, status, reason, at) {
   settleSurvivors(record);
   Object.assign(record, { status, reason: reason ?? null, finished: at ?? now() });
+  record.rules = ruleBlocks(c.diary, record.branch, record.started, record.finished);
   record.summary = summarize(record);
   const stem = `${record.app}_${record.finished.slice(0, 10)}_${tag}`;
-  let out = join(dir, `${stem}.json`);
-  for (let i = 2; existsSync(out); i++) out = join(dir, `${stem}-${i}.json`);
+  let out = join(c.dir, `${stem}.json`);
+  for (let i = 2; existsSync(out); i++) out = join(c.dir, `${stem}-${i}.json`);
   save(path, record);
   renameSync(path, out);
   console.log(`ship-log: saved ${out}`);
@@ -78,8 +80,8 @@ function prOf(branch) {
 // Agents skip the `pr` call, so a log whose branch has a PR by now is closed at that PR.
 // A PR older than the log was only updated by it, so that log ends at its own last event.
 // A long-lived branch like dev keeps its merged PRs, so an old one that is not open is not this log's.
-function closeOpened(dir, app) {
-  const open = join(dir, "open");
+function closeOpened(c, app) {
+  const open = join(c.dir, "open");
   for (const f of existsSync(open) ? readdirSync(open).filter((n) => n.startsWith(`${app}__`)) : []) {
     const path = join(open, f), record = JSON.parse(readFileSync(path, "utf8"));
     const pr = prOf(record.branch), empty = !record.gate.length && !record.findings.length;
@@ -88,16 +90,16 @@ function closeOpened(dir, app) {
     if (empty) continue;
     const opened = pr && pr.createdAt >= record.started;
     if (!pr || (!opened && pr.state !== "OPEN")) continue;
-    finalize(dir, path, Object.assign(record, { pr: pr.number }), `pr${pr.number}`,
+    finalize(c, path, Object.assign(record, { pr: pr.number }), `pr${pr.number}`,
       opened ? "pr-opened" : "pr-updated", null, opened ? pr.createdAt : lastEvent(record));
   }
 }
 
 // A ship that never reached pr or end was abandoned; keep it, but never fold it into the next one.
-function restart(dir, path, record, id) {
-  closeOpened(dir, id.app);
-  if (existsSync(path)) finalize(dir, path, record, id.branch.replace(/[^\w.-]+/g, "-"), "abandoned");
-  save(path, load(path, id));
+function restart(c, path, record, id) {
+  closeOpened(c, id.app);
+  if (existsSync(path)) finalize(c, path, record, id.branch.replace(/[^\w.-]+/g, "-"), "abandoned");
+  save(path, { ...load(path, id), registry: planRegistry(c.root) });
 }
 
 function addGateRun(record, [report, exit, seconds, base]) {
@@ -129,9 +131,7 @@ function addStep(record, [name, edge]) {
 
 // Worktrees share one diary, so only this branch's latest review since the ship started counts.
 function lastReview(diary, branch, since) {
-  const file = join(diary, "review-findings.jsonl");
-  const rows = existsSync(file) ? readFileSync(file, "utf8").split("\n").filter(Boolean) : [];
-  const last = rows.map((l) => { try { return JSON.parse(l); } catch { return null; } })
+  const last = readLines(join(diary, "review-findings.jsonl")).map(parseLine)
     .filter((r) => r?.branch === branch && r.ts >= since && typeof r.reply === "string").at(-1);
   const json = last?.reply.match(/```json\s*([\s\S]*?)```/)?.[1];
   try {
@@ -161,11 +161,11 @@ function run(mode, args) {
   if (!c.on) return 0;
   const id = identity(c.root), path = openPath(c.dir, id), record = load(path, id);
   if (mode === "start" && RELEASE.test(id.branch)) {
-    closeOpened(c.dir, id.app);
+    closeOpened(c, id.app);
     if (existsSync(path)) rmSync(path);
     return 0;
   }
-  if (mode === "start") return restart(c.dir, path, record, id), 0;
+  if (mode === "start") return restart(c, path, record, id), 0;
   if (mode === "ready") {
     const todo = existsSync(path) ? missing(record, c) : [];
     if (todo.length) console.log(todo.map((t) => `  - ${t}`).join("\n"));
@@ -178,9 +178,9 @@ function run(mode, args) {
   else if (mode === "step") addStep(record, args);
   else if (mode === "pr" && /^\d+$/.test(args[0] ?? "")) {
     record.pr = Number(args[0]);
-    return finalize(c.dir, path, record, `pr${args[0]}`, "pr-opened"), 0;
+    return finalize(c, path, record, `pr${args[0]}`, "pr-opened"), 0;
   }
-  else if (mode === "end") return finalize(c.dir, path, record, id.branch.replace(/[^\w.-]+/g, "-"), "stopped", args.join(" ") || null), 0;
+  else if (mode === "end") return finalize(c, path, record, id.branch.replace(/[^\w.-]+/g, "-"), "stopped", args.join(" ") || null), 0;
   else throw new Error("usage: ship-log.mjs on | start | ready | gate <report> <exit> <seconds> <base> | step <name> start|end | finding '<json>' | pr <number> | end [reason] | report [dir]");
   save(path, record);
   return 0;

package/hooks/ship-prep.sh

@@ -59,6 +59,9 @@ scope() {
   base=$(printf '%s\n' "$scope" | sed -n '1s/^base //p')
   while IFS=$'\t' read -r f _; do [ -n "$f" ] && files+=("$f"); done < <(printf '%s\n' "$scope" | sed '1d')
   skills_report "${files[@]}"
+  if printf '%s\n' "$scope" | grep -q '(new)$' && [ -n "$(node "$HERE/registry.mjs" --plan-missing 2>/dev/null)" ]; then
+    echo "plan none: this branch adds files and no /plan-feature marked the registry"
+  fi
   diff="/tmp/claude-ship-$(printf '%s %s' "$PWD" "$branch" | cksum | cut -d' ' -f1).diff"
   : > "$diff"
   if [ ${#files[@]} -gt 0 ]; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spardutti/claude-skills",
-  "version": "2.62.1",
+  "version": "2.64.0",
   "description": "Guardrails for Claude Code — best-practice skills, planning commands, and delivery gates.",
   "type": "module",
   "repository": {