continuous-improvement 3.9.2 → 3.11.0

package/commands/audit.md

@@ -0,0 +1,34 @@
+---
+name: audit
+description: Audit a window of recent commits for real defects, confirm each finding before fixing, verify every surface a fix touches, then report confirmed/dismissed/no-op with evidence. Enforces Law 4 (Verify Before Reporting).
+---
+
+# /audit — Confirm Recent Commits Before You Trust Them
+
+Run the audit-driven loop over recent work: a merged commit with green CI is a claim, not a proof.
+
+## What it does
+
+Takes a commit window, hunts for real defects one concern at a time, proves each finding against the actual code (false positives die before any edit), fixes on a branch with the smallest diff, verifies every surface the fix touches, and reports honestly. Backed by the `audit` skill.
+
+## The loop
+
+```
+1. Scope    git log to pick the window (e.g. HEAD~10..HEAD, or main since last release)
+2. Find     one pass per dimension: value/economy drift, concurrency, surface coverage, type/contract
+3. Confirm  read the actual lines; state in one sentence why it is real, or dismiss it
+4. Fix      one concern per commit; prefer a failing test first, then green
+5. Verify   exercise EVERY surface (backend, frontend, admin, cache, migration), not just the edited one
+6. Report   confirmed (with the proof), dismissed (with why), no-op (in scope, nothing to change)
+```
+
+## Default skeptical
+
+Findings are hypotheses. Default each to a false positive until the code proves the bug — defaulting to "real" is how plausible-but-wrong fixes ship. For a thorough audit, fan the find pass out across dimensions with parallel reviewers, then verify each survivor adversarially.
+
+## Pairs with
+
+- **`audit`** skill — the discipline this command runs.
+- **`code-review`** / **`security-review`** — the per-dimension passes.
+- **`reconcile`** — the safe branch→PR path once the audit produces a fix.
+- **`recall`** — check whether a finding was already hit and fixed before.

package/commands/companion-preference.md

@@ -0,0 +1,58 @@
+---
+name: companion-preference
+description: Inspect companion-preference hook telemetry — counts by CI skill, action breakdown, and companion-installed%.
+---
+
+# /companion-preference
+
+Read and aggregate the JSONL telemetry written by `hooks/companion-preference.mjs`. Reports per-skill totals, action breakdown (`observation`, `advisory`, `block`, `block-not-installed`), and the share of events where the companion plugin was installed at the time.
+
+The dataset is the evidence base for a future `companions-first` default-flip decision — once a 7-day shadow shows the `companions-first` path firing on a meaningful share of routed Skill calls, with companions installed in the majority of them, the flip is grounded.
+
+## Trigger phrases
+
+- `/companion-preference`
+- `/companion-preference status`
+- "show companion preference stats"
+- "what does the companion-preference hook see"
+
+## What happens
+
+1. Run `node bin/companion-preference-status.mjs` from the repo root with the operator's chosen window. Default `--days 7`. Pass `--all` for the entire file or `--days N` for a different window.
+2. Render the table the CLI emits to the user verbatim. Do not paraphrase the numbers — the JSONL is authoritative.
+3. If the CLI prints "no telemetry recorded yet," check three things in order: (a) `~/.claude/settings.json` has `continuous_improvement.companion_preference` set (otherwise the hook is a no-op and writes nothing); (b) the user has invoked at least one mapped CI skill (`tdd-workflow`, `verification-loop`, `context-budget`, `ralph`, `learn-eval`) since the hook landed; (c) the hook's PreToolUse registration is intact in `plugins/continuous-improvement/hooks/hooks.json`.
+4. Offer one decision-ready next step based on the totals — e.g., "ratio of `observation` rows with `companion_installed=true` suggests `companions-first` is safe to flip for X but not Y."
+
+## Subcommands
+
+### `/companion-preference status` (default)
+
+Same as `/companion-preference`.
+
+### `/companion-preference status --json`
+
+Emit the machine-readable JSON report. Useful when you want to pipe the output into another tool or write your own aggregator.
+
+```bash
+node bin/companion-preference-status.mjs --json --all
+```
+
+## CLI flags
+
+| Flag | Effect |
+|---|---|
+| `--days N` | Only count events from the last N days (default 7). |
+| `--all` | Ignore the window; count every row in the file. |
+| `--json` | Emit a machine-readable JSON report. |
+| `--path <file>` | Override the default JSONL path. Used by the test suite; rarely needed in practice. |
+| `-h`, `--help` | Print CLI help and exit. |
+
+## Path resolution
+
+By default the CLI reads `~/.claude/instincts/<project-hash>/companion-preference.jsonl`, where the hash is the same `sha256(projectRoot).slice(0, 12)` that the hook itself uses. The project root resolves via `CLAUDE_PROJECT_DIR` env var if set, else `git rev-parse --show-toplevel`, else the literal `"global"`. Hash and path scheme are reused verbatim from `hooks/companion-preference.mjs` to keep the read side aligned with the write side.
+
+## Companion skills
+
+- `hooks/companion-preference.mjs` — the writer that produces the JSONL this command reads.
+- `skills/superpowers.md` § "Companion-Preference Override" — the broader contract for the setting this command's dataset measures.
+- `commands/dashboard.md` — the broader continuous-improvement status surface; this command is the dispatcher-bias-specific narrower view.

package/commands/discipline.md

@@ -33,6 +33,20 @@ The Laws above are the *how*. These five principles are the *why*: code ships fr
 
 Code is a liability, not an asset. Speed without these five turns into someone else's incident at 3am — except the someone is you.
 
+## Goal-Driven Execution maps onto the Laws
+
+"Goal-Driven Execution" is the operator's global principle #4 — tie every change to a stated goal, refuse scope creep, stop when the goal is met. It is not a separate Law here; it is the spine of four existing Laws:
+
+| Sub-rule of Goal-Driven Execution | Lives in |
+|---|---|
+| Tie work to a stated goal; if none, ask | Law 2 — the `## Goal` in `task_plan.md` is the single source of truth |
+| Catch drift away from that goal mid-session | Law 2 — the `goal-monitor` skill / `/goal-check` scores recent activity against the goal |
+| Finish one thing; refuse "while I'm here" scope creep | Law 3 |
+| Commit messages lead with the outcome, not the mechanism | Law 4 — "done" is an observed outcome |
+| Iterate one change at a time toward the goal | Law 6 |
+
+The `goal-monitor` primitive (`/goal-check`, `ci_goal_check`) is the measurable arm of this principle: it reads the `## Goal` section and reports ON GOAL / DRIFT / NO DATA. Run it at phase boundaries to confirm the work and the plan still agree.
+
 ## The Loop
 
 ```

package/commands/distill.md

@@ -0,0 +1,39 @@
+---
+name: distill
+description: Distill repeated successful tool sequences from the observation log into reusable draft instincts, with an explicit propose-edit-promote ladder. Enforces Law 7 (Learn From Every Session).
+---
+
+# /distill — Trajectory Distillation
+
+Mine this project's observation log for tool sequences that recurred across multiple successful sessions, and turn the good ones into reusable instincts.
+
+## What it does
+
+Groups observations into trajectories, keeps the ones that ended in a passing verification, and finds tool-sequence n-grams that recurred across distinct sessions. Backed by the `ci_distill_candidates` / `ci_distill_propose` / `ci_distill_promote` MCP tools (expert mode) and the `skill-distillation` skill.
+
+## The ladder
+
+```
+ci_distill_candidates           # list patterns that qualify (read-only)
+ci_distill_propose id=<id>       # write a DRAFT (placeholder body) to drafts/<id>.yaml
+# ... edit the draft body to capture the real recipe ...
+ci_distill_promote id=<id>       # promote to a live instinct at 0.5 confidence (SUGGEST)
+```
+
+Drafts never affect behavior until promoted. The draft starts at 0.4 confidence in a `drafts/` subdirectory the instinct loader ignores; promotion writes a live instinct at 0.5 (SUGGEST tier).
+
+## Candidate criteria
+
+- The trajectory must have ended in success (`verify-exit-0` or `reflection-pass`).
+- The tool sequence must have recurred at least 3 times across at least 2 distinct sessions.
+- A pattern repeated only within one session is rejected — that is repetition, not a reusable skill.
+
+## Why the human edit step
+
+A tool sequence is evidence, not a recipe. `Read → Edit → Bash → Edit → Bash` is a TDD loop, but the value is in the preconditions and concrete steps. Editing the draft body before promotion is the guard against fabricating confident skills from coincidental call ordering.
+
+## Pairs with
+
+- **`skill-distillation`** skill — the discipline this command runs.
+- **`continuous-improvement`** (core SKILL.md, Law 7 — Learn From Every Session).
+- **`recall`** — before promoting, check whether an existing instinct already covers the pattern.

package/commands/goal-check.md

@@ -0,0 +1,53 @@
+---
+name: goal-check
+description: Check whether recent tool activity still relates to the stated goal in task_plan.md, reporting a drift score and the top off-goal tool calls. Enforces Law 2 (Plan Is Sacred).
+---
+
+# /goal-check — Goal Drift Check
+
+Score this session's recent tool activity against the stated goal and report whether the work is still ON GOAL or has DRIFTed.
+
+## What it does
+
+Reads the `## Goal` section of `task_plan.md` (plus optional `## Goal Keywords` and `## Goal Scope` sections), scores the most recent observations from `~/.claude/instincts/<project-hash>/observations.jsonl`, and reports a drift score with the top off-goal tool calls. Backed by the `ci_goal_check` MCP tool (expert mode) and the `goal-monitor` skill.
+
+## How to invoke
+
+```
+ci_goal_check                       # last 30 observations vs task_plan.md
+ci_goal_check limit=50              # widen the observation window
+ci_goal_check goal_file=docs/x.md   # score against a specific plan file
+```
+
+Goal source resolution order: `task_plan.md` in the project root, then `~/.claude/instincts/<project-hash>/goal.md`, then an explicit `goal_file`.
+
+## Output shape
+
+```
+## Goal Check
+
+**Goal source:** /home/me/repo/task_plan.md
+
+**Status:** DRIFT
+**Score:** 12% (1/8 matched, threshold 30%)
+**Reason:** Only 1/8 recent observations relate to the goal (threshold 0.3).
+**Goal keywords:** oauth, jwt, login, session
+
+**Top off-goal activity (most recent 5):**
+- [2026-05-28T12:01:00Z] Edit — src/marketing/landing.ts
+- ...
+
+_Drift detected. Either steer back to the goal, or update the `## Goal` section in your plan if the goal has legitimately changed._
+```
+
+## Acting on the result
+
+- **ON GOAL** — the plan and the work agree; proceed.
+- **DRIFT** — steer back to the goal, or update `## Goal` if it has legitimately changed. Keeping the plan and the work in disagreement is the Law 2 violation this command catches.
+- **NO DATA** — the observation window is still filling; keep working.
+
+## Pairs with
+
+- **`goal-monitor`** skill — the discipline this command runs.
+- **`continuous-improvement`** (core SKILL.md, Law 2 — Plan Is Sacred).
+- **`planning-with-files`** — creates the `task_plan.md` whose `## Goal` section this command reads.

package/commands/grill-me.md

@@ -0,0 +1,40 @@
+---
+name: grill-me
+description: "Interview the user relentlessly about a plan or design until shared understanding is reached. Ported from mattpocock/skills under MIT."
+---
+
+# /grill-me
+
+Stress-test the current plan or design by interviewing the user one question at a time, walking every branch of the decision tree, and recommending an answer for each.
+
+## Trigger phrases
+
+- `/grill-me`
+- "grill me"
+- "stress-test this plan"
+- "interview me about this"
+- "what am I missing?"
+
+## What happens
+
+1. Identify the current plan or design from the conversation — the high-level goal, the assumptions in play, the decisions already made.
+2. Walk the decision tree top-down. For each unresolved branch, ask exactly **one question** with a **recommended answer**.
+3. Before asking, check whether the codebase already answers the question (`grep`, `ls`, file reads). If it does, use that and skip the question.
+4. Resolve dependencies in order — do not ask about deployment before the data model is pinned.
+5. Stop when the plan is shippable cold to a fresh agent. Do not interview past the point of usefulness.
+
+## Five interview rules
+
+1. **One question at a time.** Never multi-question; force depth on every branch.
+2. **Always recommend.** Every question carries "my answer would be X because Y".
+3. **Explore before asking.** Code answers beat user-attention answers.
+4. **Walk the tree, do not jump.** Order matters.
+5. **Stop when shippable.** End state is a plan a fresh agent could execute, not an infinite interview.
+
+## Skill file
+
+Full behavior is defined in [`skills/grill-me.md`](../skills/grill-me.md). The verbatim upstream cold-storage copy lives at [`third-party/mattpocock-skills/skills/productivity/grill-me/SKILL.md`](../third-party/mattpocock-skills/skills/productivity/grill-me/SKILL.md); SHA pin in [`third-party/MANIFEST.md`](../third-party/MANIFEST.md).
+
+## Attribution
+
+Ported from [mattpocock/skills `productivity/grill-me`](https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md) (MIT, © 2026 Matt Pocock).

package/commands/grill-with-docs.md

@@ -0,0 +1,38 @@
+---
+name: grill-with-docs
+description: "Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates CONTEXT.md + ADRs inline as decisions crystallise. Ported from mattpocock/skills under MIT."
+---
+
+# /grill-with-docs
+
+Stress-test the current plan or design by interviewing the user one question at a time AND updating the project's domain-language doc (`CONTEXT.md`) and architecture decision records (`docs/adr/`) inline as decisions land.
+
+## Trigger phrases
+
+- `/grill-with-docs`
+- "grill me and update the docs"
+- "stress-test this against our domain model"
+- "let's nail down the language and ADR this"
+
+## What happens
+
+1. Read `CONTEXT.md` (or `CONTEXT-MAP.md` + per-context `CONTEXT.md`) and `docs/adr/` if they exist. Use them as the source of truth for project language and prior decisions.
+2. Walk the decision tree top-down. One question at a time with a recommended answer.
+3. Challenge fuzzy terms against the glossary. Sharpen vague language. Stress-test relationships with concrete scenarios. Cross-reference user statements against the code.
+4. When a term is resolved, update `CONTEXT.md` immediately (lazy-create if missing). Use the format in the skill's Appendix A.
+5. Offer an ADR only when all three are true: hard to reverse, surprising without context, result of a real trade-off. Use the format in Appendix B.
+
+## When to fire this instead of `/grill-me`
+
+| Skill | Use when |
+|---|---|
+| `/grill-me` | Conversation-only grilling; no project to update yet, or no docs convention. |
+| `/grill-with-docs` | Project has `CONTEXT.md` or is ready to start one; decisions should persist past the session. |
+
+## Skill file
+
+Full behavior, format specs, and 7 Laws fit are defined in [`skills/grill-with-docs.md`](../skills/grill-with-docs.md). The verbatim upstream cold-storage copies live at [`third-party/mattpocock-skills/skills/engineering/grill-with-docs/`](../third-party/mattpocock-skills/skills/engineering/grill-with-docs/) (`SKILL.md`, `CONTEXT-FORMAT.md`, `ADR-FORMAT.md`); SHA pin in [`third-party/MANIFEST.md`](../third-party/MANIFEST.md).
+
+## Attribution
+
+Ported from [mattpocock/skills `engineering/grill-with-docs`](https://github.com/mattpocock/skills/blob/main/skills/engineering/grill-with-docs/SKILL.md) (MIT, © 2026 Matt Pocock). Mattpocock calls this his most powerful skill: "It's hard to explain how powerful this is. It might be the single coolest technique in this repo."

package/commands/handoff.md

@@ -0,0 +1,42 @@
+---
+name: handoff
+description: "Compact the current conversation into a handoff document for another agent to pick up. Ported from mattpocock/skills under MIT."
+argument-hint: "What will the next session be used for?"
+---
+
+# /handoff
+
+Hand the current session off to a fresh agent by writing a brief, mktemp-backed markdown summary they can pick up cold.
+
+## Trigger phrases
+
+- `/handoff`
+- `/handoff <what the next session will focus on>`
+- "write a handoff doc"
+- "compact this into a handoff"
+
+## What happens
+
+1. Read the current conversation (and the user's argument, if given) to identify the goal, current state, decisions made, open questions, next concrete step, and skills to load.
+2. Generate a unique path with `mktemp -t handoff-XXXXXX.md` and read it (it will be empty).
+3. Write the handoff doc to that path. Reference PRDs, plans, ADRs, issues, commits, and diffs by path or URL — do not duplicate their content.
+4. Suggest the skills the next session should load.
+
+## What goes in the doc
+
+A one-screen brief, in this order:
+
+1. **Goal** — one sentence on the outcome the user is steering toward.
+2. **Current state** — what is actually true on disk / in the system right now.
+3. **Decisions made this session** — only what is not already captured in commits or other artifacts.
+4. **Open questions** — blocking choices the next agent needs the user to answer.
+5. **Next concrete step** — the single action the next agent should take first.
+6. **Skills to load** — names of the skills the next session should activate.
+
+## Skill file
+
+Full behavior is defined in [`skills/handoff.md`](../skills/handoff.md). The verbatim upstream cold-storage copy lives at [`third-party/mattpocock-skills/skills/in-progress/handoff/SKILL.md`](../third-party/mattpocock-skills/skills/in-progress/handoff/SKILL.md); SHA pin in [`third-party/MANIFEST.md`](../third-party/MANIFEST.md).
+
+## Attribution
+
+Ported from [mattpocock/skills `in-progress/handoff`](https://github.com/mattpocock/skills/blob/main/skills/in-progress/handoff/SKILL.md) (MIT, © 2026 Matt Pocock).

package/commands/proceed-with-the-recommendation.md

@@ -18,6 +18,26 @@ Invoke immediately after the agent has offered a numbered list of recommendation
 - "execute the recommendations"
 - "yes do it" / "all of them"
 
+## Fast-path: `--once` mode
+
+For a single-item, `safe`-tagged confirmation, append `--once` to skip P-MAG, Plan, Reflect, and the three-section close. Runs Phase 1 + Phase 3 + Phase 4 only and ends with one line: `Done: <item>. Verified: <check + output>.`
+
+Trigger phrases:
+
+- `/proceed-with-the-recommendation --once`
+- `/proceed --once`
+- "proceed once with that" / "just do that one"
+- Any standard trigger phrase plus the literal `--once` suffix
+
+Hard preconditions (the skill refuses `--once` and falls back to the full flow if any fail):
+
+- Recommendation list has exactly one item
+- Item is tagged `safe` (not `caution`, not `needs-approval`)
+- Item touches ≤3 files, ≤150 LOC, and none of `.github/`, `bin/`, `lib/`, `src/`, `third-party/`
+- Item is not destructive (no deploy, force-push, DB drop, secret rotation)
+
+Full behavior is defined in [`skills/proceed-with-the-recommendation.md`](../skills/proceed-with-the-recommendation.md) under § "Fast-Path: `--once` Mode".
+
 ## What happens
 
 1. **Pre-flight (Law 1)** — restate the recommendation list in original order, tag each `safe` / `caution` / `needs-approval`

package/commands/recall.md

@@ -0,0 +1,49 @@
+---
+name: recall
+description: Search past tool-call observations with BM25 ranking to answer "have I seen this before?" before re-deriving a fix or repeating a mistake. Enforces Law 1 (Research Before Executing).
+---
+
+# /recall — Episodic Search Over Past Sessions
+
+Search this project's observation history for relevant prior activity and return the most relevant past tool calls, ranked.
+
+## What it does
+
+Builds an in-memory BM25 index over `~/.claude/instincts/<project-hash>/observations.jsonl` and returns the top matches with redacted snippets, relevance scores, and timestamps. Backed by the `ci_recall` MCP tool (expert mode) and the `recall` skill.
+
+## How to invoke
+
+```
+ci_recall query="permission denied push"     # top 5 matches
+ci_recall query="jq command not found" k=3    # cap results
+ci_recall query="auth login" since=7d          # only the last 7 days
+```
+
+`since` accepts an ISO timestamp or a relative window: `7d`, `24h`, `30m`.
+
+## Output shape
+
+```
+## Recall: "permission denied push"
+
+2 match(es), most relevant first:
+
+- [2026-05-20T10:00:00Z] **Bash** (score 3.41)
+  …git push origin main  Permission denied: harness blocked direct push to main…
+- ...
+```
+
+## Privacy
+
+Snippets are passed through a secret redactor (AWS keys, JWT-shaped triplets, bearer tokens, KEY/SECRET/TOKEN/PASSWORD assignments, long hex strings) before display.
+
+## Notes
+
+- **Lexical, not semantic** — search with the vocabulary that actually appeared in the tool calls; try several phrasings if the first returns nothing.
+- Searches the full captured history, not just the recent window.
+
+## Pairs with
+
+- **`recall`** skill — the discipline this command runs.
+- **`continuous-improvement`** (core SKILL.md, Law 1 — Research Before Executing).
+- **`gateguard`** — recall a past failure before clearing a high-risk action.

package/commands/reconcile.md

@@ -0,0 +1,47 @@
+---
+name: reconcile
+description: Establish git ground truth (branch, status, stashes, worktrees, ahead/behind) before any mutation, halt on protected or destructive operations, and verify a push actually landed. Enforces Law 1 (Research Before Executing).
+---
+
+# /reconcile — Ground-Truth Git State Before You Touch It
+
+Read the repo's real state before acting on it: a branch that shifted, a push that did not land, or another session mid-merge will burn a whole session if you assume instead of check.
+
+## What it does
+
+Snapshots the full git state in one pass, detects a concurrent writer, classifies the upstream relationship, then acts only on the known state — stopping at every operation that is hard to reverse. Backed by the `reconcile` skill.
+
+## Establish ground truth
+
+```
+git branch --show-current
+git status --porcelain=v1                     # but trust git diff --stat for real drift (autocrlf)
+git rev-list --left-right --count @{u}...HEAD  # behind / ahead
+git stash list
+git worktree list
+ls .git/MERGE_HEAD .git/rebase-merge .git/rebase-apply 2>/dev/null  # in-progress op = another actor; do not race
+```
+
+## Then act, with gates
+
+```
+even      -> safe to branch (confirm local base == origin/base first)
+ahead     -> push or PR, AFTER the protected-op gate
+behind    -> git pull --ff-only
+diverged  -> rebase/merge deliberately; never blind --force
+```
+
+STOP for authorization before: pushing to a protected branch (this repo = feature branch + PR, never direct push to main), `--force` / `--force-with-lease`, `reset --hard`, `clean -fd`, or removing a dirty worktree. Never stage with `git add -A` on a Windows autocrlf tree (it commits phantom line-ending-only changes) — stage by explicit filename.
+
+## Verify the push landed
+
+```
+git ls-remote origin refs/heads/<branch>   # remote tip must equal local HEAD, else it did not land
+```
+
+## Pairs with
+
+- **`reconcile`** skill — the discipline this command runs.
+- **`gateguard`** / **`safety-guard`** — runtime + destructive-op guardrails.
+- **`recall`** — recall whether the same git op failed here before.
+- **`audit`** — the loop that often produces the fix `reconcile` then ships.

package/commands/superpowers.md

@@ -7,9 +7,9 @@ description: "Law activator and dispatcher — route the task to the right Law-a
 
 `/superpowers` is **the dispatcher**, not a peer skill. It does not do work itself; it routes each user task to the correct Law-aligned specialist so the right discipline fires automatically instead of the agent skipping a step.
 
-The 7 Laws define *what* discipline must be applied. `/superpowers` decides *which specialist* enforces it for this specific task, across five sources installed from this marketplace.
+The 7 Laws define *what* discipline must be applied. `/superpowers` decides *which specialist* enforces it for this specific task, across four sources installed from this marketplace.
 
-## Routing surface (five sources)
+## Routing surface (four sources)
 
 | Source | Where it lives | Examples of what it routes to |
 |---|---|---|

package/commands/verify-install.md

@@ -0,0 +1,55 @@
+---
+name: verify-install
+description: Walk the post-install verification in one shot — confirm slash commands loaded, the gateguard runtime hook fires, and observation capture is recording — then print a single ✓ wired / ✗ missing line.
+---
+
+# /verify-install
+
+Replaces the manual post-install dance (restart, run `/discipline`, hand-write a
+hostile prompt, eyeball `/dashboard`) with one command that runs all three
+checks and reports a single line.
+
+Run the three checks **in order**. Do not skip a check because an earlier one
+passed — each proves a different layer.
+
+## Check 1 — slash commands loaded
+
+If this command is executing, the marketplace did pick the plugin up and the
+command registry loaded it. Record `commands: ✓`.
+
+If you are reading this file directly rather than running it as `/verify-install`,
+stop — the command is not registered. The fix is a Claude Code session restart
+(slash commands load on session start). Record `commands: ✗ (restart the session)`.
+
+## Check 2 — gateguard runtime hook fires
+
+The runtime gate ships as a PreToolUse hook (`hooks/gateguard.mjs`). Probe it:
+attempt to `Write` a throwaway file at a sandbox path (`./.ci-verify-install-probe.txt`
+with the text `probe`) **without presenting any research first**.
+
+- If the hook **blocks** the write with a fact-list reason — the runtime layer is
+  wired. Record `gateguard: ✓`. Do not retry the write; the block is the pass.
+- If the write **goes through** with no pause — the hook did not load. Record
+  `gateguard: ✗ (hooks/gateguard.mjs not wired — see README → Troubleshooting install)`.
+  Delete the probe file if it was created.
+
+## Check 3 — observation capture recording
+
+The observation hook appends one row per tool call to
+`~/.claude/instincts/<project-hash>/observations.jsonl`. Read that file (resolve
+`<project-hash>` from the current repo, or check `~/.claude/instincts/global/`).
+
+- If it exists and has at least one row — capture is recording. Record `observe: ✓`.
+- If it is missing or empty — record `observe: ✗ (observation hook not recording —
+  on Windows confirm Git Bash / WSL is installed, then re-run the installer)`.
+
+## Report
+
+Emit exactly one summary line, nothing else after it:
+
+- All three passed: `✓ wired — commands, gateguard, observe all confirmed.`
+- Any failed: `✗ <comma-separated failing checks with their fix hints>.`
+
+Do not claim "should be fine" for a check you could not actually run. If a check
+is genuinely unrunnable (e.g. no repo context for the project hash), mark it
+`unverified` with the reason rather than `✓`.