continuous-improvement 3.15.0 → 3.17.0

package/lib/version-check.mjs

@@ -0,0 +1,115 @@
+// version-check.mts — Pure update-check decision core + a thin npm-registry fetch
+// helper. The decision functions take no ambient I/O: the caller injects the local
+// version, the fetched remote version, the cached state, and the clock, so the whole
+// thing is unit-testable offline (mirrors how the goal-state / recall scorers are
+// structured). The ONLY network is fetchLatestNpmVersion, which fails closed
+// (returns null) on any error. No telemetry: a one-way read of the public registry.
+//
+// Wired into bin/install.mts at install end so the nudge only appears when the user
+// explicitly invokes the CLI. See docs/plans/2026-06-25-version-check-nudge.md.
+// Two-tier TTL, copied from gstack: poll often while up-to-date so a release is
+// caught quickly, then back off once an upgrade is known so the nudge is not
+// re-fetched on every invocation.
+export const TTL_UP_TO_DATE_MS = 60 * 60 * 1000; // 60 min
+export const TTL_UPGRADE_MS = 12 * 60 * 60 * 1000; // 720 min
+const NPM_REGISTRY = "https://registry.npmjs.org";
+/** Parse "a.b.c" (ignoring a leading v and any -prerelease/+build suffix) into a
+ *  numeric triple. Fail closed: any non-numeric core component returns null. */
+export function parseSemver(version) {
+    if (typeof version !== "string")
+        return null;
+    const core = version.trim().replace(/^v/, "").split(/[-+]/)[0] ?? "";
+    const parts = core.split(".");
+    if (parts.length !== 3)
+        return null;
+    const nums = parts.map((p) => (/^\d+$/.test(p) ? Number(p) : NaN));
+    if (nums.some((n) => !Number.isFinite(n)))
+        return null;
+    return [nums[0], nums[1], nums[2]];
+}
+/** Is `remote` a strictly higher release than `local`? Non-semver on either side
+ *  fails closed to false (never nudge on garbage; never nudge a dev build that is
+ *  ahead of or equal to the registry). */
+export function isNewer(remote, local) {
+    const r = parseSemver(remote);
+    const l = parseSemver(local);
+    if (!r || !l)
+        return false;
+    for (let i = 0; i < 3; i += 1) {
+        if (r[i] > l[i])
+            return true;
+        if (r[i] < l[i])
+            return false;
+    }
+    return false;
+}
+/** Should the network fetch be skipped because the cached result is still fresh?
+ *  Absent/NaN checkedAt fails OPEN (fetch) — a corrupt cache must not wedge the
+ *  check off permanently. */
+export function isThrottled(cache, now) {
+    if (!cache || typeof cache.checkedAt !== "number" || !Number.isFinite(cache.checkedAt))
+        return false;
+    const ttl = cache.status === "upgrade-available" ? TTL_UPGRADE_MS : TTL_UP_TO_DATE_MS;
+    return now - cache.checkedAt < ttl;
+}
+function buildNotice(local, remote) {
+    return (`continuous-improvement ${remote} is available (you have ${local}). ` +
+        "Update: marketplace → /plugin marketplace update continuous-improvement, " +
+        "or npm → npx continuous-improvement install. Silence: CLAUDE_CI_UPDATE_CHECK=off");
+}
+/** Re-surface a still-valid pending upgrade straight from the cache, so a throttled
+ *  invocation does not lose the nudge. Returns null unless the cache says an upgrade
+ *  is pending AND that cached remote is still newer than the current local. */
+export function pendingNotice(cache, local) {
+    if (!cache || cache.status !== "upgrade-available")
+        return null;
+    if (typeof cache.remote !== "string" || !isNewer(cache.remote, local))
+        return null;
+    return buildNotice(local, cache.remote);
+}
+/** The pure decision from a fresh fetch. `remote === null` (fetch failed) yields
+ *  `unknown` with no notice and no cache write, so the next invocation retries
+ *  rather than caching a false "up-to-date". */
+export function evaluateUpdateCheck(args) {
+    const { local, remote, now } = args;
+    if (remote === null || parseSemver(remote) === null) {
+        return { status: "unknown", notice: null, nextCache: null };
+    }
+    if (isNewer(remote, local)) {
+        return {
+            status: "upgrade-available",
+            notice: buildNotice(local, remote),
+            nextCache: { status: "upgrade-available", local, remote, checkedAt: now },
+        };
+    }
+    return {
+        status: "up-to-date",
+        notice: null,
+        nextCache: { status: "up-to-date", local, remote, checkedAt: now },
+    };
+}
+/** Fetch the `latest` dist-tag version for a package from the public npm registry.
+ *  The only network in this module. Fails closed (returns null) on any error:
+ *  timeout, non-2xx, malformed JSON, or a non-semver version string. fetchImpl and
+ *  timeoutMs are injectable so callers and tests stay offline-deterministic. */
+export async function fetchLatestNpmVersion(pkg, opts = {}) {
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function")
+        return null;
+    try {
+        const res = await fetchImpl(`${NPM_REGISTRY}/${pkg}/latest`, {
+            headers: { Accept: "application/vnd.npm.install-v1+json" },
+            signal: AbortSignal.timeout(opts.timeoutMs ?? 5000),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        const version = typeof body.version === "string" ? body.version : null;
+        if (!version || parseSemver(version) === null)
+            return null;
+        return version;
+    }
+    catch {
+        return null;
+    }
+}

package/llms.txt

@@ -1,6 +1,6 @@
 # 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 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.
+> 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 27 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
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "continuous-improvement",
-  "version": "3.15.0",
-  "description": "The persistent-memory and runtime-discipline layer for Claude Code. It remembers the corrections you already gave, grounds every edit in real facts before it lands, and — through the Mulahazah engine — turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Built on the 7 Laws of AI Agent Discipline (research, plan, verify, reflect, learn) and shipped as 25 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts. Beginner: one /plugin install command. Expert: adds MCP tools and session hooks.",
+  "version": "3.17.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 27 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-skill",
@@ -44,6 +44,7 @@
     "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:skill-count-prose": "node bin/check-skill-count-prose.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",
@@ -52,7 +53,7 @@
     "verify:scripts-citation-drift": "node bin/check-scripts-citation-drift.mjs",
     "verify:third-party-shape": "node bin/check-third-party-shape.mjs",
     "verify:tool-count": "node bin/check-tool-count.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 verify:tool-count && 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: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 verify:tool-count && npm run typecheck"
   },
   "files": [
     ".claude-plugin/",

package/plugins/beginner.json

@@ -1,6 +1,6 @@
 {
   "name": "continuous-improvement",
-  "version": "3.15.0",
+  "version": "3.17.0",
   "mode": "beginner",
   "description": "Beginner mode: see what your agent learned, list its instincts, and request a session reflection. Bundles three grounding skills (gateguard, tdd-workflow, verification-loop) so research, memory, 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 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",
+      "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 27 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.17.0",
       "source": "./",
       "author": {
         "name": "naimkatiman"

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

@@ -1,7 +1,7 @@
 {
   "name": "continuous-improvement",
-  "version": "3.15.0",
-  "description": "The persistent-memory and runtime-discipline layer for Claude Code. It remembers the corrections you already gave, grounds every edit in real facts before it lands, and — through the Mulahazah engine — turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Built on the 7 Laws of AI Agent Discipline (research, plan, verify, reflect, learn) and shipped as 25 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.",
+  "version": "3.17.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 27 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/bin/mcp-server.mjs

@@ -219,6 +219,7 @@ function readDistillObservations(projectHash) {
         tool: getString(observation.tool),
         input_summary: getString(observation.input_summary),
         output_summary: getString(observation.output_summary),
+        event: getString(observation.event),
     }));
 }
 function detectLevel(projectHash) {

package/plugins/continuous-improvement/commands/intent-driven-development.md

@@ -0,0 +1,36 @@
+---
+name: intent-driven-development
+description: "Turn an ambiguous or high-impact change into scoped, verifiable acceptance criteria (observable AC-NNN, explicit scope, named verification methods, and a [revised] protocol that forbids silently dropping a criterion) before or alongside implementation. Enforces Law 2 (Plan Is Sacred)."
+argument-hint: "[the change to scope into acceptance criteria]"
+---
+
+# /intent-driven-development
+
+Convert an ambiguous or high-impact request into observable acceptance criteria before you build, so "done" is a fact two people would agree on and the agreed plan is held sacred (Law 2). Produce useful criteria without ceremony: inspect context first, expose only genuine ambiguity, choose verification that fits the risk.
+
+## Trigger phrases
+
+- `/intent-driven-development`
+- `/intent-driven-development <the change>`
+- "define acceptance criteria"
+- "scope this change" / "make this testable"
+- "de-risk this before we build it"
+- "prepare implementation requirements for another agent"
+
+Do not trigger for trivial edits, one-line fixes, active debugging, code review, or requests whose acceptance conditions are already clear.
+
+## What happens
+
+1. **Inspect and scope.** Read the repo, docs, schemas, and tests for technical facts before asking. Capture product or business constraints only from the user or a product artifact, never inferred from code.
+2. **Choose depth.** Quick Capture (3-7 criteria, low or moderate risk) or Full Acceptance Brief (security, data, migration, cross-system, or handoff).
+3. **Write criteria.** Each `AC-NNN` names a scenario, a trigger, an expected observable result, a prohibited side effect when meaningful, a verification method, and a priority. No vague words without defined evidence.
+4. **Proceed or hand off.** Record the criteria and continue for a clear request; present blockers and wait when a change is risky. If a criterion cannot be met mid-build, mark it `[revised]`, increment the revision, and re-present only the changed criteria.
+
+## Skill file
+
+Full behavior is defined in [`skills/intent-driven-development.md`](../skills/intent-driven-development.md).
+
+## Pairs with
+
+- `/grill-me`: grill-me clarifies a fuzzy input; this skill turns the agreed intent into verifiable criteria.
+- `/roast`: roast validates the idea, then scope the survivor into acceptance criteria.

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

@@ -0,0 +1,34 @@
+---
+name: roast
+description: "Convene a 5-persona adversarial council (Contrarian, Expansionist, Logician, Researcher, Buyer) to pressure-test an idea, then deliver one GO / RESHAPE / KILL verdict plus the cheapest 48-hour test to de-risk it. Enforces Law 1 (Research Before Executing)."
+argument-hint: "[the idea to roast]"
+---
+
+# /roast
+
+Pressure-test an idea before you build it. Convene a council of five independent persona agents who attack the idea from every angle, then act as the Judge and return one decisive verdict — so Law 1 (Research Before Executing) is satisfied on the *idea* itself, not just the plan.
+
+## Trigger phrases
+
+- `/roast`
+- `/roast <the idea>`
+- "roast this idea"
+- "convene the council"
+- "pressure-test this" / "stress-test this idea"
+- "validate this business idea"
+- "give me a brutal second opinion before I build this"
+
+## What happens
+
+1. **Brief.** Read the idea from the argument (if given) and ask up to 3-4 clarifying questions in one batch — the idea, the buyer + money model, your edge, your constraints. Skip the questions if the user says "just run it."
+2. **Council (parallel).** Spin up all five personas in parallel, each pasted the same brief: Contrarian (assume it fails), Expansionist (the 10x case), Logician (first-principles, no web), Researcher (web evidence + competitors), Buyer (role-play the target customer). Each returns a stance, 3-5 sharp points, the one thing you must hear, and a 1-10 score.
+3. **Verdict.** Act as the Judge: resolve the council's tension, fold in the economics lens, and return one `GO / RESHAPE / KILL` call with the biggest risk, biggest upside, money read, and — most importantly — the cheapest 48-hour test to validate the riskiest assumption before building anything.
+
+## Skill file
+
+Full behavior is defined in [`skills/roast.md`](../skills/roast.md).
+
+## Pairs with
+
+- `/grill-me` — roast validates the idea; grill-me then hardens the plan.
+- `/proceed-with-the-recommendation` — walk the verdict's next steps under the 7 Laws.

package/plugins/continuous-improvement/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "Gateguard fact-forcing PreToolUse, companion-preference enforcement, observation, session lifecycle, 3-section-close discipline, goal-drift Stop gate, and UserPromptSubmit lazy-routing plus opt-in proactive recall-briefing hooks for continuous-improvement.",
+  "description": "Gateguard fact-forcing PreToolUse, companion-preference enforcement, observation, session lifecycle, 3-section-close discipline, goal-drift Stop gate, opt-in workflow-distill Stop nudge, and UserPromptSubmit lazy-routing plus opt-in proactive recall-briefing hooks for continuous-improvement.",
   "hooks": {
     "PreToolUse": [
       {
@@ -88,6 +88,11 @@
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/goal-drift-stop.mjs\"",
             "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/workflow-distill.mjs\"",
+            "timeout": 5
           }
         ]
       }

package/plugins/continuous-improvement/hooks/workflow-distill.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+// workflow-distill.mts — Stop hook (opt-in, default off) that nudges the operator
+// to persist a verified native Workflow run as a Mulahazah draft instinct via the
+// ci_distill_from_workflow MCP tool. This is the one integration a per-turn
+// orchestration primitive cannot do for itself: make the lesson of an expensive
+// multi-agent run survive the run instead of evaporating when the turn ends — the
+// fast-follow deferred in docs/plans/2026-06-08-workflow-instinct-bridge.md.
+//
+// Mode via CLAUDE_WORKFLOW_DISTILL_NUDGE: "on" | "off" (default).
+//   - off (default): no-op. Operators who do not use native Workflows are never
+//     nagged.
+//   - on: if the session's observation feed shows a verified Workflow run that
+//     has not already been nudged, print ONE stderr line suggesting
+//     ci_distill_from_workflow. It is an amplifier, never a gate — it cannot
+//     block the Stop and writes nothing to stdout.
+//
+// Project-hash resolution is byte-identical to bin/observe.mts and
+// hooks/goal-drift-stop.mts so this hook reads the SAME observations.jsonl the
+// observer writes. The "is this run verified" decision is the pure, already-tested
+// workflowRunFromObservations (src/lib/skill-distill.mts), which fails closed:
+// no Workflow row, unparseable meta, or no following verify-exit-0 => null => no
+// nudge. Per-run dedup state lives in
+// ~/.claude/instincts/<project-hash>/workflow-distill-state.json keyed by run
+// name + verify command, so a run is nudged at most once. Fail-open by
+// construction: any error exits 0 and never blocks. No network. 5s hook budget.
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveHomeDir } from "../lib/resolve-home-dir.mjs";
+import { workflowRunFromObservations } from "../lib/skill-distill.mjs";
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveMode() {
+    return (process.env.CLAUDE_WORKFLOW_DISTILL_NUDGE ?? "off").trim().toLowerCase() === "on" ? "on" : "off";
+}
+// Mirrors bin/observe.mts:resolveProjectRoot — the same basis the observer uses
+// to bucket observations.jsonl, so the hash here resolves to the same file.
+function resolveProjectRoot() {
+    const fromEnv = process.env.CLAUDE_PROJECT_DIR;
+    if (fromEnv)
+        return fromEnv;
+    try {
+        const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (root)
+            return root;
+    }
+    catch {
+        // not a git repo
+    }
+    return "global";
+}
+function projectHash(root) {
+    return createHash("sha256").update(root).digest("hex").slice(0, 12);
+}
+function readObservations(instinctsProjectDir) {
+    const file = join(instinctsProjectDir, "observations.jsonl");
+    try {
+        if (!existsSync(file))
+            return [];
+        const lines = readFileSync(file, "utf8")
+            .split("\n")
+            .filter((line) => line.trim().length > 0);
+        const out = [];
+        // A workflow row plus its following verify both sit near the tail; a bounded
+        // window keeps the 5s budget safe on a long-lived feed.
+        for (const line of lines.slice(-5000)) {
+            const row = safeJsonParse(line);
+            if (!row)
+                continue;
+            out.push({
+                ts: typeof row.ts === "string" ? row.ts : "",
+                session: typeof row.session === "string" ? row.session : "",
+                session_id: typeof row.session_id === "string" ? row.session_id : "",
+                tool: typeof row.tool === "string" ? row.tool : "",
+                input_summary: typeof row.input_summary === "string" ? row.input_summary : "",
+                output_summary: typeof row.output_summary === "string" ? row.output_summary : "",
+            });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function readNudgedKeys(instinctsProjectDir) {
+    const file = join(instinctsProjectDir, "workflow-distill-state.json");
+    try {
+        if (!existsSync(file))
+            return new Set();
+        const parsed = safeJsonParse(readFileSync(file, "utf8"));
+        const arr = parsed && Array.isArray(parsed.nudged) ? parsed.nudged : [];
+        return new Set(arr.filter((x) => typeof x === "string"));
+    }
+    catch {
+        return new Set();
+    }
+}
+function persistNudged(instinctsProjectDir, keys) {
+    try {
+        mkdirSync(instinctsProjectDir, { recursive: true });
+        writeFileSync(join(instinctsProjectDir, "workflow-distill-state.json"), JSON.stringify({ ts: new Date().toISOString(), nudged: [...keys] }) + "\n", "utf8");
+    }
+    catch {
+        // dedup persistence is best-effort; never throw
+    }
+}
+function main() {
+    if (resolveMode() === "off")
+        return;
+    const home = resolveHomeDir();
+    if (!home)
+        return;
+    const projectRoot = resolveProjectRoot();
+    const instinctsProjectDir = join(home, ".claude", "instincts", projectHash(projectRoot));
+    const observations = readObservations(instinctsProjectDir);
+    if (observations.length === 0)
+        return;
+    const run = workflowRunFromObservations(observations);
+    if (!run)
+        return; // fail closed: no verified run, nothing to nudge
+    const runKey = `${run.name}::${run.verifyCommand}`;
+    const nudged = readNudgedKeys(instinctsProjectDir);
+    if (nudged.has(runKey))
+        return; // already nudged this run — stay quiet
+    process.stderr.write(`[continuous-improvement] workflow-distill: verified workflow run "${run.name}" detected — ` +
+        "run the ci_distill_from_workflow MCP tool to persist it as a Mulahazah draft instinct.\n");
+    nudged.add(runKey);
+    persistNudged(instinctsProjectDir, nudged);
+}
+try {
+    main();
+}
+catch {
+    // fail open — never block the session due to a hook bug
+}

package/plugins/continuous-improvement/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 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.";
+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 27 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
@@ -492,6 +492,11 @@ export function getPluginHooksConfig() {
         command: "node \"${CLAUDE_PLUGIN_ROOT}/hooks/goal-drift-stop.mjs\"",
         timeout: 5,
     };
+    const workflowDistillCommand = {
+        type: "command",
+        command: "node \"${CLAUDE_PLUGIN_ROOT}/hooks/workflow-distill.mjs\"",
+        timeout: 5,
+    };
     const routePromptCommand = {
         type: "command",
         command: "node \"${CLAUDE_PLUGIN_ROOT}/hooks/route-prompt.mjs\"",
@@ -503,7 +508,7 @@ export function getPluginHooksConfig() {
         timeout: 5,
     };
     return {
-        description: "Gateguard fact-forcing PreToolUse, companion-preference enforcement, observation, session lifecycle, 3-section-close discipline, goal-drift Stop gate, and UserPromptSubmit lazy-routing plus opt-in proactive recall-briefing hooks for continuous-improvement.",
+        description: "Gateguard fact-forcing PreToolUse, companion-preference enforcement, observation, session lifecycle, 3-section-close discipline, goal-drift Stop gate, opt-in workflow-distill Stop nudge, and UserPromptSubmit lazy-routing plus opt-in proactive recall-briefing hooks for continuous-improvement.",
         hooks: {
             // gateguard runs FIRST on PreToolUse so its block decision short-circuits
             // before companion-preference sees the call. companion-preference runs
@@ -527,7 +532,7 @@ export function getPluginHooksConfig() {
             UserPromptSubmit: [{ hooks: [routePromptCommand, recallBriefingCommand] }],
             SessionStart: [{ hooks: [sessionCommand] }],
             SessionEnd: [{ hooks: [sessionCommand] }],
-            Stop: [{ hooks: [threeSectionCloseCommand, goalDriftStopCommand] }],
+            Stop: [{ hooks: [threeSectionCloseCommand, goalDriftStopCommand, workflowDistillCommand] }],
         },
     };
 }

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

@@ -29,8 +29,10 @@ skill set on disk.
 - `grill-me` — Enforces Law 1 (Research Before Executing) of the 7 Laws of AI Agent Discipline. Interview the user relentlessly about a plan or design until shared understanding is reached, resolving every branch of the decision tree before any code is written. Ported from mattpocock/skills under MIT.
 - `grill-with-docs` — Enforces Law 1 (Research Before Executing) and Law 7 (Learn From Every Session) of the 7 Laws of AI Agent Discipline. Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates CONTEXT.md + ADRs inline as decisions crystallise. Ported from mattpocock/skills under MIT.
 - `handoff` — Enforces Law 5 (Reflect After Every Session) of the 7 Laws of AI Agent Discipline. Compact the current conversation into a handoff document for another agent to pick up. Ported from mattpocock/skills under MIT.
+- `intent-driven-development` — Enforces Law 2 (Plan Is Sacred) of the 7 Laws of AI Agent Discipline. Turn an ambiguous or high-impact change into scoped, verifiable acceptance criteria (observable AC-NNN, explicit in/out scope, named verification methods, and a [revised] protocol that forbids silently dropping a criterion) before or alongside implementation, so the plan that gets built is the plan that was agreed, not an invented default. Use when clarifying a feature, defining acceptance criteria, de-risking a security/data/migration/integration change, or preparing implementation requirements for another agent. Do not trigger for trivial edits, straightforward fixes, active debugging, or code review.
 - `reconcile` — Enforces Law 1 (Research Before Executing) of the 7 Laws of AI Agent Discipline. Establishes git ground truth — branch, status, stashes, worktrees, ahead/behind — before any mutation, halts on protected or destructive operations, and verifies a push actually landed instead of assuming it did.
 - `recovery-classification` — Enforces Law 4 (Verify Before Reporting) of the 7 Laws of AI Agent Discipline. After any failure in the verification ladder or auto-loop, classify the failure class before retrying — provider, tool-schema, deterministic-policy, git, worktree, runtime — so retry-vs-pause-vs-self-heal-vs-stop is an intentional decision, not a generic 'try again'.
+- `roast` — Enforces Law 1 (Research Before Executing) of the 7 Laws of AI Agent Discipline. Convene a 5-persona adversarial council (Contrarian, Expansionist, Logician, Researcher, Buyer) that attacks an idea from every angle, then a Judge returns one GO / RESHAPE / KILL verdict plus the cheapest 48-hour test to de-risk it — so you pressure-test an idea before sinking time into building the wrong thing.
 - `safety-guard` — Enforces Law 3 (One Thing at a Time) of the 7 Laws of AI Agent Discipline by scoping edits to a directory and blocking destructive shell commands. Use this skill to prevent destructive operations when working on production systems or running agents autonomously.
 - `skill-distillation` — Enforces Law 7 (Learn From Every Session) of the 7 Laws of AI Agent Discipline. Distills repeated successful tool sequences into reusable draft instincts, so a pattern that worked three times becomes a captured recipe instead of being re-derived from scratch every session.
 - `state-reconciliation` — Enforces Law 4 (Verify Before Reporting) of the 7 Laws of AI Agent Discipline. Pre-dispatch invariant: reconcile DB-vs-disk-vs-memory state before any unit runs, so a stale flag, missing artifact, or out-of-sync row never re-dispatches a unit that already completed or never started.