continuous-improvement 3.12.3 → 3.16.0

package/hooks/session.sh

@@ -1,106 +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
+#!/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/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/instinct-packs/go.json

@@ -1,58 +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"
-  }
-]
+[
+  {
+    "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/instinct-packs/meta.json

@@ -1,16 +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"
-  }
-]
+[
+  {
+    "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/instinct-packs/python.json

@@ -1,58 +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"
-  }
-]
+[
+  {
+    "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"
+  }
+]