continuous-improvement 3.23.0 → 3.25.0

package/lib/destructive-bash.mjs

@@ -0,0 +1,216 @@
+/**
+ * Destructive-Bash classifier for hooks/gateguard.mjs.
+ *
+ * Two layers, pure and dependency-free so a table test and a future
+ * `gateguard-explain` CLI can drive it without spawning the hook:
+ *
+ *   1. Structured rules: the command is split at unquoted separators
+ *      (`|`, `||`, `&&`, `;`, newline) and each simple command is tokenized,
+ *      so flag order and spelling stop mattering. `rm -r -f`, `rm -Rf` and
+ *      `rm --recursive --force` are the same command; `git clean -fdx` and
+ *      `git clean --force -d` are the same command. Each rule has a stable id
+ *      the deny reason prints, so a block is explainable.
+ *   2. The original substring list, kept verbatim as the fallback so nothing
+ *      that was caught before stops being caught.
+ *
+ * What is deliberately NOT here: plain file writes through Bash (`cat > x`,
+ * `sed -i`). Gating those would break the operator workflow that uses Bash
+ * precisely to write files; that limit is disclosed on the site and README.
+ *
+ * Message-flag carve-out: the VALUE of a commit message, PR body, title, or
+ * note is prose, never a command. It is blanked before any rule runs, so
+ * `git commit -m "rm -rf the old helper"` stays allowed. `-c` is not a message
+ * flag: `bash -c "rm -rf /"` carries a real command and still gates.
+ */
+export const DESTRUCTIVE_PATTERNS = [
+    "rm -rf",
+    "rm -fr",
+    "git reset --hard",
+    "git push --force",
+    "git push -f",
+    "--force-with-lease",
+    "git branch -D",
+    "drop table",
+    "drop database",
+    "drop schema",
+    "truncate ",
+    "mkfs",
+    "dd if=",
+    "format ",
+    "rmdir /s",
+    "del /f /q",
+    "del /q /f",
+    "Remove-Item -Recurse",
+    "Remove-Item -Force",
+];
+// Flags whose VALUE is human prose (a commit message, a PR body) or a filename —
+// never a command to execute. Their contents must not trip the destructive scan.
+const MESSAGE_FLAG_RE = /(^|\s)(-m|--message|-F|--file|--body|--body-file|--title|--notes|-C|--reuse-message)(=|\s+)('[^']*'|"[^"]*"|\S+)/g;
+/** Blank the value of every message/body flag; the flag itself is preserved. */
+export function stripMessageArgs(command) {
+    return command.replace(MESSAGE_FLAG_RE, (_match, lead, flag) => `${lead}${flag} `);
+}
+// Split at shell separators that sit outside single or double quotes.
+function splitSimpleCommands(command) {
+    const segments = [];
+    let current = "";
+    let quote = null;
+    for (let i = 0; i < command.length; i++) {
+        const ch = command[i];
+        if (quote) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        if (ch === "\n" || ch === ";") {
+            segments.push(current);
+            current = "";
+            continue;
+        }
+        if (ch === "|" || ch === "&") {
+            // `||`, `&&`, `|`, `&` all end the simple command; collapse a doubled char.
+            if (command[i + 1] === ch)
+                i++;
+            segments.push(current);
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    segments.push(current);
+    return segments.map((s) => s.trim()).filter((s) => s !== "");
+}
+function tokenize(segment) {
+    return segment.split(/\s+/).filter((t) => t !== "");
+}
+// Drop `sudo`, `env`, and leading VAR=value assignments so the command word is
+// the first token the rules look at.
+function commandTokens(segment) {
+    const tokens = tokenize(segment);
+    let i = 0;
+    while (i < tokens.length) {
+        const t = tokens[i];
+        if (t === "sudo" || t === "env" || t === "command" || /^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) {
+            i++;
+            continue;
+        }
+        break;
+    }
+    return tokens.slice(i);
+}
+// For `git`, skip global options (`-C <dir>`, `-c k=v`, `--git-dir=…`) to find
+// the subcommand and its own arguments.
+function gitSubcommand(tokens) {
+    if (tokens[0] !== "git")
+        return null;
+    let i = 1;
+    while (i < tokens.length && tokens[i].startsWith("-")) {
+        const t = tokens[i];
+        i += t === "-C" || t === "-c" || t === "--git-dir" || t === "--work-tree" ? 2 : 1;
+    }
+    const sub = tokens[i];
+    if (!sub)
+        return null;
+    return { sub, args: tokens.slice(i + 1) };
+}
+const isShortFlag = (t) => /^-[A-Za-z]+$/.test(t);
+const hasShortLetter = (t, letters) => isShortFlag(t) && letters.test(t.slice(1));
+const STRUCTURED_RULES = [
+    {
+        id: "rm-recursive-force",
+        test: (tokens) => {
+            if (tokens[0] !== "rm")
+                return false;
+            const flags = tokens.slice(1).filter((t) => t.startsWith("-"));
+            const recursive = flags.some((t) => t === "--recursive" || hasShortLetter(t, /[rR]/));
+            const force = flags.some((t) => t === "--force" || hasShortLetter(t, /f/));
+            return recursive && force;
+        },
+    },
+    {
+        id: "git-clean-force",
+        test: (tokens) => {
+            const git = gitSubcommand(tokens);
+            if (!git || git.sub !== "clean")
+                return false;
+            const dryRun = git.args.some((t) => t === "--dry-run" || hasShortLetter(t, /n/));
+            const force = git.args.some((t) => t === "--force" || hasShortLetter(t, /f/));
+            return force && !dryRun;
+        },
+    },
+    {
+        id: "git-checkout-discard",
+        test: (tokens) => {
+            const git = gitSubcommand(tokens);
+            if (!git || git.sub !== "checkout")
+                return false;
+            const dash = git.args.indexOf("--");
+            if (dash !== -1)
+                return git.args.length > dash + 1; // `git checkout -- <pathspec>` discards
+            const first = git.args.find((t) => !t.startsWith("-"));
+            return first === "." || first === "./";
+        },
+    },
+    {
+        id: "git-restore-discard",
+        test: (tokens) => {
+            const git = gitSubcommand(tokens);
+            if (!git || git.sub !== "restore")
+                return false;
+            const pathspec = git.args.some((t) => !t.startsWith("-"));
+            if (!pathspec)
+                return false;
+            const staged = git.args.some((t) => t === "--staged" || hasShortLetter(t, /S/));
+            const worktree = git.args.some((t) => t === "--worktree" || hasShortLetter(t, /W/));
+            return !staged || worktree; // `--staged` alone only unstages
+        },
+    },
+    {
+        id: "find-delete",
+        test: (tokens) => tokens[0] === "find" && tokens.includes("-delete"),
+    },
+    {
+        id: "git-push-plus-refspec",
+        test: (tokens) => {
+            const git = gitSubcommand(tokens);
+            if (!git || git.sub !== "push")
+                return false;
+            return git.args.some((t) => t.startsWith("+") && t.length > 1);
+        },
+    },
+    {
+        id: "git-stash-drop",
+        test: (tokens) => {
+            const git = gitSubcommand(tokens);
+            if (!git || git.sub !== "stash")
+                return false;
+            return git.args[0] === "drop" || git.args[0] === "clear";
+        },
+    },
+];
+/** Classify one Bash command string. Pure; never throws on odd input. */
+export function classifyDestructiveBash(command) {
+    if (typeof command !== "string" || command.trim() === "")
+        return { destructive: false, rule: null };
+    const stripped = stripMessageArgs(command);
+    for (const segment of splitSimpleCommands(stripped)) {
+        const tokens = commandTokens(segment);
+        if (tokens.length === 0)
+            continue;
+        for (const rule of STRUCTURED_RULES) {
+            if (rule.test(tokens))
+                return { destructive: true, rule: rule.id };
+        }
+    }
+    const lower = stripped.toLowerCase();
+    const hit = DESTRUCTIVE_PATTERNS.find((p) => lower.includes(p.toLowerCase()));
+    if (hit !== undefined)
+        return { destructive: true, rule: `substring:${hit}` };
+    return { destructive: false, rule: null };
+}

package/lib/gateguard-state.mjs

@@ -45,7 +45,7 @@ export function resolveSessionDir(sessionId) {
     if (fromEnv)
         return fromEnv;
     const projectRoot = resolveProjectRoot();
-    const projectHash = createHash("sha256").update(canonicalizeProjectRoot(projectRoot)).digest("hex").slice(0, 12);
+    const projectHash = hashProjectRoot(projectRoot);
     const base = join(resolveInstinctsRoot(), projectHash);
     const scoped = sanitizeSessionId(sessionId);
     return scoped ? join(base, "sessions", scoped) : base;
@@ -160,6 +160,10 @@ export function canonicalizeProjectRoot(p) {
 export function canonicalizeFileKey(p) {
     return canonicalizePath(p);
 }
+/** SHA-256[:12] of the canonical project root. C:/x, c:/x, and C:\\x share a bucket. */
+export function hashProjectRoot(projectRoot) {
+    return createHash("sha256").update(canonicalizeProjectRoot(projectRoot)).digest("hex").slice(0, 12);
+}
 export function isFileCleared(state, filePath) {
     return canonicalizeFileKey(filePath) in state.cleared_files;
 }

package/lib/plugin-metadata.mjs

@@ -26,7 +26,7 @@ const KEYWORDS = [
     "transcript-linter",
 ];
 const CLAUDE_PLUGIN_CATEGORY = "productivity";
-const SHARED_PLUGIN_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 29 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.";
+const SHARED_PLUGIN_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 28 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.";
 // Four vendored upstream companions registered alongside the CI plugin.
 // Each entry points at a pinned-SHA snapshot under third-party/<name>/.
 // See third-party/MANIFEST.md for refresh recipes and per-snapshot
@@ -474,6 +474,11 @@ export function getPluginHooksConfig() {
         command: "node \"${CLAUDE_PLUGIN_ROOT}/hooks/hook-pack.mjs\"",
         timeout: hookTimeoutSeconds,
     };
+    const configGuardCommand = {
+        type: "command",
+        command: "node \"${CLAUDE_PLUGIN_ROOT}/hooks/config-guard.mjs\"",
+        timeout: hookTimeoutSeconds,
+    };
     const observeCommand = {
         type: "command",
         command: "node \"${CLAUDE_PLUGIN_ROOT}/bin/observe.mjs\"",
@@ -538,6 +543,12 @@ export function getPluginHooksConfig() {
                 // Edit/Read/etc. Warn-default (CLAUDE_CI_HOOKPACK_GATE) — never blocks
                 // until the operator opts in.
                 { matcher: "Bash", hooks: [hookPackCommand] },
+                // config-guard watches the files that wire the guardrails
+                // (.claude/settings*.json, .mcp.json, hooks.json, .claude/hooks/,
+                // .claude/plugins/, .claude-plugin/) and the `claude plugin|mcp|config`
+                // CLI forms. Matcher keeps read-only tools off the hot path.
+                // Warn-default (CI_CONFIG_GUARD) — denies only under block.
+                { matcher: "Bash|Edit|MultiEdit|Write|NotebookEdit", hooks: [configGuardCommand] },
             ],
             PostToolUse: [{ hooks: [observeCommand] }],
             UserPromptSubmit: [{ hooks: [routePromptCommand, recallBriefingCommand] }],

package/lib/skill-catalog.mjs

@@ -0,0 +1,169 @@
+/**
+ * Skill -> enforcing hook filename. Explicit because hook filenames describe
+ * the event they fire on, not the skill they serve. Adding a hook without
+ * adding its row here makes the catalog under-claim, which is the safe
+ * direction.
+ */
+export const HOOK_BY_SKILL = {
+    gateguard: "gateguard.mjs",
+    "goal-monitor": "goal-drift-stop.mjs",
+    recall: "recall-briefing.mjs",
+    superpowers: "companion-preference.mjs",
+    "verification-loop": "typecheck-stop.mjs",
+    "skill-distillation": "workflow-distill.mjs",
+};
+const TIER_LABEL = {
+    core: "Core",
+    featured: "Featured",
+    "1": "Tier 1 — beginner",
+    "2": "Tier 2 — expert",
+    companion: "Always bundled",
+    unknown: "Unclassified",
+};
+const TIER_ORDER = ["core", "featured", "1", "2", "companion", "unknown"];
+const ENFORCEMENT_TITLE = {
+    hook: "Enforced at the tool boundary by a hook — it fires whether or not the model cooperates.",
+    command: "Invoked by a slash command. Runs when you ask for it.",
+    prose: "Model-side discipline only. Nothing blocks and nothing fires automatically.",
+};
+/** Lift the Law tag out of a Law-tagged description. */
+export function lawOf(description) {
+    if (!description)
+        return undefined;
+    if (/\ball\s+7\s+Laws\b/i.test(description))
+        return "all 7";
+    if (/\bLaw\s+activator\b/i.test(description))
+        return "activator";
+    const multi = description.match(/\bLaw\s*([1-7])\s*\+\s*([1-7])\b/i);
+    if (multi)
+        return `${multi[1]} + ${multi[2]}`;
+    const single = description.match(/\bLaw\s*([1-7])\b/i);
+    return single ? single[1] : undefined;
+}
+/** Resolve the enforcement surface for one skill from the shipped file set. */
+export function enforcementOf(name, commandNames) {
+    const hookFile = HOOK_BY_SKILL[name];
+    if (hookFile)
+        return { enforcement: "hook", hookFile };
+    if (commandNames.has(name))
+        return { enforcement: "command" };
+    return { enforcement: "prose" };
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+/** Strip the "Enforces Law N (…) of the 7 Laws…" preamble; keep what it does. */
+export function summarize(description) {
+    if (!description)
+        return "";
+    return description
+        .replace(/^Enforces\s+(all\s+7\s+Laws|Law\s*[1-7](\s*\+\s*[1-7])?)[^.]*\.\s*/i, "")
+        .replace(/^Use this skill to\s*/i, "")
+        .trim();
+}
+const STYLE = `
+:root { color-scheme: light dark; --bg:#fbfbfa; --fg:#1a1a19; --muted:#6b6b66;
+  --line:#e3e3df; --card:#fff; --hook:#0f6f4b; --hookbg:#e4f3ec;
+  --cmd:#1b4f8a; --cmdbg:#e5eefa; --prose:#8a5a12; --prosebg:#faf0dc; }
+@media (prefers-color-scheme: dark) { :root { --bg:#121211; --fg:#ececeb;
+  --muted:#9a9a94; --line:#2c2c29; --card:#1b1b1a; --hook:#6fd3a8; --hookbg:#12332a;
+  --cmd:#8fbdf0; --cmdbg:#132840; --prose:#e3b464; --prosebg:#3a2c12; } }
+:root[data-theme="dark"] { --bg:#121211; --fg:#ececeb; --muted:#9a9a94; --line:#2c2c29;
+  --card:#1b1b1a; --hook:#6fd3a8; --hookbg:#12332a; --cmd:#8fbdf0; --cmdbg:#132840;
+  --prose:#e3b464; --prosebg:#3a2c12; }
+:root[data-theme="light"] { --bg:#fbfbfa; --fg:#1a1a19; --muted:#6b6b66; --line:#e3e3df;
+  --card:#fff; --hook:#0f6f4b; --hookbg:#e4f3ec; --cmd:#1b4f8a; --cmdbg:#e5eefa;
+  --prose:#8a5a12; --prosebg:#faf0dc; }
+body { margin:0; padding:2.5rem 1.25rem 4rem; background:var(--bg); color:var(--fg);
+  font:16px/1.6 ui-sans-serif,-apple-system,"Segoe UI",Roboto,sans-serif; }
+.wrap { max-width:70rem; margin:0 auto; }
+h1 { font-size:1.75rem; margin:0 0 .35rem; letter-spacing:-.015em; }
+.sub { color:var(--muted); margin:0 0 1.25rem; max-width:52rem; }
+h2 { font-size:1rem; text-transform:uppercase; letter-spacing:.08em; color:var(--muted);
+  margin:2.5rem 0 .75rem; font-weight:600; }
+.legend { display:flex; flex-wrap:wrap; gap:1rem; margin:0 0 1rem; padding:0; list-style:none; }
+.legend li { color:var(--muted); font-size:.85rem; }
+.scroll { overflow-x:auto; border:1px solid var(--line); border-radius:.6rem; background:var(--card); }
+table { border-collapse:collapse; width:100%; min-width:44rem; }
+th, td { text-align:left; padding:.7rem .85rem; border-bottom:1px solid var(--line); vertical-align:top; }
+th { font-size:.78rem; text-transform:uppercase; letter-spacing:.06em; color:var(--muted); font-weight:600; }
+tr:last-child td { border-bottom:0; }
+td.name { font-family:ui-monospace,SFMono-Regular,Menlo,monospace; font-size:.88rem; white-space:nowrap; }
+td.law { color:var(--muted); white-space:nowrap; font-variant-numeric:tabular-nums; }
+td.what { min-width:22rem; }
+.badge { display:inline-block; padding:.12rem .5rem; border-radius:1rem; font-size:.75rem;
+  font-weight:600; white-space:nowrap; }
+.badge.hook { color:var(--hook); background:var(--hookbg); }
+.badge.command { color:var(--cmd); background:var(--cmdbg); }
+.badge.prose { color:var(--prose); background:var(--prosebg); }
+.hookfile { display:block; margin-top:.25rem; font-family:ui-monospace,monospace;
+  font-size:.72rem; color:var(--muted); }
+footer { margin-top:3rem; color:var(--muted); font-size:.85rem; max-width:52rem; }
+code { font-family:ui-monospace,monospace; font-size:.9em; }
+`;
+/**
+ * Render the full catalog page. Pure — takes the resolved skill list and
+ * returns the complete HTML document.
+ */
+export function renderSkillCatalogHtml(skills) {
+    const counts = { hook: 0, command: 0, prose: 0 };
+    for (const s of skills)
+        counts[s.enforcement]++;
+    const sections = [];
+    for (const tier of TIER_ORDER) {
+        const rows = skills.filter((s) => s.tier === tier);
+        if (rows.length === 0)
+            continue;
+        const body = rows
+            .map((s) => {
+            const badge = `<span class="badge ${s.enforcement}" title="${escapeHtml(ENFORCEMENT_TITLE[s.enforcement])}">` +
+                `${s.enforcement}</span>` +
+                (s.hookFile ? `<span class="hookfile">hooks/${escapeHtml(s.hookFile)}</span>` : "");
+            return ("        <tr>" +
+                `<td class="name">${escapeHtml(s.name)}</td>` +
+                `<td class="law">${escapeHtml(s.law ?? "—")}</td>` +
+                `<td>${badge}</td>` +
+                `<td class="what">${escapeHtml(summarize(s.description))}</td>` +
+                "</tr>");
+        })
+            .join("\n");
+        sections.push(`    <h2>${escapeHtml(TIER_LABEL[tier])} (${rows.length})</h2>\n` +
+            '    <div class="scroll">\n      <table>\n' +
+            "        <thead><tr><th>Skill</th><th>Law</th><th>Enforcement</th><th>What it does</th></tr></thead>\n" +
+            `        <tbody>\n${body}\n        </tbody>\n` +
+            "      </table>\n    </div>");
+    }
+    return [
+        "<!doctype html>",
+        '<html lang="en">',
+        "<head>",
+        '  <meta charset="utf-8">',
+        '  <meta name="viewport" content="width=device-width,initial-scale=1">',
+        `  <title>Skill catalog — continuous-improvement (${skills.length} skills)</title>`,
+        "  <!-- GENERATED by npm run build from skills/*.md frontmatter. Do not edit by hand. -->",
+        `  <style>${STYLE}  </style>`,
+        "</head>",
+        "<body>",
+        '  <div class="wrap">',
+        "    <h1>Skill catalog</h1>",
+        `    <p class="sub">${skills.length} bundled skills, generated from <code>skills/*.md</code> frontmatter. ` +
+            "The <strong>Enforcement</strong> column is the point of this page: it states what actually backs each skill, " +
+            "derived from the shipped file set rather than from the skill's own prose. " +
+            `Today ${counts.hook} are enforced by a hook, ${counts.command} by a slash command, and ${counts.prose} by model-side discipline alone.</p>`,
+        '    <ul class="legend">',
+        '      <li><span class="badge hook">hook</span> fires at the tool boundary; model cooperation not required</li>',
+        '      <li><span class="badge command">command</span> runs when you invoke it</li>',
+        '      <li><span class="badge prose">prose</span> model-side discipline only — nothing blocks</li>',
+        "    </ul>",
+        sections.join("\n"),
+        '    <footer>A skill may only claim enforcement it ships. A <span class="badge prose">prose</span> skill that describes a runtime gate is a bug — that is what retired <code>safety-guard</code> on 2026-08-07. See <code>docs/plans/2026-08-07-six-rules-context-engineering.md</code>.</footer>',
+        "  </div>",
+        "</body>",
+        "</html>",
+        "",
+    ].join("\n");
+}

package/llms.txt

@@ -1,11 +1,22 @@
 # continuous-improvement
 
-> 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 29 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.
+> 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 28 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.
 
 ## What This Is
 
 The persistent-memory and discipline layer for AI coding agents. It carries the corrections Claude has already received from one session into the next, grounds each edit in real facts before it lands, and learns from every session so its competence compounds over time — research, plan, execute one thing at a time, verify, reflect, iterate, learn — building behavioral instincts via the Mulahazah learning system, so the same correction never has to be given twice and each run starts smarter than the last. Orchestration tools run a task; this is the layer that makes the lessons survive the run.
 
+Why these seven: every red flag an agent says ("this should work", "I'll remember", "next time I'll") is a wish standing in for a check. The Laws are one old sentence turned into checks an agent can run on itself: the wise one takes account of himself and works for what comes after; the weak one follows his impulse and merely wishes (Jami` at-Tirmidhi 2459). Before saying done: did I check, or did I hope? Sources and the mapping to each Law: docs/philosophy.md.
+
+What the gate can and cannot do: hooks/gateguard.mjs denies the first Edit/Write/MultiEdit per file until a four-item fact list is presented and the printed clear command is run (honor system, 50 files per session); destructive Bash on a fixed blocklist is denied on every call with no clearance route; Bash file writes are not gated. Goal-drift warns by default (CLAUDE_GOAL_DRIFT_GATE=block to refuse), typecheck gate and recall briefing are opt-in.
+
+Smarter models do not retire this product. Planning etiquette and "remember to verify" reminders merge into the model over time. The runtime gate, this-repo memory, and proof that a change worked do not. Keep goal-driven execution plus research / verify / learn guardrails; retire scaffolding when the native harness covers it (see skills/model-forward.md).
+
+How you actually benefit:
+1. Beginner install (or `npx continuous-improvement install`) — gateguard fires on Edit/Write; no prompt prefix required.
+2. After a real session run `/seven-laws` — capture is silent; instincts form when you close the loop. `/recall` for "have I hit this before?". `/planning-with-files` writes `task_plan.md`.
+3. Expert mode for MCP tools, `/harvest`, `/distill`, and optional `CLAUDE_RECALL_BRIEFING=1`. Empty harvest/distill on day 1 means missing observation history, not a broken command.
+
 ## Install
 
 ```bash

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "continuous-improvement",
-  "version": "3.23.0",
-  "description": "Claude Code that gets sharper every session: the persistent-memory and runtime-discipline layer built on the 7 Laws of AI Agent Discipline. It 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. Shipped as 29 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. Beginner: one /plugin install command. Expert: adds MCP tools and session hooks.",
+  "version": "3.25.0",
+  "description": "Claude Code that gets sharper every session: the persistent-memory and runtime-discipline layer built on the 7 Laws of AI Agent Discipline. It 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. Shipped as 28 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. Beginner: one /plugin install command. Expert: adds MCP tools and session hooks.",
   "keywords": [
     "claude-code",
     "claude-code-plugin",
@@ -52,6 +52,8 @@
     "verify:skill-count": "node bin/check-skill-count.mjs",
     "verify:skill-count-prose": "node bin/check-skill-count-prose.mjs",
     "verify:command-count": "node bin/check-command-count.mjs",
+    "verify:test-count": "node bin/check-test-count.mjs",
+    "verify:invariant-count": "node bin/check-invariant-count.mjs",
     "verify:docs-substrings": "node bin/check-docs-substrings.mjs",
     "verify:everything-mirror": "node bin/check-everything-mirror.mjs",
     "verify:routing-targets": "node bin/check-routing-targets.mjs",
@@ -62,7 +64,7 @@
     "verify:third-party-shape": "node bin/check-third-party-shape.mjs",
     "verify:tool-count": "node bin/check-tool-count.mjs",
     "verify:reconcile-parity": "node bin/check-reconcile-parity.mjs",
-    "verify:all": "npm run verify:skill-mirror && npm run verify:skill-tiers && npm run verify:skill-law-tag && npm run verify:skill-count && npm run verify:skill-count-prose && npm run verify:command-count && npm run verify:docs-substrings && npm run verify:everything-mirror && npm run verify:routing-targets && npm run verify:doc-runtime-claims && npm run verify:test-imports-only && npm run verify:landing-version && npm run verify:scripts-citation-drift && npm run verify:third-party-shape && npm run verify:tool-count && npm run verify:reconcile-parity && npm run typecheck"
+    "verify:all": "npm run verify:skill-mirror && npm run verify:skill-tiers && npm run verify:skill-law-tag && npm run verify:skill-count && npm run verify:skill-count-prose && npm run verify:command-count && npm run verify:test-count && npm run verify:invariant-count && npm run verify:docs-substrings && npm run verify:everything-mirror && npm run verify:routing-targets && npm run verify:doc-runtime-claims && npm run verify:test-imports-only && npm run verify:landing-version && npm run verify:scripts-citation-drift && npm run verify:third-party-shape && npm run verify:tool-count && npm run verify:reconcile-parity && npm run typecheck"
   },
   "files": [
     ".claude-plugin/",

package/plugins/beginner.json

@@ -1,6 +1,6 @@
 {
   "name": "continuous-improvement",
-  "version": "3.23.0",
+  "version": "3.25.0",
   "mode": "beginner",
   "description": "Beginner mode: see what your agent learned, list its instincts, and request a session reflection. Bundles the ship fast path plus grounding skills (gateguard, tdd-workflow, verification-loop) so one-defect delivery, research, tests, and verification happen by default — every edit starts from facts, not guesses.",
   "tools": [

package/plugins/continuous-improvement/.claude-plugin/marketplace.json

@@ -7,8 +7,8 @@
   "plugins": [
     {
       "name": "continuous-improvement",
-      "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 29 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.23.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 28 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.25.0",
       "source": "./",
       "author": {
         "name": "naimkatiman"

package/plugins/continuous-improvement/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "continuous-improvement",
-  "version": "3.23.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 29 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.25.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 28 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.",
   "author": {
     "name": "naimkatiman",
     "url": "https://github.com/naimkatiman"

package/plugins/continuous-improvement/README.md

@@ -36,8 +36,7 @@ the trade-off is fallback quality vs dedicated-skill quality.
 - `tdd-workflow` — RED/GREEN/REFACTOR + 80% coverage gate
 - `workspace-surface-audit` — environment + capability audit
 - Tier-1/Tier-2 enforcement skills (`gateguard`, `verification-loop`,
-  `safety-guard`, `token-budget-advisor`,
-  `strategic-compact`, `wild-risa-balance`)
+  `token-budget-advisor`, `strategic-compact`, `wild-risa-balance`)
 
 **Optional companions the orchestrator routes to (install separately if
 you want the dedicated skill instead of the inline fallback):**

package/plugins/continuous-improvement/bin/mcp-server.mjs

@@ -16,12 +16,11 @@ import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
 import { PACKAGE_NAME, VERSION, getToolDefinitions, isPluginMode, } from "../lib/plugin-metadata.mjs";
 import { formatDriftReport, parseGoalFromPlan, scoreObservations, } from "../lib/goal-state.mjs";
 import { buildIndex, formatRecallHits, parseSince, query as queryRecall, } from "../lib/recall-index.mjs";
 import { draftFromCandidate, draftFromWorkflowRun, extractTrajectories, findCandidates, formatCandidates, serializeDraft, workflowRunFromObservations, } from "../lib/skill-distill.mjs";
-import { MAX_CLEARED_FILES, canonicalizeFileKey, clearFiles, resolveInstinctsRoot, resolveSessionDir, } from "../lib/gateguard-state.mjs";
+import { MAX_CLEARED_FILES, canonicalizeFileKey, clearFiles, hashProjectRoot, resolveInstinctsRoot, resolveProjectRoot, resolveSessionDir, } from "../lib/gateguard-state.mjs";
 function getHomeDir() {
     return process.env.HOME || process.env.USERPROFILE || homedir();
 }
@@ -93,14 +92,10 @@ const modeIndex = args.indexOf("--mode");
 const requestedMode = args[modeIndex + 1];
 const MODE = isPluginMode(requestedMode) ? requestedMode : "beginner";
 function getProjectHash() {
-    try {
-        const root = execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf8" }).trim();
-        const hash = createHash("sha256").update(root).digest("hex").slice(0, 12);
-        return { root, hash, name: basename(root) };
-    }
-    catch {
+    const root = resolveProjectRoot();
+    if (root === "global")
         return { root: "global", hash: "global", name: "global" };
-    }
+    return { root, hash: hashProjectRoot(root), name: basename(root) };
 }
 function readInstincts(projectHash) {
     const instincts = [];

package/plugins/continuous-improvement/bin/observe.mjs

@@ -16,10 +16,10 @@
 //
 // See docs/plans/2026-05-05-node-observer-rich-schema.md for the full design.
 import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
+import { canonicalizeProjectRoot, hashProjectRoot } from "../lib/gateguard-state.mjs";
 import { parseHookPayload, summariseInput, summariseOutput } from "../lib/observe-event.mjs";
 const ROTATION_LINE_THRESHOLD = 10_000;
 const ARCHIVE_RETENTION = 10;
@@ -40,8 +40,8 @@ function runObserver() {
     const payload = parseHookPayload(raw);
     if (!payload)
         return;
-    const projectRoot = resolveProjectRoot();
-    const projectHash = createHash("sha256").update(projectRoot).digest("hex").slice(0, 12);
+    const projectRoot = canonicalizeProjectRoot(resolveProjectRoot());
+    const projectHash = hashProjectRoot(projectRoot);
     const projectName = basename(projectRoot.replace(/\.git$/, ""));
     const instinctsDir = join(getHomeDir(), ".claude", "instincts");
     const projectDir = join(instinctsDir, projectHash);

package/plugins/continuous-improvement/commands/discipline.md

@@ -19,6 +19,8 @@ Print this card and check yourself against each law.
 | 6 | **Iterate One Change** | Am I changing one thing at a time? | "And also..." |
 | 7 | **Learn From Every Session** | Did I capture this as an instinct? | "Next time I'll..." |
 
+Read the seven as three moments around every act. **Before** (Laws 1, 2): set the terms. **During** (Laws 3, 6): watch yourself. **After** (Laws 4, 5, 7): settle the account and carry it forward. Every check is an audit you run on yourself; every red flag is you hoping instead. The sentence this comes from, and its sources: `docs/philosophy.md`.
+
 ## Operator Stakes
 
 The Laws above are the *how*. These five principles are the *why*: code ships from your account, the incident lands on your pager, the bill hits your budget. Each one pairs with the Law that prevents it from going wrong.
@@ -31,7 +33,7 @@ The Laws above are the *how*. These five principles are the *why*: code ships fr
 | 4 | **Problem framing** | Builds the websocket chat the ticket asked for | Finds out users wanted faster support replies, not chat | 1 |
 | 5 | **Constraints management** | Calls the $0.02/image model on every upload | Does the math, adds client-side validation + caching + cheaper triage model | 2 |
 
-Code is a liability, not an asset. Speed without these five turns into someone else's incident at 3am — except the someone is you.
+Code is a liability, not an asset. Speed without these five turns into someone else's incident at 3am — except the someone is you. The other half of the why is not fear: the session ends and the context is gone, so the only work that survives is what you verified and wrote down for the one who comes after, whether that is tomorrow's session or the engineer who inherits the repo.
 
 ## Goal-Driven Execution maps onto the Laws
 
@@ -61,5 +63,6 @@ Before saying "Done", verify ALL:
 - [ ] I checked the **actual** result (not assumed)
 - [ ] Build passes
 - [ ] I can explain the change in one sentence
+- [ ] For each item above I checked, not hoped
 
-If you're skipping a step, that's the step you need most.
+If you're skipping a step, that's the step you need most. The step you skip is the one you are hoping through.

package/plugins/continuous-improvement/commands/reconcile.md

@@ -95,7 +95,7 @@ git branch -d <type>/<slug>            # delete the merged feature branch (safe
 ## Pairs with
 
 - **`reconcile`** skill — the discipline this command runs.
-- **`gateguard`** / **`safety-guard`** — runtime + destructive-op guardrails.
+- **`gateguard`** — the runtime gate for mutating tool calls and destructive shell.
 - **`recall`** — recall whether the same git op failed here before.
 - **`audit`** — the loop that often produces the fix `/reconcile` then ships.
 - **`/ship`** — the TDD-gated single-defect variant; `commit-commands:commit-push-pr` is the external-plugin equivalent of the commit → PR tail.