continuous-improvement 3.1.0 → 3.8.0

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

@@ -0,0 +1,172 @@
+#!/usr/bin/env bash
+# observe.sh — Mulahazah PreToolUse/PostToolUse observation hook.
+#
+# Two-phase design:
+#   1. PREFERRED: exec the Node observer (bin/observe.mjs) which captures the
+#      rich event schema (tool_input.command for Bash, file_path for Edit/
+#      Write/Read, tool_output) without depending on jq.
+#   2. FALLBACK: if either node is missing OR the Node observer file is not
+#      installed alongside this script, fall through to the in-bash thin-
+#      schema path below. The fallback preserves prior behavior so an
+#      operator who never re-runs `npx continuous-improvement install` is
+#      no worse off than today.
+#
+# Always exits 0 — never blocks the Claude session.
+# Usage: echo '<hook_json>' | observe.sh
+
+trap 'exit 0' EXIT ERR INT TERM
+
+# Phase 1 — try the Node observer. The shim copies bin/observe.mjs and
+# lib/observe-event.mjs alongside this script under ${HOME}/.claude/instincts/
+# preserving the bin/ + lib/ subdirectory layout so the relative import
+# resolves: observe.mjs lives at .../instincts/bin/observe.mjs, the imported
+# observe-event.mjs at .../instincts/lib/observe-event.mjs.
+NODE_OBSERVER="$(dirname "${BASH_SOURCE[0]}")/bin/observe.mjs"
+if [[ -f "$NODE_OBSERVER" ]] && command -v node &>/dev/null; then
+  exec node "$NODE_OBSERVER"
+fi
+
+# Phase 2 — bash fallback (thin schema; preserved for back-compat).
+INSTINCTS_DIR="${HOME}/.claude/instincts"
+
+# ---------------------------------------------------------------------------
+# Read stdin (hook payload) — single read for performance
+# ---------------------------------------------------------------------------
+INPUT="$(cat)"
+[[ -z "$INPUT" ]] && exit 0
+
+# ---------------------------------------------------------------------------
+# Parse hook payload — use jq if available, otherwise basic extraction
+#
+# When jq is missing, observation rows lack tool_input/tool_output, which
+# defeats the auto-instinct pipeline. Emit a one-shot stderr warning per
+# project so the operator notices at the next session start instead of
+# discovering the gap weeks later. The marker file makes it idempotent.
+# ---------------------------------------------------------------------------
+if command -v jq &>/dev/null; then
+  read -r TOOL_NAME SESSION_ID HAS_OUTPUT INPUT_JSON OUTPUT_JSON <<< "$(
+    printf '%s' "$INPUT" | jq -r '
+      (.tool_name // ""),
+      (.session_id // ""),
+      (if has("tool_output") then "yes" else "no" end),
+      ((.tool_input // {} | tostring) | .[0:500]),
+      ((.tool_output // {} | tostring) | .[0:200])
+    ' | paste - - - - -
+  )"
+else
+  # One-shot stderr warning per HOME so the operator learns the constraint.
+  # Marker lives next to instincts/ (not inside it) so it never collides with
+  # tests or analysis loops that iterate INSTINCTS_DIR for project-hash dirs.
+  JQ_WARN_MARKER="${HOME}/.claude/.continuous-improvement-jq-warned"
+  if [[ ! -f "$JQ_WARN_MARKER" ]]; then
+    mkdir -p "${HOME}/.claude" 2>/dev/null
+    printf '[continuous-improvement] jq not found on PATH — observe.sh is using thin-schema fallback. Install jq to enable auto-instinct detection (winget install jqlang.jq | brew install jq | apt install jq). This warning is one-shot per host.\n' >&2
+    : > "$JQ_WARN_MARKER"
+  fi
+  # Fallback: extract tool_name with basic pattern matching
+  TOOL_NAME="$(printf '%s' "$INPUT" | sed -n 's/.*"tool_name" *: *"\([^"]*\)".*/\1/p' | head -1)"
+  SESSION_ID="$(printf '%s' "$INPUT" | sed -n 's/.*"session_id" *: *"\([^"]*\)".*/\1/p' | head -1)"
+  HAS_OUTPUT="no"
+  printf '%s' "$INPUT" | grep -q '"tool_output"' && HAS_OUTPUT="yes"
+  INPUT_JSON="$(printf '%s' "$INPUT" | head -c 500)"
+  OUTPUT_JSON=""
+fi
+
+[[ -z "$TOOL_NAME" ]] && exit 0
+
+# Determine event type
+if [[ "$HAS_OUTPUT" == "yes" ]]; then
+  EVENT="tool_complete"
+else
+  EVENT="tool_start"
+fi
+
+# ---------------------------------------------------------------------------
+# Project detection
+# ---------------------------------------------------------------------------
+PROJECT_ROOT=""
+
+if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
+  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
+fi
+
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+fi
+
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="global"
+fi
+
+# ---------------------------------------------------------------------------
+# Compute project hash and name
+# ---------------------------------------------------------------------------
+PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
+PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
+
+# ---------------------------------------------------------------------------
+# Directory setup
+# ---------------------------------------------------------------------------
+PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
+OBS_FILE="${PROJECT_DIR}/observations.jsonl"
+
+[[ -d "$PROJECT_DIR" ]] || mkdir -p "$PROJECT_DIR"
+
+# ---------------------------------------------------------------------------
+# Rotate observations.jsonl at 10,000 lines
+# ---------------------------------------------------------------------------
+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
+fi
+
+# ---------------------------------------------------------------------------
+# Append JSONL observation line
+# ---------------------------------------------------------------------------
+TS="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+
+if command -v jq &>/dev/null; then
+  printf '%s\n' "$(jq -cn \
+    --arg ts "$TS" \
+    --arg event "$EVENT" \
+    --arg session "$SESSION_ID" \
+    --arg tool "$TOOL_NAME" \
+    --arg input_summary "$INPUT_JSON" \
+    --arg output_summary "$OUTPUT_JSON" \
+    --arg project_id "$PROJECT_HASH" \
+    --arg project_name "$PROJECT_NAME" \
+    '{ts:$ts,event:$event,session:$session,tool:$tool,input_summary:$input_summary,output_summary:$output_summary,project_id:$project_id,project_name:$project_name}')" \
+    >> "$OBS_FILE"
+else
+  # Fallback: manual JSON construction
+  printf '{"ts":"%s","event":"%s","session":"%s","tool":"%s","project_id":"%s","project_name":"%s"}\n' \
+    "$TS" "$EVENT" "$SESSION_ID" "$TOOL_NAME" "$PROJECT_HASH" "$PROJECT_NAME" \
+    >> "$OBS_FILE"
+fi
+
+# ---------------------------------------------------------------------------
+# Write project.json if new project
+# ---------------------------------------------------------------------------
+PROJECT_JSON="${PROJECT_DIR}/project.json"
+if [[ ! -f "$PROJECT_JSON" ]]; then
+  if command -v jq &>/dev/null; then
+    jq -n \
+      --arg id "$PROJECT_HASH" \
+      --arg name "$PROJECT_NAME" \
+      --arg root "$PROJECT_ROOT" \
+      --arg created_at "$TS" \
+      '{id:$id,name:$name,root:$root,created_at:$created_at}' \
+      > "$PROJECT_JSON"
+  else
+    printf '{"id":"%s","name":"%s","root":"%s","created_at":"%s"}\n' \
+      "$PROJECT_HASH" "$PROJECT_NAME" "$PROJECT_ROOT" "$TS" \
+      > "$PROJECT_JSON"
+  fi
+fi
+
+exit 0

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

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+# session.sh — SessionStart/SessionEnd hook for continuous-improvement
+# SessionStart: loads instincts and prints status
+# SessionEnd: prompts reflection
+# Always exits 0 — never blocks the session
+trap 'exit 0' EXIT ERR INT TERM
+
+INSTINCTS_DIR="${HOME}/.claude/instincts"
+
+# Read stdin
+INPUT="$(cat)"
+[[ -z "$INPUT" ]] && exit 0
+
+# ---------------------------------------------------------------------------
+# Detect event type from hook context
+# ---------------------------------------------------------------------------
+# SessionStart hooks receive no tool_name, SessionEnd hooks may vary.
+# We detect based on the hook_type field or the calling context.
+EVENT_TYPE=""
+if command -v jq &>/dev/null; then
+  EVENT_TYPE="$(printf '%s' "$INPUT" | jq -r '.hook_type // .event_type // "unknown"' 2>/dev/null)"
+else
+  if printf '%s' "$INPUT" | grep -q '"SessionStart"'; then
+    EVENT_TYPE="SessionStart"
+  elif printf '%s' "$INPUT" | grep -q '"SessionEnd"'; then
+    EVENT_TYPE="SessionEnd"
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Project detection (same as observe.sh)
+# ---------------------------------------------------------------------------
+PROJECT_ROOT=""
+if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
+  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="global"
+fi
+
+PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
+PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
+
+# ---------------------------------------------------------------------------
+# SessionStart: count observations and instincts, print brief status
+# ---------------------------------------------------------------------------
+if [[ "$EVENT_TYPE" == "SessionStart" || "$EVENT_TYPE" == "unknown" ]]; then
+  OBS_COUNT=0
+  INSTINCT_COUNT=0
+
+  OBS_FILE="${PROJECT_DIR}/observations.jsonl"
+  if [[ -f "$OBS_FILE" ]]; then
+    OBS_COUNT="$(wc -l < "$OBS_FILE" 2>/dev/null || echo 0)"
+  fi
+
+  # Count yaml files in project + global
+  for dir in "$PROJECT_DIR" "${INSTINCTS_DIR}/global"; do
+    if [[ -d "$dir" ]]; then
+      count="$(find "$dir" -maxdepth 1 -name '*.yaml' 2>/dev/null | wc -l)"
+      INSTINCT_COUNT=$((INSTINCT_COUNT + count))
+    fi
+  done
+
+  # Determine level
+  LEVEL="CAPTURE"
+  if (( OBS_COUNT >= 20 )) || (( INSTINCT_COUNT > 0 )); then
+    LEVEL="ANALYZE"
+  fi
+
+  # Check for high-confidence instincts
+  if (( INSTINCT_COUNT > 0 )); then
+    for dir in "$PROJECT_DIR" "${INSTINCTS_DIR}/global"; do
+      if [[ -d "$dir" ]]; then
+        for f in "$dir"/*.yaml; do
+          [[ -f "$f" ]] || continue
+          conf="$(grep '^confidence:' "$f" 2>/dev/null | head -1 | sed 's/confidence: *//')"
+          if [[ -n "$conf" ]]; then
+            # Compare as integer (multiply by 100) using awk for portability
+            int_conf="$(printf '%s' "$conf" | awk '{printf "%.0f", $1 * 100}')"
+            if [[ -n "$int_conf" ]] && (( int_conf >= 70 )); then
+              LEVEL="AUTO-APPLY"
+              break 2
+            elif (( int_conf >= 50 )); then
+              LEVEL="SUGGEST"
+            fi
+          fi
+        done
+      fi
+    done
+  fi
+
+  # Write status to stderr (visible in hook output, not blocking)
+  echo "[continuous-improvement] Level: ${LEVEL} | Observations: ${OBS_COUNT} | Instincts: ${INSTINCT_COUNT}" >&2
+fi
+
+# ---------------------------------------------------------------------------
+# SessionEnd: remind to reflect
+# ---------------------------------------------------------------------------
+if [[ "$EVENT_TYPE" == "SessionEnd" ]]; then
+  echo "[continuous-improvement] Session ending. Run /continuous-improvement to reflect and capture learnings." >&2
+fi
+
+exit 0

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"
+  }
+]