continuous-improvement 3.9.2 → 3.11.0

package/plugins/continuous-improvement/hooks/goal-drift-stop.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// goal-drift-stop.mts — Stop hook that scores the turn's activity against the
+// stated goal (task_plan.md ## Goal) and, when the session has DRIFTed on a
+// substantive wrap-up, warns or (opt-in) blocks the close. This is the runtime
+// arm of goal-monitor: it auto-fires the drift check at the Stop phase boundary
+// instead of waiting for someone to run /goal-check.
+//
+// Mode via CLAUDE_GOAL_DRIFT_GATE: "warn" (default) | "block" | "off".
+//   - warn  : print a one-line drift notice to stderr; never blocks.
+//   - block : emit {"decision":"block","reason":...} to re-prompt.
+//   - off   : no-op.
+// The drift status is persisted to
+// ~/.claude/instincts/<project-hash>/goal-drift-state.json every turn.
+//
+// Project-hash resolution is byte-identical to bin/observe.mts so this hook
+// reads the SAME observations.jsonl the observer writes. Fail-open by
+// construction: any error / missing goal / unreadable observations 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 { evaluateGoalDrift } from "../lib/goal-drift-gate.mjs";
+import { resolveHomeDir } from "../lib/resolve-home-dir.mjs";
+function readStdinSync() {
+    try {
+        return readFileSync(0, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveMode() {
+    const raw = (process.env.CLAUDE_GOAL_DRIFT_GATE ?? "warn").trim().toLowerCase();
+    return raw === "block" || raw === "off" ? raw : "warn";
+}
+// 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 readGoalMarkdown(projectRoot, instinctsProjectDir) {
+    const candidates = [join(projectRoot, "task_plan.md"), join(instinctsProjectDir, "goal.md")];
+    for (const file of candidates) {
+        try {
+            if (existsSync(file))
+                return readFileSync(file, "utf8");
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return "";
+}
+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 = [];
+        for (const line of lines.slice(-100)) {
+            const row = safeJsonParse(line);
+            if (!row)
+                continue;
+            out.push({
+                ts: typeof row.ts === "string" ? row.ts : "",
+                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 lastAssistantTextLength(transcriptPath) {
+    try {
+        const lines = readFileSync(transcriptPath, "utf8").split(/\r?\n/);
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const obj = safeJsonParse(line);
+            if (!obj || obj.type !== "assistant")
+                continue;
+            const blocks = obj.message?.content;
+            if (!Array.isArray(blocks))
+                continue;
+            const text = blocks
+                .filter((b) => b &&
+                typeof b === "object" &&
+                b.type === "text" &&
+                typeof b.text === "string")
+                .map((b) => b.text)
+                .join("\n");
+            if (text.length === 0)
+                continue;
+            return text.length;
+        }
+    }
+    catch {
+        // fall through to 0
+    }
+    return 0;
+}
+function persistState(instinctsProjectDir, state) {
+    try {
+        mkdirSync(instinctsProjectDir, { recursive: true });
+        writeFileSync(join(instinctsProjectDir, "goal-drift-state.json"), JSON.stringify({ ts: new Date().toISOString(), ...state }) + "\n", "utf8");
+    }
+    catch {
+        // state persistence is best-effort; never throw
+    }
+}
+function main() {
+    const mode = resolveMode();
+    if (mode === "off")
+        return;
+    const stdin = readStdinSync();
+    if (!stdin)
+        return;
+    const payload = safeJsonParse(stdin);
+    if (!payload)
+        return;
+    const home = resolveHomeDir();
+    if (!home)
+        return;
+    const projectRoot = resolveProjectRoot();
+    const instinctsProjectDir = join(home, ".claude", "instincts", projectHash(projectRoot));
+    const goalMarkdown = readGoalMarkdown(projectRoot, instinctsProjectDir);
+    const observations = readObservations(instinctsProjectDir);
+    const textLength = payload.transcript_path && existsSync(payload.transcript_path)
+        ? lastAssistantTextLength(payload.transcript_path)
+        : 0;
+    const decision = evaluateGoalDrift({ goalMarkdown, observations, textLength, mode });
+    persistState(instinctsProjectDir, {
+        status: decision.status,
+        score: decision.score,
+        action: decision.action,
+    });
+    if (decision.action === "block") {
+        process.stdout.write(JSON.stringify({ decision: "block", reason: decision.reason }) + "\n");
+    }
+    else if (decision.action === "warn") {
+        process.stderr.write(`[continuous-improvement] goal-drift: ${decision.reason}\n`);
+    }
+}
+try {
+    main();
+}
+catch {
+    // fail open — never block the session due to a hook bug
+}

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

@@ -1,5 +1,5 @@
 {
-  "description": "Gateguard fact-forcing PreToolUse, observation, session lifecycle, and 3-section-close discipline hooks for continuous-improvement.",
+  "description": "Gateguard fact-forcing PreToolUse, companion-preference enforcement, observation, session lifecycle, 3-section-close discipline, goal-drift Stop gate, and UserPromptSubmit lazy-routing hooks for continuous-improvement.",
   "hooks": {
     "PreToolUse": [
       {
@@ -11,7 +11,7 @@
           },
           {
             "type": "command",
-            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/observe.sh\"",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/companion-preference.mjs\"",
             "timeout": 5
           }
         ]
@@ -28,6 +28,17 @@
         ]
       }
     ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/route-prompt.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
     "SessionStart": [
       {
         "hooks": [
@@ -57,6 +68,11 @@
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/three-section-close.mjs\"",
             "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/goal-drift-stop.mjs\"",
+            "timeout": 5
           }
         ]
       }

package/plugins/continuous-improvement/hooks/observe.sh

@@ -101,6 +101,20 @@ fi
 # ---------------------------------------------------------------------------
 # Compute project hash and name
 # ---------------------------------------------------------------------------
+# Canonicalize MSYS-mounted Windows paths (/d/Path) to native form (D:/Path)
+# so the bash fallback hashes to the same project bucket as the Node observer.
+# Without this, Git Bash on Windows produces /d/Ai/repo from `git rev-parse`
+# while Node's child_process produces D:/Ai/repo for the same physical path,
+# splitting telemetry between two SHA-256 buckets per project.
+# Pattern matches /<single-letter>/... only — Linux/macOS paths like /usr,
+# /home, /Users are unaffected.
+case "$PROJECT_ROOT" in
+  /[a-zA-Z]/*)
+    drive_letter="$(printf '%s' "$PROJECT_ROOT" | cut -c2 | tr '[:lower:]' '[:upper:]')"
+    PROJECT_ROOT="${drive_letter}:$(printf '%s' "$PROJECT_ROOT" | cut -c3-)"
+    ;;
+esac
+
 PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
 PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
 
@@ -119,7 +133,7 @@ if [[ -f "$OBS_FILE" ]]; then
   LINE_COUNT="$(wc -l < "$OBS_FILE")"
   if (( LINE_COUNT >= 10000 )); then
     mv "$OBS_FILE" "${PROJECT_DIR}/observations.$(date -u +"%Y-%m-%d-%H%M%S").jsonl"
-    
+
     # Clean up old archives - keep only 10 most recent
     ls -t "${PROJECT_DIR}"/observations.*.jsonl 2>/dev/null | tail -n +11 | xargs -r rm -f
   fi

package/plugins/continuous-improvement/hooks/route-prompt.mjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * Runtime UserPromptSubmit prompt-router hook.
+ *
+ * Reads the user prompt, matches it against patterns in
+ * hooks/route-table.json, and emits a single `<system-reminder>` recommending
+ * the matched skill. When no row matches, the hook emits nothing — the prompt
+ * passes through untouched.
+ *
+ * Stdin  : JSON { prompt, session_id?, transcript_path?, cwd? }
+ * Stdout : JSON { hookSpecificOutput: { hookEventName: "UserPromptSubmit",
+ *                                       additionalContext: string } }
+ *          OR empty when there is no match.
+ * Exit   : 0 always — routing decisions live in stdout, never in exit code.
+ *
+ * Fail-open: any unexpected error reading stdin / parsing the route table /
+ * compiling a pattern → emit nothing and exit 0. The hook never blocks a
+ * prompt on its own bugs.
+ *
+ * Telemetry: each match appends one JSONL line to
+ * ~/.claude/instincts/<project-hash>/route-prompt.jsonl with the row index,
+ * skill, and pattern. Telemetry failures never change the decision.
+ *
+ * Route table schema (hooks/route-table.json):
+ *   {
+ *     "rows": [
+ *       { "pattern": "regex source", "flags": "i", "skill": "skill-name",
+ *         "reason": "one-line description" }
+ *     ]
+ *   }
+ * Rows are evaluated in order; first match wins.
+ */
+import { createHash } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+function readStdin() {
+    try {
+        return readFileSync(0, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function resolveHome() {
+    return process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+}
+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 in a git repo
+    }
+    return "global";
+}
+function telemetryPath(home) {
+    const hash = createHash("sha256")
+        .update(resolveProjectRoot())
+        .digest("hex")
+        .slice(0, 12);
+    return join(home, ".claude", "instincts", hash, "route-prompt.jsonl");
+}
+function writeTelemetry(home, event) {
+    try {
+        const path = telemetryPath(home);
+        const dir = dirname(path);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        appendFileSync(path, `${JSON.stringify(event)}\n`);
+    }
+    catch {
+        // fail-open
+    }
+}
+function loadRouteTable() {
+    // Hook lives at <plugin-root>/hooks/route-prompt.mjs at runtime; the table
+    // sits next to it. import.meta.url gives the file:// URL of the compiled
+    // .mjs.
+    try {
+        const here = fileURLToPath(new URL(".", import.meta.url));
+        const tablePath = join(here, "route-table.json");
+        const raw = readFileSync(tablePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.rows))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function findMatch(prompt, table) {
+    for (let i = 0; i < table.rows.length; i++) {
+        const row = table.rows[i];
+        if (!row || typeof row.pattern !== "string" || typeof row.skill !== "string") {
+            continue;
+        }
+        let rx;
+        try {
+            rx = new RegExp(row.pattern, row.flags ?? "");
+        }
+        catch {
+            continue;
+        }
+        if (rx.test(prompt)) {
+            return { row, index: i };
+        }
+    }
+    return null;
+}
+function buildContext(row) {
+    const reason = row.reason
+        ? `${row.reason}\nConsider invoking \`/${row.skill}\` now.`
+        : `Consider invoking \`/${row.skill}\` now.`;
+    return `<system-reminder>\nPrompt-router suggestion: ${reason}\n</system-reminder>`;
+}
+function emit(output) {
+    if (output !== null) {
+        process.stdout.write(`${JSON.stringify(output)}\n`);
+    }
+    process.exit(0);
+}
+function main() {
+    const raw = readStdin();
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        emit(null);
+        return;
+    }
+    const prompt = payload.prompt;
+    if (typeof prompt !== "string" || prompt.length === 0) {
+        emit(null);
+        return;
+    }
+    const table = loadRouteTable();
+    if (!table) {
+        emit(null);
+        return;
+    }
+    const match = findMatch(prompt, table);
+    const home = resolveHome();
+    if (!match) {
+        writeTelemetry(home, {
+            ts: new Date().toISOString(),
+            hook: "route-prompt",
+            matched: false,
+        });
+        emit(null);
+        return;
+    }
+    writeTelemetry(home, {
+        ts: new Date().toISOString(),
+        hook: "route-prompt",
+        matched: true,
+        row_index: match.index,
+        skill: match.row.skill,
+        pattern: match.row.pattern,
+    });
+    emit({
+        hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext: buildContext(match.row),
+        },
+    });
+}
+main();

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

@@ -0,0 +1,35 @@
+{
+  "description": "Declarative prompt-router for the continuous-improvement UserPromptSubmit hook. Each row maps a regex (prompt-side trigger) to a skill the agent should consider invoking. First match wins; rows are evaluated in order. Edit this file to grow the routing table — no code change required.",
+  "rows": [
+    {
+      "pattern": "\\b(write|add|new)\\s+(a\\s+)?(failing\\s+)?test\\b|\\btdd\\b|\\bred[- ]green[- ]refactor\\b",
+      "flags": "i",
+      "skill": "tdd-workflow",
+      "reason": "Prompt mentions writing tests, TDD, or RED-GREEN-REFACTOR."
+    },
+    {
+      "pattern": "\\b(verify|verification|prove\\s+it\\s+works|smallest\\s+check|check\\s+it\\s+passes)\\b",
+      "flags": "i",
+      "skill": "verification-loop",
+      "reason": "Prompt asks for verification before declaring done."
+    },
+    {
+      "pattern": "\\b(plan|blueprint|design\\s+(the\\s+)?approach|step[- ]by[- ]step\\s+plan|roadmap)\\b",
+      "flags": "i",
+      "skill": "planning-with-files",
+      "reason": "Prompt asks for a plan, blueprint, or design before implementation."
+    },
+    {
+      "pattern": "\\b(security\\s+review|threat\\s+model|owasp|vulnerab|auth(entication|orization)\\s+check)\\b",
+      "flags": "i",
+      "skill": "security-review",
+      "reason": "Prompt touches security review, threat modeling, or auth surface."
+    },
+    {
+      "pattern": "\\b(code\\s+review|review\\s+(my|the|this)\\s+(code|pr|diff|patch)|critique\\s+(the|this)\\s+code)\\b",
+      "flags": "i",
+      "skill": "code-review",
+      "reason": "Prompt asks for a code review on existing changes."
+    }
+  ]
+}