luciazero 2.0.3 → 2.1.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ Versioning: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [2.1.0] - 2026-08-15
+
+### Added
+
+- `/show` turns code relationships, structural changes, and verification
+  evidence into the smallest useful traceable visual.
+- `./test.sh --fast` provides a measured intermediate tier while the default
+  and `--full` preserve complete CI/closeout coverage.
+- Opt-in Claude hooks use private per-session scratch state to record
+  privacy-preserving aggregate turn/merged-Bash wall time and Bash, failed or
+  successful verify, and model/user skill counts; `luciazero discipline`
+  summarizes them.
+
+### Changed
+
+- `/luciazero-bootstrap` is now `/ready`. The old command remains as a
+  deprecated compatibility alias for one release.
+- The doctrine reserves full verification for closeout, and `/plan` plus
+  `/debug` no longer auto-trigger for routine edits or first obvious failures.
+
 ## [2.0.3] - 2026-08-13
 
 ### Fixed

package/README.md

@@ -16,7 +16,7 @@ of handing back work they merely believe is finished.
 > Done is proven by a command, not by my judgment. If no verification command
 > exists, that is the first bug.
 
-It ships a compact [9-rule doctrine](claude/luciazero.md), 9 on-demand skills,
+It ships a compact [9-rule doctrine](claude/luciazero.md), 10 on-demand skills,
 verification hooks, a risk-routed reviewer, and an eval harness. It is a
 discipline layer, not an agent runtime or overnight orchestrator.
 
@@ -83,7 +83,7 @@ Carries the doctrine, all skills, reviewer, and verify-tracking hooks:
 /plugin install luciazero@luciazero
 ```
 
-Start a repository with `/luciazero:luciazero-bootstrap`. Plugin skills use the
+Start a repository with `/luciazero:ready`. Plugin skills use the
 `/luciazero:` prefix. The plugin has no statusline because Claude Code plugins
 cannot set one.
 
@@ -93,7 +93,8 @@ cannot set one.
 npx skills add ohm41321/luciazero
 ```
 
-This installs the 9 skills only: no doctrine, reviewer, or hooks.
+This installs the 10 skills plus the temporary `/luciazero-bootstrap`
+compatibility alias: no doctrine, reviewer, or hooks.
 
 ### Classic Claude Code and Codex
 
@@ -140,14 +141,15 @@ Claude Code can auto-update the plugin at startup: open `/plugin` →
 marketplaces leave this off by default. For release-only notifications, use
 GitHub **Watch → Custom → Releases**.
 
-## The 9 skills
+## The 10 skills
 
-Run `/luciazero-bootstrap` first; the rest activate when their moment arrives.
+Run `/ready` first; the rest activate when their moment arrives.
 
 | Moment | Skill | Result |
 |---|---|---|
-| Entering a repository | `/luciazero-bootstrap` | Finds or creates a verify command and proves it can fail |
-| Before risky or multi-step work | `/plan` | Fixes scope and observable acceptance evidence |
+| Entering a repository | `/ready` | Finds or creates a verify command and proves it can fail |
+| Structure or evidence is hard to scan | `/show` | Maps connections, changes, and proof into the smallest useful visual |
+| Before risky, ambiguous, or multi-module work | `/plan` | Fixes scope and observable acceptance evidence |
 | A bug survives the first look | `/debug` | Reproduction, hypothesis ledger, regression test |
 | Good and bad revisions are known | `/bisect` | Finds the first bad commit in a temporary worktree |
 | Before claiming completion | `/done` | Full verify, skeptic review, scope report |
@@ -205,6 +207,9 @@ only one run per arm per task. See the [full benchmark](docs/benchmark.md),
 - Core installers, hooks, helpers, and graders are offline. Real behavioral
   evals invoke a model CLI and consume API credit or subscription quota.
 - Hooks run commands on your machine. Read them before enabling them.
+- Hook telemetry stays local in private per-session state and records aggregate
+  turn/Bash wall time plus Bash, verify, and model/user skill counts—never raw
+  commands, skill names, or paths.
 - Set `LUCIAZERO_VERIFY_CMD` to the repo's exact fast verify command.
 - Put `LUCIAZERO_STRICT_VERIFY_CMD` only in personal settings, never in a
   committed repository config. Strict mode fails open on internal errors.
@@ -214,12 +219,16 @@ See [SECURITY.md](SECURITY.md) for the complete trust boundary.
 ## Development
 
 ```bash
-./test.sh
+./test.sh --fast   # intermediate loop: core doctrine/hooks/report/Relay checks
+./test.sh          # closeout/CI: full eval, packaging, and install coverage
 ```
 
-The suite covers scripts, hook state, Relay, bisect, plugin/npm manifests,
-self-proving eval graders, and sandboxed install → reinstall → uninstall for
-Claude Code and Codex.
+The fast tier is the default intermediate check for this repository; use a
+more targeted command when changing a component it does not cover. The default
+full tier (also `./test.sh --full`) covers scripts, hook state, Relay, bisect,
+plugin/npm manifests, self-proving eval graders, and sandboxed install →
+reinstall → uninstall for Claude Code and Codex. CI and `/done` use the full
+tier.
 
 More detail:
 

package/README.th.md

@@ -17,7 +17,7 @@ Luciazero ทำให้ coding agent รันลูป `วางแผน
 > ถ้ายังไม่มีคำสั่งตรวจ นั่นคือบั๊กแรก
 
 ภายในมี [doctrine 9 ข้อ](claude/luciazero.md) ที่สั้น, skill แบบเรียกเมื่อจำเป็น
-9 ตัว, hook ติดตามการ verify, reviewer ที่ route ตามความเสี่ยง และ eval harness
+10 ตัว, hook ติดตามการ verify, reviewer ที่ route ตามความเสี่ยง และ eval harness
 นี่คือชั้นวินัย ไม่ใช่ agent runtime หรือระบบ orchestration สำหรับรันงานข้ามคืน
 
 ## ดูการทำงานใน 15 วินาที
@@ -81,7 +81,7 @@ fingerprint เก่า (5/6) ตัวเลขเหล่านี้เป
 /plugin install luciazero@luciazero
 ```
 
-เริ่ม repo ด้วย `/luciazero:luciazero-bootstrap` ชื่อ skill แบบ plugin มี prefix
+เริ่ม repo ด้วย `/luciazero:ready` ชื่อ skill แบบ plugin มี prefix
 `/luciazero:` และไม่มี statusline เพราะ Claude Code plugin ตั้งค่านี้ไม่ได้
 
 ### เฉพาะ skill — agent ที่รองรับ
@@ -90,7 +90,8 @@ fingerprint เก่า (5/6) ตัวเลขเหล่านี้เป
 npx skills add ohm41321/luciazero
 ```
 
-ช่องทางนี้ติดตั้งเฉพาะ skill 9 ตัว ไม่มี doctrine, reviewer หรือ hook
+ช่องทางนี้ติดตั้งเฉพาะ skill 10 ตัว พร้อม alias `/luciazero-bootstrap`
+ชั่วคราว ไม่มี doctrine, reviewer หรือ hook
 
 ### Classic Claude Code และ Codex
 
@@ -136,14 +137,15 @@ Claude Code อัปเดต plugin ตอนเริ่มโปรแกร
 ภายนอกจะปิดตัวเลือกนี้เป็นค่าเริ่มต้น ถ้าต้องการเพียงการแจ้งเตือน release ให้ใช้
 GitHub **Watch → Custom → Releases**
 
-## Skill ทั้ง 9 ตัว
+## Skill ทั้ง 10 ตัว
 
-รัน `/luciazero-bootstrap` ก่อนหนึ่งครั้ง ที่เหลือใช้เมื่อถึงจังหวะของมัน
+รัน `/ready` ก่อนหนึ่งครั้ง ที่เหลือใช้เมื่อถึงจังหวะของมัน
 
 | จังหวะ | Skill | ผลลัพธ์ |
 |---|---|---|
-| เข้า repository | `/luciazero-bootstrap` | หาหรือสร้างคำสั่ง verify และพิสูจน์ว่าแดงได้ |
-| ก่อนงานเสี่ยงหรือหลายขั้น | `/plan` | ล็อก scope และหลักฐานยอมรับที่สังเกตได้ |
+| เข้า repository | `/ready` | หาหรือสร้างคำสั่ง verify และพิสูจน์ว่าแดงได้ |
+| โครงสร้างหรือหลักฐานไล่อ่านยาก | `/show` | แสดงความเชื่อมโยง สิ่งที่เปลี่ยน และหลักฐานด้วยภาพที่เล็กที่สุด |
+| ก่อนงานเสี่ยง กำกวม หรือแตะหลาย module | `/plan` | ล็อก scope และหลักฐานยอมรับที่สังเกตได้ |
 | บั๊กที่มองรอบแรกไม่ออก | `/debug` | Reproduction, hypothesis ledger, regression test |
 | รู้ revision ดีและเสีย | `/bisect` | หา first bad commit ใน worktree ชั่วคราว |
 | ก่อนบอกว่าเสร็จ | `/done` | Full verify, skeptic review และรายงาน scope |
@@ -200,6 +202,9 @@ pilot มีเพียง 1 run ต่อ arm ต่อ task ดู [ผลเ
 - Installer, hook, helper และ grader หลักรัน offline ส่วน behavioral eval จริง
   เรียก model CLI และใช้เครดิต API หรือโควตา subscription
 - Hook รันคำสั่งบนเครื่อง ควรอ่านก่อนเปิดใช้
+- Telemetry ของ hook อยู่ใน private state แยกตาม session ภายในเครื่อง เก็บเวลา
+  wall time ของ turn/Bash และจำนวน Bash, verify, skill ที่ model/user เรียก
+  โดยไม่เก็บ command, ชื่อ skill หรือ path ดิบ
 - ตั้ง `LUCIAZERO_VERIFY_CMD` เป็นคำสั่ง verify ระดับเร็วที่ exact ของ repo
 - ใส่ `LUCIAZERO_STRICT_VERIFY_CMD` ใน personal settings เท่านั้น ห้าม commit ลง
   config ของ repository; strict mode จะ fail open เมื่อเกิด internal error
@@ -209,12 +214,15 @@ pilot มีเพียง 1 run ต่อ arm ต่อ task ดู [ผลเ
 ## พัฒนา repo นี้
 
 ```bash
-./test.sh
+./test.sh --fast   # loop ระหว่างทำ: ตรวจ doctrine/hook/report/Relay ส่วนหลัก
+./test.sh          # ปิดงาน/CI: ตรวจ eval, packaging และ install แบบเต็ม
 ```
 
-ชุดทดสอบครอบคลุม script, state ของ hook, Relay, bisect, manifest ของ plugin/npm,
-eval grader ที่พิสูจน์ตัวเองได้ และ install → reinstall → uninstall แบบ sandbox
-ทั้ง Claude Code และ Codex
+fast tier เป็นคำสั่งระหว่างทำงานของ repo นี้; ถ้าแก้ส่วนที่ fast tier ไม่ครอบคลุม
+ให้ใช้คำสั่ง targeted ของส่วนนั้น ส่วน full tier (`./test.sh` หรือ
+`./test.sh --full`) ครอบคลุม script, state ของ hook, Relay, bisect, manifest ของ
+plugin/npm, eval grader ที่พิสูจน์ตัวเองได้ และ install → reinstall → uninstall
+แบบ sandbox ทั้ง Claude Code และ Codex โดย CI และ `/done` ใช้ full tier
 
 อ่านต่อ:
 

package/bin/discipline-report.js

@@ -56,12 +56,20 @@ function parseLine(line) {
     if (Number.isNaN(timestamp.valueOf()) || typeof row.project_id !== "string" || typeof row.project !== "string") {
       return { malformed: true };
     }
+    let telemetry = null;
+    if (row.telemetry && typeof row.telemetry === "object") {
+      const keys = ["turn_ms", "bash_ms", "bash_count", "verify_count", "skill_count"];
+      if (keys.every((key) => Number.isSafeInteger(row.telemetry[key]) && row.telemetry[key] >= 0)) {
+        telemetry = Object.fromEntries(keys.map((key) => [key, row.telemetry[key]]));
+      }
+    }
     return {
       timestamp,
       event: row.event,
       project: row.project,
       projectId: row.project_id,
       verifyMode: ["regex", "exact", "strict"].includes(row.verify_mode) ? row.verify_mode : "unknown",
+      telemetry,
       legacy: false,
     };
   }
@@ -75,6 +83,7 @@ function parseLine(line) {
     project: match[3],
     projectId: `legacy-${crypto.createHash("sha256").update(match[3]).digest("hex").slice(0, 12)}`,
     verifyMode: "unknown",
+    telemetry: null,
     legacy: true,
   };
 }
@@ -111,10 +120,23 @@ if (options.project) {
 
 const counts = { "stop-clean": 0, nudge: 0, "strict-block": 0 };
 const modes = { regex: 0, exact: 0, strict: 0, unknown: 0 };
+const telemetry = {
+  measured_turns: 0, turn_ms: 0, bash_ms: 0, non_bash_ms: 0,
+  bash_count: 0, verify_count: 0, skill_count: 0,
+};
 const projects = new Map();
 for (const row of rows) {
   counts[row.event] += 1;
   modes[row.verifyMode] = (modes[row.verifyMode] || 0) + 1;
+  if (row.telemetry) {
+    telemetry.measured_turns += 1;
+    telemetry.turn_ms += row.telemetry.turn_ms;
+    telemetry.bash_ms += row.telemetry.bash_ms;
+    telemetry.non_bash_ms += Math.max(0, row.telemetry.turn_ms - row.telemetry.bash_ms);
+    telemetry.bash_count += row.telemetry.bash_count;
+    telemetry.verify_count += row.telemetry.verify_count;
+    telemetry.skill_count += row.telemetry.skill_count;
+  }
   const current = projects.get(row.projectId) || {
     project: row.project,
     project_id: row.projectId,
@@ -160,6 +182,7 @@ const report = {
   legacy_records: legacyRecords,
   outcomes: counts,
   verify_modes: modes,
+  telemetry,
   top_nudged_projects: topNudged,
   recommendations,
 };
@@ -182,6 +205,18 @@ console.log(`  Clean stops:   ${String(counts["stop-clean"]).padStart(5)} (${per
 console.log(`  Nudges:        ${String(counts.nudge).padStart(5)} (${percent(counts.nudge)})`);
 console.log(`  Strict blocks: ${String(counts["strict-block"]).padStart(5)} (${percent(counts["strict-block"])})`);
 console.log("");
+console.log("Latency Telemetry:");
+if (telemetry.measured_turns === 0) {
+  console.log("  No measured turns (new hooks collect this locally).");
+} else {
+  const average = (value) => Math.round(value / telemetry.measured_turns);
+  console.log(`  Measured turns:    ${telemetry.measured_turns}`);
+  console.log(`  Average turn:      ${average(telemetry.turn_ms)} ms`);
+  console.log(`  Average Bash time: ${average(telemetry.bash_ms)} ms`);
+  console.log(`  Average non-Bash:  ${average(telemetry.non_bash_ms)} ms`);
+  console.log(`  Bash / verify / skill calls: ${telemetry.bash_count} / ${telemetry.verify_count} / ${telemetry.skill_count}`);
+}
+console.log("");
 console.log("Top Nudged Repositories:");
 if (topNudged.length === 0) console.log("  None in the selected period.");
 for (const [index, item] of topNudged.entries()) {

package/claude/hooks/hooks.json

@@ -1,5 +1,27 @@
 {
   "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          { "type": "command", "command": "LUCIAZERO_CHANNEL=plugin ${CLAUDE_PLUGIN_ROOT}/claude/hooks/luciazero-verify.sh prompt" }
+        ]
+      }
+    ],
+    "UserPromptExpansion": [
+      {
+        "hooks": [
+          { "type": "command", "command": "LUCIAZERO_CHANNEL=plugin ${CLAUDE_PLUGIN_ROOT}/claude/hooks/luciazero-verify.sh skill-prompt" }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          { "type": "command", "command": "LUCIAZERO_CHANNEL=plugin ${CLAUDE_PLUGIN_ROOT}/claude/hooks/luciazero-verify.sh bash-start" }
+        ]
+      }
+    ],
     "PostToolUse": [
       {
         "matcher": "Edit|Write|NotebookEdit",
@@ -12,6 +34,20 @@
         "hooks": [
           { "type": "command", "command": "LUCIAZERO_CHANNEL=plugin ${CLAUDE_PLUGIN_ROOT}/claude/hooks/luciazero-verify.sh bash" }
         ]
+      },
+      {
+        "matcher": "Skill",
+        "hooks": [
+          { "type": "command", "command": "LUCIAZERO_CHANNEL=plugin ${CLAUDE_PLUGIN_ROOT}/claude/hooks/luciazero-verify.sh skill" }
+        ]
+      }
+    ],
+    "PostToolUseFailure": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          { "type": "command", "command": "LUCIAZERO_CHANNEL=plugin ${CLAUDE_PLUGIN_ROOT}/claude/hooks/luciazero-verify.sh bash-failure" }
+        ]
       }
     ],
     "Stop": [

package/claude/hooks/luciazero-statusline.sh

@@ -16,7 +16,7 @@ set -u
 IN="$(cat 2>/dev/null || true)"
 
 LINE="$(printf '%s' "${IN}" | python3 -c '
-import json, os, sys, time, hashlib
+import json, os, sys, time, hashlib, stat
 
 try:
     d = json.load(sys.stdin)
@@ -27,9 +27,24 @@ model = ((d.get("model") or {}).get("display_name")) or "claude"
 cwd = ((d.get("workspace") or {}).get("current_dir")) or d.get("cwd") or os.getcwd()
 
 key = hashlib.md5(cwd.encode()).hexdigest()[:12]
-state = os.path.join(os.environ.get("TMPDIR", "/tmp"), "luciazero-verify-state", key)
+uid = os.getuid() if hasattr(os, "getuid") else "unknown"
+base = os.path.join(os.environ.get("TMPDIR", "/tmp"), f"luciazero-verify-state-{uid}")
+try:
+    info = os.lstat(base)
+    if stat.S_ISLNK(info.st_mode) or not stat.S_ISDIR(info.st_mode):
+        raise OSError("unsafe state base")
+    if hasattr(os, "getuid") and info.st_uid != os.getuid():
+        raise OSError("wrong state owner")
+    if stat.S_IMODE(info.st_mode) & 0o077:
+        raise OSError("state base is not private")
+except OSError:
+    state = None
+else:
+    state = os.path.join(base, key)
 
 def mtime(name):
+    if state is None:
+        return None
     try:
         return os.path.getmtime(os.path.join(state, name))
     except OSError:

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.3",
-  "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" },

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

package/skills/ready/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: ready
+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.
+---
+
+# 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/ready/` or `~/.codex/skills/ready/`.) 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

package/skills/{luciazero-bootstrap → ready}/scripts/detect.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Read-only evidence scan for luciazero-bootstrap Phase 1.
+# Read-only evidence scan for ready Phase 1.
 # Prints what exists in a repo — docs, manifests, script/target names, CI run
 # lines, test dirs, workspace markers. It surfaces candidates only; it never
 # picks the verify command. Judgment stays with the agent.

package/skills/show/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: show
+description: Turn code structure, changes, and verification evidence into the smallest useful visual. Use when the user invokes /show, asks what connects to what, what changed, how a flow works, or what proves a result; use for compact pseudocode, call or component trees, file maps, structural diffs, Mermaid diagrams, and evidence maps, with focused HTML only when simpler forms cannot carry the information.
+---
+
+# Show — make the evidence visible
+
+Answer three questions at a glance:
+
+1. What connects to what?
+2. What changed?
+3. What proves it?
+
+Build an evidence view, not a decorative diagram. The view summarizes reality;
+source files, diffs, and command results remain the ground truth.
+
+## 1. Set the focus
+
+Use the user's question and current task context as the input. Do not ask for
+details that can be discovered from the repository. Narrow broad requests to
+the smallest boundary that answers the question, and state that boundary.
+
+Gather only the relevant evidence:
+
+- definitions, callers, consumers, configuration, and ownership;
+- the current diff or before/after revisions;
+- verification command, exit code, shortest decisive output, and coverage gaps.
+
+Never expose private chain-of-thought. Show observable structure, evidence, and
+concise conclusions instead.
+
+## 2. Normalize the evidence
+
+Reduce what was found to five kinds of information:
+
+- **Entities** — files, functions, components, services, states, or commands;
+- **Relations** — calls, owns, reads, writes, emits, depends on, or verifies;
+- **Changes** — added, removed, or modified entities and relations;
+- **Proof** — commands and observations that confirm or refute a claim;
+- **Gaps** — unknown, inferred, or unverified parts.
+
+Label inference as `? inferred`; never draw a guessed edge as fact.
+
+## 3. Choose the smallest useful view
+
+Prefer the first form that carries the relationship clearly:
+
+| Question | View |
+|---|---|
+| What does this logic decide? | Compact pseudocode |
+| Who calls what at runtime? | Call tree |
+| Who owns or contains what? | Component or shallow file tree |
+| How do 3+ parts exchange control or data? | Mermaid flow or sequence |
+| What changed structurally? | Before/after structural diff |
+| Why is this considered complete? | Requirement-to-proof evidence map |
+| Is prose already clearer? | One sentence or a short list; draw nothing |
+
+Use one primary view. Add a second only when it answers a different question.
+Use focused HTML only for dense UI, layout, or interactive state that text and
+Mermaid cannot show clearly. Keep HTML temporary unless the user asks to keep
+it, and open it only when the harness and user permissions allow.
+
+## 4. Render with a stable grammar
+
+Use these marks consistently in text views:
+
+```text
+A --> B              calls or moves data to
+A --owns--> B        named relationship
++ item               added
+- item               removed
+~ item               changed
+[+] proven           verification passed
+[x] disproven        verification failed
+[?] unknown          not verified
+[path/to/file:line]  source pointer
+```
+
+Keep labels concrete and short. Omit unrelated files, helper calls, props,
+states, and branches. A reader should not need a legend beyond the grammar
+above.
+
+For Mermaid, keep node IDs simple, quote labels containing punctuation, and
+put source pointers outside the diagram when they would make nodes noisy.
+
+## 5. Attach evidence
+
+Every important node or edge must be traceable to at least one of:
+
+- `path/to/file:line` for source structure;
+- a diff hunk or revision for a change;
+- an exact command, exit code, and shortest decisive output for proof.
+
+Do not use a green-looking diagram as verification. If no command ran, write
+`not run`. If a check does not cover a shown claim, mark that claim `[?]` and
+name the missing coverage. Failed proof remains visible as `[x]`; do not hide it
+to make the view look complete.
+
+## Output contract
+
+Return, in this order:
+
+1. **Answer** — one or two sentences naming the focus and conclusion.
+2. **View** — the smallest useful visual.
+3. **Sources** — compact file/line or revision pointers.
+4. **Proof** — command, exit code, and decisive output; or `not run`.
+5. **Unknowns** — uncovered or inferred parts; omit only when there are none.
+
+For a completed change, an evidence map may look like:
+
+```text
+request
+  --> ~ skills/catalog.txt
+  --> + skills/show/SKILL.md
+  --> ~ README.md / README.th.md
+        |
+        +--verified by--> [+] ./test.sh (exit 0)
+                           `PASS  all checks green`
+
+[?] Real invocation in a fresh agent session was not exercised.
+```
+
+## Fit into the Luciazero loop
+
+- With `/ready`, show the path from CI to the repository verify command.
+- With `/plan`, show the proposed before/after boundary and acceptance proof.
+- With `/debug`, show hypothesis → observation → conclusion without replacing
+  the reproduction or hypothesis ledger.
+- With `/done`, show requirement → changed artifact → verification evidence.
+- With `/lucia-relay`, show current state → next action → blocker.
+
+The lifecycle skill owns the work and verification. `/show` only makes its
+structure and evidence easier to inspect.

package/skills/show/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Show"
+  short_description: "Map code changes and proof visually"
+  default_prompt: "Use $show to map what connects, what changed, and what proves it."

package/uninstall-codex.sh

@@ -14,6 +14,10 @@ END='<!-- luciazero:end -->'
 MANAGED_DIR="${CODEX_DIR}/.luciazero-managed"
 
 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() {
@@ -48,7 +52,7 @@ rm -f "${CODEX_DIR}/.luciazero-version"
 while IFS= read -r SKILL; do
   remove_managed_tree "${CODEX_DIR}/skills/${SKILL}" \
     "${MANAGED_DIR}/skills/${SKILL}" "${SRC}/skills/${SKILL}" "skills/${SKILL}"
-done < <(catalog "${SRC}/skills/catalog.txt")
+done < <(skill_inventory)
 
 AGENT_STAGE_ROOT="$(mktemp -d)"
 trap 'rm -rf "${AGENT_STAGE_ROOT}"' EXIT

package/uninstall.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Remove the Luciazero doctrine + bootstrap skill from ~/.claude/
+# Remove the Luciazero doctrine + skills from ~/.claude/
 set -euo pipefail
 
 for ARG in "$@"; do
@@ -14,6 +14,10 @@ GLOBAL_MD="${CLAUDE_DIR}/CLAUDE.md"
 MANAGED_DIR="${CLAUDE_DIR}/.luciazero-managed"
 
 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() {
@@ -66,7 +70,7 @@ rm -f "${CLAUDE_DIR}/.luciazero-version"
 while IFS= read -r SKILL; do
   remove_managed_tree "${CLAUDE_DIR}/skills/${SKILL}" \
     "${MANAGED_DIR}/skills/${SKILL}" "${SRC}/skills/${SKILL}" "skills/${SKILL}"
-done < <(catalog "${SRC}/skills/catalog.txt")
+done < <(skill_inventory)
 
 while IFS= read -r AGENT_NAME; do
   remove_managed_file "${CLAUDE_DIR}/agents/${AGENT_NAME}.md" \