continuous-improvement 3.11.0 → 3.15.0

package/.claude-plugin/marketplace.json

@@ -7,8 +7,8 @@
   "plugins": [
     {
       "name": "continuous-improvement",
-      "description": "Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 25 bundled skills, gating hooks, the Mulahazah auto-leveling instinct engine, and a GitHub Action transcript linter.",
-      "version": "3.11.0",
+      "description": "The persistent-memory and runtime-discipline layer for Claude Code. It remembers the corrections you already gave, grounds every edit in real facts before it lands, and — through the Mulahazah engine — turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Built on the 7 Laws of AI Agent Discipline (research, plan, verify, reflect, learn) and shipped as 25 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.",
+      "version": "3.15.0",
       "source": "./plugins/continuous-improvement",
       "author": {
         "name": "naimkatiman"
@@ -53,7 +53,7 @@
     },
     {
       "name": "oh-my-claudecode",
-      "description": "Multi-agent orchestration system for Claude Code — 39 skills + 19 agents covering audit, plan, build, verify, ship, release, retrospective, and ops. Includes ralph (autonomous PRD loop), release, ultrawork, ultraqa, team, trace, visual-verdict, debug, deep-dive, deep-interview, autopilot, autoresearch. Vendored snapshot at third-party/oh-my-claudecode/ pinned to upstream SHA aacde3e (v4.13.6). Heavy overlap with continuous-improvement /ralph and /superpowers — pick per task.",
+      "description": "Multi-agent orchestration system for Claude Code — 38 skills + 19 agents covering audit, plan, build, verify, ship, release, retrospective, and ops. Includes ralph (autonomous PRD loop), release, ultrawork, ultraqa, team, trace, visual-verdict, debug, deep-dive, deep-interview, autopilot, autoresearch. Vendored snapshot at third-party/oh-my-claudecode/ pinned to upstream SHA aacde3e (v4.13.6). Heavy overlap with continuous-improvement /ralph and /superpowers — pick per task.",
       "version": "4.13.6",
       "source": "./third-party/oh-my-claudecode",
       "author": {

package/CHANGELOG.md

@@ -4,7 +4,71 @@ All notable changes to this skill are documented here.
 
 ---
 
-## [Unreleased]
+## [3.15.0] — 2026-06-21
+
+### Added
+
+- **`/ship` cuts one defect from audit to an open PR** — a single-concern fast path that routes `reconcile` → `tdd-workflow` → `verification-loop` → `commit-push-pr` → `deploy-receipt` for one fix, then stops at PR-open. Never auto-merges or deploys. Command-only; `/release-train` remains the multi-PR path. Plan: `docs/plans/2026-06-17-ship-command.md`. (#246)
+- **`/production-readiness-review` fans a blind multi-agent review into one punch-list** — parallel reviewers across performance, security, UI/UX, and test coverage, each grounding findings in real code/logs/live data, reconciled into a deduplicated, severity-ranked list. Report-only; never fixes, merges, or deploys. Plan: `docs/plans/2026-06-17-production-readiness-review-command.md`. (#247)
+- **`hook-pack` enforces push-to-main and commit-size at the tool boundary** — a warn-default PreToolUse hook (Bash-matched so the non-Bash hot path stays cheap; gateguard stays first) that flags a direct `git push` to a protected branch (`main`/`master`/`release/*`) and a `git commit` staging more than 15 files. Mode `CLAUDE_CI_HOOKPACK_GATE=warn|block|off`; warn never blocks, so zero disruption until you opt into `block`. Pure logic in `lib/hook-pack-gate`. Plan: `docs/plans/2026-06-17-enforcing-hook-pack.md`. (#248)
+- **`/plan-pack` turns a plan doc into a commentable review packet for colleague review** — converts a `docs/plans/` doc into a structured packet a colleague can comment on before implementation. (#244)
+- **How-to-best-use guide** mapping the agentic-engineering workflow to the plugin's skills, commands, and hooks (`docs/using-this-plugin.md`). (#245)
+
+## [3.14.0] — 2026-06-14
+
+### Fixed
+
+- **Gateguard clearance cap no longer bleeds across concurrent sessions and self-heals instead of needing a manual `rm`** — the per-session clearance state was keyed on the project hash only, so every Claude session on a repo (sequential or concurrent) shared one 50-file counter that only grew; on a multi-Claude host later sessions inherited a near-full gate, and the "start a new session to reset" message did nothing because a new session resolved to the same file. State is now scoped to `~/.claude/instincts/<projectHash>/sessions/<sessionId>/` (the hook reads `session_id` from stdin; ids are sanitized against path traversal), a 12h TTL self-heals a stale state file to empty on load, and the MCP `ci_gateguard_clear` route accepts a `state_path` so it writes to the session-scoped file. The `MAX_CLEARED_FILES` rogue-loop cap still bounds a single session. Plan: `docs/plans/2026-06-14-gateguard-session-scoped-cap.md`. (#242)
+
+## [3.13.0] — 2026-06-10
+
+### Added
+
+- **model-forward ships as a default tier-1 skill** — the standing stance that skills are scaffolding which merges into the model over time; durable core = goal-driven execution + guardrails. (#229)
+- **`distill` turns a verified Workflow run into a draft instinct** — the ultracode-to-memory bridge: a completed multi-agent Workflow's verified trajectory becomes a reviewable instinct draft instead of evaporating with the session. (#226)
+
+### Fixed
+
+- **PreToolUse hooks no longer flood every session with `Hook JSON output validation failed — (root): Invalid input` errors (twice per tool call)** — `gateguard.mjs` and `companion-preference.mjs` emitted `{"decision":"allow"}` on every allowed call, which was never schema-valid PreToolUse output (the deprecated `decision` enum is `approve | block`), and current Claude Code clients surface the validation failure instead of silently discarding it. Allow is now empty stdout + exit 0; block uses the documented `hookSpecificOutput.permissionDecision: "deny"` shape. (#230)
+- **goal-state keyword extraction works for Korean goals** — a script-aware minimum keyword length (2 for Hangul tokens, 4 elsewhere) stops Korean goal statements from extracting zero keywords and scoring all work as drift.
+
+### Removed
+
+- **`ci` toolkit slimmed to CLI-Anything only — Compound Engineering + PM-Skills removed (breaking)** — the published `ci` command dropped its `compound`, `pm`, `learnings`, and `init`/`workflow`/`research`/`planning`/`execution`/`review` subcommands. Compound Engineering overlapped the Mulahazah instinct engine and PM-Skills overlapped the out-of-band `phuryn/pm-skills` marketplace install, so both were tree-shaken; the vestigial `unified-plugin` orchestrator was deleted and `unified-cli` rewritten as a thin front-end over the retained CLI-Anything library (`ci generate <repo>` / `ci list` / `ci config`). Removes ~4,500 LOC of source + tests; `cli-anything` and the build-critical `pm-marketplace` are unchanged. Plan: `docs/plans/2026-06-08-slim-ci-to-cli-anything.md`.
+
+## [3.12.3] — 2026-06-08
+
+### Fixed
+
+- **Completed the OIDC trusted-publishing pipeline by restoring setup-node `registry-url`** — #211 had removed it to kill the dummy-token `.npmrc`, but that left npm with no registry anchor for the OIDC token exchange (`ENEEDAUTH` on 3.12.1/3.12.2). With `registry-url` back, Node 22 (#213), npm ≥ 11.5.1, and a configured trusted publisher, npm mints and uses the OIDC token. **3.12.3 is the first version actually published to npm** carrying the 3.12.0 changes (#198 positioning, #199 recall hook, #202 OIDC, #203 doc-drift, #204 tool-count); 3.12.0–3.12.2 were never published. (#215)
+
+## [3.12.2] — 2026-06-08
+
+### Fixed
+
+- **Release workflow now runs on Node 22 so OIDC trusted publishing actually authenticates** — npm trusted publishing requires npm ≥ 11.5.1 **and Node ≥ 22.14.0** ([docs.npmjs.com/trusted-publishers](https://docs.npmjs.com/trusted-publishers)). `release.yml` ran on Node 20, below the floor, so the OIDC token exchange never engaged: the `v3.12.0` publish fell back to setup-node's dummy `.npmrc` token (`E404`) and `v3.12.1` had no auth at all (`ENEEDAUTH`). Bumping `setup-node` to Node 22 (plus #211 dropping the token-bearing `.npmrc`) completes the OIDC pipeline. **3.12.2 is the first npm artifact to carry the 3.12.0 changes** (#198 positioning, #199 recall hook, #202 OIDC pipeline, #203 doc-drift, #204 tool-count invariant); `3.12.0` and `3.12.1` were never published to npm. (#211, #213)
+
+## [3.12.1] — 2026-06-08
+
+### Fixed
+
+- **npm release pipeline now authenticates via OIDC instead of a dummy token** — the `v3.12.0` tag publish failed with `E404` on the registry PUT: `actions/setup-node` with `registry-url` wrote an `.npmrc` carrying `_authToken=${NODE_AUTH_TOKEN}` set to its placeholder value, so npm used that dummy token for the publish instead of OIDC trusted publishing (provenance still signed, since the sigstore OIDC token is separate). Dropping `registry-url` from `release.yml` lets `npm publish --provenance` fall back to OIDC as intended. **3.12.1 is the first npm artifact to carry the 3.12.0 changes** (intelligence-amplifier positioning #198, recall-briefing hook #199, OIDC pipeline #202, doc-drift fixes #203, `verify:tool-count` invariant #204); the `3.12.0` version was never published to npm. (#211)
+
+## [3.12.0] — 2026-06-07
+
+### Added
+
+- **Proactive recall-briefing hook (opt-in episodic memory)** — `hooks/recall-briefing.mjs` runs on `UserPromptSubmit`, queries the BM25 observation index in-process, and surfaces the most relevant prior corrections as a briefing before the agent acts. First capability increment of the intelligence-amplifier reframe: a lesson learned once is recalled automatically on the next related prompt instead of being re-taught. Opt-in — disabled unless wired into the hook config.
+- **`verify:tool-count` content invariant (12th in `verify:all`)** — `bin/check-tool-count.mjs` pins MCP tool-count claims in docs and source to the generated `plugins/{expert,beginner}.json` `tools[].length`, so a count can't drift when a tool is added — the gap that let "12 tools" pass `verify:all` green in the 2026-06-07 audit. Pins four claims across `docs/skills.md`, `README.md`, `QUICKSTART.md`, and the `mcp-server` banner. Follow-up to #203 (PR #204).
+
+### Changed
+
+- **Positioning reframed from "seatbelt" to intelligence amplifier across every user-facing surface** — the 7 Laws of AI Agent Discipline keep their names but each is reframed from a restriction into a capability the agent gains. README h1 "A seatbelt for Claude Code" → "Claude Code that gets sharper every session"; landing page title/hero/CTA, `SHARED_PLUGIN_DESCRIPTION` (the source of truth that propagates to `package.json` + all generated manifests + `llms.txt`), SKILL.md, and CONTRIBUTING.md all reframed from "Stops Claude Code from…" loss-framing to capability-led copy. Honesty held: recall stays lexical/BM25, instincts decay, GateGuard still blocks (framed as forced grounding) — no over-claiming. Plan: `docs/plans/2026-06-07-intelligence-amplifier-reframe.md`.
+- **npm release now publishes via OIDC trusted publishing instead of `NPM_TOKEN`** — the account enforces 2FA-on-writes, which makes long-lived granular tokens hit EOTP in CI. `release.yml` upgrades npm to ≥ 11.5.1 and publishes with `npm publish --access public --provenance` (signed provenance from the OIDC claims); the `NPM_TOKEN` secret dependency is gone. See `docs/RELEASING.md` for the one-time trusted-publisher setup.
+
+### Fixed
+
+- **Doc/count drift surfaced by a post-merge audit** — corrected prose/count claims that drifted from the v3.11.0 implementation and that no `verify:all` invariant covers: MCP expert surface is 18 tools (not 12); the CONTRIBUTING release checklist now defers to `docs/RELEASING.md` instead of describing the retired manual publish flow; `agents/README.md` repointed off a non-existent reference doc; the oh-my-claudecode vendored snapshot count corrected to 38 skills; `harvest` observe-path corrected to `instincts/bin/observe.mjs`; and reports/update-card test counts synced to 793.
 
 ## [3.11.0] — 2026-06-07
 

package/QUICKSTART.md

@@ -130,7 +130,7 @@ Corrections drop instinct confidence. Unused instincts decay. The system self-co
 
 ## Expert (npx) — only if you want MCP, hooks, or instinct packs
 
-The Beginner path above is enough for most users. Pick this only if you want the MCP tools (12 of them, including `ci_plan_init` / `ci_plan_status` for `task_plan.md`-style planning), the session hooks that feed Mulahazah, or the starter instinct packs.
+The Beginner path above is enough for most users. Pick this only if you want the MCP tools (19 of them, including `ci_plan_init` / `ci_plan_status` for `task_plan.md`-style planning), the session hooks that feed Mulahazah, or the starter instinct packs.
 
 Do not run both paths against the same `~/.claude/` — that produces duplicated state. Pick one and stick with it.
 

package/README.md

@@ -4,14 +4,14 @@
   <img src="assets/combined.gif" alt="Before vs After — The 7 Laws of AI Agent Discipline" width="700" />
 </p>
 
-<h1 align="center">A seatbelt for Claude Code</h1>
+<h1 align="center">Claude Code that gets sharper every session</h1>
 
 <p align="center">
-  <b>Research first. Edit safely. Verify before done. Remember what worked.</b>
+  <b>Remembers what it already solved. Grounds every edit in facts. Verifies before "done". Carries every lesson into the next session.</b>
 </p>
 
 <p align="center">
-  <i>The 7 Laws of AI Agent Discipline — runtime hooks, enforcement skills, and project memory.</i>
+  <i>The 7 Laws of AI Agent Discipline — runtime hooks, instinct memory, and skills that compound what it learns.</i>
 </p>
 
 <p align="center">
@@ -26,17 +26,17 @@
   <b>New here?</b> → <a href="QUICKSTART.md">QUICKSTART.md</a> (2 minutes) · <a href="https://continuous-improvement.dev">continuous-improvement.dev</a>
 </p>
 
-> **What this is *not*:** a prompt template, a `CLAUDE.md`, or a vibes-based reminder. It is a runtime hook (`hooks/gateguard.mjs`) plus a bundled skill set that physically blocks `Edit` / `Write` / destructive `Bash` until the agent has done the work.
+> **What this is *not*:** a prompt template, a `CLAUDE.md`, or a vibes-based reminder. It is a runtime hook (`hooks/gateguard.mjs`) plus a bundled skill set that makes the agent ground every change in real facts — it physically blocks `Edit` / `Write` / destructive `Bash` until the investigation is done, so edits land on understanding instead of guesses.
 
 ---
 
 ## What this does
 
-Claude Code is powerful but skips the boring discipline: it edits before reading, guesses instead of checking, stacks five concerns into one commit, and says "done" without running tests. Continuous Improvement adds three layers that stop that:
+Claude Code is powerful but leaves intelligence on the table: it edits before reading, guesses instead of checking, stacks five concerns into one commit, and says "done" without running tests. Continuous Improvement adds three layers that make it sharper:
 
 1. **Before an edit** — [`gateguard`](skills/gateguard.md) ships as a `PreToolUse` hook (`hooks/gateguard.mjs`) that physically blocks `Edit` / `Write` / `MultiEdit` and destructive `Bash` until the agent presents a fact-list investigation.
 2. **During work** — bundled skills enforce planning, one-thing-at-a-time execution, TDD ([`tdd-workflow`](skills/tdd-workflow.md)), and a six-phase verification ladder ([`verification-loop`](skills/verification-loop.md)) before "done".
-3. **After work** — `/seven-laws` reflection plus the Mulahazah instinct engine capture lessons so the same mistake does not repeat next session.
+3. **After work** — `/seven-laws` reflection plus the Mulahazah instinct engine capture lessons, and the opt-in [`recall-briefing`](hooks/recall-briefing.mjs) hook resurfaces the most relevant past fix on the next related prompt, so the same mistake does not repeat next session.
 
 Beginner install is two slash commands inside Claude Code (no Node, no bash). Expert install adds MCP tools, observation hooks, instinct packs, and a GitHub Action transcript linter for CI.
 
@@ -52,7 +52,7 @@ With Continuous Improvement, the same prompt is forced through the gate:
 
 > `gateguard` blocks the first `Edit` until Claude presents a fact list. Claude reads `useAuth.ts`, finds the existing `redirectAfterLogin` helper, traces *why* the redirect loops (a stale `from` query param), and edits one line in one file. `verification-loop` runs the tests. The reply names the file, the line, the cause.
 
-Same agent. Same model. Different discipline.
+Same agent. Same model. Different intelligence.
 
 ---
 
@@ -86,7 +86,7 @@ You have used Claude Code (or any agentic coding tool) long enough to recognize
 | 2 | **No shared language** | The agent uses 20 words where 1 would do; jargon decoded fresh every session; variable names drift from domain terms | Law 2 (Plan), Law 7 (Learn) | [`grill-with-docs`](skills/grill-with-docs.md) (writes & maintains `CONTEXT.md`), [`token-budget-advisor`](skills/token-budget-advisor.md), [`strategic-compact`](skills/strategic-compact.md) |
 | 3 | **No feedback loop** | The code doesn't work — agent claims "done" without running build, tests, or healthcheck | Law 4 (Verify) | [`tdd-workflow`](skills/tdd-workflow.md), [`verification-loop`](skills/verification-loop.md), [`deploy-receipt`](skills/deploy-receipt.md) |
 | 4 | **Design rot** | Ball-of-mud accelerates — agent bundles three concerns into one PR, stacks untested changes, ignores prior architectural decisions | Law 2 (Plan), Law 3 (One Thing) | [`superpowers:writing-plans`](https://github.com/obra/superpowers/blob/main/skills/writing-plans/SKILL.md), [`safety-guard`](skills/safety-guard.md), [`worktree-safety`](skills/worktree-safety.md), [`wild-risa-balance`](skills/wild-risa-balance.md) |
-| 5 | **Forgotten lessons** | Next session starts from zero — prior corrections, decisions, instincts are lost; the same mistake repeats next week | Law 5 (Reflect), Law 7 (Learn) | [`handoff`](skills/handoff.md), [`para-memory-files`](skills/para-memory-files.md), Mulahazah instinct engine |
+| 5 | **Forgotten lessons** | Next session starts from zero — prior corrections, decisions, instincts are lost; the same mistake repeats next week | Law 5 (Reflect), Law 7 (Learn) | [`handoff`](skills/handoff.md), Mulahazah instinct engine |
 
 Three of those alignment + reflection skills (`grill-me`, `grill-with-docs`, `handoff`) are MIT-licensed ports from mattpocock/skills; the rest are continuous-improvement-native. Every failure mode has at least one runtime hook or model-side skill that catches it before it lands in the diff.
 
@@ -138,7 +138,7 @@ V1 honest limitations: the runtime gate is honor-system once the agent flips `_g
 
 ### Expert — adds MCP server, observation hooks, and instinct packs
 
-Pick this if you want the MCP tools (12 of them, including `ci_plan_init` / `ci_plan_status` for `task_plan.md`-style planning), the session hooks that feed Mulahazah, and starter packs.
+Pick this if you want the MCP tools (19 of them, including `ci_plan_init` / `ci_plan_status` for `task_plan.md`-style planning), the session hooks that feed Mulahazah, and starter packs.
 
 Preconditions: Node 18 / 20 / 22, plus bash on Windows (Git Bash or WSL — `hooks/observe.sh` is a bash script and silently no-ops without it). **`jq` is no longer required**: as of v3.6.0, `observe.sh` prefers the Node observer (`bin/observe.mjs`) which writes the rich event schema natively without external dependencies. The bash thin-schema path is kept as a two-phase shim, so legacy installs that have not re-run `npx continuous-improvement install` since v3.5.x will still degrade silently without `jq` (`winget install jqlang.jq` on Windows, `brew install jq` on macOS, `apt install jq` on Debian/Ubuntu) — re-running the installer is the cleaner fix and removes the dependency entirely. See [CHANGELOG.md](CHANGELOG.md) `[3.6.0]` for the migration details.
 
@@ -171,20 +171,41 @@ The framework has documented operator-level modes that change hook behavior with
 |---|---|---|
 | `CLAUDE_THREE_SECTION_CLOSE_DISABLED=1` | `three-section-close.mjs` short-circuits before any enforcement or telemetry. Use when end-of-turn reflection should run as internal thinking rather than visible "What has been done / What is next / Recommendation" sections. Public default unchanged — the rule still fires for everyone else. | bash/zsh: `export CLAUDE_THREE_SECTION_CLOSE_DISABLED=1` in `~/.bashrc` / `~/.zshrc`. PowerShell: `$env:CLAUDE_THREE_SECTION_CLOSE_DISABLED=1` (session) or `[Environment]::SetEnvironmentVariable('CLAUDE_THREE_SECTION_CLOSE_DISABLED','1','User')` (persistent). |
 | `CLAUDE_GOAL_DRIFT_GATE` | `goal-drift-stop.mjs` (a `Stop` hook) scores each turn's activity against the `## Goal` in `task_plan.md` and acts on drift. `warn` (default) prints a one-line stderr notice and never blocks; `block` re-prompts a substantive wrap-up that has drifted off-goal so the goal gates the close; `off` disables it. Reads the same observation feed as Mulahazah; fails open on any error. | bash/zsh: `export CLAUDE_GOAL_DRIFT_GATE=block` in `~/.bashrc` / `~/.zshrc`. PowerShell: `$env:CLAUDE_GOAL_DRIFT_GATE='block'` (session) or `[Environment]::SetEnvironmentVariable('CLAUDE_GOAL_DRIFT_GATE','block','User')` (persistent). |
+| `CLAUDE_RECALL_BRIEFING=1` | `hooks/recall-briefing.mjs` (a UserPromptSubmit hook) makes episodic memory proactive: on the first substantive prompt of a session it searches this project's past observations (BM25) and injects a one-time `<system-reminder>` with the most relevant prior activity, so the agent reuses a past fix instead of re-deriving it. Opt-in and default off; it is an amplifier, never a gate — it cannot block a prompt and fails open. The `ci_recall` MCP tool stays available for explicit, deeper searches. | bash/zsh: `export CLAUDE_RECALL_BRIEFING=1` in `~/.bashrc` / `~/.zshrc`. PowerShell: `$env:CLAUDE_RECALL_BRIEFING=1` (session) or `[Environment]::SetEnvironmentVariable('CLAUDE_RECALL_BRIEFING','1','User')` (persistent). |
+
+### Works with other agents
+
+Claude Code gets the full install (hooks, MCP server, instinct learning). Every other agent platform can still run the 7 Laws as a rules file — one flag writes the skill text into the file that platform reads, at your project root:
+
+```bash
+npx continuous-improvement install --target gemini,codex
+```
+
+| Target | File written |
+|---|---|
+| `gemini` | `GEMINI.md` (Gemini CLI context file) |
+| `codex` | `AGENTS.md` (agents.md standard — also read by opencode, Jules, Cursor ≥0.50) |
+| `cursor` | `.cursor/rules/continuous-improvement.mdc` (`alwaysApply: true`) |
+| `windsurf` | `.windsurf/rules/continuous-improvement.md` |
+| `zed` | `.rules` |
+| `aider` | `CONVENTIONS.md` + a minimal `.aider.conf.yml` if none exists |
+| `copilot` | `.github/copilot-instructions.md` |
+
+Shared files (`GEMINI.md`, `AGENTS.md`, `.rules`, `CONVENTIONS.md`, `copilot-instructions.md`) are merged through a managed marker block — your existing content is preserved and reinstalls are idempotent. Targets can be combined freely (`--target claude,gemini,codex` runs the full Claude Code install plus the rules files).
 
 ---
 
 ## The 7 Laws
 
-| # | Law | Without it, agents... |
+| # | Law | What it gives the agent |
 |---|-----|----------------------|
-| 1 | **Research Before Executing** | reinvent what already exists |
-| 2 | **Plan Is Sacred** | scope-creep and overbuild |
-| 3 | **One Thing at a Time** | stack untested changes |
-| 4 | **Verify Before Reporting** | lie about being "done" |
-| 5 | **Reflect After Sessions** | repeat the same failures |
-| 6 | **Iterate One Change** | debug 5 changes at once |
-| 7 | **Learn From Every Session** | lose knowledge when context ends |
+| 1 | **Research Before Executing** | builds on what already exists instead of reinventing it |
+| 2 | **Plan Is Sacred** | lands effort on the goal with success defined up front |
+| 3 | **One Thing at a Time** | ships each change on a known-good base |
+| 4 | **Verify Before Reporting** | backs every "done" with evidence you can trust |
+| 5 | **Reflect After Sessions** | turns each session into a captured lesson |
+| 6 | **Iterate One Change** | keeps debugging isolated and the signal clean |
+| 7 | **Learn From Every Session** | compounds knowledge so next week's agent is sharper |
 
 ```
 Research -> Plan -> Execute (one thing) -> Verify -> Reflect -> Learn -> Iterate
@@ -298,7 +319,7 @@ Authored end-to-end with `/superpowers` and `/proceed-with-the-recommendation`:
 
 - [QUICKSTART.md](QUICKSTART.md) — 2-minute setup
 - [SKILL.md](SKILL.md) — full 7 Laws spec
-- [docs/skills.md](docs/skills.md) — full 25-skill catalog
+- [docs/skills.md](docs/skills.md) — full 26-skill catalog
 - [examples/](examples/) — bug fix, feature build, refactor walkthroughs
 - [templates/insights-claude-md.md](templates/insights-claude-md.md) — paste-in CLAUDE.md blocks for verification discipline, environment notes, think-before-acting, and git/deploy workflow (sourced from the 28-day usage report)
 - [CONTRIBUTING.md](CONTRIBUTING.md) — architecture, repo internals, adding a new skill

package/SKILL.md

@@ -6,7 +6,7 @@ description: "Install structured self-improvement loops with instinct-based lear
 
 # continuous-improvement
 
-You follow the continuous-improvement framework. These 7 laws govern all your work.
+You follow the continuous-improvement framework. These 7 laws make every task sharper — each is a capability that compounds: research deeper, plan tighter, verify with evidence, reflect, and learn so the same lesson is never re-taught.
 
 ## Law 1: Research Before Executing
 

package/bin/check-skill-count.mjs

@@ -24,6 +24,11 @@
  *   - plugins/continuous-improvement/.claude-plugin/plugin.json
  *   - package.json
  *   - llms.txt
+ *   - .cloudplugin/marketplace.json   (hand-maintained, not generator-owned)
+ *
+ * Stat-block files (count lives in a split HTML stat, not the phrase):
+ *   - docs/landing/index.html — `<span class="v">N</span><span class="k">Bundled skills</span>`
+ *     (PR #229 found this surface stale at 25 while every phrase file said 26)
  *
  * Usage:
  *   node bin/check-skill-count.mjs              # Check the current repo
@@ -42,7 +47,9 @@ const CHECKED_FILES = [
     "plugins/continuous-improvement/.claude-plugin/plugin.json",
     "package.json",
     "llms.txt",
+    ".cloudplugin/marketplace.json",
 ];
+const STAT_CHECKED_FILES = ["docs/landing/index.html"];
 export function countSkills(repoRoot) {
     const skillsDir = join(repoRoot, BUNDLE_SKILLS_DIR);
     const entries = readdirSync(skillsDir);
@@ -75,6 +82,24 @@ function checkFile(repoRoot, relPath, expected) {
         found: staleMatch ? staleMatch[0] : undefined,
     };
 }
+function checkStatFile(repoRoot, relPath, expected) {
+    let content;
+    try {
+        content = readFileSync(join(repoRoot, relPath), "utf8");
+    }
+    catch {
+        return { file: relPath, reason: "missing" };
+    }
+    const expectedPattern = new RegExp(`class="v">${expected}</span><span class="k">Bundled skills`);
+    if (expectedPattern.test(content))
+        return null;
+    const staleMatch = content.match(/class="v">(\d+)<\/span><span class="k">Bundled skills/);
+    return {
+        file: relPath,
+        reason: staleMatch ? "stale" : "missing",
+        found: staleMatch ? `${staleMatch[1]} Bundled skills (stat block)` : undefined,
+    };
+}
 function main() {
     const repoRoot = argv[2] ?? cwd();
     const expected = countSkills(repoRoot);
@@ -84,8 +109,14 @@ function main() {
         if (v)
             violations.push(v);
     }
+    for (const file of STAT_CHECKED_FILES) {
+        const v = checkStatFile(repoRoot, file, expected);
+        if (v)
+            violations.push(v);
+    }
+    const totalChecked = CHECKED_FILES.length + STAT_CHECKED_FILES.length;
     if (violations.length === 0) {
-        console.log(`OK skill-count: all ${CHECKED_FILES.length} description string(s) state "${expected} bundled skills" (matches skills/ source-of-truth).`);
+        console.log(`OK skill-count: all ${totalChecked} description string(s) state "${expected} bundled skills" (matches skills/ source-of-truth).`);
         exit(0);
     }
     console.error(`FAIL skill-count: ${violations.length} description string(s) do not state the actual bundled-skill count of ${expected}.`);

package/bin/check-test-imports-only.mjs

@@ -12,7 +12,7 @@
  *   - reach-through into `hooks/`, `scripts/`, `src/`, or deeper paths under
  *     `bin/` or `lib/`
  *
- * Baseline: all 50 `src/test/*.test.mts` files pass today.
+ * Baseline: all 56 `src/test/*.test.mts` files pass today.
  *
  * Usage:
  *   node bin/check-test-imports-only.mjs              # Check the current repo

package/bin/check-tool-count.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+/**
+ * Tool Count Check
+ *
+ * Docs and source comments claim the size of the MCP tool surface
+ * ("N tools"). Those numbers drift every time a tool is added without the
+ * claim being bumped — exactly what the 2026-06-07 post-merge audit (PR #203)
+ * found: docs/skills.md said "12 tools" and src/bin/mcp-server.mts said
+ * "beginner (3 tools)" while the catalog had grown to 18 expert / 4 beginner,
+ * and `verify:all` stayed green because no invariant covered those strings.
+ *
+ * Source of truth: the GENERATED, committed manifests
+ *   - plugins/expert.json   tools[].length  (expert mode = all tools)
+ *   - plugins/beginner.json tools[].length  (beginner mode)
+ * Both are generated from src/lib/plugin-metadata.mts by `npm run build` and
+ * pinned against drift by `verify:generated`, so they are the honest count.
+ *
+ * Each ASSERTION names a file, a capture regex around its tool-count claim, and
+ * which mode's count the captured integer must equal. Precise per-claim regexes
+ * avoid false positives on historical CHANGELOG or vendored "N tools" strings.
+ * The installer banner is intentionally NOT listed: PR #203 made it derive the
+ * count from getToolNames("expert") at runtime, so it can never drift.
+ *
+ * Usage:
+ *   node bin/check-tool-count.mjs              # Check the current repo
+ *   node bin/check-tool-count.mjs <repo-root>  # Check a specific repo root
+ *
+ * Exit codes:
+ *   0 — every claim matches the manifest count
+ *   1 — at least one claim is stale or missing
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { argv, cwd, exit } from "node:process";
+const MANIFEST = {
+    expert: "plugins/expert.json",
+    beginner: "plugins/beginner.json",
+};
+const ASSERTIONS = [
+    {
+        file: "docs/skills.md",
+        pattern: /MCP server \((\d+) tools\)/,
+        mode: "expert",
+        label: "expert MCP tool count",
+    },
+    {
+        file: "README.md",
+        pattern: /MCP tools \((\d+) of them/,
+        mode: "expert",
+        label: "expert MCP tool count (README)",
+    },
+    {
+        file: "QUICKSTART.md",
+        pattern: /MCP tools \((\d+) of them/,
+        mode: "expert",
+        label: "expert MCP tool count (QUICKSTART)",
+    },
+    {
+        file: "src/bin/mcp-server.mts",
+        pattern: /beginner \((\d+) tools\)/,
+        mode: "beginner",
+        label: "beginner mode tool count",
+    },
+];
+export function countTools(repoRoot, mode) {
+    const raw = readFileSync(join(repoRoot, MANIFEST[mode]), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.tools)) {
+        throw new Error(`${MANIFEST[mode]} has no "tools" array`);
+    }
+    return parsed.tools.length;
+}
+function checkAssertion(repoRoot, a, expected) {
+    let content;
+    try {
+        content = readFileSync(join(repoRoot, a.file), "utf8");
+    }
+    catch {
+        return { file: a.file, label: a.label, reason: "missing", expected };
+    }
+    const m = content.match(a.pattern);
+    if (!m)
+        return { file: a.file, label: a.label, reason: "missing", expected };
+    if (Number(m[1]) === expected)
+        return null;
+    return { file: a.file, label: a.label, reason: "stale", found: m[0], expected };
+}
+export function checkToolCount(repoRoot) {
+    const counts = {
+        expert: countTools(repoRoot, "expert"),
+        beginner: countTools(repoRoot, "beginner"),
+    };
+    const violations = [];
+    for (const a of ASSERTIONS) {
+        const v = checkAssertion(repoRoot, a, counts[a.mode]);
+        if (v)
+            violations.push(v);
+    }
+    return { violations, counts };
+}
+function main() {
+    const repoRoot = argv[2] ?? cwd();
+    const { violations, counts } = checkToolCount(repoRoot);
+    if (violations.length === 0) {
+        console.log(`OK tool-count: all ${ASSERTIONS.length} claim(s) match the generated manifests ` +
+            `(expert=${counts.expert}, beginner=${counts.beginner}).`);
+        exit(0);
+    }
+    console.error(`FAIL tool-count: ${violations.length} claim(s) do not match the generated tool manifests ` +
+        `(expert=${counts.expert}, beginner=${counts.beginner}).`);
+    console.error("");
+    for (const v of violations) {
+        if (v.reason === "stale") {
+            console.error(`  ${v.file} — ${v.label}: states "${v.found}", expected ${v.expected}`);
+        }
+        else {
+            console.error(`  ${v.file} — ${v.label}: no matching tool-count claim found (expected ${v.expected})`);
+        }
+    }
+    console.error("");
+    console.error("Fix: bump the claim to match plugins/{expert,beginner}.json tools[].length, or add the");
+    console.error("tool to BEGINNER_TOOL_ENTRIES/EXPERT_TOOL_ENTRIES in src/lib/plugin-metadata.mts and");
+    console.error("re-run `npm run build` to regenerate the manifests.");
+    exit(1);
+}
+const invokedDirectly = argv[1] !== undefined && import.meta.url.endsWith(argv[1].replace(/\\/g, "/"));
+if (invokedDirectly || argv[1]?.endsWith("check-tool-count.mjs")) {
+    main();
+}

package/bin/generate-plugin-manifests.mjs

@@ -107,7 +107,7 @@ async function writePluginBundleReadme() {
         "- `tdd-workflow` — RED/GREEN/REFACTOR + 80% coverage gate",
         "- `workspace-surface-audit` — environment + capability audit",
         "- Tier-1/Tier-2 enforcement skills (`gateguard`, `verification-loop`,",
-        "  `para-memory-files`, `safety-guard`, `token-budget-advisor`,",
+        "  `safety-guard`, `token-budget-advisor`,",
         "  `strategic-compact`, `wild-risa-balance`)",
         "",
         "**Optional companions the orchestrator routes to (install separately if",
@@ -152,7 +152,9 @@ async function writePluginBundle() {
         copyFileTo(join(REPO_ROOT, "lib", "observe-event.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "observe-event.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "goal-state.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "goal-state.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "goal-drift-gate.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "goal-drift-gate.mjs")),
+        copyFileTo(join(REPO_ROOT, "lib", "hook-pack-gate.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "hook-pack-gate.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "recall-index.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "recall-index.mjs")),
+        copyFileTo(join(REPO_ROOT, "lib", "recall-briefing.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "recall-briefing.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "skill-distill.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "skill-distill.mjs")),
         copyFileTo(join(REPO_ROOT, "LICENSE"), join(PLUGIN_BUNDLE_DIR, "LICENSE")),
         writePluginBundleReadme(),

package/bin/harvest-friction.mjs

@@ -248,7 +248,7 @@ function main() {
         console.log("  the Node observer is not on PATH — never tool_complete with output_summary,");
         console.log("  which is what the classifier needs.");
         console.log("  Install jq (winget install jqlang.jq | brew install jq | apt install jq)");
-        console.log("  OR ensure hooks/bin/observe.mjs is reachable from the hook script.");
+        console.log("  OR ensure instincts/bin/observe.mjs is reachable from the hook script.");
     }
     else if (result.thinSchemaRows > 0 && result.classifiedRows === 0) {
         console.log("");

package/bin/install.mjs

@@ -6,6 +6,7 @@
  *   npx continuous-improvement install                # beginner mode (default)
  *   npx continuous-improvement install --mode expert  # + MCP server + session hooks
  *   npx continuous-improvement install --pack react   # load starter instinct pack
+ *   npx continuous-improvement install --target gemini,codex  # skill into other agents' rules files
  *   npx continuous-improvement install --uninstall    # remove everything
  */
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
@@ -14,6 +15,8 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
+import { getToolNames } from "../lib/plugin-metadata.mjs";
+import { TARGET_IDS, planTargetWrites, resolveTargets } from "../lib/install-targets.mjs";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const SKILL_SOURCE = join(__dirname, "..", "SKILL.md");
@@ -492,6 +495,17 @@ Options for 'install':
                       beginner  — hooks + skill + commands (default)
                       expert    — beginner + MCP server + session hooks
   --pack <name>     Load a starter instinct pack (react, python, go, meta)
+  --target <names>  Comma-separated platform list (default: claude):
+                      claude    — full install: hooks + skill + commands
+                      gemini    — GEMINI.md (Gemini CLI)
+                      codex     — AGENTS.md (Codex CLI / agents.md standard)
+                      cursor    — .cursor/rules/continuous-improvement.mdc
+                      windsurf  — .windsurf/rules/continuous-improvement.md
+                      zed       — .rules
+                      aider     — CONVENTIONS.md + .aider.conf.yml
+                      copilot   — .github/copilot-instructions.md
+                    Non-claude targets write the 7-Laws skill text into the
+                    current project; hooks/MCP/instincts stay Claude Code-only.
   --help            Show this help
 
 Options for 'backfill':
@@ -502,6 +516,7 @@ Examples:
   npx continuous-improvement install                # beginner (default)
   npx continuous-improvement install --mode expert  # full power
   npx continuous-improvement install --pack react   # load React instincts
+  npx continuous-improvement install --target gemini,codex  # other agents' rules files
   npx continuous-improvement backfill --dry-run     # report thin/rich row counts
   npx continuous-improvement backfill               # tag rows in place
   npx continuous-improvement install --uninstall    # remove everything
@@ -509,7 +524,12 @@ Examples:
 }
 function getProjectHashSync() {
     try {
-        const root = execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf8" }).trim();
+        // No shell redirect — `2>/dev/null` breaks under cmd.exe (tries to open a
+        // file literally named /dev/null); ignore stderr via stdio instead.
+        const root = execSync("git rev-parse --show-toplevel", {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
         const hash = createHash("sha256").update(root).digest("hex").slice(0, 12);
         return { root, hash };
     }
@@ -546,6 +566,60 @@ if (args.includes("--uninstall")) {
     uninstallAll();
     process.exit(0);
 }
+// --target <names>: comma-separated platform list, default claude-only.
+// Non-claude targets receive the skill text in their platform's rules file
+// (project-level); the full hook/MCP/instinct install stays Claude Code-only.
+const targetFlagIndex = rawArgs.indexOf("--target");
+let requestedTargets = ["claude"];
+if (targetFlagIndex !== -1) {
+    const targetCsv = rawArgs[targetFlagIndex + 1];
+    if (!targetCsv || targetCsv.startsWith("--")) {
+        console.error(`--target requires a value. Valid targets: ${TARGET_IDS.join(", ")}`);
+        process.exit(1);
+    }
+    const resolved = resolveTargets(targetCsv);
+    if (resolved.unknown.length > 0) {
+        console.error(`Unknown --target name(s): ${resolved.unknown.join(", ")}. Valid targets: ${TARGET_IDS.join(", ")}`);
+        process.exit(1);
+    }
+    if (resolved.targets.length === 0) {
+        console.error(`--target requires at least one name. Valid targets: ${TARGET_IDS.join(", ")}`);
+        process.exit(1);
+    }
+    requestedTargets = resolved.targets;
+}
+function installNonClaudeTargets(targetIds) {
+    const skillMd = readFileSync(SKILL_SOURCE, "utf8");
+    const project = getProjectHashSync();
+    const projectRoot = project.root === "global" ? process.cwd() : project.root;
+    const readExisting = (relPath) => {
+        const absPath = join(projectRoot, relPath);
+        return existsSync(absPath) ? readFileSync(absPath, "utf8") : null;
+    };
+    const notes = new Set();
+    for (const targetId of targetIds) {
+        const plan = planTargetWrites(targetId, skillMd, readExisting);
+        for (const write of plan.writes) {
+            const absPath = join(projectRoot, write.relPath);
+            mkdirSync(dirname(absPath), { recursive: true });
+            writeFileSync(absPath, write.content);
+            console.log(`  ✓ ${targetId} → ${write.relPath}`);
+        }
+        for (const note of plan.notes)
+            notes.add(note);
+    }
+    for (const note of notes)
+        console.log(`  ℹ ${note}`);
+}
+const nonClaudeTargets = requestedTargets.filter((targetId) => targetId !== "claude");
+if (nonClaudeTargets.length > 0) {
+    console.log("\ncontinuous-improvement multi-platform install\n");
+    installNonClaudeTargets(nonClaudeTargets);
+    if (!requestedTargets.includes("claude")) {
+        console.log("\nDone. Claude Code install skipped (not in --target list).");
+        process.exit(0);
+    }
+}
 console.log(`
 continuous-improvement (mode: ${INSTALL_MODE})
 Research → Plan → Execute → Verify → Reflect → Learn → Iterate
@@ -556,7 +630,7 @@ console.log("Installing to Claude Code...\n");
 const installed = installSkill() ? 1 : 0;
 const modeInfo = {
     beginner: "Hooks are capturing silently. System auto-levels as you use it.",
-    expert: "Full plugin active: hooks + MCP server + session hooks. 12 tools available.",
+    expert: `Full plugin active: hooks + MCP server + session hooks. ${getToolNames("expert").length} tools available.`,
 };
 const packIndex = rawArgs.indexOf("--pack");
 if (packIndex !== -1 && rawArgs[packIndex + 1]) {
@@ -617,6 +691,6 @@ Next steps:
   3. If a task needs persistent planning, run: /planning-with-files
   4. After your first task, run: /continuous-improvement
   5. Try: /discipline for quick reference, /dashboard for instinct health
-${INSTALL_MODE === "expert" ? "\nMCP tools available: ci_status, ci_instincts, ci_reflect, ci_reinforce,\n  ci_create_instinct, ci_observations, ci_export, ci_import, ci_plan_init,\n  ci_plan_status, ci_dashboard, ci_load_pack" : ""}
+${INSTALL_MODE === "expert" ? `\nMCP tools available (${getToolNames("expert").length}): ${getToolNames("expert").join(", ")}` : ""}
 Available instinct packs: npx continuous-improvement install --pack react|python|go|meta
 `);