create-anpunkit 2.1.0 → 2.3.0

package/template/setup.sh

@@ -11,9 +11,8 @@
 #   user-owned  -> NEVER overwritten
 #   hybrid      -> merged idempotently, never replaced
 #
+# Claude Code only (v2.3 — Cursor support dropped, §5.69).
 # Flags: --src DIR --kb-path P --kb-remote URL --no-kb --force --dry-run
-#        --tools LIST   (comma/space list from: claude cursor; default both)
-#        --add-tool T   (additive: install T's files into an existing project)
 set -euo pipefail
 
 SRC="."
@@ -22,9 +21,6 @@ KB_REMOTE="${ANPUNKIT_KB_REMOTE:-}"
 NO_KB=0
 FORCE=0
 DRY=0
-TOOLS_FLAG=""
-ADD_TOOL=""
-AVAILABLE_TOOLS="claude cursor"   # tools with real adapters; extend here
 while [ $# -gt 0 ]; do
   case "$1" in
     --src)       SRC="$2"; shift 2;;
@@ -33,8 +29,6 @@ while [ $# -gt 0 ]; do
     --no-kb)     NO_KB=1; shift;;
     --force)     FORCE=1; shift;;
     --dry-run)   DRY=1; shift;;
-    --tools)     TOOLS_FLAG="$2"; shift 2;;
-    --add-tool)  ADD_TOOL="$2"; shift 2;;
     *) echo "unknown flag: $1" >&2; exit 2;;
   esac
 done
@@ -70,36 +64,6 @@ fi
 say "mode: $MODE (installed: ${OLD_VER:-none} -> new: $NEW_VER)"
 [ "$MODE" = "newer-installed" ] && say "  ! installed version is newer than this package — proceeding as repair, review carefully."
 
-# ---- tool selection (v2.1): install only the selected tools' adapters/hooks/files
-TOOLS_FILE="$DEST/.claude/anpunkit-tools.json"
-norm_tools() { printf '%s' "$1" | tr ',' ' ' | tr -s ' ' | sed 's/^ //; s/ $//'; }
-read_recorded_tools() {
-  [ -f "$TOOLS_FILE" ] || { printf ''; return; }
-  node -e "try{console.log((JSON.parse(require('fs').readFileSync(process.argv[1],'utf8')).tools||[]).join(' '))}catch(e){console.log('')}" "$TOOLS_FILE" 2>/dev/null || printf ''
-}
-valid_tool() { case " $AVAILABLE_TOOLS " in *" $1 "*) return 0;; *) return 1;; esac; }
-
-RECORDED="$(read_recorded_tools)"
-if [ -n "$TOOLS_FLAG" ]; then
-  TOOLS="$(norm_tools "$TOOLS_FLAG")"
-elif [ -n "$RECORDED" ]; then
-  TOOLS="$RECORDED"               # re-run: preserve prior selection
-elif [ "$MODE" = "fresh" ] && [ -t 0 ]; then
-  printf "  Select tools to install (space-separated from: %s) [claude cursor]: " "$AVAILABLE_TOOLS"
-  read -r _sel || true
-  TOOLS="$(norm_tools "${_sel:-claude cursor}")"
-else
-  TOOLS="claude cursor"           # non-interactive default = both (no regression)
-fi
-# additive: --add-tool unions into the selection (and is recorded)
-[ -n "$ADD_TOOL" ] && TOOLS="$(norm_tools "$TOOLS $(norm_tools "$ADD_TOOL")" | tr ' ' '\n' | sort -u | tr '\n' ' ')"
-TOOLS="$(norm_tools "$TOOLS")"
-# validate
-for t in $TOOLS; do valid_tool "$t" || { echo "FATAL: unknown tool '$t' (available: $AVAILABLE_TOOLS)"; exit 2; }; done
-[ -z "$TOOLS" ] && { echo "FATAL: no tools selected"; exit 2; }
-tool_selected() { case " $TOOLS " in *" $1 "*) return 0;; *) return 1;; esac; }
-say "tools: $TOOLS$([ -n "$ADD_TOOL" ] && echo '  (+'"$ADD_TOOL"' added)')"
-
 BACKUP="$DEST/.anpunkit-backup-$(date +%Y%m%d-%H%M%S)"
 backup_one() {
   [ "$MODE" = "fresh" ] && return 0
@@ -114,11 +78,6 @@ backup_one() {
 install_kit_file() {
   local rel="$1" s="$SRC/$1" d="$DEST/$1"
   [ -f "$s" ] || return 0
-  # v2.1 tool gating: cursor-only files skipped unless cursor selected.
-  # (.claude/* is shared infra — Cursor reads .claude/agents + .claude/hooks too.)
-  case "$rel" in
-    .cursor/*) tool_selected cursor || { act "skip     $rel (cursor not selected)"; return 0; };;
-  esac
   if [ ! -f "$d" ]; then
     act "write    $rel"; [ "$DRY" = 1 ] && return 0
     mkdir -p "$(dirname "$d")"; cp -p "$s" "$d"; return 0
@@ -156,76 +115,44 @@ else
 fi
 
 # ---- generate command adapters from commands.src/ (manifest-owned output)
-say ""; say "[2/6] generate command adapters (tools: $TOOLS):"
+say ""; say "[2/6] generate command adapters (.claude/commands/):"
 gen_adapters() {
-  tool_selected claude && mkdir -p "$DEST/.claude/commands"
-  tool_selected cursor && mkdir -p "$DEST/.cursor/commands" "$DEST/.cursor/rules"
+  mkdir -p "$DEST/.claude/commands"
   for f in "$DEST"/commands.src/*.md; do
     [ -f "$f" ] || continue
     n=$(basename "$f")
-    if tool_selected claude; then
-      act "claude   .claude/commands/$n"
-      [ "$DRY" = 1 ] || cp -p "$f" "$DEST/.claude/commands/$n"
-    fi
-    if tool_selected cursor; then
-      act "cursor   .cursor/commands/$n"
-      [ "$DRY" = 1 ] || awk 'BEGIN{fm=0} NR==1 && $0=="---"{fm=1; next} fm==1 && $0=="---"{fm=0; next} fm==0{print}' "$f" \
-        | sed '/^$/{1d}' > "$DEST/.cursor/commands/$n"
-    fi
+    act "claude   .claude/commands/$n"
+    [ "$DRY" = 1 ] || cp -p "$f" "$DEST/.claude/commands/$n"
   done
 }
 gen_adapters
 
-# ---- hybrid JSON merge: ensure the hook entries for selected tools, never drop user keys
-say ""; say "[3/6] wire hooks (idempotent merge, tools: $TOOLS):"
+# ---- hybrid JSON merge: ensure the Claude hook entries, never drop user keys
+say ""; say "[3/6] wire hooks (idempotent merge, .claude/settings.json):"
 merge_settings() {
-  [ "$DRY" = 1 ] && { act "merge    $(tool_selected claude && echo -n '.claude/settings.json ')$(tool_selected cursor && echo -n '.cursor/hooks.json')"; return 0; }
-  tool_selected claude && backup_one "$DEST/.claude/settings.json"
-  tool_selected cursor && backup_one "$DEST/.cursor/hooks.json"
-  CLAUDE_SEL=$(tool_selected claude && echo 1 || echo 0) \
-  CURSOR_SEL=$(tool_selected cursor && echo 1 || echo 0) \
+  [ "$DRY" = 1 ] && { act "merge    .claude/settings.json"; return 0; }
+  backup_one "$DEST/.claude/settings.json"
   node - "$DEST" <<'NODE'
 const fs=require('fs'),path=require('path');
 const dest=process.argv[2];
-const claudeSel=process.env.CLAUDE_SEL==='1', cursorSel=process.env.CURSOR_SEL==='1';
 const load=(p,d)=>{try{return JSON.parse(fs.readFileSync(p,'utf8'))}catch(e){return d}};
 const save=(p,o)=>{fs.mkdirSync(path.dirname(p),{recursive:true});fs.writeFileSync(p,JSON.stringify(o,null,2)+"\n")};
-const out=[];
-// Claude settings.json
-if(claudeSel){
-  const sp=path.join(dest,'.claude/settings.json');
-  const s=load(sp,{});
-  if(!s.$schema)s.$schema='https://json.schemastore.org/claude-code-settings.json';
-  s.hooks=s.hooks||{};
-  const ensure=(event,matcher,cmd)=>{
-    const arr=s.hooks[event]=s.hooks[event]||[];
-    for(const blk of arr)for(const h of (blk.hooks||[]))if(h.command===cmd)return;
-    const blk={hooks:[{type:'command',command:cmd}]};
-    if(matcher)blk.matcher=matcher;
-    arr.push(blk);
-  };
-  ensure('SessionStart','startup|clear|compact','bash .claude/hooks/session-start.sh');
-  ensure('PreCompact','auto|manual','bash .claude/hooks/pre-compact.sh');
-  ensure('SubagentStop','','bash .claude/hooks/subagent-stop.sh');
-  save(sp,s);
-  out.push('.claude/settings.json');
-}
-// Cursor hooks.json
-if(cursorSel){
-  const cp=path.join(dest,'.cursor/hooks.json');
-  const c=load(cp,{version:1,hooks:{}});
-  c.hooks=c.hooks||{};
-  const cursorEnsure=(event,cmd)=>{
-    const arr=c.hooks[event]=c.hooks[event]||[];
-    if(!arr.some(h=>h.command===cmd))arr.push({command:cmd});
-  };
-  cursorEnsure('sessionStart','bash .claude/hooks/cursor-session-start.sh');
-  cursorEnsure('preCompact','bash .claude/hooks/pre-compact.sh');
-  cursorEnsure('subagentStop','bash .claude/hooks/subagent-stop.sh');
-  save(cp,c);
-  out.push('.cursor/hooks.json');
-}
-console.log('  merged '+(out.join(' + ')||'(nothing — no tool selected hooks)'));
+const sp=path.join(dest,'.claude/settings.json');
+const s=load(sp,{});
+if(!s.$schema)s.$schema='https://json.schemastore.org/claude-code-settings.json';
+s.hooks=s.hooks||{};
+const ensure=(event,matcher,cmd)=>{
+  const arr=s.hooks[event]=s.hooks[event]||[];
+  for(const blk of arr)for(const h of (blk.hooks||[]))if(h.command===cmd)return;
+  const blk={hooks:[{type:'command',command:cmd}]};
+  if(matcher)blk.matcher=matcher;
+  arr.push(blk);
+};
+ensure('SessionStart','startup|clear|compact','bash .claude/hooks/session-start.sh');
+ensure('PreCompact','auto|manual','bash .claude/hooks/pre-compact.sh');
+ensure('SubagentStop','','bash .claude/hooks/subagent-stop.sh');
+save(sp,s);
+console.log('  merged .claude/settings.json');
 NODE
 }
 merge_settings
@@ -237,17 +164,11 @@ say ""; say "[4/6] AGENTS.md / CLAUDE.md verify:"
 verify_import() {
   local CL="$DEST/CLAUDE.md" AG="$DEST/AGENTS.md"
   [ -f "$AG" ] || { echo "FATAL VERIFY: AGENTS.md not on disk"; exit 1; }
-  # sentinel present in AGENTS.md (shared — both tools read AGENTS.md)
   if ! grep -q 'ANPUNKIT-AGENTS-SENTINEL' "$AG"; then
     echo "FATAL VERIFY: AGENTS.md sentinel missing (file clobbered or empty?)"; exit 1; fi
-  # CLAUDE.md bare @AGENTS.md import is Claude-specific — only verify if claude selected
-  if tool_selected claude; then
-    if ! grep -qE '^@AGENTS\.md[[:space:]]*$' "$CL"; then
-      echo "FATAL VERIFY: CLAUDE.md is missing a bare top-level '@AGENTS.md' import line"; exit 1; fi
-    say "  VERIFY ok: bare @AGENTS.md import + AGENTS.md on disk + sentinel present."
-  else
-    say "  VERIFY ok: AGENTS.md on disk + sentinel present (claude not selected — CLAUDE.md import not required)."
-  fi
+  if ! grep -qE '^@AGENTS\.md[[:space:]]*$' "$CL"; then
+    echo "FATAL VERIFY: CLAUDE.md is missing a bare top-level '@AGENTS.md' import line"; exit 1; fi
+  say "  VERIFY ok: bare @AGENTS.md import + AGENTS.md on disk + sentinel present."
 }
 verify_import
 
@@ -305,14 +226,12 @@ configure_kb() {
 
 configure_kb
 
-# ---- finalize: stamp the installed manifest (copy the new one) + record tools
+# ---- finalize: stamp the installed manifest (copy the new one)
 if [ "$DRY" != 1 ]; then
   cp -p "$MAN_SRC" "$MAN_DEST" 2>/dev/null || true
-  mkdir -p "$DEST/.claude"
-  node -e "require('fs').writeFileSync(process.argv[1],JSON.stringify({tools:process.argv[2].split(' ').filter(Boolean)},null,2)+'\n')" "$TOOLS_FILE" "$TOOLS" 2>/dev/null || true
   [ -d "$BACKUP" ] && say "" && say "backup written: ${BACKUP#$DEST/}"
 fi
 
-say ""; say "anpunkit setup complete ($MODE, tools: $TOOLS). Open Claude Code or Cursor — the SessionStart/sessionStart hook fires automatically."
+say ""; say "anpunkit setup complete ($MODE). Open Claude Code — the SessionStart hook fires automatically."
 if [ "$DRY" = 1 ]; then say "(dry-run: no files were written.)"; fi
 exit 0

package/template/tests/helpers/spec-assert.py

@@ -0,0 +1,162 @@
+"""spec-assert.py — kit-versioned matcher-aware deep-equality comparator (v2.2).
+
+The generated `data` boundary harness (test-author) asserts an actual response
+against `fixtures/<case-id>-expected.json` via `spec_assert(actual, expected)`.
+Deep equality, EXCEPT that volatile fields in the expected fixture carry a matcher
+token instead of a literal (see §5.49). This is the ONLY comparator — no per-project
+assertion logic. One file per supported test language; this is the Python one.
+
+Matcher tokens (string values in the expected fixture):
+
+    "<UUID>"            any UUID v4 string
+    "<ISO8601>"         any ISO 8601 datetime string
+    "<ANY_STRING>"      any non-null string
+    "<ANY_NUMBER>"      any finite number (not bool)
+    "<UNORDERED>"       any array (presence + shape only)
+    "<MATCHES:regex>"   any string matching the pattern (re.search)
+
+Order-insensitive array WITH item checking: wrap the expected array as
+    {"<UNORDERED>": [item, item, ...]}
+and the actual must be a list that is an order-insensitive deep-equal multiset of
+those items.
+
+A matcher token asserts PRESENCE + SHAPE — never "ignore this field". A missing
+volatile field still fails (strict key sets). Extra actual keys also fail.
+
+Usage (pytest or any runner):
+
+    from importlib import import_module
+    spec_assert = import_module("tests.helpers.spec-assert").spec_assert  # if importable
+    # or load directly:
+    #   import importlib.util, pathlib
+    #   spec = importlib.util.spec_from_file_location("spec_assert", ".../spec-assert.py")
+    ...
+    spec_assert(actual, expected)          # raises AssertionError with a JSON path on mismatch
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from numbers import Number
+from pathlib import Path
+from typing import Any
+
+_UUID4 = re.compile(
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$"
+)
+_ISO8601 = re.compile(
+    r"^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:?\d{2})?$"
+)
+_MATCHES_PREFIX = "<MATCHES:"
+
+
+class SpecMismatch(AssertionError):
+    """Raised when actual does not satisfy the expected fixture (with a JSON path)."""
+
+
+def load_fixture(path: str | Path) -> Any:
+    """Convenience loader for fixtures/<case-id>-*.json."""
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def _is_real_number(v: Any) -> bool:
+    # bool is a subclass of int in Python — exclude it explicitly.
+    return isinstance(v, Number) and not isinstance(v, bool)
+
+
+def _fail(path: str, msg: str) -> None:
+    raise SpecMismatch(f"spec-assert mismatch at {path}: {msg}")
+
+
+def _match_token(actual: Any, token: str, path: str) -> bool:
+    """Return True if `token` is a known matcher and `actual` satisfies it.
+    Raises on a known token that is NOT satisfied. Returns False if not a token."""
+    if token == "<UUID>":
+        if not (isinstance(actual, str) and _UUID4.match(actual)):
+            _fail(path, f"expected a UUID v4 string, got {actual!r}")
+        return True
+    if token == "<ISO8601>":
+        if not (isinstance(actual, str) and _ISO8601.match(actual)):
+            _fail(path, f"expected an ISO 8601 datetime string, got {actual!r}")
+        return True
+    if token == "<ANY_STRING>":
+        if not isinstance(actual, str):
+            _fail(path, f"expected any string, got {type(actual).__name__}")
+        return True
+    if token == "<ANY_NUMBER>":
+        if not _is_real_number(actual):
+            _fail(path, f"expected any finite number, got {actual!r}")
+        return True
+    if token == "<UNORDERED>":
+        if not isinstance(actual, list):
+            _fail(path, f"expected any array, got {type(actual).__name__}")
+        return True
+    if token.startswith(_MATCHES_PREFIX) and token.endswith(">"):
+        pattern = token[len(_MATCHES_PREFIX):-1]
+        if not (isinstance(actual, str) and re.search(pattern, actual)):
+            _fail(path, f"expected a string matching /{pattern}/, got {actual!r}")
+        return True
+    return False
+
+
+def _unordered_equal(actual: list, items: list, path: str) -> None:
+    if not isinstance(actual, list):
+        _fail(path, f"expected an array (unordered), got {type(actual).__name__}")
+    if len(actual) != len(items):
+        _fail(path, f"array length {len(actual)} != expected {len(items)} (unordered)")
+    remaining = list(actual)
+    for i, exp in enumerate(items):
+        found = -1
+        for j, act in enumerate(remaining):
+            try:
+                spec_assert(act, exp, f"{path}[unordered:{i}]")
+                found = j
+                break
+            except SpecMismatch:
+                continue
+        if found < 0:
+            _fail(path, f"no actual element matches expected item #{i}: {exp!r}")
+        remaining.pop(found)
+
+
+def spec_assert(actual: Any, expected: Any, path: str = "$") -> None:
+    """Assert `actual` deep-equals `expected`, honoring matcher tokens. Raises
+    SpecMismatch (an AssertionError) with a JSON path on the first divergence."""
+    # scalar matcher token
+    if isinstance(expected, str) and _match_token(actual, expected, path):
+        return
+
+    # {"<UNORDERED>": [...]} wrapper → order-insensitive item compare
+    if isinstance(expected, dict) and list(expected.keys()) == ["<UNORDERED>"]:
+        _unordered_equal(actual, expected["<UNORDERED>"], path)
+        return
+
+    if isinstance(expected, dict):
+        if not isinstance(actual, dict):
+            _fail(path, f"expected object, got {type(actual).__name__}")
+        exp_keys, act_keys = set(expected), set(actual)
+        if exp_keys != act_keys:
+            missing = exp_keys - act_keys
+            extra = act_keys - exp_keys
+            _fail(path, f"key mismatch (missing={sorted(missing)}, extra={sorted(extra)})")
+        for k in expected:
+            spec_assert(actual[k], expected[k], f"{path}.{k}")
+        return
+
+    if isinstance(expected, list):
+        if not isinstance(actual, list):
+            _fail(path, f"expected array, got {type(actual).__name__}")
+        if len(actual) != len(expected):
+            _fail(path, f"array length {len(actual)} != expected {len(expected)}")
+        for i, (a, e) in enumerate(zip(actual, expected)):
+            spec_assert(a, e, f"{path}[{i}]")
+        return
+
+    # scalar literal — strict equality (bool/int kept distinct)
+    if type(actual) is not type(expected) and not (
+        _is_real_number(actual) and _is_real_number(expected)
+    ):
+        _fail(path, f"type {type(actual).__name__} != expected {type(expected).__name__}")
+    if actual != expected:
+        _fail(path, f"{actual!r} != expected {expected!r}")

package/template/tests/helpers/spec-assert.ts

@@ -0,0 +1,158 @@
+/**
+ * spec-assert.ts — kit-versioned matcher-aware deep-equality comparator (v2.2).
+ *
+ * The generated `data`/`ui` boundary harness asserts an actual value against
+ * `fixtures/<case-id>-expected.json` via `specAssert(actual, expected)`. Deep
+ * equality, EXCEPT that volatile fields in the expected fixture carry a matcher
+ * token instead of a literal (§5.49). This is the ONLY comparator — no per-project
+ * assertion logic. One file per supported test language; this is the TS/JS one.
+ *
+ * Matcher tokens (string values in the expected fixture):
+ *
+ *   "<UUID>"            any UUID v4 string
+ *   "<ISO8601>"         any ISO 8601 datetime string
+ *   "<ANY_STRING>"      any string
+ *   "<ANY_NUMBER>"      any finite number
+ *   "<UNORDERED>"       any array (presence + shape only)
+ *   "<MATCHES:regex>"   any string matching the pattern (RegExp.test)
+ *
+ * Order-insensitive array WITH item checking: wrap the expected array as
+ *   { "<UNORDERED>": [item, item, ...] }
+ * and the actual must be an array that is an order-insensitive deep-equal multiset.
+ *
+ * A token asserts PRESENCE + SHAPE — never "ignore this field". Missing volatile
+ * fields fail (strict key sets); extra actual keys also fail.
+ *
+ *   import { specAssert, loadFixture } from "../helpers/spec-assert";
+ *   specAssert(actual, loadFixture("fixtures/PH2-ORDER-01-expected.json"));
+ */
+
+import { readFileSync } from "node:fs";
+
+const UUID4 =
+  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+const ISO8601 =
+  /^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:?\d{2})?$/;
+const MATCHES_PREFIX = "<MATCHES:";
+
+export class SpecMismatch extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SpecMismatch";
+  }
+}
+
+export function loadFixture<T = unknown>(path: string): T {
+  return JSON.parse(readFileSync(path, "utf-8")) as T;
+}
+
+function fail(path: string, msg: string): never {
+  throw new SpecMismatch(`spec-assert mismatch at ${path}: ${msg}`);
+}
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function typeName(v: unknown): string {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+
+/** Returns true if `token` is a known matcher and `actual` satisfies it.
+ *  Throws on a known token that is NOT satisfied. Returns false if not a token. */
+function matchToken(actual: unknown, token: string, path: string): boolean {
+  switch (token) {
+    case "<UUID>":
+      if (!(typeof actual === "string" && UUID4.test(actual)))
+        fail(path, `expected a UUID v4 string, got ${JSON.stringify(actual)}`);
+      return true;
+    case "<ISO8601>":
+      if (!(typeof actual === "string" && ISO8601.test(actual)))
+        fail(path, `expected an ISO 8601 datetime string, got ${JSON.stringify(actual)}`);
+      return true;
+    case "<ANY_STRING>":
+      if (typeof actual !== "string")
+        fail(path, `expected any string, got ${typeName(actual)}`);
+      return true;
+    case "<ANY_NUMBER>":
+      if (typeof actual !== "number" || !Number.isFinite(actual))
+        fail(path, `expected any finite number, got ${JSON.stringify(actual)}`);
+      return true;
+    case "<UNORDERED>":
+      if (!Array.isArray(actual))
+        fail(path, `expected any array, got ${typeName(actual)}`);
+      return true;
+  }
+  if (token.startsWith(MATCHES_PREFIX) && token.endsWith(">")) {
+    const pattern = token.slice(MATCHES_PREFIX.length, -1);
+    if (!(typeof actual === "string" && new RegExp(pattern).test(actual)))
+      fail(path, `expected a string matching /${pattern}/, got ${JSON.stringify(actual)}`);
+    return true;
+  }
+  return false;
+}
+
+function unorderedEqual(actual: unknown, items: unknown[], path: string): void {
+  if (!Array.isArray(actual))
+    fail(path, `expected an array (unordered), got ${typeName(actual)}`);
+  if (actual.length !== items.length)
+    fail(path, `array length ${actual.length} != expected ${items.length} (unordered)`);
+  const remaining = [...actual];
+  items.forEach((exp, i) => {
+    let found = -1;
+    for (let j = 0; j < remaining.length; j++) {
+      try {
+        specAssert(remaining[j], exp, `${path}[unordered:${i}]`);
+        found = j;
+        break;
+      } catch (e) {
+        if (e instanceof SpecMismatch) continue;
+        throw e;
+      }
+    }
+    if (found < 0) fail(path, `no actual element matches expected item #${i}: ${JSON.stringify(exp)}`);
+    remaining.splice(found, 1);
+  });
+}
+
+/** Assert `actual` deep-equals `expected`, honoring matcher tokens. Throws
+ *  SpecMismatch with a JSON path on the first divergence. */
+export function specAssert(actual: unknown, expected: unknown, path = "$"): void {
+  // scalar matcher token
+  if (typeof expected === "string" && matchToken(actual, expected, path)) return;
+
+  // { "<UNORDERED>": [...] } wrapper → order-insensitive item compare
+  if (isPlainObject(expected)) {
+    const keys = Object.keys(expected);
+    if (keys.length === 1 && keys[0] === "<UNORDERED>") {
+      unorderedEqual(actual, expected["<UNORDERED>"] as unknown[], path);
+      return;
+    }
+    if (!isPlainObject(actual)) fail(path, `expected object, got ${typeName(actual)}`);
+    const expKeys = new Set(keys);
+    const actKeys = new Set(Object.keys(actual));
+    const missing = [...expKeys].filter((k) => !actKeys.has(k));
+    const extra = [...actKeys].filter((k) => !expKeys.has(k));
+    if (missing.length || extra.length)
+      fail(path, `key mismatch (missing=${JSON.stringify(missing)}, extra=${JSON.stringify(extra)})`);
+    for (const k of keys) specAssert(actual[k], expected[k], `${path}.${k}`);
+    return;
+  }
+
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) fail(path, `expected array, got ${typeName(actual)}`);
+    if (actual.length !== expected.length)
+      fail(path, `array length ${actual.length} != expected ${expected.length}`);
+    for (let i = 0; i < expected.length; i++)
+      specAssert(actual[i], expected[i], `${path}[${i}]`);
+    return;
+  }
+
+  // scalar literal — strict equality (typeof must agree; NaN-safe)
+  if (typeName(actual) !== typeName(expected))
+    fail(path, `type ${typeName(actual)} != expected ${typeName(expected)}`);
+  if (actual !== expected && !(Number.isNaN(actual) && Number.isNaN(expected)))
+    fail(path, `${JSON.stringify(actual)} != expected ${JSON.stringify(expected)}`);
+}

package/template/.claude/hooks/cursor-session-start.sh

@@ -1,17 +0,0 @@
-#!/usr/bin/env bash
-# cursor-session-start.sh — Cursor wiring for the SESSION-OPEN ritual.
-# Cursor's sessionStart hook expects JSON on stdout ({"additional_context": ...}),
-# unlike Claude Code, which injects raw stdout. This wrapper runs the SHARED
-# session-start.sh body (single copy — anti-drift) and wraps its output in the
-# JSON envelope Cursor requires. Cursor sets CLAUDE_PROJECT_DIR (compat alias),
-# so the shared script needs no changes.
-# Uses node for JSON (the kit assumes Node; python3 is a fallback only).
-# Verified against cursor.com/docs/hooks (sessionStart output schema), 2026-06.
-set -euo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"
-OUT="$(bash "$HERE/session-start.sh" 2>/dev/null || true)"
-if command -v node >/dev/null 2>&1; then
-  printf '%s' "$OUT" | node -e 'let d="";process.stdin.on("data",c=>d+=c).on("end",()=>console.log(JSON.stringify({additional_context:d})))'
-else
-  printf '%s' "$OUT" | python3 -c 'import json,sys; print(json.dumps({"additional_context": sys.stdin.read()}))'
-fi

package/template/.claude/skills/caveman/SKILL.md

@@ -1,39 +0,0 @@
----
-name: caveman
-description: >
-  Ultra-compressed communication mode. Cuts token usage ~75% by dropping
-  filler, articles, and pleasantries while keeping full technical accuracy.
-  Use when user says "caveman mode", "talk like caveman", "use caveman",
-  "less tokens", "be brief", or invokes /caveman.
----
-
-Respond terse like smart caveman. All technical substance stay. Only fluff die.
-
-## Persistence
-
-ACTIVE EVERY RESPONSE once triggered. No revert after many turns. No filler drift. Still active if unsure. Off only when user says "stop caveman" or "normal mode".
-
-## Rules
-
-Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). Abbreviate common terms (DB/auth/config/req/res/fn/impl). Strip conjunctions. Use arrows for causality (X -> Y). One word when one word enough.
-
-Technical terms stay exact. Code blocks unchanged. Errors quoted exact.
-
-Pattern: `[thing] [action] [reason]. [next step].`
-
-Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
-Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
-
-### Examples
-
-**"Why React component re-render?"**
-
-> Inline obj prop -> new ref -> re-render. `useMemo`.
-
-**"Explain database connection pooling."**
-
-> Pool = reuse DB conn. Skip handshake -> fast under load.
-
-## Auto-Clarity Exception
-
-Drop caveman temporarily for: security warnings, irreversible action confirmations, multi-step sequences where fragment order risks misread, user asks to clarify or repeats question. Resume caveman after.