luciazero 2.0.3 → 2.2.0

package/CHANGELOG.md

@@ -7,6 +7,34 @@ Versioning: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [2.2.0] - 2026-08-15
+
+### Added
+
+- `/imouto-mode` adds Lucia's optional warm, lightly tsundere younger-sister
+  coding voice. It is explicit-only, off by default, invocation-scoped, and
+  keeps technical work, safety, and verification ahead of persona.
+
+## [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), 11 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 11 skills plus the temporary `/luciazero-bootstrap`
+compatibility alias: no doctrine, reviewer, or hooks.
 
 ### Classic Claude Code and Codex
 
@@ -140,14 +141,16 @@ 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 11 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 |
+| Want Lucia's optional coding voice | `/imouto-mode focus` | Adds a warm, lightly tsundere sibling voice; explicit-only and off by default |
+| 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 |
@@ -156,6 +159,11 @@ Run `/luciazero-bootstrap` first; the rest activate when their moment arrives.
 | Reviewing local verify habits | `/discipline-report` | Time/project-filtered local outcome report |
 | After difficult work | `/retro` | Stores reusable lessons and disproved approaches |
 
+`/imouto-mode` never activates itself. Use `focus` (recommended), `on`, or
+`off`; the mode applies only to that invocation, writes no config, and leaves
+technical evidence plain. Plugin users invoke `/luciazero:imouto-mode focus`;
+Codex users invoke `$imouto-mode focus`.
+
 Risky diffs also pass through one read-only `reviewer` with `security`,
 `contract`, or `general` focus. Security and contract risk together receive two
 separate passes.
@@ -205,6 +213,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 +225,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
+11 ตัว, 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 11 ตัว พร้อม alias `/luciazero-bootstrap`
+ชั่วคราว ไม่มี doctrine, reviewer หรือ hook
 
 ### Classic Claude Code และ Codex
 
@@ -136,14 +137,16 @@ Claude Code อัปเดต plugin ตอนเริ่มโปรแกร
 ภายนอกจะปิดตัวเลือกนี้เป็นค่าเริ่มต้น ถ้าต้องการเพียงการแจ้งเตือน release ให้ใช้
 GitHub **Watch → Custom → Releases**
 
-## Skill ทั้ง 9 ตัว
+## Skill ทั้ง 11 ตัว
 
-รัน `/luciazero-bootstrap` ก่อนหนึ่งครั้ง ที่เหลือใช้เมื่อถึงจังหวะของมัน
+รัน `/ready` ก่อนหนึ่งครั้ง ที่เหลือใช้เมื่อถึงจังหวะของมัน
 
 | จังหวะ | Skill | ผลลัพธ์ |
 |---|---|---|
-| เข้า repository | `/luciazero-bootstrap` | หาหรือสร้างคำสั่ง verify และพิสูจน์ว่าแดงได้ |
-| ก่อนงานเสี่ยงหรือหลายขั้น | `/plan` | ล็อก scope และหลักฐานยอมรับที่สังเกตได้ |
+| เข้า repository | `/ready` | หาหรือสร้างคำสั่ง verify และพิสูจน์ว่าแดงได้ |
+| โครงสร้างหรือหลักฐานไล่อ่านยาก | `/show` | แสดงความเชื่อมโยง สิ่งที่เปลี่ยน และหลักฐานด้วยภาพที่เล็กที่สุด |
+| อยากได้เสียงพูดแบบลูเซียระหว่างเขียนโค้ด | `/imouto-mode focus` | เพิ่มน้ำเสียงน้องสาวซึนเดเระแบบอ่อน ๆ; ต้องเปิดเองและค่าเริ่มต้นปิด |
+| ก่อนงานเสี่ยง กำกวม หรือแตะหลาย module | `/plan` | ล็อก scope และหลักฐานยอมรับที่สังเกตได้ |
 | บั๊กที่มองรอบแรกไม่ออก | `/debug` | Reproduction, hypothesis ledger, regression test |
 | รู้ revision ดีและเสีย | `/bisect` | หา first bad commit ใน worktree ชั่วคราว |
 | ก่อนบอกว่าเสร็จ | `/done` | Full verify, skeptic review และรายงาน scope |
@@ -152,6 +155,11 @@ GitHub **Watch → Custom → Releases**
 | ดูนิสัยการ verify ในเครื่อง | `/discipline-report` | รายงาน outcome กรองตามเวลา/โปรเจกต์ |
 | หลังงานยาก | `/retro` | เก็บบทเรียนและแนวทางที่พิสูจน์แล้วว่าไม่เวิร์ก |
 
+`/imouto-mode` จะไม่เปิดตัวเอง ใช้ `focus` (แนะนำ), `on` หรือ `off` โดยโหมดมีผล
+เฉพาะ invocation นั้น ไม่เขียน config และหลักฐานทางเทคนิคจะใช้ภาษาตรงเสมอ
+ผู้ใช้ plugin เรียก `/luciazero:imouto-mode focus`; ผู้ใช้ Codex เรียก
+`$imouto-mode focus`
+
 Diff เสี่ยงจะผ่าน `reviewer` แบบอ่านอย่างเดียวใน focus `security`, `contract`
 หรือ `general` ถ้าเสี่ยงทั้ง security และ contract จะตรวจแยกสองรอบ
 
@@ -200,6 +208,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 +220,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