continuous-improvement 3.12.3 → 3.15.0

package/.claude-plugin/marketplace.json

@@ -7,8 +7,8 @@
   "plugins": [
     {
       "name": "continuous-improvement",
-      "description": "Makes Claude Code reason harder, recall past corrections, and learn from every session so its competence compounds run over run. The Mulahazah engine turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time — 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.12.3",
+      "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"

package/CHANGELOG.md

@@ -4,7 +4,37 @@ 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
 

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Naim Katiman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Naim Katiman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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 (18 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

@@ -7,7 +7,7 @@
 <h1 align="center">Claude Code that gets sharper every session</h1>
 
 <p align="center">
-  <b>Reasons deeper. Recalls what it already solved. Verifies before "done". Keeps every lesson.</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">
@@ -36,7 +36,7 @@ Claude Code is powerful but leaves intelligence on the table: it edits before re
 
 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.
 
@@ -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 (18 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.
 
@@ -173,6 +173,26 @@ The framework has documented operator-level modes that change hook behavior with
 | `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
@@ -299,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/bin/analyze.sh

@@ -1,161 +1,161 @@
-#!/usr/bin/env bash
-# analyze.sh — Read observations.jsonl, detect patterns, create instinct YAML files
-# Runs via /continuous-improvement command. Uses claude CLI with Haiku for cost-efficient analysis.
-
-set -euo pipefail
-
-INSTINCTS_DIR="${HOME}/.claude/instincts"
-
-# ---------------------------------------------------------------------------
-# Detect project
-# ---------------------------------------------------------------------------
-PROJECT_ROOT=""
-if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
-  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
-fi
-if [[ -z "$PROJECT_ROOT" ]]; then
-  PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
-fi
-if [[ -z "$PROJECT_ROOT" ]]; then
-  PROJECT_ROOT="global"
-fi
-
-# Use shasum on macOS, sha256sum on Linux
-if command -v sha256sum &>/dev/null; then
-  PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
-elif command -v shasum &>/dev/null; then
-  PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | shasum -a 256 | cut -c1-12)"
-else
-  # Fallback: use project root basename if no hashing available
-  PROJECT_HASH="$(basename "$PROJECT_ROOT" | tr -cd 'a-zA-Z0-9' | cut -c1-12)"
-fi
-PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
-PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
-OBS_FILE="${PROJECT_DIR}/observations.jsonl"
-
-# ---------------------------------------------------------------------------
-# Check observations exist
-# ---------------------------------------------------------------------------
-if [[ ! -f "$OBS_FILE" ]] || [[ ! -s "$OBS_FILE" ]]; then
-  echo "No observations found at ${OBS_FILE}"
-  echo "Use Claude Code with hooks installed to generate observations."
-  exit 0
-fi
-
-OBS_COUNT=$(wc -l < "$OBS_FILE")
-echo "Found ${OBS_COUNT} observations in ${OBS_FILE}"
-
-if (( OBS_COUNT < 20 )); then
-  echo "Need at least 20 observations for meaningful analysis. Keep using Claude Code (${OBS_COUNT}/20)."
-  exit 0
-fi
-
-# ---------------------------------------------------------------------------
-# Read existing instincts to avoid duplicates
-# ---------------------------------------------------------------------------
-EXISTING_INSTINCTS=""
-for f in "${PROJECT_DIR}"/*.yaml "${INSTINCTS_DIR}/global"/*.yaml; do
-  [[ -f "$f" ]] && EXISTING_INSTINCTS="${EXISTING_INSTINCTS}$(cat "$f")"$'\n'
-done
-
-# ---------------------------------------------------------------------------
-# Take last 500 observations
-# ---------------------------------------------------------------------------
-RECENT_OBS=$(tail -500 "$OBS_FILE")
-
-# ---------------------------------------------------------------------------
-# Build analysis prompt
-# ---------------------------------------------------------------------------
-ANALYSIS_PROMPT="Analyze these Claude Code session observations and extract behavioral patterns as instinct YAML files.
-
-OBSERVATIONS (JSONL — each line is a tool call):
-${RECENT_OBS}
-
-EXISTING INSTINCTS (already learned — do NOT duplicate these):
-${EXISTING_INSTINCTS}
-
-YOUR TASK:
-1. Look for REPEATED PATTERNS — same tool sequence used 3+ times
-2. Look for ERROR-THEN-FIX sequences — tool fails, next tools fix it
-3. Look for TOOL PREFERENCES — one tool consistently chosen over alternatives
-4. Look for WORKFLOW PATTERNS — consistent ordering of operations
-5. Look for USER CORRECTIONS — user says no/stop/don't after an action
-
-OUTPUT FORMAT — output ONLY new instincts as YAML blocks, separated by ---:
-
-id: descriptive-kebab-case-id
-trigger: \"when [specific situation]\"
-confidence: 0.5
-domain: workflow|tooling|testing|patterns
-source: observation
-scope: project
-project_id: ${PROJECT_HASH}
-created: \"$(date -u +%Y-%m-%d)\"
-last_seen: \"$(date -u +%Y-%m-%d)\"
-observation_count: [number of times pattern was seen]
----
-[One sentence describing the specific actionable behavior]
-
-Rules:
-- Only create instincts for patterns seen 3+ times
-- Start confidence at 0.5 (suggest level)
-- Be specific and actionable (not vague advice)
-- Different from existing instincts listed above
-
-If no new patterns are found, output exactly: NO_NEW_PATTERNS
-
-Output ONLY the YAML blocks or NO_NEW_PATTERNS. No explanation, no preamble."
-
-# ---------------------------------------------------------------------------
-# Run analysis with Haiku
-# ---------------------------------------------------------------------------
-echo "Analyzing patterns with Haiku..."
-RESULT=$(echo "$ANALYSIS_PROMPT" | claude --model haiku --print -p - 2>/dev/null) || {
-  echo "Analysis failed — claude CLI error. Try running manually."
-  exit 1
-}
-
-if [[ "$RESULT" == "NO_NEW_PATTERNS" ]] || [[ -z "$RESULT" ]]; then
-  echo "No new patterns detected yet. Keep using Claude Code — patterns emerge over time."
-  exit 0
-fi
-
-# ---------------------------------------------------------------------------
-# Write instinct YAML files
-# ---------------------------------------------------------------------------
-mkdir -p "$PROJECT_DIR"
-
-NEW_COUNT=0
-INSTINCT_ID=""
-BLOCK=""
-
-while IFS= read -r line; do
-  if [[ "$line" == "---" ]] && [[ -n "$BLOCK" ]]; then
-    if [[ -n "$INSTINCT_ID" ]]; then
-      DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
-      printf '%s\n' "$BLOCK" > "$DEST"
-      echo "  + ${INSTINCT_ID} -> ${DEST}"
-      NEW_COUNT=$((NEW_COUNT + 1))
-    fi
-    INSTINCT_ID=""
-    BLOCK=""
-  else
-    BLOCK="${BLOCK}${line}"$'\n'
-    if [[ "$line" =~ ^id:\ (.+) ]]; then
-      INSTINCT_ID="${BASH_REMATCH[1]}"
-      INSTINCT_ID="${INSTINCT_ID//\"/}"
-      INSTINCT_ID="${INSTINCT_ID//\'/}"
-    fi
-  fi
-done <<< "$RESULT"
-
-# Handle last block
-if [[ -n "$INSTINCT_ID" ]] && [[ -n "$BLOCK" ]]; then
-  DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
-  printf '%s\n' "$BLOCK" > "$DEST"
-  echo "  + ${INSTINCT_ID} -> ${DEST}"
-  NEW_COUNT=$((NEW_COUNT + 1))
-fi
-
-echo ""
-echo "Created ${NEW_COUNT} new instinct(s) in ${PROJECT_DIR}/"
+#!/usr/bin/env bash
+# analyze.sh — Read observations.jsonl, detect patterns, create instinct YAML files
+# Runs via /continuous-improvement command. Uses claude CLI with Haiku for cost-efficient analysis.
+
+set -euo pipefail
+
+INSTINCTS_DIR="${HOME}/.claude/instincts"
+
+# ---------------------------------------------------------------------------
+# Detect project
+# ---------------------------------------------------------------------------
+PROJECT_ROOT=""
+if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
+  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="global"
+fi
+
+# Use shasum on macOS, sha256sum on Linux
+if command -v sha256sum &>/dev/null; then
+  PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
+elif command -v shasum &>/dev/null; then
+  PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | shasum -a 256 | cut -c1-12)"
+else
+  # Fallback: use project root basename if no hashing available
+  PROJECT_HASH="$(basename "$PROJECT_ROOT" | tr -cd 'a-zA-Z0-9' | cut -c1-12)"
+fi
+PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
+PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
+OBS_FILE="${PROJECT_DIR}/observations.jsonl"
+
+# ---------------------------------------------------------------------------
+# Check observations exist
+# ---------------------------------------------------------------------------
+if [[ ! -f "$OBS_FILE" ]] || [[ ! -s "$OBS_FILE" ]]; then
+  echo "No observations found at ${OBS_FILE}"
+  echo "Use Claude Code with hooks installed to generate observations."
+  exit 0
+fi
+
+OBS_COUNT=$(wc -l < "$OBS_FILE")
+echo "Found ${OBS_COUNT} observations in ${OBS_FILE}"
+
+if (( OBS_COUNT < 20 )); then
+  echo "Need at least 20 observations for meaningful analysis. Keep using Claude Code (${OBS_COUNT}/20)."
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Read existing instincts to avoid duplicates
+# ---------------------------------------------------------------------------
+EXISTING_INSTINCTS=""
+for f in "${PROJECT_DIR}"/*.yaml "${INSTINCTS_DIR}/global"/*.yaml; do
+  [[ -f "$f" ]] && EXISTING_INSTINCTS="${EXISTING_INSTINCTS}$(cat "$f")"$'\n'
+done
+
+# ---------------------------------------------------------------------------
+# Take last 500 observations
+# ---------------------------------------------------------------------------
+RECENT_OBS=$(tail -500 "$OBS_FILE")
+
+# ---------------------------------------------------------------------------
+# Build analysis prompt
+# ---------------------------------------------------------------------------
+ANALYSIS_PROMPT="Analyze these Claude Code session observations and extract behavioral patterns as instinct YAML files.
+
+OBSERVATIONS (JSONL — each line is a tool call):
+${RECENT_OBS}
+
+EXISTING INSTINCTS (already learned — do NOT duplicate these):
+${EXISTING_INSTINCTS}
+
+YOUR TASK:
+1. Look for REPEATED PATTERNS — same tool sequence used 3+ times
+2. Look for ERROR-THEN-FIX sequences — tool fails, next tools fix it
+3. Look for TOOL PREFERENCES — one tool consistently chosen over alternatives
+4. Look for WORKFLOW PATTERNS — consistent ordering of operations
+5. Look for USER CORRECTIONS — user says no/stop/don't after an action
+
+OUTPUT FORMAT — output ONLY new instincts as YAML blocks, separated by ---:
+
+id: descriptive-kebab-case-id
+trigger: \"when [specific situation]\"
+confidence: 0.5
+domain: workflow|tooling|testing|patterns
+source: observation
+scope: project
+project_id: ${PROJECT_HASH}
+created: \"$(date -u +%Y-%m-%d)\"
+last_seen: \"$(date -u +%Y-%m-%d)\"
+observation_count: [number of times pattern was seen]
+---
+[One sentence describing the specific actionable behavior]
+
+Rules:
+- Only create instincts for patterns seen 3+ times
+- Start confidence at 0.5 (suggest level)
+- Be specific and actionable (not vague advice)
+- Different from existing instincts listed above
+
+If no new patterns are found, output exactly: NO_NEW_PATTERNS
+
+Output ONLY the YAML blocks or NO_NEW_PATTERNS. No explanation, no preamble."
+
+# ---------------------------------------------------------------------------
+# Run analysis with Haiku
+# ---------------------------------------------------------------------------
+echo "Analyzing patterns with Haiku..."
+RESULT=$(echo "$ANALYSIS_PROMPT" | claude --model haiku --print -p - 2>/dev/null) || {
+  echo "Analysis failed — claude CLI error. Try running manually."
+  exit 1
+}
+
+if [[ "$RESULT" == "NO_NEW_PATTERNS" ]] || [[ -z "$RESULT" ]]; then
+  echo "No new patterns detected yet. Keep using Claude Code — patterns emerge over time."
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Write instinct YAML files
+# ---------------------------------------------------------------------------
+mkdir -p "$PROJECT_DIR"
+
+NEW_COUNT=0
+INSTINCT_ID=""
+BLOCK=""
+
+while IFS= read -r line; do
+  if [[ "$line" == "---" ]] && [[ -n "$BLOCK" ]]; then
+    if [[ -n "$INSTINCT_ID" ]]; then
+      DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
+      printf '%s\n' "$BLOCK" > "$DEST"
+      echo "  + ${INSTINCT_ID} -> ${DEST}"
+      NEW_COUNT=$((NEW_COUNT + 1))
+    fi
+    INSTINCT_ID=""
+    BLOCK=""
+  else
+    BLOCK="${BLOCK}${line}"$'\n'
+    if [[ "$line" =~ ^id:\ (.+) ]]; then
+      INSTINCT_ID="${BASH_REMATCH[1]}"
+      INSTINCT_ID="${INSTINCT_ID//\"/}"
+      INSTINCT_ID="${INSTINCT_ID//\'/}"
+    fi
+  fi
+done <<< "$RESULT"
+
+# Handle last block
+if [[ -n "$INSTINCT_ID" ]] && [[ -n "$BLOCK" ]]; then
+  DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
+  printf '%s\n' "$BLOCK" > "$DEST"
+  echo "  + ${INSTINCT_ID} -> ${DEST}"
+  NEW_COUNT=$((NEW_COUNT + 1))
+fi
+
+echo ""
+echo "Created ${NEW_COUNT} new instinct(s) in ${PROJECT_DIR}/"

package/bin/backfill.mjs

@@ -27,25 +27,25 @@ const args = process.argv.slice(2);
 const DRY_RUN = args.includes("--dry-run");
 const HELP = args.includes("--help") || args.includes("-h");
 if (HELP) {
-    console.log(`
-backfill — Tag legacy thin-schema observation rows.
-
-Usage:
-  npx continuous-improvement backfill            Tag rows in place
-  npx continuous-improvement backfill --dry-run  Report counts, write nothing
-
-What it does:
-  Walks ~/.claude/instincts/<hash>/observations.jsonl files and adds a
-  schema field ("thin" or "rich") to every row that lacks one. Thin rows
-  came from the legacy bash fallback (jq missing) and have no input_summary;
-  rich rows came from the Node observer and have full tool_input.command /
-  Edit.file_path / etc.
-
-Output:
-  - observations.jsonl rewritten in place (original kept as .bak)
-  - backfill-summary.json with per-project counts
-
-Idempotent. Always exits 0 — failures go to stderr only.
+    console.log(`
+backfill — Tag legacy thin-schema observation rows.
+
+Usage:
+  npx continuous-improvement backfill            Tag rows in place
+  npx continuous-improvement backfill --dry-run  Report counts, write nothing
+
+What it does:
+  Walks ~/.claude/instincts/<hash>/observations.jsonl files and adds a
+  schema field ("thin" or "rich") to every row that lacks one. Thin rows
+  came from the legacy bash fallback (jq missing) and have no input_summary;
+  rich rows came from the Node observer and have full tool_input.command /
+  Edit.file_path / etc.
+
+Output:
+  - observations.jsonl rewritten in place (original kept as .bak)
+  - backfill-summary.json with per-project counts
+
+Idempotent. Always exits 0 — failures go to stderr only.
 `);
     process.exit(0);
 }

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}.`);