continuous-improvement 3.0.0 → 3.1.0

package/bin/lint-transcript.mjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+
+/**
+ * Agent Transcript Linter
+ *
+ * Analyzes AI agent transcripts/observations for compliance with
+ * the 7 Laws of AI Agent Discipline.
+ *
+ * Usage:
+ *   node bin/lint-transcript.mjs <file.jsonl>         # Lint a transcript file
+ *   cat observations.jsonl | node bin/lint-transcript.mjs --stdin  # Pipe input
+ *   node bin/lint-transcript.mjs --help
+ *
+ * Exit codes:
+ *   0 — no violations (or --strict not set)
+ *   1 — violations found (with --strict)
+ */
+
+import { readFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+
+const LAWS = {
+  1: { name: "Research Before Executing", patterns: [] },
+  2: { name: "Plan Is Sacred", patterns: [] },
+  3: { name: "One Thing at a Time", patterns: [] },
+  4: { name: "Verify Before Reporting", patterns: [] },
+  5: { name: "Reflect After Sessions", patterns: [] },
+  6: { name: "Iterate One Change", patterns: [] },
+  7: { name: "Learn From Every Session", patterns: [] },
+};
+
+function analyzeTranscript(events) {
+  const violations = [];
+  const stats = {
+    totalEvents: events.length,
+    toolCalls: 0,
+    researchTools: 0, // Grep, Glob, Read
+    writeTools: 0, // Write, Edit, Bash
+    verifyTools: 0, // Bash (test/build commands)
+    sessions: new Set(),
+  };
+
+  // Classify events
+  for (const event of events) {
+    stats.toolCalls++;
+    if (event.session_id) stats.sessions.add(event.session_id);
+
+    const tool = event.tool || event.tool_name || "";
+    const input = event.tool_input || event.input || {};
+    const command = input.command || "";
+
+    if (["Grep", "Glob", "Read"].includes(tool)) {
+      stats.researchTools++;
+    }
+    if (["Write", "Edit"].includes(tool)) {
+      stats.writeTools++;
+    }
+    if (tool === "Bash" && /\b(test|build|npm run|jest|pytest|go test|cargo test)\b/.test(command)) {
+      stats.verifyTools++;
+    }
+  }
+
+  // Law 1: Research Before Executing
+  // Check if writes happen without prior reads/greps
+  let lastResearchIdx = -1;
+  for (let i = 0; i < events.length; i++) {
+    const tool = events[i].tool || events[i].tool_name || "";
+    if (["Grep", "Glob", "Read"].includes(tool)) {
+      lastResearchIdx = i;
+    }
+    if (["Write", "Edit"].includes(tool) && lastResearchIdx === -1) {
+      violations.push({
+        law: 1,
+        severity: "high",
+        message: `Write/Edit at event ${i} without any prior research (Grep/Glob/Read)`,
+        event: i,
+      });
+      break; // Only report first occurrence
+    }
+  }
+
+  // Law 1 ratio check
+  if (stats.writeTools > 0 && stats.researchTools === 0) {
+    violations.push({
+      law: 1,
+      severity: "high",
+      message: `${stats.writeTools} writes with 0 research operations. Agent likely skipped research.`,
+    });
+  } else if (stats.writeTools > stats.researchTools * 3) {
+    violations.push({
+      law: 1,
+      severity: "medium",
+      message: `Write-to-research ratio is ${stats.writeTools}:${stats.researchTools}. Consider more research.`,
+    });
+  }
+
+  // Law 3: One Thing at a Time
+  // Detect rapid context switching (different files edited in quick succession without verification)
+  let consecutiveEdits = 0;
+  const editedFiles = new Set();
+  for (const event of events) {
+    const tool = event.tool || event.tool_name || "";
+    const input = event.tool_input || event.input || {};
+
+    if (["Write", "Edit"].includes(tool)) {
+      consecutiveEdits++;
+      if (input.file_path) editedFiles.add(input.file_path);
+    } else if (tool === "Bash") {
+      consecutiveEdits = 0; // Reset on verification
+    }
+
+    if (consecutiveEdits > 5) {
+      violations.push({
+        law: 3,
+        severity: "medium",
+        message: `${consecutiveEdits} consecutive edits without verification. Editing multiple files at once.`,
+      });
+      consecutiveEdits = 0;
+    }
+  }
+
+  // Law 4: Verify Before Reporting
+  if (stats.writeTools > 0 && stats.verifyTools === 0) {
+    violations.push({
+      law: 4,
+      severity: "high",
+      message: `${stats.writeTools} code changes with 0 verification commands (test/build). Agent may have declared done without verifying.`,
+    });
+  }
+
+  // Law 6: Iterate One Change
+  if (editedFiles.size > 8) {
+    violations.push({
+      law: 6,
+      severity: "medium",
+      message: `${editedFiles.size} different files modified. Consider smaller, focused iterations.`,
+    });
+  }
+
+  // Calculate discipline score
+  const maxViolations = 7; // One per law
+  const violationWeight = violations.reduce((sum, v) => {
+    return sum + (v.severity === "high" ? 2 : 1);
+  }, 0);
+  const score = Math.max(0, Math.round(100 - (violationWeight / maxViolations) * 100));
+
+  return { violations, stats, score };
+}
+
+function formatReport(result) {
+  const { violations, stats, score } = result;
+  const lines = [];
+
+  lines.push("## Agent Discipline Report");
+  lines.push("");
+  lines.push(`**Score:** ${score}/100`);
+  lines.push(`**Events analyzed:** ${stats.totalEvents}`);
+  lines.push(`**Tool calls:** ${stats.toolCalls}`);
+  lines.push(`**Research ops:** ${stats.researchTools} | **Write ops:** ${stats.writeTools} | **Verify ops:** ${stats.verifyTools}`);
+  lines.push("");
+
+  if (violations.length === 0) {
+    lines.push("No law violations detected. Good discipline!");
+  } else {
+    lines.push(`### Violations (${violations.length})`);
+    lines.push("");
+    for (const v of violations) {
+      const severity = v.severity === "high" ? "HIGH" : "MEDIUM";
+      lines.push(`- **[${severity}] Law ${v.law}: ${LAWS[v.law].name}**`);
+      lines.push(`  ${v.message}`);
+    }
+  }
+
+  lines.push("");
+  lines.push("---");
+  lines.push("*Generated by [continuous-improvement](https://github.com/naimkatiman/continuous-improvement) transcript linter*");
+
+  return lines.join("\n");
+}
+
+// --- Main ---
+
+const args = process.argv.slice(2);
+
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+Agent Transcript Linter — The 7 Laws of AI Agent Discipline
+
+Usage:
+  node bin/lint-transcript.mjs <file.jsonl>         Lint a transcript file
+  cat obs.jsonl | node bin/lint-transcript.mjs --stdin  Pipe input
+  node bin/lint-transcript.mjs --help               Show help
+
+Options:
+  --stdin     Read from stdin
+  --strict    Exit 1 if violations found
+  --json      Output as JSON instead of markdown
+`);
+  process.exit(0);
+}
+
+const isStrict = args.includes("--strict");
+const isJson = args.includes("--json");
+const isStdin = args.includes("--stdin");
+
+async function main() {
+  let lines;
+
+  if (isStdin) {
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    lines = [];
+    for await (const line of rl) {
+      if (line.trim()) lines.push(line.trim());
+    }
+  } else {
+    const filePath = args.find((a) => !a.startsWith("--"));
+    if (!filePath) {
+      console.error("Error: provide a file path or use --stdin");
+      process.exit(1);
+    }
+    const content = readFileSync(filePath, "utf8");
+    lines = content.split("\n").filter((l) => l.trim());
+  }
+
+  const events = [];
+  for (const line of lines) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+      // skip non-JSON lines
+    }
+  }
+
+  if (events.length === 0) {
+    console.log("No events found to analyze.");
+    process.exit(0);
+  }
+
+  const result = analyzeTranscript(events);
+
+  if (isJson) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatReport(result));
+  }
+
+  // GitHub Actions output
+  if (process.env.GITHUB_OUTPUT) {
+    const outputLines = [
+      `violations=${result.violations.length}`,
+      `score=${result.score}`,
+    ];
+    const { appendFileSync } = await import("node:fs");
+    for (const line of outputLines) {
+      appendFileSync(process.env.GITHUB_OUTPUT, line + "\n");
+    }
+  }
+
+  if (isStrict && result.violations.length > 0) {
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/bin/mcp-server.mjs

@@ -13,15 +13,16 @@
  */
 
 import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from "node:fs";
-import { join, basename } from "node:path";
+import { join, basename, dirname } from "node:path";
 import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
 import { execSync } from "node:child_process";
 import { createInterface } from "node:readline";
 
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
-const VERSION = "3.0.0";
+const VERSION = "3.1.0";
 const INSTINCTS_DIR = join(homedir(), ".claude", "instincts");
 const GLOBAL_DIR = join(INSTINCTS_DIR, "global");
 
@@ -200,6 +201,8 @@ const BEGINNER_TOOLS = [
   },
 ];
 
+const PACKS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "instinct-packs");
+
 const EXPERT_TOOLS = [
   {
     name: "ci_reinforce",
@@ -263,6 +266,22 @@ const EXPERT_TOOLS = [
       required: ["instincts_json"],
     },
   },
+  {
+    name: "ci_dashboard",
+    description: "Visual dashboard showing instinct health, observation stats, confidence distribution, and learning progress.",
+    inputSchema: { type: "object", properties: {}, required: [] },
+  },
+  {
+    name: "ci_load_pack",
+    description: "Load a starter instinct pack (react, python, go) into the current project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pack: { type: "string", description: "Pack name: react, python, or go" },
+      },
+      required: ["pack"],
+    },
+  },
 ];
 
 function getAllTools() {
@@ -406,6 +425,107 @@ function handleTool(name, params) {
       return text(`Imported ${imported} instincts (${toImport.length - imported} skipped as duplicates)`);
     }
 
+    case "ci_dashboard": {
+      if (MODE !== "expert") return error("ci_dashboard requires expert mode");
+      const level = detectLevel(project.hash);
+      const obsCount = countObservations(project.hash);
+      const instincts = readInstincts(project.hash);
+      const byConf = {
+        auto: instincts.filter((i) => i.confidence >= 0.7),
+        suggest: instincts.filter((i) => i.confidence >= 0.5 && i.confidence < 0.7),
+        silent: instincts.filter((i) => i.confidence < 0.5),
+      };
+      const globalCount = instincts.filter((i) => i.scope === "global").length;
+      const projectCount = instincts.length - globalCount;
+      const today = new Date();
+      const stale = instincts.filter((i) => {
+        if (!i.last_seen) return false;
+        const diff = (today - new Date(i.last_seen)) / (1000 * 60 * 60 * 24);
+        return diff > 30;
+      });
+
+      const autoBar = "█".repeat(Math.min(10, byConf.auto.length)) + "░".repeat(Math.max(0, 10 - byConf.auto.length));
+      const sugBar = "█".repeat(Math.min(10, byConf.suggest.length)) + "░".repeat(Math.max(0, 10 - byConf.suggest.length));
+      const silBar = "█".repeat(Math.min(10, byConf.silent.length)) + "░".repeat(Math.max(0, 10 - byConf.silent.length));
+
+      const top5 = instincts
+        .sort((a, b) => b.confidence - a.confidence)
+        .slice(0, 5)
+        .map((i) => `  ${("█".repeat(Math.round(i.confidence * 10)) + "░".repeat(10 - Math.round(i.confidence * 10)))} ${i.confidence.toFixed(2)} ${i.id}`)
+        .join("\n");
+
+      // Check available packs
+      let packInfo = "";
+      if (existsSync(PACKS_DIR)) {
+        const packs = readdirSync(PACKS_DIR).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+        packInfo = `\n  Available packs: ${packs.join(", ")}`;
+      }
+
+      return text([
+        `╔══════════════════════════════════════════════════════════════╗`,
+        `║              continuous-improvement Dashboard                ║`,
+        `╠══════════════════════════════════════════════════════════════╣`,
+        `║                                                              ║`,
+        `║  Project: ${project.name.padEnd(20)} Level: ${level.padEnd(12)}   ║`,
+        `║  Sessions: ~${String(Math.floor(obsCount / 10)).padEnd(17)} Mode: ${MODE.padEnd(13)}  ║`,
+        `║                                                              ║`,
+        `║  ┌─ Observations ────────────────────────────────────────┐   ║`,
+        `║  │  Total: ${String(obsCount).padEnd(48)} │   ║`,
+        `║  └───────────────────────────────────────────────────────┘   ║`,
+        `║                                                              ║`,
+        `║  ┌─ Instincts ───────────────────────────────────────────┐   ║`,
+        `║  │  Total: ${String(instincts.length).padEnd(48)} │   ║`,
+        `║  │  ${autoBar} Auto-apply (0.7+): ${String(byConf.auto.length).padEnd(20)} │   ║`,
+        `║  │  ${sugBar} Suggest (0.5-0.69): ${String(byConf.suggest.length).padEnd(19)} │   ║`,
+        `║  │  ${silBar} Silent (< 0.5): ${String(byConf.silent.length).padEnd(23)} │   ║`,
+        `║  │  Global: ${String(globalCount).padEnd(10)} Project: ${String(projectCount).padEnd(28)} │   ║`,
+        `║  └───────────────────────────────────────────────────────┘   ║`,
+        `║                                                              ║`,
+        instincts.length > 0 ? [
+          `║  ┌─ Top Instincts ───────────────────────────────────────┐   ║`,
+          ...top5.split("\n").map((l) => `║  │${l.padEnd(56)}│   ║`),
+          `║  └───────────────────────────────────────────────────────┘   ║`,
+        ].join("\n") : "",
+        `║                                                              ║`,
+        `║  ┌─ Health ──────────────────────────────────────────────┐   ║`,
+        `║  │  Stale (30+ days): ${String(stale.length).padEnd(38)} │   ║`,
+        `║  └───────────────────────────────────────────────────────┘   ║`,
+        packInfo ? `║${packInfo.padEnd(63)}║` : "",
+        `║                                                              ║`,
+        `╚══════════════════════════════════════════════════════════════╝`,
+      ].filter(Boolean).join("\n"));
+    }
+
+    case "ci_load_pack": {
+      if (MODE !== "expert") return error("ci_load_pack requires expert mode");
+      const packName = params.pack;
+      const packPath = join(PACKS_DIR, `${packName}.json`);
+      if (!existsSync(packPath)) {
+        const available = existsSync(PACKS_DIR)
+          ? readdirSync(PACKS_DIR).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""))
+          : [];
+        return error(`Unknown pack: ${packName}. Available: ${available.join(", ")}`);
+      }
+
+      const packInstincts = JSON.parse(readFileSync(packPath, "utf8"));
+      const existing = readInstincts(project.hash);
+      const existingIds = new Set(existing.map((i) => i.id));
+      let loaded = 0;
+
+      for (const inst of packInstincts) {
+        if (existingIds.has(inst.id)) continue;
+        writeInstinct(project.hash, {
+          ...inst,
+          source: `pack-${packName}`,
+          scope: "project",
+          observation_count: 0,
+        });
+        loaded++;
+      }
+
+      return text(`Loaded ${loaded}/${packInstincts.length} instincts from **${packName}** pack (${packInstincts.length - loaded} already existed)`);
+    }
+
     default:
       return error(`Unknown tool: ${name}`);
   }

package/commands/dashboard.md

@@ -0,0 +1,56 @@
+---
+name: dashboard
+description: Visual dashboard showing instinct health, observation stats, and learning progress
+---
+
+# Instinct Dashboard
+
+Generate a visual dashboard for this project's continuous-improvement status.
+
+## Instructions
+
+1. **Find project hash:** Run `git rev-parse --show-toplevel 2>/dev/null`, then SHA-256 first 12 chars
+2. **Read observations:** Count lines in `~/.claude/instincts/<hash>/observations.jsonl`
+3. **Read instincts:** Load all `*.yaml` files from project dir + `global/`
+4. **Read instinct packs:** Check if any packs from `instinct-packs/` have been loaded
+
+## Display Format
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║              continuous-improvement Dashboard                ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  Project: <name>              Level: <CAPTURE|ANALYZE|...>   ║
+║  Sessions: ~<obs/10>          Mode: <beginner|expert>        ║
+║                                                              ║
+║  ┌─ Observations ────────────────────────────────────────┐   ║
+║  │  Total: <n>    Unprocessed: <n>    Last: <date>       │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Instincts ───────────────────────────────────────────┐   ║
+║  │  Total: <n>                                           │   ║
+║  │  ████████░░ Auto-apply (0.7+): <n>                    │   ║
+║  │  █████░░░░░ Suggest (0.5-0.69): <n>                   │   ║
+║  │  ██░░░░░░░░ Silent (< 0.5): <n>                       │   ║
+║  │  Global: <n>    Project: <n>                          │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Top Instincts ───────────────────────────────────────┐   ║
+║  │  <list top 5 instincts by confidence with bars>       │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Health ──────────────────────────────────────────────┐   ║
+║  │  Stale (30+ days): <n>    Decaying: <n>               │   ║
+║  │  Recently reinforced: <n>                             │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+## After Display
+
+- If stale instincts > 0: suggest reviewing them
+- If unprocessed observations > 20: suggest running analysis
+- If no instincts exist: explain the auto-leveling timeline
+- Show available instinct packs that haven't been loaded yet

package/commands/discipline.md

@@ -0,0 +1,37 @@
+---
+name: discipline
+description: Quick reference card for the 7 Laws of AI Agent Discipline
+---
+
+# The 7 Laws — Quick Reference
+
+Print this card and check yourself against each law.
+
+## The Laws
+
+| # | Law | Check | Red Flag |
+|---|-----|-------|----------|
+| 1 | **Research Before Executing** | Did I search for existing solutions? | "I'll just quickly..." |
+| 2 | **Plan Is Sacred** | Did I state WILL / WILL NOT / VERIFY? | "Let me also add..." |
+| 3 | **One Thing at a Time** | Am I finishing before starting? | "While I'm here..." |
+| 4 | **Verify Before Reporting** | Did I check the ACTUAL output? | "This should work..." |
+| 5 | **Reflect After Sessions** | Did I note what worked/failed? | "I'll remember..." |
+| 6 | **Iterate One Change** | Am I changing one thing at a time? | "And also..." |
+| 7 | **Learn From Every Session** | Did I capture this as an instinct? | "Next time I'll..." |
+
+## The Loop
+
+```
+Research → Plan → Execute (one thing) → Verify → Reflect → Learn → Iterate
+```
+
+## Self-Check
+
+Before saying "Done", verify ALL:
+- [ ] Code runs without errors
+- [ ] Output matches expected result
+- [ ] I checked the **actual** result (not assumed)
+- [ ] Build passes
+- [ ] I can explain the change in one sentence
+
+If you're skipping a step, that's the step you need most.

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