luciazero 2.0.2 → 2.1.0

package/claude/hooks/luciazero-verify.sh

@@ -5,8 +5,13 @@
 # ("done is proven by a command") at the exact moment it is most violated.
 #
 # Subcommands (wired in settings.json):
+#   prompt  — UserPromptSubmit: start privacy-preserving turn telemetry
+#   bash-start — PreToolUse on Bash: start shell-command timing
 #   edit    — PostToolUse on Edit|Write|NotebookEdit : record "an edit happened"
-#   bash    — PostToolUse on Bash                    : record verify runs + status
+#   bash    — PostToolUse on Bash: record duration, verify runs, and status
+#   bash-failure — PostToolUseFailure on Bash: record failed commands
+#   skill   — PostToolUse on Skill: count model-invoked skills
+#   skill-prompt — UserPromptExpansion: count user-invoked slash skills
 #   stop    — Stop                                   : warn once if edits are unverified
 #   session — SessionStart                           : point at an existing Lucia Relay
 #   doctrine— SessionStart (plugin installs only)    : emit the doctrine as context
@@ -29,8 +34,8 @@
 # stop hook appends one schema-versioned JSON line per stop outcome
 # (stop-clean / nudge / strict-block) to luciazero-stats.log in the harness
 # config dir — local only, capped at ~250 lines, fail-open. It records a
-# privacy-preserving project hash and verify mode, never the project path or
-# command. Uninstall keeps it (it is learned data).
+# privacy-preserving project hash, verify mode, and aggregate latency/counts;
+# never the project path, command, or skill name. Uninstall keeps it.
 set -u
 
 MODE="${1:-}"
@@ -79,8 +84,54 @@ CWD="$(pyfield "d.get('cwd')")"
 [ -n "${CWD}" ] || CWD="${PWD}"
 KEY="$(printf '%s' "${CWD}" | python3 -c 'import sys,hashlib;print(hashlib.md5(sys.stdin.buffer.read()).hexdigest()[:12])' 2>/dev/null)" || exit 0
 [ -n "${KEY}" ] || exit 0
-STATE="${TMPDIR:-/tmp}/luciazero-verify-state/${KEY}"
+BASE="${TMPDIR:-/tmp}/luciazero-verify-state-$(id -u 2>/dev/null || echo unknown)"
+# The base name is predictable, so validate ownership/type before touching it.
+# A hostile pre-created symlink or directory makes the hook fail open.
+python3 - "${BASE}" <<'PY' 2>/dev/null || exit 0
+import os, stat, sys
+path = sys.argv[1]
+try:
+    info = os.lstat(path)
+except FileNotFoundError:
+    os.mkdir(path, 0o700)
+    info = os.lstat(path)
+if not stat.S_ISDIR(info.st_mode) or stat.S_ISLNK(info.st_mode):
+    raise SystemExit(1)
+if hasattr(os, "getuid") and info.st_uid != os.getuid():
+    raise SystemExit(1)
+os.chmod(path, 0o700)
+PY
+STATE="${BASE}/${KEY}"
 mkdir -p "${STATE}" 2>/dev/null || exit 0
+chmod 700 "${STATE}" 2>/dev/null || exit 0
+SESSION_RAW="$(pyfield "d.get('session_id')")"
+[ -n "${SESSION_RAW}" ] || SESSION_RAW="parent-${PPID}"
+SESSION_KEY="$(printf '%s' "${SESSION_RAW}" | python3 -c 'import hashlib,sys; print(hashlib.sha256(sys.stdin.buffer.read()).hexdigest()[:16])' 2>/dev/null)" || exit 0
+TELEMETRY="${STATE}/telemetry/${SESSION_KEY}"
+
+tool_key() { # stable opaque key; raw tool input never leaves temporary state
+  RAW="$(pyfield "d.get('tool_use_id') or d.get('tool_input', {}).get('command') or d.get('tool_input', {}).get('skill') or d.get('command_name') or d.get('prompt') or d.get('command')")"
+  [ -n "${RAW}" ] || RAW=unknown
+  printf '%s' "${RAW}" | python3 -c 'import hashlib,sys; print(hashlib.sha256(sys.stdin.buffer.read()).hexdigest()[:16])' 2>/dev/null
+}
+
+now_ms() {
+  python3 -c 'import time; print(int(time.time() * 1000))' 2>/dev/null
+}
+
+record_strict_telemetry() { # record_strict_telemetry <start-ms>
+  STRICT_END_MS="$(now_ms || true)"
+  case "${1:-}:${STRICT_END_MS}" in
+    *[!0-9:]*|:|*:|*::* ) return ;;
+  esac
+  [ "${STRICT_END_MS}" -ge "$1" ] 2>/dev/null || return
+  mkdir -p "${TELEMETRY}/bash_count" "${TELEMETRY}/bash_intervals" \
+    "${TELEMETRY}/verify_count" 2>/dev/null || return
+  : > "${TELEMETRY}/bash_count/strict-gate" 2>/dev/null || true
+  : > "${TELEMETRY}/verify_count/strict-gate" 2>/dev/null || true
+  printf '%s %s\n' "$1" "${STRICT_END_MS}" \
+    > "${TELEMETRY}/bash_intervals/strict-gate" 2>/dev/null || true
+}
 
 stat_log() { # stat_log <event> — discipline stats; fail-open, capped
   SDIR="${CLAUDE_CONFIG_DIR:-${HOME:-}/.claude}"
@@ -88,9 +139,9 @@ stat_log() { # stat_log <event> — discipline stats; fail-open, capped
   VMODE=regex
   [ -n "${VERIFY_CMD:-}" ] && VMODE=exact
   [ -n "${LUCIAZERO_STRICT_VERIFY_CMD:-}" ] && VMODE=strict
-  python3 - "${SFILE}" "${CWD}" "$1" "${VMODE}" <<'PY' 2>/dev/null || true
+  python3 - "${SFILE}" "${CWD}" "$1" "${VMODE}" "${TELEMETRY}" <<'PY' 2>/dev/null || true
 import datetime, hashlib, json, os, sys
-path, cwd, event, mode = sys.argv[1:]
+path, cwd, event, mode, telemetry_dir = sys.argv[1:]
 os.makedirs(os.path.dirname(path), exist_ok=True)
 real = os.path.realpath(cwd)
 row = {
@@ -101,6 +152,47 @@ row = {
     "project": os.path.basename(real) or "(root)",
     "verify_mode": mode,
 }
+def read_int(path):
+    try:
+        value = int(open(path, encoding="utf-8").read().strip())
+        return value if value >= 0 else None
+    except (OSError, ValueError):
+        return None
+def count_files(name):
+    try:
+        return sum(os.path.isfile(os.path.join(telemetry_dir, name, item))
+                   for item in os.listdir(os.path.join(telemetry_dir, name)))
+    except OSError:
+        return 0
+start = read_int(os.path.join(telemetry_dir, "turn_start_ms"))
+if start is not None:
+    now = int(datetime.datetime.now(datetime.timezone.utc).timestamp() * 1000)
+    intervals = []
+    try:
+        interval_dir = os.path.join(telemetry_dir, "bash_intervals")
+        for item in os.listdir(interval_dir):
+            try:
+                a, b = map(int, open(os.path.join(interval_dir, item), encoding="utf-8").read().split())
+            except (OSError, ValueError):
+                continue
+            if 0 <= a <= b:
+                intervals.append((max(start, a), min(now, b)))
+    except OSError:
+        pass
+    merged = []
+    for a, b in sorted((a, b) for a, b in intervals if a <= b):
+        if not merged or a > merged[-1][1]:
+            merged.append([a, b])
+        else:
+            merged[-1][1] = max(merged[-1][1], b)
+    bash_ms = sum(b - a for a, b in merged)
+    row["telemetry"] = {
+        "turn_ms": max(0, now - start),
+        "bash_ms": bash_ms,
+        "bash_count": count_files("bash_count"),
+        "verify_count": count_files("verify_count"),
+        "skill_count": count_files("skill_count"),
+    }
 with open(path, "a", encoding="utf-8") as handle:
     handle.write(json.dumps(row, separators=(",", ":")) + "\n")
 with open(path, encoding="utf-8", errors="replace") as handle:
@@ -123,6 +215,18 @@ VERIFY_RE="${LUCIAZERO_VERIFY_REGEX:-verify|test\.sh|pytest|npm (run )?test|pnpm
 VERIFY_CMD="${LUCIAZERO_VERIFY_CMD:-}"
 
 case "${MODE}" in
+  prompt)
+    # Per-turn scratch data is ephemeral. Persistent rows keep aggregates only.
+    rm -rf "${TELEMETRY}" 2>/dev/null || exit 0
+    mkdir -p "${TELEMETRY}" 2>/dev/null || exit 0
+    now_ms > "${TELEMETRY}/turn_start_ms" 2>/dev/null || true
+    ;;
+  bash-start)
+    TK="$(tool_key)" || exit 0
+    mkdir -p "${TELEMETRY}/bash_start_ms" "${TELEMETRY}/bash_count" 2>/dev/null || exit 0
+    now_ms > "${TELEMETRY}/bash_start_ms/${TK}" 2>/dev/null || true
+    : > "${TELEMETRY}/bash_count/${TK}" 2>/dev/null || true
+    ;;
   edit)
     # Documentation writes do not re-arm the nudge: the closeout skills
     # Closeout skills write docs AFTER the final green verify. Relay's JSON is
@@ -141,7 +245,20 @@ case "${MODE}" in
         ;;
     esac
     ;;
-  bash)
+  bash|bash-failure)
+    TK="$(tool_key)" || TK=unknown
+    mkdir -p "${TELEMETRY}/bash_count" "${TELEMETRY}/bash_intervals" 2>/dev/null || true
+    : > "${TELEMETRY}/bash_count/${TK}" 2>/dev/null || true
+    START_MS="$(cat "${TELEMETRY}/bash_start_ms/${TK}" 2>/dev/null || true)"
+    END_MS="$(now_ms || true)"
+    case "${START_MS}:${END_MS}" in
+      *[!0-9:]*|:|*:|*::* ) : ;;
+      *)
+        if [ "${END_MS}" -ge "${START_MS}" ] 2>/dev/null; then
+          printf '%s %s\n' "${START_MS}" "${END_MS}" > "${TELEMETRY}/bash_intervals/${TK}" 2>/dev/null || true
+        fi
+        ;;
+    esac
     CMD="$(pyfield "d.get('tool_input', {}).get('command')")"
     IS_VERIFY=no
     if [ -n "${CMD}" ]; then
@@ -155,15 +272,31 @@ case "${MODE}" in
       fi
     fi
     if [ "${IS_VERIFY}" = yes ]; then
-      # Best-effort red/green from the tool response; unknown shape -> "ran"
-      STATUS="$(pyfield "(lambda r, c=None: (lambda c: 'ok' if c == 0 else ('fail' if isinstance(c, int) else ('fail' if r.get('is_error') is True else 'ran')))(r.get('exit_code', r.get('exitCode'))))(d.get('tool_response') or {})")"
+      mkdir -p "${TELEMETRY}/verify_count" 2>/dev/null || true
+      : > "${TELEMETRY}/verify_count/${TK}" 2>/dev/null || true
+      # Best-effort red/green from the tool response; failure hooks are red.
+      if [ "${MODE}" = bash-failure ]; then
+        STATUS=fail
+      else
+        STATUS="$(pyfield "(lambda r, c=None: (lambda c: 'ok' if c == 0 else ('fail' if isinstance(c, int) else ('fail' if r.get('is_error') is True else 'ran')))(r.get('exit_code', r.get('exitCode'))))(d.get('tool_response') or {})")"
+      fi
       printf '%s\n' "${STATUS:-ran}" > "${STATE}/last_verify"
-      # remember WHICH command produced the state — the strict gate's fast
-      # path trusts a green only when this matches its own command
-      printf '%s\n' "${CMD}" > "${STATE}/last_verify_cmd" 2>/dev/null || true
+      # Keep only an opaque digest for strict-gate equality; raw commands may
+      # contain paths or secrets and must never persist in shared state.
+      printf '%s' "${CMD}" | python3 -c 'import hashlib,sys; print(hashlib.sha256(sys.stdin.buffer.read()).hexdigest())' \
+        > "${STATE}/last_verify_cmd_hash" 2>/dev/null || true
       rm -f "${STATE}/nudged"
     fi
     ;;
+  skill|skill-prompt)
+    if [ "${MODE}" = skill-prompt ]; then
+      EXPANSION_TYPE="$(pyfield "d.get('expansion_type')")"
+      [ "${EXPANSION_TYPE}" = slash_command ] || exit 0
+    fi
+    TK="$(tool_key)" || TK=unknown
+    mkdir -p "${TELEMETRY}/skill_count" 2>/dev/null || true
+    : > "${TELEMETRY}/skill_count/${TK}" 2>/dev/null || true
+    ;;
   stop)
     # Never re-block a continuation that a stop hook itself caused
     ACTIVE="$(pyfield "d.get('stop_hook_active')")"
@@ -178,6 +311,7 @@ case "${MODE}" in
     # break both the fail-open and the never-re-block guarantees.
     JSON_OK="$(printf '%s' "${IN}" | python3 -c 'import json,sys; json.load(sys.stdin); print("yes")' 2>/dev/null || echo no)"
     if [ -n "${STRICT_CMD}" ] && [ "${JSON_OK}" = yes ]; then
+      STRICT_START_MS="$(now_ms || true)"
       OUT="$(python3 -c '
 import os, subprocess, sys
 state, cwd, cmd, timeout = sys.argv[1:5]
@@ -192,13 +326,14 @@ def read(name):
     except OSError:
         return ""
 e, v = m("last_edit"), m("last_verify")
-# Fast path only for a green that THIS command (or a longer invocation of
-# it) produced — a broad-regex green from a mere read of the test file must
+# Fast path only for a green whose command digest exactly matches. A
+# broad-regex green from a mere read of the test file must
 # not disarm a gate whose promise is "actually runs the command".
-vcmd = read("last_verify_cmd")
+vcmd = read("last_verify_cmd_hash")
+cmd_hash = __import__("hashlib").sha256(cmd.encode()).hexdigest()
 if (v is not None and read("last_verify") == "ok"
         and (e is None or e <= v)
-        and (vcmd == cmd or vcmd.startswith(cmd + " "))):
+        and vcmd == cmd_hash):
     print("green"); sys.exit(0)
 try:
     r = subprocess.run(cmd, shell=True, cwd=cwd or None, timeout=float(timeout),
@@ -218,14 +353,18 @@ else:
       case "${OUT%%$'\n'*}" in
         green) stat_log stop-clean; exit 0 ;;
         ok)
+          record_strict_telemetry "${STRICT_START_MS}"
           printf 'ok\n' > "${STATE}/last_verify" 2>/dev/null || true
-          printf '%s\n' "${STRICT_CMD}" > "${STATE}/last_verify_cmd" 2>/dev/null || true
+          printf '%s' "${STRICT_CMD}" | python3 -c 'import hashlib,sys; print(hashlib.sha256(sys.stdin.buffer.read()).hexdigest())' \
+            > "${STATE}/last_verify_cmd_hash" 2>/dev/null || true
           rm -f "${STATE}/nudged"
           stat_log stop-clean
           exit 0 ;;
         red)
+          record_strict_telemetry "${STRICT_START_MS}"
           printf 'fail\n' > "${STATE}/last_verify" 2>/dev/null || true
-          printf '%s\n' "${STRICT_CMD}" > "${STATE}/last_verify_cmd" 2>/dev/null || true
+          printf '%s' "${STRICT_CMD}" | python3 -c 'import hashlib,sys; print(hashlib.sha256(sys.stdin.buffer.read()).hexdigest())' \
+            > "${STATE}/last_verify_cmd_hash" 2>/dev/null || true
           stat_log strict-block
           echo "Strict verify gate: '${STRICT_CMD}' is RED. Fix it before finishing — or say plainly that you are handing back a red state. Failing output:" >&2
           echo "${OUT#red}" >&2

package/claude/luciazero.md

@@ -1,11 +1,11 @@
 # Luciazero — default operating mode
 
-Applies to every repo, every session. The loop is plan → change → verify → fix, repeated until verify passes or the blocker is real.
+Applies to every repo, every session. The loop is plan → change → fastest relevant check → fix; run full verification once at closeout.
 
 ## Ground truth
 
 1. **Done is proven by a command, not by my judgment.** Before saying a change works, run something that returns an exit code — test, lint, type-check, build, or a real invocation — and quote the shortest decisive line of its output. A run that did not happen is reported as exactly that. (closeout procedure: `/done`)
-2. **If no verification command exists, that is the first bug.** Say so and offer to create the smallest one that covers the change (procedure: `/luciazero-bootstrap`). Do not silently proceed on vibes.
+2. **If no verification command exists, that is the first bug.** Say so and offer to create the smallest one that covers the change (procedure: `/ready`). Do not silently proceed on vibes.
 3. **Failing test/lint means not done.** Fix the cause. Never delete, skip, weaken, or suppress a check to reach green — if a check is genuinely wrong, say why and ask.
 
 ## Loop

package/install-codex.sh

@@ -4,7 +4,7 @@
 #
 # Mapping (single source of truth stays in claude/):
 #   claude/luciazero.md        -> marker block in ~/.codex/AGENTS.md
-#   skills/catalog.txt entries           -> ~/.codex/skills/<each>/
+#   skills/catalog.txt + aliases.txt     -> ~/.codex/skills/<each>/
 #   claude/agents/catalog.txt entries     -> ~/.codex/skills/<agent>/SKILL.md
 #                                           (Claude-only `tools:`/`model:` lines dropped)
 #   claude/hooks/ (enforcement pack)     -> NOT installed: Codex has no hooks/statusline
@@ -23,6 +23,10 @@ MANAGED_DIR="${CODEX_DIR}/.luciazero-managed"
 BACKUP_DIR="${CODEX_DIR}/.luciazero-backups"
 
 catalog() { sed '/^[[:space:]]*#/d; /^[[:space:]]*$/d' "$1"; }
+skill_inventory() {
+  catalog "${SRC}/skills/catalog.txt"
+  catalog "${SRC}/skills/aliases.txt"
+}
 
 # collision-proof backup path for $1 (two runs in the same second must not overwrite)
 bakpath() {
@@ -93,7 +97,7 @@ while IFS= read -r SKILL; do
     "${MANAGED_DIR}/skills/${SKILL}" \
     "skills/${SKILL}"
   echo "  ok  skills/${SKILL}"
-done < <(catalog "${SRC}/skills/catalog.txt")
+done < <(skill_inventory)
 
 LEGACY_HANDOFF="${CODEX_DIR}/skills/handoff"
 if [ -f "${LEGACY_HANDOFF}/SKILL.md" ]; then

package/install.sh

@@ -29,6 +29,10 @@ MANAGED_DIR="${CLAUDE_DIR}/.luciazero-managed"
 BACKUP_DIR="${CLAUDE_DIR}/.luciazero-backups"
 
 catalog() { sed '/^[[:space:]]*#/d; /^[[:space:]]*$/d' "$1"; }
+skill_inventory() {
+  catalog "${SRC}/skills/catalog.txt"
+  catalog "${SRC}/skills/aliases.txt"
+}
 
 # newest released version in this checkout's CHANGELOG (informational)
 version_of() {
@@ -50,8 +54,8 @@ if [ "${STATUS_ONLY}" = 1 ]; then
   check -f "${CLAUDE_DIR}/${DOCTRINE}" "doctrine ${DOCTRINE}"
   while IFS= read -r SKILL; do
     check -f "${CLAUDE_DIR}/skills/${SKILL}/SKILL.md" "skill ${SKILL}"
-  done < <(catalog "${SRC}/skills/catalog.txt")
-  check -x "${CLAUDE_DIR}/skills/luciazero-bootstrap/scripts/detect.sh" "detect.sh executable"
+  done < <(skill_inventory)
+  check -x "${CLAUDE_DIR}/skills/ready/scripts/detect.sh" "detect.sh executable"
   check -x "${CLAUDE_DIR}/skills/done/scripts/revert-probe.sh" "revert-probe.sh executable"
   check -x "${CLAUDE_DIR}/skills/bisect/scripts/safe-bisect.sh" "safe-bisect.sh executable"
   check -x "${CLAUDE_DIR}/skills/lucia-relay/scripts/relay.py" "relay.py executable"
@@ -87,12 +91,12 @@ if [ "${STATUS_ONLY}" = 1 ]; then
       fi
     done
     WIRE_MISS=""
-    for SUB in edit bash stop session; do
-      grep -qF "${CLAUDE_DIR}/hooks/luciazero-verify.sh ${SUB}" "${CLAUDE_DIR}/settings.json" 2>/dev/null \
+    for SUB in prompt skill-prompt bash-start edit bash bash-failure skill stop session; do
+      grep -qF "${CLAUDE_DIR}/hooks/luciazero-verify.sh ${SUB}\"" "${CLAUDE_DIR}/settings.json" 2>/dev/null \
         || WIRE_MISS="${WIRE_MISS} ${SUB}"
     done
     if [ -z "${WIRE_MISS}" ]; then
-      echo "  ok    hooks wired in settings.json (edit/bash/stop/session)"
+      echo "  ok    hooks wired in settings.json (prompt/skill-prompt/bash-start/edit/bash/bash-failure/skill/stop/session)"
     else
       echo "  MISS  settings.json missing hook entries:${WIRE_MISS} (re-run ./install.sh --with-hooks)"; STATUS_RC=1
     fi
@@ -187,14 +191,14 @@ install_file "${SRC}/claude/${DOCTRINE}" "${CLAUDE_DIR}/${DOCTRINE}" \
   "${MANAGED_DIR}/${DOCTRINE}" "${DOCTRINE}"
 echo "  ok  ${DOCTRINE}"
 
-# 2. skills — catalog.txt is the single install/status/uninstall inventory
+# 2. canonical skills plus temporary compatibility aliases
 while IFS= read -r SKILL; do
   install_tree "${SRC}/skills/${SKILL}" \
     "${CLAUDE_DIR}/skills/${SKILL}" \
     "${MANAGED_DIR}/skills/${SKILL}" \
     "skills/${SKILL}"
   echo "  ok  skills/${SKILL}"
-done < <(catalog "${SRC}/skills/catalog.txt")
+done < <(skill_inventory)
 
 # v1.5 migration: remove only an untouched Luciazero /handoff. A customized
 # skill is user data and stays in place with an explicit warning.
@@ -290,6 +294,11 @@ def ensure(event, matcher, command):
 
 ensure("PostToolUse", "Edit|Write|NotebookEdit", verify_cmd + " edit")
 ensure("PostToolUse", "Bash", verify_cmd + " bash")
+ensure("PostToolUse", "Skill", verify_cmd + " skill")
+ensure("PostToolUseFailure", "Bash", verify_cmd + " bash-failure")
+ensure("PreToolUse", "Bash", verify_cmd + " bash-start")
+ensure("UserPromptSubmit", None, verify_cmd + " prompt")
+ensure("UserPromptExpansion", None, verify_cmd + " skill-prompt")
 ensure("Stop", None, verify_cmd + " stop")
 ensure("SessionStart", None, verify_cmd + " session")
 
@@ -323,6 +332,7 @@ echo
 SKILL_SUMMARY="$(catalog "${SRC}/skills/catalog.txt" | awk 'BEGIN{s=""} {s=s (s ? ", " : "") "/" $0} END{print s}')"
 AGENT_SUMMARY="$(catalog "${SRC}/claude/agents/catalog.txt" | awk 'BEGIN{s=""} {s=s (s ? ", " : "") $0} END{print s}')"
 echo "Skills: ${SKILL_SUMMARY}. Agents: ${AGENT_SUMMARY}."
+echo "Compatibility alias for one release: /luciazero-bootstrap -> /ready."
 if [ "${WITH_HOOKS}" = 1 ]; then
   echo "Enforcement pack installed: verify-tracking hooks + statusline (see settings.json)."
 else

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "luciazero",
-  "version": "2.0.2",
-  "description": "Verification-first discipline for coding agents (Claude Code + Codex CLI): 9-rule doctrine, 9 skills, risk-routed reviewer, fail-open enforcement hooks. npx luciazero installs it.",
+  "version": "2.1.0",
+  "description": "Verification-first discipline for coding agents (Claude Code + Codex CLI): 9-rule doctrine, 10 skills plus a temporary command alias, risk-routed reviewer, fail-open enforcement hooks. npx luciazero installs it.",
   "repository": { "type": "git", "url": "git+https://github.com/ohm41321/luciazero.git" },
   "homepage": "https://github.com/ohm41321/luciazero#readme",
   "bugs": { "url": "https://github.com/ohm41321/luciazero/issues" },
@@ -10,6 +10,7 @@
   },
   "files": [
     "bin",
+    "agents",
     "claude",
     "skills",
     "migrations",

package/skills/aliases.txt

@@ -0,0 +1,2 @@
+# Temporary compatibility aliases. Remove luciazero-bootstrap after one release.
+luciazero-bootstrap

package/skills/catalog.txt

@@ -1,5 +1,6 @@
 # Canonical install order. Installers, uninstallers, and tests read this file.
-luciazero-bootstrap
+ready
+show
 plan
 debug
 bisect

package/skills/debug/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: debug
-description: Hypothesis-driven debugging procedure. Use when a bug is not yet reliably reproduced, when a fix attempt just failed, when debugging has gone two or more iterations without progress, or when the user asks "why is this failing", "debug this properly", "ไล่บั๊ก". Not for trivial errors whose cause is already visible in the message.
+description: Hypothesis-driven debugging procedure. Use when a bug is not yet reliably reproduced, a fix attempt failed, debugging has gone two or more iterations without progress, or the user asks "debug this properly" or "ไล่บั๊ก". Not for a first obvious failure whose cause is already visible; reproduce and fix it directly.
 ---
 
 # Debug — hypothesis before edit

package/skills/discipline-report/SKILL.md

@@ -11,8 +11,10 @@ Run:
 npx luciazero discipline [--days N] [--project PATH_OR_ID] [--json]
 ```
 
-The report reads `luciazero-stats.log` from the Claude config directory by default. It accepts current schema-versioned JSON lines and legacy space-delimited records, ignores malformed lines without failing, and never sends data over the network.
+The report reads `luciazero-stats.log` from the Claude config directory by default. It accepts current schema-versioned JSON lines and legacy space-delimited records, ignores malformed lines without failing, and never sends data over the network. New enforcement-pack installs also summarize measured turn/Bash wall-clock milliseconds and Bash, verify, and model/user skill invocation counts. Parallel Bash intervals are merged before subtraction. These are aggregates: raw commands and skill names are never persisted.
 
 Treat recorded outcomes as observations, not causes. A `nudge` proves an edit lacked a recognized later verify run; it does not prove why. A `strict-block` proves the configured strict command was red. Recommendations derived from patterns must say `likely` unless the log directly records the cause.
 
+Latency telemetry separates observed Bash time from the rest of the measured turn. The non-Bash remainder can include model reasoning, non-Bash tools, hook overhead, and harness scheduling, so do not label it as model latency without another measurement.
+
 Use `--project .` to filter by the current repository's privacy-preserving project hash, or `--project <display-name-or-id>` for another entry. Use `--json` when feeding a dashboard or `/retro`.

package/skills/done/SKILL.md

@@ -12,7 +12,7 @@ The doctrine says: *done is proven by a command, not by my judgment.* This is th
 Run the **full** tier (`verify-full` if the repo has two tiers, else the verify command). Quote the shortest decisive line of real output.
 
 - Red → you are not here yet. Go back to the loop; do not continue this ritual.
-- No verify command exists → that is the first bug (`/luciazero-bootstrap`). Say so instead of declaring done.
+- No verify command exists → that is the first bug (`/ready`). Say so instead of declaring done.
 - The command must actually have run **now**, in this session — a green from an hour ago proves the past, not the present.
 
 ## 2. Skeptic diff pass

package/skills/done/scripts/revert-probe.sh

@@ -28,7 +28,7 @@ git rev-parse --verify --quiet "${BASE}^{commit}" >/dev/null 2>&1 \
 TOP="$(git rev-parse --show-toplevel 2>/dev/null)" || unassessable "no working tree (bare repo?)"
 cd "${TOP}"
 
-# test-file patterns mirror luciazero-bootstrap's detect.sh: tests-style dirs
+# test-file patterns mirror ready's detect.sh: tests-style dirs
 # plus the common root `test.sh` entrypoint and test_*.*, *_test.*, *.test.*,
 # *.spec.* file names
 is_test_file() {

package/skills/luciazero-bootstrap/SKILL.md

@@ -1,109 +1,10 @@
 ---
 name: luciazero-bootstrap
-description: Make a repository agentic-ready so an agent can run its own plan→change→verify→fix loop without a human checking each step. Use when entering an unfamiliar repo, when the user asks to "set up agentic engineering", "make this repo agent-friendly", "add a verify command", "add smoke tests so you can check your own work", "set up hooks/CLAUDE.md/allowlist" — or when a change was requested but no automated way exists to prove it works.
+description: Compatibility alias for /ready. Use only when the user explicitly invokes /luciazero-bootstrap; tell them it was renamed to /ready, then follow the canonical ready procedure completely.
 ---
 
-# Luciazero Bootstrap
+# Renamed to Ready
 
-Goal: leave the repo with **one command that returns an exit code** and enough guardrails that future agent work self-verifies. Nothing here is language-specific — detect, don't assume.
-
-Bootstrapping is itself work: verify each artifact you add actually runs before reporting it.
-
-## Phase 1 — Detect (never assume)
-
-Run the bundled evidence scan first — it replaces a dozen manual reads with one call:
-
-```
-<this-skill-dir>/scripts/detect.sh <repo-root>
-```
-
-(The skill directory is wherever this SKILL.md lives, e.g. `~/.claude/skills/luciazero-bootstrap/` or `~/.codex/skills/luciazero-bootstrap/`.) The script surfaces candidates — **you still decide**. It cannot parse CI matrices or exotic build systems; open anything it flags and read the CI config yourself.
-
-Sources, in order of trust:
-
-1. CI config — the most honest source of truth: `.github/workflows/*`, `.gitlab-ci.yml`, `.circleci/`. **Whatever CI runs is the verify command.**
-2. Manifests: `package.json` scripts, `pyproject.toml` / `tox.ini` / `noxfile.py`, `Makefile`, `justfile`, `Cargo.toml`, `go.mod`, `build.gradle`, `composer.json`
-3. Repo docs: `README*`, `CONTRIBUTING*`, `AGENTS.md`, `CLAUDE.md`, `docs/` — docs go stale; cross-check any doc-claimed command against CI when CI exists. A docs/CI mismatch is itself a finding to record in Phase 5.
-4. Existing test dirs: `tests/`, `test/`, `spec/`, `__tests__/`, `*_test.*`, `test_*.*`
-
-Report what was found as a short table: run / test / lint / typecheck / build / git repo — command or `MISSING`.
-
-**If the directory is not under version control**, propose `git init` early (ask first — some dirs are deliberately not repos): without git there is no smallest reversible step, no safe break-and-restore in Phase 6, and no bisect.
-
-## Phase 2 — Establish the verify command
-
-If a verify path exists, **use it** — do not invent a parallel one.
-
-If none exists, create the smallest real one. Order of preference:
-
-1. The project's native runner, already installed (`pytest`, `vitest`, `go test`, `cargo test`, `dotnet test`)
-2. A single entrypoint that chains them, matching the repo's existing convention (`Makefile` target, `package.json` script, `justfile` recipe) — e.g. `make verify` running lint then tests
-
-Rules:
-- Must exit non-zero on failure. A script that always exits 0 is worse than nothing.
-- Must run to completion unattended: disable watch/interactive modes (e.g. `CI=1`, `--run`, `--watch=false`) — a command that waits for input or watches files hangs the loop.
-- Must run offline, with no credentials. Anything needing GPU/network/secrets belongs in a separate slow target.
-- Time the suite once (`time <cmd>`); the measurement, not a guess, decides one tier or two.
-- On success, output should be near-silent — prefer quiet flags in the fast tier so failures, not progress spam, fill the context.
-- Add it to the repo's own docs so humans find it too.
-
-**Two tiers when the repo has slow checks.** One `verify` command forces a bad trade: either the loop crawls or coverage gets cut. Split it:
-
-- `verify` — fast (<~60s), offline: lint, typecheck, unit/smoke tests. Run on **every** loop iteration.
-- `verify-full` — everything else: full suite, integration, build, slow checks. Run **before declaring done** and before a PR — "done" means `verify-full` green, not just `verify`.
-
-Name them by the repo's convention (`make verify` / `make verify-full`, npm scripts, just recipes). A small repo whose whole suite runs in seconds needs only the single tier — do not add ceremony it does not need.
-
-**Monorepos:** detect the workspace layout (`package.json` `workspaces`, `pnpm-workspace.yaml`, turbo/nx config, `go.work`, Cargo `[workspace]`). Prefer a repo-owned `verify-changed` target backed by the workspace's native dependency graph; `verify-full` remains the root suite. Never make a global hook guess package mappings from path prefixes. Read [references/smart-verification.md](references/smart-verification.md) before creating the target, and record its base-revision/fallback contract in Phase 5 notes.
-
-**Enforcement pack users (Claude Code, ask first):** if the verify-tracking hooks are active — classic install: `~/.claude/hooks/luciazero-verify.sh` exists; plugin install: the `luciazero` plugin is enabled — offer to record the established command in the repo's *personal* settings so the tracker matches it exactly instead of by broad regex — `.claude/settings.local.json` (gitignored, never committed): `{"env": {"LUCIAZERO_VERIFY_CMD": "<the fast-tier command>"}}`. Derive it from CI (the honest source); it is a cache of that truth, so note it must be updated if CI changes. Show the exact JSON before writing anything.
-
-## Phase 3 — Smoke tests, if there are none
-
-Do **not** attempt coverage. Write 3–6 tests that would catch a catastrophic break. Pick by this heuristic:
-
-- **Contract shape** — the core data structure in/out: dimensions, keys, types, no NaN/null where impossible
-- **Round trip** — serialize→deserialize, encode→decode, save→load returns equal
-- **Import/boot** — every package imports, the app answers one request, the CLI runs `--help`. Prefer the framework's test client over binding a real port; any test that starts a process needs a hard timeout and must kill what it started.
-- **Artifact loads** — trained model / migration / config parses and does one forward pass or one query
-- **The bug you were sent to fix** — a regression test reproducing it, written *before* the fix
-
-Use fixtures small enough to commit. Never depend on the user's real data paths.
-
-State plainly that these are smoke tests, not a suite.
-
-## Phase 4 — Guardrails (only ones that pay for themselves)
-
-Hooks, `.claude/settings.json`, and `/fewer-permission-prompts` are **Claude Code mechanisms**. On a harness without them (Codex CLI), skip the hook items and encode the same guardrails as instructions in the project's `AGENTS.md` instead: which files are untouchable, which derived file must be regenerated after editing which source.
-
-Prefer few and deterministic. Candidates, in value order:
-
-- **Auto-format/lint on write** — `PostToolUse` hook matching `Edit|Write`, running the repo's own formatter. Only if the repo already has one configured.
-- **Regenerate derived files** — if editing source X requires regenerating Y (protobuf, OpenAPI clients, migrations, lockfiles), hook it, scoped inside the command to the relevant paths. This is the highest-value hook in most repos because humans forget it.
-- **Protect the untouchables** — `PreToolUse` deny on production config, secrets, live model/deploy pointers.
-- **Permission allowlist** — put the repo's read-only and verify commands into `.claude/settings.json` so the loop is not interrupted. `/fewer-permission-prompts` derives this from real transcripts.
-
-Put project-scoped settings in the repo's `.claude/settings.json` (shared) or `.claude/settings.local.json` (personal, gitignored) — **not** in global settings.
-
-Hooks execute automatically on the user's machine. Show the exact command before installing it, and never install one that pushes, deploys, deletes, or writes outside the repo.
-
-## Phase 5 — Project notes file (`CLAUDE.md` / `AGENTS.md`)
-
-Extend the notes file the repo already uses; if neither exists, create the one matching the current harness and add a one-line pointer from the other name so both find it. Write only what reading the code cannot tell you:
-
-- How to run / test / verify — the commands from Phase 2
-- Architecture facts that are load-bearing and non-obvious (what serves what, which file is source of truth)
-- **Footguns and null results**: "X looks right but breaks Y", "tried A, measured no gain, do not retry", "always rebuild Z after W"
-- Where the real docs live
-
-Do not restate the directory tree, git history, or anything a `grep` answers. Keep it dense; every line costs context on every future session.
-
-## Phase 6 — Prove it and report
-
-1. **Flake check** — run the fast verify tier twice. A green that does not repeat is a flake, and a flaky verify makes every future red ambiguous; fixing or quarantining the flake comes before relying on the loop. (Skip the double run only when the repo has a single slow tier — say so.)
-2. **Red check** — break a line a smoke test actually covers (flip an expected value or a return), confirm verify goes red, then restore. The break is one deliberate edit: **record file, line, and original text before making it, and restore by reverting exactly that edit.** Only use `git checkout -- <file>` if the file was committed before the break — on a file carrying uncommitted work it silently discards that work too, and it cannot restore the untracked test files this skill just wrote. Never use bare `git stash` here (it sweeps the whole tree and skips untracked files). Breaking an uncovered line and staying green proves nothing. A verify command that cannot fail is not a verify command.
-
-Report:
-- The one command to run (both tiers if split)
-- What it does and does not cover
-- What was added, and what was deliberately left out
+Tell the user `/luciazero-bootstrap` is deprecated and renamed to `/ready`.
+Then read `../ready/SKILL.md` and follow that procedure completely, resolving
+its relative resource paths from `../ready/`.

package/skills/plan/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: plan
-description: Build a verification-first implementation plan for new features, major refactors, ambiguous work, or any multi-step change whose acceptance criteria are not yet falsifiable. Use when the user asks for a plan or before risky work; request approval only when ambiguity, high stakes, destructive action, a public-contract choice, or a scope change requires it.
+description: Build a verification-first implementation plan for new features, major refactors, ambiguous work, or risky multi-module changes whose acceptance criteria are not yet falsifiable. Use when the user asks for a plan or material choices remain. Not for routine edits whose scope and proof are already clear.
 ---
 
 # Plan — make the change falsifiable