continuous-improvement 3.11.0 → 3.12.3

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

@@ -153,6 +153,7 @@ async function writePluginBundle() {
         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", "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/hook-stats.mjs

@@ -46,27 +46,27 @@ import { platform } from "node:os";
 import { join } from "node:path";
 import { argv, cwd, exit, stderr, stdout } from "node:process";
 import { resolveHomeDir } from "../lib/resolve-home-dir.mjs";
-const USAGE = `Usage: node bin/hook-stats.mjs [options]
-
-Reads JSONL telemetry from <HOME>/.claude/hook-telemetry/*.jsonl and
-prints per-hook aggregate counts over a recent time window.
-
-Options:
-  --hours=<n>            Time window in hours (default: 24)
-  --hash=<hash>          Only read this single <hash>.jsonl file
-                         (default: sha256 of the current working directory,
-                         normalized to forward slashes and lowercased on
-                         Windows, then first 12 hex chars)
-  --telemetry-dir=<path> Override telemetry dir
-                         (default: <HOME>/.claude/hook-telemetry)
-  --help                 Show this help and exit 0
-
-Output:
-  One line per hook: "<hook> last <hours>h: pass=<n> block=<n>
-  skip-short=<n> total=<n> avg-duration=<X>ms".
-  If there are no records in the window: "no records in last <hours>h".
-
-The reader is parse-tolerant: malformed JSONL lines are skipped silently.
+const USAGE = `Usage: node bin/hook-stats.mjs [options]
+
+Reads JSONL telemetry from <HOME>/.claude/hook-telemetry/*.jsonl and
+prints per-hook aggregate counts over a recent time window.
+
+Options:
+  --hours=<n>            Time window in hours (default: 24)
+  --hash=<hash>          Only read this single <hash>.jsonl file
+                         (default: sha256 of the current working directory,
+                         normalized to forward slashes and lowercased on
+                         Windows, then first 12 hex chars)
+  --telemetry-dir=<path> Override telemetry dir
+                         (default: <HOME>/.claude/hook-telemetry)
+  --help                 Show this help and exit 0
+
+Output:
+  One line per hook: "<hook> last <hours>h: pass=<n> block=<n>
+  skip-short=<n> total=<n> avg-duration=<X>ms".
+  If there are no records in the window: "no records in last <hours>h".
+
+The reader is parse-tolerant: malformed JSONL lines are skipped silently.
 `;
 function parseArgs(rawArgs) {
     const opts = {

package/bin/install.mjs

@@ -14,6 +14,7 @@ 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";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const SKILL_SOURCE = join(__dirname, "..", "SKILL.md");
@@ -556,7 +557,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 +618,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
 `);

package/bin/mcp-server.mjs

@@ -3,7 +3,7 @@
  * continuous-improvement MCP Server
  *
  * Exposes instincts, observations, and reflection as MCP tools + resources.
- * Two modes: beginner (3 tools) and expert (all tools).
+ * Two modes: beginner (4 tools) and expert (all tools).
  *
  * Usage:
  *   node bin/mcp-server.mjs                  # default: beginner mode

package/commands/continuous-improvement.md

@@ -1,115 +1,115 @@
----
-name: continuous-improvement
-description: "Reflect on the current session, analyze observations for patterns, and show instinct status. Runs on-demand to save tokens."
----
-
-# /continuous-improvement
-
-Run this when you want to reflect and learn — not every session. Three steps in order.
-
-## Step 1: Reflect
-
-Generate a reflection for this session based on what happened:
-
-```
-## Reflection — [Date]
-- What worked:
-- What failed:
-- What I'd do differently:
-- Rule to add:
-- Iteration — Next best recommendations (ranked, top 3):
-  1. <primary — strongest next move>
-  2. <alternative — different angle>
-  3. <alternative — smaller/larger scope>
-```
-
-If there's a "Rule to add", create an instinct YAML file with 0.6 starting confidence in the project's instinct directory.
-
-The "Iteration — Next best recommendations" field is the Law 6 handoff. List the **top 3 ranked** core-development moves — what to build, fix, refactor, or investigate next so the feature/system advances. Item #1 is the strongest; #2 and #3 are alternatives the user can pivot to. NOT git steps (commit, push, PR), NOT verification re-runs, NOT deploy actions — those belong in the end-of-run summary.
-
-Format per item: `<verb> <object at path:line> (<why, one clause grounded in current context>)`.
-
-Rules: always exactly 3 distinct directions, not padding. If fewer real moves exist, fill remaining slots with `None — goal met from this angle.` If the goal is fully met across all angles, write `1. None — goal met, stop.` and omit #2 and #3.
-
-## Step 2: Analyze Observations
-
-Check `~/.claude/instincts/` for the current project (detect via git root → SHA-256 first 12 chars).
-
-Look at `~/.claude/instincts/<hash>/observations.jsonl`. If 20+ lines exist:
-
-1. Read the last 500 lines
-2. Read existing instinct `*.yaml` files (project + global)
-3. Detect patterns:
-   - User corrections → "don't do X" instincts
-   - Error→fix sequences → "when X fails, try Y"
-   - Repeated workflows (3+ times) → "for X, do A→B→C"
-   - Tool preferences → "use tool Y for task X"
-4. Create/update instinct YAML files
-5. Be conservative: only create instincts for 3+ observations of the same pattern
-
-If fewer than 20 observations, skip analysis and note the count.
-
-### Multi-Agent Analysis (500+ observations)
-
-When observation backlog is large, parallelize:
-- **Agent 1:** User corrections + error→fix patterns
-- **Agent 2:** Repeated workflows + tool preferences
-- **Agent 3:** Cross-reference existing instincts for updates
-
-Merge results and deduplicate before writing YAML files.
-
-## Step 3: Show Status
-
-Display all instincts for the current project + global:
-
-```
-=== continuous-improvement ===
-
-## Level: [CAPTURE | ANALYZE | SUGGEST | AUTO-APPLY]
-
-## Session Reflection
-- What worked: [from this session]
-- What failed: [from this session]
-- What I'd do differently: [from this session]
-- Rule to add: [captured as instinct]
-- Iteration — Next best recommendations (ranked, top 3):
-  1. [primary core-development move]
-  2. [alternative angle]
-  3. [alternative scope]
-
-## Learning
-  NEW  [instinct-id]        [domain]  [confidence]  (from reflection)
-   ↑   [instinct-id]        [domain]  [old]→[new]   (+N observations)
-
-## Instincts — [project-name] ([hash])
-  ● [0.85] instinct-id       domain   auto-apply
-  ◐ [0.60] instinct-id       domain   suggest
-  ○ [0.35] instinct-id       domain   silent
-
-## Instincts — global
-  ● [0.90] instinct-id       domain   auto-apply
-
-## Next
-- Keep working — hooks capture automatically
-- System auto-levels as instincts gain confidence
-```
-
-If no instincts or observations exist yet, explain this is expected — the system is in CAPTURE level and will create instincts after 20+ observations accumulate.
-
-## Subcommands
-
-### `/continuous-improvement weekly`
-
-Set up a weekly analysis schedule:
-1. Create a cron/loop schedule that runs `/continuous-improvement analyze` every 7 days
-2. Confirm the schedule to the user
-3. Show next scheduled run date
-
-### `/continuous-improvement always-on`
-
-Toggle always-on mode for the current project:
-1. Find project hash
-2. Create/update `~/.claude/instincts/<hash>/config.yaml` with `always_on: true|false`
-3. Confirm the change
-
-**Default is off** — observations accumulate silently, analysis only runs when you ask.
+---
+name: continuous-improvement
+description: "Reflect on the current session, analyze observations for patterns, and show instinct status. Runs on-demand to save tokens."
+---
+
+# /continuous-improvement
+
+Run this when you want to reflect and learn — not every session. Three steps in order.
+
+## Step 1: Reflect
+
+Generate a reflection for this session based on what happened:
+
+```
+## Reflection — [Date]
+- What worked:
+- What failed:
+- What I'd do differently:
+- Rule to add:
+- Iteration — Next best recommendations (ranked, top 3):
+  1. <primary — strongest next move>
+  2. <alternative — different angle>
+  3. <alternative — smaller/larger scope>
+```
+
+If there's a "Rule to add", create an instinct YAML file with 0.6 starting confidence in the project's instinct directory.
+
+The "Iteration — Next best recommendations" field is the Law 6 handoff. List the **top 3 ranked** core-development moves — what to build, fix, refactor, or investigate next so the feature/system advances. Item #1 is the strongest; #2 and #3 are alternatives the user can pivot to. NOT git steps (commit, push, PR), NOT verification re-runs, NOT deploy actions — those belong in the end-of-run summary.
+
+Format per item: `<verb> <object at path:line> (<why, one clause grounded in current context>)`.
+
+Rules: always exactly 3 distinct directions, not padding. If fewer real moves exist, fill remaining slots with `None — goal met from this angle.` If the goal is fully met across all angles, write `1. None — goal met, stop.` and omit #2 and #3.
+
+## Step 2: Analyze Observations
+
+Check `~/.claude/instincts/` for the current project (detect via git root → SHA-256 first 12 chars).
+
+Look at `~/.claude/instincts/<hash>/observations.jsonl`. If 20+ lines exist:
+
+1. Read the last 500 lines
+2. Read existing instinct `*.yaml` files (project + global)
+3. Detect patterns:
+   - User corrections → "don't do X" instincts
+   - Error→fix sequences → "when X fails, try Y"
+   - Repeated workflows (3+ times) → "for X, do A→B→C"
+   - Tool preferences → "use tool Y for task X"
+4. Create/update instinct YAML files
+5. Be conservative: only create instincts for 3+ observations of the same pattern
+
+If fewer than 20 observations, skip analysis and note the count.
+
+### Multi-Agent Analysis (500+ observations)
+
+When observation backlog is large, parallelize:
+- **Agent 1:** User corrections + error→fix patterns
+- **Agent 2:** Repeated workflows + tool preferences
+- **Agent 3:** Cross-reference existing instincts for updates
+
+Merge results and deduplicate before writing YAML files.
+
+## Step 3: Show Status
+
+Display all instincts for the current project + global:
+
+```
+=== continuous-improvement ===
+
+## Level: [CAPTURE | ANALYZE | SUGGEST | AUTO-APPLY]
+
+## Session Reflection
+- What worked: [from this session]
+- What failed: [from this session]
+- What I'd do differently: [from this session]
+- Rule to add: [captured as instinct]
+- Iteration — Next best recommendations (ranked, top 3):
+  1. [primary core-development move]
+  2. [alternative angle]
+  3. [alternative scope]
+
+## Learning
+  NEW  [instinct-id]        [domain]  [confidence]  (from reflection)
+   ↑   [instinct-id]        [domain]  [old]→[new]   (+N observations)
+
+## Instincts — [project-name] ([hash])
+  ● [0.85] instinct-id       domain   auto-apply
+  ◐ [0.60] instinct-id       domain   suggest
+  ○ [0.35] instinct-id       domain   silent
+
+## Instincts — global
+  ● [0.90] instinct-id       domain   auto-apply
+
+## Next
+- Keep working — hooks capture automatically
+- System auto-levels as instincts gain confidence
+```
+
+If no instincts or observations exist yet, explain this is expected — the system is in CAPTURE level and will create instincts after 20+ observations accumulate.
+
+## Subcommands
+
+### `/continuous-improvement weekly`
+
+Set up a weekly analysis schedule:
+1. Create a cron/loop schedule that runs `/continuous-improvement analyze` every 7 days
+2. Confirm the schedule to the user
+3. Show next scheduled run date
+
+### `/continuous-improvement always-on`
+
+Toggle always-on mode for the current project:
+1. Find project hash
+2. Create/update `~/.claude/instincts/<hash>/config.yaml` with `always_on: true|false`
+3. Confirm the change
+
+**Default is off** — observations accumulate silently, analysis only runs when you ask.

package/commands/dashboard.md

@@ -1,56 +1,56 @@
----
-name: dashboard
-description: Visual dashboard showing instinct health, observation stats, and learning progress
----
-
-# Instinct Dashboard
-
-Generate a visual dashboard for this project's continuous-improvement status.
-
-## Instructions
-
-1. **Find project hash:** Run `git rev-parse --show-toplevel 2>/dev/null`, then SHA-256 first 12 chars
-2. **Read observations:** Count lines in `~/.claude/instincts/<hash>/observations.jsonl`
-3. **Read instincts:** Load all `*.yaml` files from project dir + `global/`
-4. **Read instinct packs:** Check if any packs from `instinct-packs/` have been loaded
-
-## Display Format
-
-```
-╔══════════════════════════════════════════════════════════════╗
-║              continuous-improvement Dashboard                ║
-╠══════════════════════════════════════════════════════════════╣
-║                                                              ║
-║  Project: <name>              Level: <CAPTURE|ANALYZE|...>   ║
-║  Sessions: ~<obs/10>          Mode: <beginner|expert>        ║
-║                                                              ║
-║  ┌─ Observations ────────────────────────────────────────┐   ║
-║  │  Total: <n>    Unprocessed: <n>    Last: <date>       │   ║
-║  └───────────────────────────────────────────────────────┘   ║
-║                                                              ║
-║  ┌─ Instincts ───────────────────────────────────────────┐   ║
-║  │  Total: <n>                                           │   ║
-║  │  ████████░░ Auto-apply (0.7+): <n>                    │   ║
-║  │  █████░░░░░ Suggest (0.5-0.69): <n>                   │   ║
-║  │  ██░░░░░░░░ Silent (< 0.5): <n>                       │   ║
-║  │  Global: <n>    Project: <n>                          │   ║
-║  └───────────────────────────────────────────────────────┘   ║
-║                                                              ║
-║  ┌─ Top Instincts ───────────────────────────────────────┐   ║
-║  │  <list top 5 instincts by confidence with bars>       │   ║
-║  └───────────────────────────────────────────────────────┘   ║
-║                                                              ║
-║  ┌─ Health ──────────────────────────────────────────────┐   ║
-║  │  Stale (30+ days): <n>    Decaying: <n>               │   ║
-║  │  Recently reinforced: <n>                             │   ║
-║  └───────────────────────────────────────────────────────┘   ║
-║                                                              ║
-╚══════════════════════════════════════════════════════════════╝
-```
-
-## After Display
-
-- If stale instincts > 0: suggest reviewing them
-- If unprocessed observations > 20: suggest running analysis
-- If no instincts exist: explain the auto-leveling timeline
-- Show available instinct packs that haven't been loaded yet
+---
+name: dashboard
+description: Visual dashboard showing instinct health, observation stats, and learning progress
+---
+
+# Instinct Dashboard
+
+Generate a visual dashboard for this project's continuous-improvement status.
+
+## Instructions
+
+1. **Find project hash:** Run `git rev-parse --show-toplevel 2>/dev/null`, then SHA-256 first 12 chars
+2. **Read observations:** Count lines in `~/.claude/instincts/<hash>/observations.jsonl`
+3. **Read instincts:** Load all `*.yaml` files from project dir + `global/`
+4. **Read instinct packs:** Check if any packs from `instinct-packs/` have been loaded
+
+## Display Format
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║              continuous-improvement Dashboard                ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  Project: <name>              Level: <CAPTURE|ANALYZE|...>   ║
+║  Sessions: ~<obs/10>          Mode: <beginner|expert>        ║
+║                                                              ║
+║  ┌─ Observations ────────────────────────────────────────┐   ║
+║  │  Total: <n>    Unprocessed: <n>    Last: <date>       │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Instincts ───────────────────────────────────────────┐   ║
+║  │  Total: <n>                                           │   ║
+║  │  ████████░░ Auto-apply (0.7+): <n>                    │   ║
+║  │  █████░░░░░ Suggest (0.5-0.69): <n>                   │   ║
+║  │  ██░░░░░░░░ Silent (< 0.5): <n>                       │   ║
+║  │  Global: <n>    Project: <n>                          │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Top Instincts ───────────────────────────────────────┐   ║
+║  │  <list top 5 instincts by confidence with bars>       │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Health ──────────────────────────────────────────────┐   ║
+║  │  Stale (30+ days): <n>    Decaying: <n>               │   ║
+║  │  Recently reinforced: <n>                             │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+## After Display
+
+- If stale instincts > 0: suggest reviewing them
+- If unprocessed observations > 20: suggest running analysis
+- If no instincts exist: explain the auto-leveling timeline
+- Show available instinct packs that haven't been loaded yet

package/commands/harvest.md

@@ -65,7 +65,7 @@ Appended 12 instinct(s) to /Users/.../instincts/0af156594b39/instincts.jsonl
 If `tool_complete rows: 0`, the bash-fallback hook is active (no jq AND the Node observer is not on PATH) and only emits `tool_start` events. Two remediation paths:
 
 - **Install jq** — `winget install jqlang.jq` (Windows), `brew install jq` (macOS), `apt install jq` (Linux).
-- **Wire the Node observer** — ensure `hooks/bin/observe.mjs` is reachable from the active hook script.
+- **Wire the Node observer** — ensure the installed observer shim `instincts/bin/observe.mjs` (copied from `bin/observe.mjs`) sits beside the active hook script.
 
 Both are documented in the WARNING the classifier prints on a thin-schema host.
 

package/commands/seven-laws.md

@@ -1,16 +1,16 @@
----
-name: seven-laws
-description: "Brand-aligned alias for /continuous-improvement. Reflect on the current session, analyze observations for patterns, and show instinct status under the 7 Laws of AI Agent Discipline."
----
-
-# /seven-laws
-
-Brand-aligned alias for [`/continuous-improvement`](continuous-improvement.md). Both commands run the exact same three-step workflow under the 7 Laws of AI Agent Discipline:
-
-1. **Reflect** (Law 5) — generate a reflection block for this session.
-2. **Analyze** (Law 7) — process pending observations into instincts.
-3. **Status** — show all instincts for the project + global with confidence and current level.
-
-Run the workflow defined in [`continuous-improvement.md`](continuous-improvement.md). Subcommands `weekly` and `always-on` work identically.
-
-`/continuous-improvement` remains supported indefinitely for backward compatibility. Prefer `/seven-laws` going forward — it matches the brand and the SKILL.md spec.
+---
+name: seven-laws
+description: "Brand-aligned alias for /continuous-improvement. Reflect on the current session, analyze observations for patterns, and show instinct status under the 7 Laws of AI Agent Discipline."
+---
+
+# /seven-laws
+
+Brand-aligned alias for [`/continuous-improvement`](continuous-improvement.md). Both commands run the exact same three-step workflow under the 7 Laws of AI Agent Discipline:
+
+1. **Reflect** (Law 5) — generate a reflection block for this session.
+2. **Analyze** (Law 7) — process pending observations into instincts.
+3. **Status** — show all instincts for the project + global with confidence and current level.
+
+Run the workflow defined in [`continuous-improvement.md`](continuous-improvement.md). Subcommands `weekly` and `always-on` work identically.
+
+`/continuous-improvement` remains supported indefinitely for backward compatibility. Prefer `/seven-laws` going forward — it matches the brand and the SKILL.md spec.