continuous-improvement 3.9.2 → 3.11.0

package/lib/skill-distill.mjs

@@ -0,0 +1,222 @@
+// skill-distill.mts — Pure trajectory → draft-skill distillation.
+//
+// No I/O. Scans observation rows for repeated tool sequences that ended in a
+// successful verification, and proposes DRAFT instincts capturing the pattern.
+// The MCP tools ci_distill_candidates / ci_distill_propose / ci_distill_promote
+// (src/bin/mcp-server.mts) wire the file reads and writes around these
+// functions.
+//
+// Closed-loop "Learn From Every Session" (Law 7) on the SUCCESS side: the
+// friction harvester (src/bin/harvest-friction.mts) already turns failures into
+// instincts; this turns repeated wins into reusable drafts. Drafts never enter
+// the suggestion pool — they require explicit promotion — so a coincidental
+// tool sequence cannot cargo-cult itself into enforced behavior.
+const MIN_TRAJECTORY_LENGTH = 4;
+const GAP_MS = 10 * 60 * 1000;
+const NGRAM_SIZES = [3, 4, 5];
+const DEFAULT_MIN_OCCURRENCES = 3;
+const DEFAULT_MIN_SESSIONS = 2;
+const DRAFT_CONFIDENCE = 0.4;
+const VERIFY_CMD = /\b(npm\s+(run\s+)?(test|verify(:[\w-]+)?|build)|pnpm\s+(test|build)|yarn\s+(test|build)|pytest|cargo\s+test|go\s+test|jest|vitest|make\s+test)\b/i;
+const FAILURE_MARKER = /\b(error|errors|fail|failed|failing|not found|denied|cannot|exception|traceback)\b|exit code [1-9]/i;
+const SUCCESS_MARKER = /\b(pass|passed|passing|success|succeeded|green|0 failures|all tests)\b|\bok\b/i;
+const REFLECTION_MARKER = /\b(verified|phase[- ]?4|verify:all green|all tests pass)\b/i;
+const NOISE_TOOL = /^(ci_|mcp__|TodoWrite$)/;
+function session(obs) {
+    return (obs.session ?? obs.session_id ?? "").toString();
+}
+function text(obs) {
+    return `${obs.input_summary ?? ""}\n${obs.output_summary ?? ""}`;
+}
+function classifyTrajectorySuccess(observations) {
+    for (const obs of observations) {
+        if ((obs.tool ?? "") === "Bash") {
+            const input = (obs.input_summary ?? "").toString();
+            const output = (obs.output_summary ?? "").toString();
+            if (VERIFY_CMD.test(input) && !FAILURE_MARKER.test(output) && (output === "" || SUCCESS_MARKER.test(output))) {
+                return "verify-exit-0";
+            }
+        }
+    }
+    for (const obs of observations) {
+        if (REFLECTION_MARKER.test(text(obs))) {
+            return "reflection-pass";
+        }
+    }
+    return null;
+}
+/**
+ * Split a chronological observation list into contiguous trajectories. A
+ * boundary occurs on session change or a time gap longer than GAP_MS. Only
+ * trajectories of at least MIN_TRAJECTORY_LENGTH observations are returned;
+ * each is classified as succeeded or not.
+ */
+export function extractTrajectories(observations) {
+    const out = [];
+    let group = [];
+    const flush = () => {
+        if (group.length < MIN_TRAJECTORY_LENGTH) {
+            group = [];
+            return;
+        }
+        const successReason = classifyTrajectorySuccess(group);
+        out.push({
+            observations: group,
+            session: session(group[0]),
+            startTs: (group[0].ts ?? "").toString(),
+            endTs: (group[group.length - 1].ts ?? "").toString(),
+            succeeded: successReason !== null,
+            successReason,
+        });
+        group = [];
+    };
+    for (const obs of observations) {
+        if (group.length === 0) {
+            group.push(obs);
+            continue;
+        }
+        const prev = group[group.length - 1];
+        const sessionChanged = session(obs) !== session(prev);
+        const prevMs = Date.parse((prev.ts ?? "").toString());
+        const curMs = Date.parse((obs.ts ?? "").toString());
+        const prevValid = !Number.isNaN(prevMs);
+        const curValid = !Number.isNaN(curMs);
+        const gapTooBig = (prevValid && curValid && curMs - prevMs > GAP_MS) || (prevValid !== curValid);
+        if (sessionChanged || gapTooBig) {
+            flush();
+        }
+        group.push(obs);
+    }
+    flush();
+    return out;
+}
+function toolSequence(trajectory) {
+    return trajectory.observations
+        .map((obs) => (obs.tool ?? "").toString())
+        .filter((tool) => tool.length > 0 && !NOISE_TOOL.test(tool));
+}
+// Tool names are external data (observations.jsonl). The candidate id is later
+// joined into a draft file path, so it must be slugified to [a-z0-9-] to keep a
+// hostile tool name (`../`, `/`, `\`) from escaping the drafts directory.
+function slugifyNgram(ngram) {
+    const slug = ngram
+        .join("-")
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug.length > 0 ? slug : "sequence";
+}
+/**
+ * Mine repeated tool-sequence n-grams from SUCCESSFUL trajectories. A candidate
+ * must occur at least `minOccurrences` times across at least `minSessions`
+ * distinct sessions — so a pattern repeated within a single session is rejected.
+ * Sorted by occurrences then n-gram length, both descending.
+ */
+export function findCandidates(trajectories, opts = {}) {
+    const minOccurrences = opts.minOccurrences ?? DEFAULT_MIN_OCCURRENCES;
+    const minSessions = opts.minSessions ?? DEFAULT_MIN_SESSIONS;
+    const aggregates = new Map();
+    for (const trajectory of trajectories) {
+        if (!trajectory.succeeded)
+            continue;
+        const sequence = toolSequence(trajectory);
+        const outcome = trajectory.successReason ?? "unknown";
+        for (const size of NGRAM_SIZES) {
+            for (let i = 0; i + size <= sequence.length; i += 1) {
+                const ngram = sequence.slice(i, i + size);
+                const key = ngram.join(">");
+                let aggregate = aggregates.get(key);
+                if (!aggregate) {
+                    aggregate = { ngram, occurrences: 0, sessions: new Set(), outcomes: new Set() };
+                    aggregates.set(key, aggregate);
+                }
+                aggregate.occurrences += 1;
+                aggregate.sessions.add(trajectory.session);
+                aggregate.outcomes.add(outcome);
+            }
+        }
+    }
+    const candidates = [];
+    for (const aggregate of aggregates.values()) {
+        if (aggregate.occurrences < minOccurrences)
+            continue;
+        if (aggregate.sessions.size < minSessions)
+            continue;
+        candidates.push({
+            id: `draft-${slugifyNgram(aggregate.ngram)}`,
+            ngram: aggregate.ngram,
+            occurrences: aggregate.occurrences,
+            sessions: [...aggregate.sessions],
+            outcomes: [...aggregate.outcomes],
+        });
+    }
+    candidates.sort((a, b) => b.occurrences !== a.occurrences ? b.occurrences - a.occurrences : b.ngram.length - a.ngram.length);
+    return candidates;
+}
+/** Turn a candidate into a DRAFT instinct with a placeholder body for the user to fill in. */
+export function draftFromCandidate(candidate) {
+    const arrow = candidate.ngram.join(" → ");
+    const outcome = candidate.outcomes.join(", ");
+    return {
+        id: candidate.id,
+        trigger: `Auto-detected pattern: ${candidate.ngram.join(" then ")} (seen ${candidate.occurrences}x across ${candidate.sessions.length} sessions)`,
+        body: [
+            "When this situation recurs, follow the proven sequence that worked before:",
+            "",
+            `  ${arrow}`,
+            "",
+            `This pattern succeeded in ${candidate.occurrences} run(s) across ${candidate.sessions.length} session(s) (outcome: ${outcome}).`,
+            "Replace this placeholder with the concrete steps, preconditions, and gotchas before promoting —",
+            "the tool sequence alone is evidence, not a recipe.",
+        ].join("\n"),
+        confidence: DRAFT_CONFIDENCE,
+        domain: "workflow",
+        ngram: candidate.ngram,
+        occurrences: candidate.occurrences,
+        sessions: candidate.sessions.length,
+        outcome,
+    };
+}
+/**
+ * Serialize a draft to the instinct YAML format (key: value lines, `---`, body)
+ * so it round-trips through the same parser that reads live instincts. Stored
+ * under drafts/ so it is not picked up as a live instinct until promoted.
+ */
+export function serializeDraft(draft) {
+    return [
+        `id: ${draft.id}`,
+        `trigger: "${draft.trigger}"`,
+        `confidence: ${draft.confidence}`,
+        `domain: ${draft.domain}`,
+        "source: distilled",
+        "status: draft",
+        `evidence_ngram: "${draft.ngram.join(">")}"`,
+        `evidence_occurrences: ${draft.occurrences}`,
+        `evidence_sessions: ${draft.sessions}`,
+        `evidence_outcome: "${draft.outcome}"`,
+        "---",
+        draft.body,
+        "",
+    ].join("\n");
+}
+/** Render candidates as a markdown block for the MCP tool output. */
+export function formatCandidates(candidates, limit = 10) {
+    if (candidates.length === 0) {
+        return "No distillation candidates found. A candidate needs a tool sequence that recurred across multiple successful sessions. Keep working — patterns accrue as the observation log grows.";
+    }
+    const shown = candidates.slice(0, limit);
+    const lines = [
+        `## Distillation Candidates (${candidates.length})`,
+        "",
+        "Repeated tool sequences from successful sessions. Propose a draft with `ci_distill_propose id=<id>`, edit its body, then `ci_distill_promote id=<id>`.",
+        "",
+    ];
+    for (const candidate of shown) {
+        lines.push(`- **${candidate.id}**`, `  Sequence: ${candidate.ngram.join(" → ")}`, `  Seen ${candidate.occurrences}x across ${candidate.sessions.length} session(s) — outcome: ${candidate.outcomes.join(", ")}`);
+    }
+    if (candidates.length > limit) {
+        lines.push("", `_…and ${candidates.length - limit} more._`);
+    }
+    return lines.join("\n");
+}

package/llms.txt

@@ -1,6 +1,6 @@
 # continuous-improvement
 
-> Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 13 enforcement skills, gating hooks, and the Mulahazah auto-leveling instinct engine.
+> Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 25 bundled skills, gating hooks, the Mulahazah auto-leveling instinct engine, and a GitHub Action transcript linter.
 
 ## What This Is
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "continuous-improvement",
-  "version": "3.9.2",
-  "description": "Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 13 enforcement skills, gating hooks, the Mulahazah auto-leveling instinct engine, and a GitHub Action transcript linter. Beginner: one /plugin install command. Expert: adds MCP tools and session hooks.",
+  "version": "3.11.0",
+  "description": "Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 25 bundled skills, gating hooks, the Mulahazah auto-leveling instinct engine, and a GitHub Action transcript linter. Beginner: one /plugin install command. Expert: adds MCP tools and session hooks.",
   "keywords": [
     "claude-code",
     "claude-code-skill",
@@ -22,7 +22,7 @@
     "type": "git",
     "url": "git+https://github.com/naimkatiman/continuous-improvement.git"
   },
-  "homepage": "https://github.com/naimkatiman/continuous-improvement#readme",
+  "homepage": "https://continuous-improvement.dev",
   "bugs": {
     "url": "https://github.com/naimkatiman/continuous-improvement/issues"
   },
@@ -32,21 +32,25 @@
     "ci": "bin/unified-cli.mjs"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && node bin/generate-plugin-manifests.mjs",
+    "build": "tsc -p tsconfig.json && node bin/generate-plugin-manifests.mjs && node -e \"const fs=require('node:fs'); for (const f of fs.readdirSync('bin')) { if (f.endsWith('.mjs')) fs.chmodSync('bin/'+f, 0o755); } for (const f of fs.readdirSync('hooks')) { if (f.endsWith('.mjs')) fs.chmodSync('hooks/'+f, 0o755); } for (const f of fs.readdirSync('lib')) { if (f.endsWith('.mjs')) fs.chmodSync('lib/'+f, 0o755); } for (const f of fs.readdirSync('plugins/continuous-improvement/bin')) { if (f.endsWith('.mjs')) fs.chmodSync('plugins/continuous-improvement/bin/'+f, 0o755); } for (const f of fs.readdirSync('plugins/continuous-improvement/lib')) { if (f.endsWith('.mjs')) fs.chmodSync('plugins/continuous-improvement/lib/'+f, 0o755); } for (const f of fs.readdirSync('plugins/continuous-improvement/hooks')) { if (f.endsWith('.mjs')) fs.chmodSync('plugins/continuous-improvement/hooks/'+f, 0o755); } for (const f of fs.readdirSync('scripts')) { if (f.endsWith('.mjs')) fs.chmodSync('scripts/'+f, 0o755); } for (const f of fs.readdirSync('synthetic-checks')) { if (f.endsWith('.mjs')) fs.chmodSync('synthetic-checks/'+f, 0o755); } \"",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "clean": "node -e \"const fs=require('node:fs'); for (const dir of ['bin','test','lib']) { if (!fs.existsSync(dir)) continue; for (const file of fs.readdirSync(dir)) { if (file.endsWith('.mjs')) fs.rmSync(dir + '/' + file, { force: true }); } }\"",
+    "clean": "node -e \"const fs=require('node:fs'); for (const dir of ['bin','hooks','test','lib']) { if (!fs.existsSync(dir)) continue; for (const file of fs.readdirSync(dir)) { if (file.endsWith('.mjs')) fs.rmSync(dir+'/'+file, { force: true }); } }\"",
     "hooks:stats": "node bin/hook-stats.mjs",
     "test": "npm run build && node --test test/*.test.mjs",
     "lint": "node bin/lint-transcript.mjs --help",
-    "verify:generated": "npm run build && git diff --exit-code -- .claude-plugin bin test lib plugins",
+    "verify:generated": "npm run build && git diff --exit-code -- .claude-plugin bin hooks test lib plugins",
     "verify:skill-mirror": "node bin/check-skill-mirror.mjs",
     "verify:skill-tiers": "node bin/check-skill-tiers.mjs",
     "verify:skill-law-tag": "node bin/check-skill-law-tag.mjs",
+    "verify:skill-count": "node bin/check-skill-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",
     "verify:doc-runtime-claims": "node bin/check-doc-runtime-claims.mjs",
-    "verify:all": "npm run verify:skill-mirror && npm run verify:skill-tiers && npm run verify:skill-law-tag && npm run verify:docs-substrings && npm run verify:everything-mirror && npm run verify:routing-targets && npm run verify:doc-runtime-claims && npm run typecheck"
+    "verify:test-imports-only": "node bin/check-test-imports-only.mjs",
+    "verify:scripts-citation-drift": "node bin/check-scripts-citation-drift.mjs",
+    "verify:third-party-shape": "node bin/check-third-party-shape.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: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:scripts-citation-drift && npm run verify:third-party-shape && npm run typecheck"
   },
   "files": [
     ".claude-plugin/",

package/plugins/beginner.json

@@ -1,6 +1,6 @@
 {
   "name": "continuous-improvement",
-  "version": "3.9.2",
+  "version": "3.11.0",
   "mode": "beginner",
   "description": "Beginner mode: see what your agent learned, list its instincts, and request a session reflection. Bundles four discipline skills (gateguard, para-memory-files, tdd-workflow, verification-loop) so research, memory, tests, and verification happen by default.",
   "tools": [
@@ -15,6 +15,10 @@
     {
       "name": "ci_reflect",
       "what": "Reflect on what you did this session"
+    },
+    {
+      "name": "ci_gateguard_clear",
+      "what": "Clear the GateGuard gate for files after presenting facts"
     }
   ],
   "setup": {
@@ -46,8 +50,9 @@
   "hooks": {
     "included": [
       "PreToolUse",
-      "PostToolUse"
+      "PostToolUse",
+      "UserPromptSubmit"
     ],
-    "description": "Silently captures every tool call as observations. Lightweight and non-blocking."
+    "description": "Silently captures every tool call as observations and routes prompts to the matching discipline skill via the route table. Lightweight and non-blocking."
   }
 }

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

@@ -7,8 +7,8 @@
   "plugins": [
     {
       "name": "continuous-improvement",
-      "description": "Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 13 enforcement skills, gating hooks, and the Mulahazah auto-leveling instinct engine.",
-      "version": "3.9.2",
+      "description": "Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 25 bundled skills, gating hooks, the Mulahazah auto-leveling instinct engine, and a GitHub Action transcript linter.",
+      "version": "3.11.0",
       "source": "./",
       "author": {
         "name": "naimkatiman"

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

@@ -1,7 +1,7 @@
 {
   "name": "continuous-improvement",
-  "version": "3.9.2",
-  "description": "Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 13 enforcement skills, gating hooks, and the Mulahazah auto-leveling instinct engine.",
+  "version": "3.11.0",
+  "description": "Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 25 bundled skills, gating hooks, the Mulahazah auto-leveling instinct engine, and a GitHub Action transcript linter.",
   "author": {
     "name": "naimkatiman",
     "url": "https://github.com/naimkatiman"

package/plugins/continuous-improvement/agents/README.md

@@ -40,7 +40,7 @@ Pick this only when **independent** investigations can run in parallel and produ
 
 - `/ship` → fans out to `code-reviewer` + `security-auditor` + `test-engineer` in parallel, then synthesizes their reports into a go/no-go decision
 
-This is the only orchestration pattern this repo endorses. See [references/orchestration-patterns.md](../references/orchestration-patterns.md) for the full pattern catalog and anti-patterns.
+This is the only orchestration pattern this repo endorses. See `references/orchestration-patterns.md` for the full pattern catalog and anti-patterns.
 
 ## Decision matrix
 
@@ -107,7 +107,7 @@ The personas in this repo are designed to work as Claude Code subagents and as A
 - **As subagents:** auto-discovered when this plugin is enabled (no path config needed). Use the Agent tool with `subagent_type: code-reviewer` (or `security-auditor`, `test-engineer`). `/ship` is the canonical example.
 - **As Agent Teams teammates** (experimental, requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`): reference the same persona name when spawning a teammate. The persona's body is **appended to** the teammate's system prompt as additional instructions (not a replacement), so your persona text sits on top of the team-coordination instructions the lead installs (SendMessage, task-list tools, etc.).
 
-Subagents only report results back to the main agent. Agent Teams let teammates message each other directly. Use subagents when reports are enough; use Agent Teams when sub-agents need to challenge each other's findings (e.g. competing-hypothesis debugging). See [references/orchestration-patterns.md](../references/orchestration-patterns.md) for the full mapping.
+Subagents only report results back to the main agent. Agent Teams let teammates message each other directly. Use subagents when reports are enough; use Agent Teams when sub-agents need to challenge each other's findings (e.g. competing-hypothesis debugging). See `references/orchestration-patterns.md` for the full mapping.
 
 Plugin agents do not support `hooks`, `mcpServers`, or `permissionMode` frontmatter — those fields are silently ignored. Avoid relying on them when authoring new personas here.
 

package/plugins/continuous-improvement/bin/gateguard-clear.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * gateguard-clear — record GateGuard clearance for files from the Bash route.
+ *
+ * The GateGuard PreToolUse hook blocks the first Edit/Write per file and prints
+ * the session-state path in its block reason. After presenting the required
+ * facts, run this to clear the gate so the retry is allowed. Bash is not gated
+ * (unless the command is destructive), so this surface always works — including
+ * where the ci_gateguard_clear MCP tool is not connected.
+ *
+ * Usage:
+ *   node bin/gateguard-clear.mjs <file_path> [<file_path>...] [--state <path>]
+ *
+ * Default resolves the session dir canonically, the same way the hook does.
+ * --state <path> writes that exact gateguard-session.json — the path the block
+ * reason prints — bypassing resolution for any residual env mismatch.
+ */
+import { dirname, join } from "node:path";
+import { MAX_CLEARED_FILES, clearFiles, resolveSessionDir, } from "../lib/gateguard-state.mjs";
+function main() {
+    const argv = process.argv.slice(2);
+    const files = [];
+    let stateFile = "";
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--state") {
+            stateFile = argv[i + 1] ?? "";
+            i += 1;
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    if (argv.includes("--state") && stateFile === "") {
+        process.stderr.write("--state requires a <gateguard-session.json> path argument\n");
+        process.exit(2);
+    }
+    if (files.length === 0) {
+        process.stderr.write("usage: gateguard-clear <file_path> [<file_path>...] [--state <gateguard-session.json>]\n");
+        process.exit(2);
+    }
+    // clearFiles writes <sessionDir>/gateguard-session.json. With --state the
+    // caller hands us the full state-file path the block reason printed, so the
+    // session dir is its parent.
+    const sessionDir = stateFile ? dirname(stateFile) : resolveSessionDir();
+    const { cleared, skippedForCap } = clearFiles(sessionDir, files);
+    process.stdout.write(`Cleared ${cleared.length}: ${cleared.length > 0 ? cleared.join(", ") : "(none — already cleared)"}\n`);
+    if (skippedForCap.length > 0) {
+        process.stdout.write(`Skipped — session cap of ${MAX_CLEARED_FILES} reached: ${skippedForCap.join(", ")}\n`);
+    }
+    process.stdout.write(`State: ${join(sessionDir, "gateguard-session.json")}\n`);
+}
+main();