continuous-improvement 3.1.0 → 3.9.1

package/plugins/continuous-improvement/hooks/three-section-close.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// three-section-close.mjs — Stop hook that requires every substantive
+// assistant reply to close with three named sections:
+//   "What has been done", "What is next", "Recommendation".
+//
+// Implements Law 4 + Law 5 in-band: verify before reporting, reflect at
+// the end. See SKILL.md for the discipline rationale.
+//
+// Behavior:
+//   - exit 0 to allow the response to stand
+//   - emit {"decision":"block","reason":"..."} on stdout to re-prompt
+//   - never block on internal failure (parse error, missing transcript,
+//     unexpected message shape) — fail open
+//
+// Heuristic: skip messages shorter than 600 chars. Pure clarifying replies
+// don't need the close; only substantive technical responses (work
+// summaries, plan responses, post-execution reports) get gated.
+//
+// Telemetry: best-effort JSONL line per gated invocation written to
+// ~/.claude/hook-telemetry/<project-hash>.jsonl. Never throws, never
+// blocks the response. No network. No transcript content recorded.
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { platform } from "node:os";
+import { dirname, join } from "node:path";
+import { performance } from "node:perf_hooks";
+
+import { resolveHomeDir } from "../lib/resolve-home-dir.mjs";
+
+const MIN_LENGTH_TO_GATE = 600;
+
+const REQUIRED_SECTIONS = [
+  {
+    heading: "What has been done",
+    hint: "concrete summary of changes/findings from this turn",
+    pattern: /^#+ +What has been done(?:\s|$)/m,
+  },
+  {
+    heading: "What is next",
+    hint: "minimum 5 specific, actionable bullets",
+    pattern: /^#+ +What is next(?:\s|$)/m,
+  },
+  {
+    heading: "Recommendation",
+    hint: "ranked descending by impact, or write \"no\" if there is no recommendation",
+    pattern: /^#+ +Recommendation(?:\s|$)/m,
+  },
+];
+
+function readStdinSync() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function extractLastAssistantText(transcriptPath) {
+  const raw = readFileSync(transcriptPath, "utf8");
+  const lines = raw.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    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 texts = blocks
+      .filter((b) => b && b.type === "text" && typeof b.text === "string")
+      .map((b) => b.text);
+    if (texts.length === 0) continue;
+    return texts.join("\n");
+  }
+  return null;
+}
+
+function emitBlock(missing) {
+  const bullets = missing
+    .map(
+      (s) =>
+        `- "## ${s.heading}" — ${s.hint}`,
+    )
+    .join("\n");
+  const reason =
+    `Your reply is missing the required 3-section close. Add these sections at the end of the reply with these exact headings:\n${bullets}`;
+  process.stdout.write(JSON.stringify({ decision: "block", reason }) + "\n");
+}
+
+function projectHashFor(transcriptPath) {
+  const dir = dirname(transcriptPath);
+  let normalized = dir.split("\\").join("/");
+  if (platform() === "win32") normalized = normalized.toLowerCase();
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+}
+
+function recordTelemetry(entry, transcriptPath) {
+  try {
+    const home = resolveHomeDir();
+    if (!home) return;
+    const telemetryDir = join(home, ".claude", "hook-telemetry");
+    try {
+      mkdirSync(telemetryDir, { recursive: true });
+    } catch {
+      return;
+    }
+    const file = join(telemetryDir, `${projectHashFor(transcriptPath)}.jsonl`);
+    try {
+      appendFileSync(file, JSON.stringify(entry) + "\n", "utf8");
+    } catch {
+      return;
+    }
+  } catch {
+    // belt-and-suspenders: telemetry must never throw
+  }
+}
+
+function main() {
+  // Per-operator opt-out. When CLAUDE_THREE_SECTION_CLOSE_DISABLED=1, the hook
+  // short-circuits entirely: no enforcement, no telemetry. Public default is
+  // unchanged (rule still fires for everyone else). See feedback memory
+  // 2026-05-04 for rationale: an audit found 22,876 observations produced
+  // only 2 graduated instincts, so visible end-of-turn reflection earns its
+  // keep poorly enough that operators may want to run it as internal thinking.
+  if (process.env.CLAUDE_THREE_SECTION_CLOSE_DISABLED === "1") return;
+  const startedAt = performance.now();
+  const stdin = readStdinSync();
+  if (!stdin) return;
+
+  const payload = safeJsonParse(stdin);
+  if (!payload || typeof payload.transcript_path !== "string") return;
+  if (!existsSync(payload.transcript_path)) return;
+
+  let lastText;
+  try {
+    lastText = extractLastAssistantText(payload.transcript_path);
+  } catch {
+    return; // fail open on read error
+  }
+  if (!lastText) return;
+
+  const textLength = lastText.length;
+  let action;
+  let missing = [];
+
+  if (textLength < MIN_LENGTH_TO_GATE) {
+    action = "skip-short";
+  } else {
+    missing = REQUIRED_SECTIONS.filter((s) => !s.pattern.test(lastText));
+    if (missing.length === 0) {
+      action = "pass";
+    } else {
+      action = "block";
+      emitBlock(missing);
+    }
+  }
+
+  const entry = {
+    ts: new Date().toISOString(),
+    hook: "three-section-close",
+    action,
+    textLength,
+    missing: missing.map((s) => s.heading),
+    durationMs: Math.round((performance.now() - startedAt) * 1000) / 1000,
+  };
+  recordTelemetry(entry, payload.transcript_path);
+}
+
+try {
+  main();
+} catch {
+  // fail open — never block the session due to a hook bug
+}

package/plugins/continuous-improvement/instinct-packs/go.json

@@ -0,0 +1,58 @@
+[
+  {
+    "id": "go-error-handling",
+    "trigger": "when calling functions that return errors",
+    "body": "Always check returned errors immediately. Never use _ to discard errors unless you've explicitly decided it's safe and documented why.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-defer-cleanup",
+    "trigger": "when opening files, connections, or acquiring locks",
+    "body": "Use defer immediately after acquiring a resource for cleanup. Place defer right after the error check for the acquisition.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-interface-consumer",
+    "trigger": "when defining Go interfaces",
+    "body": "Define interfaces at the consumer side, not the producer side. Keep interfaces small (1-3 methods). Accept interfaces, return structs.",
+    "confidence": 0.65,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-table-driven-tests",
+    "trigger": "when writing Go tests",
+    "body": "Use table-driven tests with subtests (t.Run) for functions with multiple input/output cases. Name test cases descriptively.",
+    "confidence": 0.7,
+    "domain": "testing"
+  },
+  {
+    "id": "go-context-propagation",
+    "trigger": "when writing HTTP handlers or long-running operations",
+    "body": "Accept context.Context as the first parameter. Propagate it to all downstream calls. Use it for cancellation and timeouts.",
+    "confidence": 0.65,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-goroutine-lifecycle",
+    "trigger": "when spawning goroutines",
+    "body": "Always ensure goroutines have a way to exit (context cancellation, done channel, or WaitGroup). Never fire-and-forget goroutines without cleanup.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-struct-zero-values",
+    "trigger": "when designing Go structs",
+    "body": "Design structs so their zero value is useful. Use pointer fields only when nil is a meaningful distinct state from zero value.",
+    "confidence": 0.6,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-mod-tidy",
+    "trigger": "when adding or removing dependencies",
+    "body": "Run 'go mod tidy' after adding or removing imports to keep go.mod and go.sum clean.",
+    "confidence": 0.65,
+    "domain": "workflow"
+  }
+]

package/plugins/continuous-improvement/instinct-packs/meta.json

@@ -0,0 +1,16 @@
+[
+  {
+    "id": "skip-thin-observation-schema",
+    "trigger": "when running /continuous-improvement and observations.jsonl entries contain only tool_start events with no inputs/outputs/errors",
+    "body": "Skip instinct fabrication and report the schema gap instead. With only ts/event/session/tool/project_id/project_name fields, the stream cannot distinguish a `git status` Bash call from a `rm -rf` Bash call. Tool-name bigrams (Bash→Bash, Edit→Edit, Read→Edit) reflect parallel-call artifacts and harness-enforced read-before-edit, not learned preferences. Recommend enhancing PostToolUse/PreToolUse hooks to log tool inputs (Bash command head, Skill name) and tool_end with success flag before retrying analysis.",
+    "confidence": 0.6,
+    "domain": "meta"
+  },
+  {
+    "id": "parallelize-independent-tool-calls",
+    "trigger": "when issuing 2+ tool calls with no data dependency between them in the same turn",
+    "body": "Batch independent tool calls into a single message instead of issuing them sequentially. Independent reads, independent greps, independent git inspections, independent file edits in unrelated files belong in one message with multiple tool blocks. Dependent calls (output of A determines input of B) stay sequential. Exception: when a single check would short-circuit the whole task (e.g., `git status` returning empty), one call first is fine. Sequential issuing of independent calls wastes wall-clock time and burns context per round-trip.",
+    "confidence": 0.6,
+    "domain": "workflow"
+  }
+]

package/plugins/continuous-improvement/instinct-packs/python.json

@@ -0,0 +1,58 @@
+[
+  {
+    "id": "python-virtual-env",
+    "trigger": "when starting work on a Python project",
+    "body": "Check for virtual environment (venv, .venv, conda) before installing packages. Never install to system Python.",
+    "confidence": 0.7,
+    "domain": "workflow"
+  },
+  {
+    "id": "python-type-hints",
+    "trigger": "when writing Python functions",
+    "body": "Add type hints to function parameters and return values. Use Optional[], list[], dict[] (Python 3.10+) or typing module for older versions.",
+    "confidence": 0.6,
+    "domain": "code-style"
+  },
+  {
+    "id": "python-pathlib",
+    "trigger": "when working with file paths in Python",
+    "body": "Use pathlib.Path instead of os.path for file operations. It's more readable and cross-platform.",
+    "confidence": 0.65,
+    "domain": "patterns"
+  },
+  {
+    "id": "python-context-managers",
+    "trigger": "when opening files or database connections",
+    "body": "Always use context managers (with statement) for files, database connections, and locks. Never rely on manual .close() calls.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "python-list-comprehension",
+    "trigger": "when writing simple for loops that build lists",
+    "body": "Prefer list comprehensions for simple transformations. Use regular for loops when the logic is complex or has side effects.",
+    "confidence": 0.6,
+    "domain": "code-style"
+  },
+  {
+    "id": "python-requirements-check",
+    "trigger": "when adding a new import",
+    "body": "Check if the package is already in requirements.txt, pyproject.toml, or Pipfile before adding. Search for existing usage in the codebase.",
+    "confidence": 0.65,
+    "domain": "workflow"
+  },
+  {
+    "id": "python-pytest-fixtures",
+    "trigger": "when writing Python tests",
+    "body": "Use pytest fixtures for test setup/teardown instead of unittest setUp/tearDown. Use conftest.py for shared fixtures.",
+    "confidence": 0.6,
+    "domain": "testing"
+  },
+  {
+    "id": "python-dataclass",
+    "trigger": "when creating classes that primarily hold data",
+    "body": "Use @dataclass or Pydantic BaseModel instead of plain classes for data containers. They provide __init__, __repr__, and comparison for free.",
+    "confidence": 0.65,
+    "domain": "patterns"
+  }
+]

package/plugins/continuous-improvement/instinct-packs/react.json

@@ -0,0 +1,58 @@
+[
+  {
+    "id": "react-check-existing-components",
+    "trigger": "when creating a new React component",
+    "body": "Search the codebase for existing components that solve the same problem before creating new ones. Check shared/, components/, and ui/ directories.",
+    "confidence": 0.65,
+    "domain": "workflow"
+  },
+  {
+    "id": "react-prefer-server-components",
+    "trigger": "when creating components in Next.js App Router",
+    "body": "Default to Server Components. Only add 'use client' when the component needs useState, useEffect, event handlers, or browser APIs.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-key-prop-lists",
+    "trigger": "when rendering lists with .map()",
+    "body": "Always use a stable, unique key prop. Never use array index as key unless the list is static and never reordered.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-effect-cleanup",
+    "trigger": "when writing useEffect with subscriptions or timers",
+    "body": "Always return a cleanup function from useEffect when setting up subscriptions, event listeners, or timers to prevent memory leaks.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-memo-expensive",
+    "trigger": "when a component re-renders with expensive calculations",
+    "body": "Use useMemo for expensive computations and React.memo for components that receive the same props frequently. Don't memo everything — only what's measurably slow.",
+    "confidence": 0.6,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-form-validation",
+    "trigger": "when building forms",
+    "body": "Check if react-hook-form or zod is already in the project before building custom form validation. Prefer library solutions over hand-rolled validation.",
+    "confidence": 0.65,
+    "domain": "tooling"
+  },
+  {
+    "id": "react-error-boundary",
+    "trigger": "when adding a new page or route",
+    "body": "Ensure error boundaries exist around new pages/routes. In Next.js App Router, add error.tsx. In other React apps, wrap with ErrorBoundary component.",
+    "confidence": 0.6,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-test-user-behavior",
+    "trigger": "when writing React component tests",
+    "body": "Test user behavior, not implementation details. Use @testing-library/react. Query by role, label, or text — not by class name or test ID.",
+    "confidence": 0.65,
+    "domain": "testing"
+  }
+]

package/plugins/continuous-improvement/lib/observe-event.mjs

@@ -0,0 +1,128 @@
+// observe-event.mts — Pure parsers for the Mulahazah observation hook.
+//
+// These functions have NO I/O. They turn raw stdin text and tool input/output
+// payloads into shaped data the entrypoint (src/bin/observe.mts) writes to
+// observations.jsonl. Pure separation lets the unit tests cover schema edge
+// cases (malformed JSON, missing fields, oversized payloads) without ever
+// touching the filesystem or computing project hashes.
+//
+// Truncation budgets match the prior bash/jq behavior to preserve the existing
+// privacy contract: input head ≤500 chars, output head ≤200 chars.
+const INPUT_TRUNCATE = 500;
+const OUTPUT_TRUNCATE = 200;
+/**
+ * Parse the raw JSON stdin payload from a Claude Code PreToolUse/PostToolUse
+ * hook event. Returns null for any unparseable or schema-invalid input —
+ * never throws. Empty/null/array payloads are rejected (the harness only
+ * sends objects).
+ *
+ * Field-name normalisation: Claude Code's PostToolUse payload uses
+ * `tool_response`. Older mocks and some third-party harnesses emit
+ * `tool_output` or `toolOutput`. We accept all three at the boundary and
+ * expose a single `tool_response` field downstream so the discriminator and
+ * `summariseOutput` only have to know one name.
+ */
+export function parseHookPayload(raw) {
+    if (!raw)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const obj = parsed;
+    if (typeof obj.tool_name !== "string" || obj.tool_name.length === 0) {
+        return null;
+    }
+    const toolResponse = obj.tool_response !== undefined
+        ? obj.tool_response
+        : obj.tool_output !== undefined
+            ? obj.tool_output
+            : obj.toolOutput;
+    return {
+        tool_name: obj.tool_name,
+        session_id: typeof obj.session_id === "string" ? obj.session_id : "",
+        tool_input: obj.tool_input,
+        tool_response: toolResponse,
+    };
+}
+/**
+ * Extract a tool-aware short summary from `tool_input`. Tool-specific cases
+ * cover the high-frequency surfaces the linter/analyser reads (Bash command
+ * head, Edit/Write/Read file_path, Grep/Glob pattern). Unknown tools fall
+ * back to JSON.stringify(input) capped at INPUT_TRUNCATE.
+ *
+ * Returns an empty string when the expected field is missing on a known tool
+ * or when input is null/undefined — never returns "undefined" or "null"
+ * literals to the caller.
+ */
+export function summariseInput(toolName, input) {
+    if (input === null || input === undefined)
+        return "";
+    switch (toolName) {
+        case "Bash": {
+            const cmd = readStringField(input, "command");
+            return cmd === null ? "" : truncate(cmd, INPUT_TRUNCATE);
+        }
+        case "Edit":
+        case "Write":
+        case "Read":
+        case "NotebookEdit": {
+            const path = readStringField(input, "file_path");
+            return path === null ? "" : truncate(path, INPUT_TRUNCATE);
+        }
+        case "Grep":
+        case "Glob": {
+            const pattern = readStringField(input, "pattern");
+            return pattern === null ? "" : truncate(pattern, INPUT_TRUNCATE);
+        }
+        default: {
+            // Unknown tool: stringify input so we record *something* useful for
+            // future analysis. Truncate to keep observations.jsonl row size bounded.
+            let serialised;
+            try {
+                serialised = JSON.stringify(input);
+            }
+            catch {
+                serialised = "";
+            }
+            return truncate(serialised ?? "", INPUT_TRUNCATE);
+        }
+    }
+}
+/**
+ * Extract a short summary from `tool_response`. Strings pass through (capped
+ * at OUTPUT_TRUNCATE); numbers/booleans coerce to string; objects
+ * JSON-stringify. Null/undefined collapse to "".
+ */
+export function summariseOutput(output) {
+    if (output === null || output === undefined)
+        return "";
+    if (typeof output === "string")
+        return truncate(output, OUTPUT_TRUNCATE);
+    if (typeof output === "number" || typeof output === "boolean") {
+        return String(output);
+    }
+    let serialised;
+    try {
+        serialised = JSON.stringify(output);
+    }
+    catch {
+        serialised = "";
+    }
+    return truncate(serialised ?? "", OUTPUT_TRUNCATE);
+}
+function readStringField(input, field) {
+    if (input === null || typeof input !== "object")
+        return null;
+    const value = input[field];
+    return typeof value === "string" ? value : null;
+}
+function truncate(value, max) {
+    return value.length > max ? value.slice(0, max) : value;
+}