@massu/core 0.7.0 → 0.8.0

package/dist/hooks/incident-pipeline.js

@@ -2,12 +2,13 @@
 import{createRequire as __cr}from"module";const require=__cr(import.meta.url);
 
 // src/hooks/incident-pipeline.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
-import { basename, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync } from "fs";
+import { basename as basename2, resolve as resolve3 } from "path";
 
 // src/config.ts
 import { resolve, dirname } from "path";
 import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
 import { parse as parseYaml } from "yaml";
 import { z } from "zod";
 var DomainConfigSchema = z.object({
@@ -149,6 +150,18 @@ var AutoLearningConfigSchema = z.object({
       "added_missing_import"
     ])
   }).default({}),
+  failureClassification: z.object({
+    enabled: z.boolean().default(true),
+    thresholds: z.object({
+      known: z.number().default(5),
+      similar: z.number().default(3)
+    }).default({}),
+    scoring: z.object({
+      diffPatternWeight: z.number().default(3),
+      filePatternWeight: z.number().default(2),
+      promptKeywordWeight: z.number().default(2)
+    }).default({})
+  }).default({}),
   pipeline: z.object({
     requireIncidentReport: z.boolean().default(true),
     requirePreventionRule: z.boolean().default(true),
@@ -323,6 +336,654 @@ function getConfig() {
   }
   return _config;
 }
+function getResolvedPaths() {
+  const config = getConfig();
+  const root = getProjectRoot();
+  const claudeDirName = config.conventions?.claudeDirName ?? ".claude";
+  return {
+    codegraphDbPath: resolve(root, ".codegraph/codegraph.db"),
+    dataDbPath: resolve(root, ".massu/data.db"),
+    prismaSchemaPath: resolve(root, config.paths.schema ?? "prisma/schema.prisma"),
+    rootRouterPath: resolve(root, config.paths.routerRoot ?? "src/server/api/root.ts"),
+    routersDir: resolve(root, config.paths.routers ?? "src/server/api/routers"),
+    srcDir: resolve(root, config.paths.source),
+    pathAlias: Object.fromEntries(
+      Object.entries(config.paths.aliases).map(([alias, target]) => [
+        alias,
+        resolve(root, target)
+      ])
+    ),
+    extensions: [".ts", ".tsx", ".js", ".jsx"],
+    indexFiles: ["index.ts", "index.tsx", "index.js", "index.jsx"],
+    patternsDir: resolve(root, claudeDirName, "patterns"),
+    claudeMdPath: resolve(root, claudeDirName, "CLAUDE.md"),
+    docsMapPath: resolve(root, ".massu/docs-map.json"),
+    helpSitePath: resolve(root, "../" + config.project.name + "-help"),
+    memoryDbPath: resolve(root, ".massu/memory.db"),
+    knowledgeDbPath: resolve(root, ".massu/knowledge.db"),
+    plansDir: resolve(root, "docs/plans"),
+    docsDir: resolve(root, "docs"),
+    claudeDir: resolve(root, claudeDirName),
+    memoryDir: resolve(homedir(), claudeDirName, "projects", root.replace(/\//g, "-"), "memory"),
+    sessionStatePath: resolve(root, config.conventions?.sessionStatePath ?? `${claudeDirName}/session-state/CURRENT.md`),
+    sessionArchivePath: resolve(root, config.conventions?.sessionArchivePath ?? `${claudeDirName}/session-state/archive`),
+    mcpJsonPath: resolve(root, ".mcp.json"),
+    settingsLocalPath: resolve(root, claudeDirName, "settings.local.json")
+  };
+}
+
+// src/memory-db.ts
+import Database from "better-sqlite3";
+import { dirname as dirname2, basename } from "path";
+import { existsSync as existsSync2, mkdirSync } from "fs";
+function getMemoryDb() {
+  const dbPath = getResolvedPaths().memoryDbPath;
+  const dir = dirname2(dbPath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  initMemorySchema(db);
+  return db;
+}
+function initMemorySchema(db) {
+  db.exec(`
+    -- Sessions table (linked to Claude Code session IDs)
+    CREATE TABLE IF NOT EXISTS sessions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT UNIQUE NOT NULL,
+      project TEXT NOT NULL DEFAULT 'my-project',
+      git_branch TEXT,
+      started_at TEXT NOT NULL,
+      started_at_epoch INTEGER NOT NULL,
+      ended_at TEXT,
+      ended_at_epoch INTEGER,
+      status TEXT CHECK(status IN ('active', 'completed', 'abandoned')) NOT NULL DEFAULT 'active',
+      plan_file TEXT,
+      plan_phase TEXT,
+      task_id TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_session_id ON sessions(session_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at_epoch DESC);
+    CREATE INDEX IF NOT EXISTS idx_sessions_task_id ON sessions(task_id);
+
+    -- Observations table (structured knowledge from tool usage)
+    CREATE TABLE IF NOT EXISTS observations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      type TEXT NOT NULL CHECK(type IN (
+        'decision', 'bugfix', 'feature', 'refactor', 'discovery',
+        'cr_violation', 'vr_check', 'pattern_compliance', 'failed_attempt',
+        'file_change', 'incident_near_miss'
+      )),
+      title TEXT NOT NULL,
+      detail TEXT,
+      files_involved TEXT DEFAULT '[]',
+      plan_item TEXT,
+      cr_rule TEXT,
+      vr_type TEXT,
+      evidence TEXT,
+      importance INTEGER NOT NULL DEFAULT 3 CHECK(importance BETWEEN 1 AND 5),
+      recurrence_count INTEGER NOT NULL DEFAULT 1,
+      original_tokens INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL,
+      created_at_epoch INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
+    CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type);
+    CREATE INDEX IF NOT EXISTS idx_observations_created ON observations(created_at_epoch DESC);
+    CREATE INDEX IF NOT EXISTS idx_observations_plan_item ON observations(plan_item);
+    CREATE INDEX IF NOT EXISTS idx_observations_cr_rule ON observations(cr_rule);
+    CREATE INDEX IF NOT EXISTS idx_observations_importance ON observations(importance DESC);
+  `);
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS observations_fts USING fts5(
+        title, detail, evidence,
+        content='observations',
+        content_rowid='id'
+      );
+    `);
+  } catch (_e) {
+  }
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS observations_ai AFTER INSERT ON observations BEGIN
+      INSERT INTO observations_fts(rowid, title, detail, evidence)
+      VALUES (new.id, new.title, new.detail, new.evidence);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS observations_ad AFTER DELETE ON observations BEGIN
+      INSERT INTO observations_fts(observations_fts, rowid, title, detail, evidence)
+      VALUES ('delete', old.id, old.title, old.detail, old.evidence);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS observations_au AFTER UPDATE ON observations BEGIN
+      INSERT INTO observations_fts(observations_fts, rowid, title, detail, evidence)
+      VALUES ('delete', old.id, old.title, old.detail, old.evidence);
+      INSERT INTO observations_fts(rowid, title, detail, evidence)
+      VALUES (new.id, new.title, new.detail, new.evidence);
+    END;
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_summaries (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      request TEXT,
+      investigated TEXT,
+      decisions TEXT,
+      completed TEXT,
+      failed_attempts TEXT,
+      next_steps TEXT,
+      files_created TEXT DEFAULT '[]',
+      files_modified TEXT DEFAULT '[]',
+      verification_results TEXT DEFAULT '{}',
+      plan_progress TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL,
+      created_at_epoch INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_summaries_session ON session_summaries(session_id);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS user_prompts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      prompt_text TEXT NOT NULL,
+      prompt_number INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      created_at_epoch INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+  `);
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS user_prompts_fts USING fts5(
+        prompt_text,
+        content='user_prompts',
+        content_rowid='id'
+      );
+    `);
+  } catch (_e) {
+  }
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS prompts_ai AFTER INSERT ON user_prompts BEGIN
+      INSERT INTO user_prompts_fts(rowid, prompt_text) VALUES (new.id, new.prompt_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS prompts_ad AFTER DELETE ON user_prompts BEGIN
+      INSERT INTO user_prompts_fts(user_prompts_fts, rowid, prompt_text)
+      VALUES ('delete', old.id, old.prompt_text);
+    END;
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS conversation_turns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      turn_number INTEGER NOT NULL,
+      user_prompt TEXT NOT NULL,
+      assistant_response TEXT,
+      tool_calls_json TEXT,
+      tool_call_count INTEGER DEFAULT 0,
+      model_used TEXT,
+      duration_ms INTEGER,
+      prompt_tokens INTEGER,
+      response_tokens INTEGER,
+      created_at TEXT DEFAULT (datetime('now')),
+      created_at_epoch INTEGER DEFAULT (unixepoch()),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_ct_session ON conversation_turns(session_id);
+    CREATE INDEX IF NOT EXISTS idx_ct_created ON conversation_turns(created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_ct_turn ON conversation_turns(session_id, turn_number);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tool_call_details (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      turn_number INTEGER NOT NULL,
+      tool_name TEXT NOT NULL,
+      tool_input_summary TEXT,
+      tool_input_size INTEGER,
+      tool_output_size INTEGER,
+      tool_success INTEGER DEFAULT 1,
+      duration_ms INTEGER,
+      files_involved TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      created_at_epoch INTEGER DEFAULT (unixepoch()),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tcd_session ON tool_call_details(session_id);
+    CREATE INDEX IF NOT EXISTS idx_tcd_tool ON tool_call_details(tool_name);
+    CREATE INDEX IF NOT EXISTS idx_tcd_created ON tool_call_details(created_at DESC);
+  `);
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS conversation_turns_fts USING fts5(
+        user_prompt,
+        assistant_response,
+        content=conversation_turns,
+        content_rowid=id
+      );
+    `);
+  } catch (_e) {
+  }
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS ct_fts_insert AFTER INSERT ON conversation_turns BEGIN
+      INSERT INTO conversation_turns_fts(rowid, user_prompt, assistant_response)
+      VALUES (new.id, new.user_prompt, new.assistant_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS ct_fts_delete AFTER DELETE ON conversation_turns BEGIN
+      INSERT INTO conversation_turns_fts(conversation_turns_fts, rowid, user_prompt, assistant_response)
+      VALUES ('delete', old.id, old.user_prompt, old.assistant_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS ct_fts_update AFTER UPDATE ON conversation_turns BEGIN
+      INSERT INTO conversation_turns_fts(conversation_turns_fts, rowid, user_prompt, assistant_response)
+      VALUES ('delete', old.id, old.user_prompt, old.assistant_response);
+      INSERT INTO conversation_turns_fts(rowid, user_prompt, assistant_response)
+      VALUES (new.id, new.user_prompt, new.assistant_response);
+    END;
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_quality_scores (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL UNIQUE,
+      project TEXT NOT NULL DEFAULT 'my-project',
+      score INTEGER NOT NULL DEFAULT 100,
+      security_score INTEGER NOT NULL DEFAULT 100,
+      architecture_score INTEGER NOT NULL DEFAULT 100,
+      coupling_score INTEGER NOT NULL DEFAULT 100,
+      test_score INTEGER NOT NULL DEFAULT 100,
+      rule_compliance_score INTEGER NOT NULL DEFAULT 100,
+      observations_total INTEGER NOT NULL DEFAULT 0,
+      bugs_found INTEGER NOT NULL DEFAULT 0,
+      bugs_fixed INTEGER NOT NULL DEFAULT 0,
+      vr_checks_passed INTEGER NOT NULL DEFAULT 0,
+      vr_checks_failed INTEGER NOT NULL DEFAULT 0,
+      incidents_triggered INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_sqs_session ON session_quality_scores(session_id);
+    CREATE INDEX IF NOT EXISTS idx_sqs_project ON session_quality_scores(project);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_costs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL UNIQUE,
+      project TEXT NOT NULL DEFAULT 'my-project',
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      estimated_cost_usd REAL NOT NULL DEFAULT 0.0,
+      model TEXT,
+      duration_minutes REAL NOT NULL DEFAULT 0.0,
+      tool_calls INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_sc_session ON session_costs(session_id);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS feature_costs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_key TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      tokens_used INTEGER NOT NULL DEFAULT 0,
+      estimated_cost_usd REAL NOT NULL DEFAULT 0.0,
+      commit_hash TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_fc_feature ON feature_costs(feature_key);
+    CREATE INDEX IF NOT EXISTS idx_fc_session ON feature_costs(session_id);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS prompt_outcomes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      prompt_hash TEXT NOT NULL,
+      prompt_text TEXT NOT NULL,
+      prompt_category TEXT NOT NULL DEFAULT 'feature',
+      word_count INTEGER NOT NULL DEFAULT 0,
+      outcome TEXT NOT NULL DEFAULT 'success' CHECK(outcome IN ('success', 'partial', 'failure', 'abandoned')),
+      corrections_needed INTEGER NOT NULL DEFAULT 0,
+      follow_up_prompts INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_po_session ON prompt_outcomes(session_id);
+    CREATE INDEX IF NOT EXISTS idx_po_category ON prompt_outcomes(prompt_category);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS audit_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      timestamp TEXT DEFAULT (datetime('now')),
+      event_type TEXT NOT NULL CHECK(event_type IN ('code_change', 'rule_enforced', 'approval', 'review', 'commit', 'compaction')),
+      actor TEXT NOT NULL DEFAULT 'ai' CHECK(actor IN ('ai', 'human', 'hook', 'agent')),
+      model_id TEXT,
+      file_path TEXT,
+      change_type TEXT CHECK(change_type IN ('create', 'edit', 'delete')),
+      rules_in_effect TEXT,
+      approval_status TEXT CHECK(approval_status IN ('auto_approved', 'human_approved', 'pending', 'denied')),
+      evidence TEXT,
+      metadata TEXT,
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_al_session ON audit_log(session_id);
+    CREATE INDEX IF NOT EXISTS idx_al_file ON audit_log(file_path);
+    CREATE INDEX IF NOT EXISTS idx_al_event ON audit_log(event_type);
+    CREATE INDEX IF NOT EXISTS idx_al_timestamp ON audit_log(timestamp DESC);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS validation_results (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      validation_type TEXT NOT NULL,
+      passed INTEGER NOT NULL DEFAULT 1,
+      details TEXT,
+      rules_violated TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_vr_session ON validation_results(session_id);
+    CREATE INDEX IF NOT EXISTS idx_vr_file ON validation_results(file_path);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS architecture_decisions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      context TEXT,
+      decision TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'accepted' CHECK(status IN ('accepted', 'superseded', 'deprecated')),
+      alternatives TEXT,
+      consequences TEXT,
+      affected_files TEXT,
+      commit_hash TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_ad_session ON architecture_decisions(session_id);
+    CREATE INDEX IF NOT EXISTS idx_ad_status ON architecture_decisions(status);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS security_scores (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      risk_score INTEGER NOT NULL DEFAULT 0,
+      findings TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_ss_session ON security_scores(session_id);
+    CREATE INDEX IF NOT EXISTS idx_ss_file ON security_scores(file_path);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS dependency_assessments (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      package_name TEXT NOT NULL,
+      version TEXT,
+      risk_score INTEGER NOT NULL DEFAULT 0,
+      vulnerabilities INTEGER NOT NULL DEFAULT 0,
+      last_publish_days INTEGER,
+      weekly_downloads INTEGER,
+      license TEXT,
+      bundle_size_kb INTEGER,
+      previous_removals INTEGER NOT NULL DEFAULT 0,
+      assessed_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_da_package ON dependency_assessments(package_name);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS developer_expertise (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      developer_id TEXT NOT NULL,
+      module TEXT NOT NULL,
+      session_count INTEGER NOT NULL DEFAULT 0,
+      observation_count INTEGER NOT NULL DEFAULT 0,
+      expertise_score INTEGER NOT NULL DEFAULT 0,
+      last_active TEXT DEFAULT (datetime('now')),
+      UNIQUE(developer_id, module)
+    );
+    CREATE INDEX IF NOT EXISTS idx_de_developer ON developer_expertise(developer_id);
+    CREATE INDEX IF NOT EXISTS idx_de_module ON developer_expertise(module);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS shared_observations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      original_id INTEGER,
+      developer_id TEXT NOT NULL,
+      project TEXT NOT NULL,
+      observation_type TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      file_path TEXT,
+      module TEXT,
+      severity INTEGER NOT NULL DEFAULT 3,
+      is_shared INTEGER NOT NULL DEFAULT 0,
+      shared_at TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_so_developer ON shared_observations(developer_id);
+    CREATE INDEX IF NOT EXISTS idx_so_file ON shared_observations(file_path);
+    CREATE INDEX IF NOT EXISTS idx_so_module ON shared_observations(module);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_conflicts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL,
+      developer_a TEXT NOT NULL,
+      developer_b TEXT NOT NULL,
+      conflict_type TEXT NOT NULL DEFAULT 'concurrent_edit',
+      resolved INTEGER NOT NULL DEFAULT 0,
+      detected_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_kc_file ON knowledge_conflicts(file_path);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS feature_health (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_key TEXT NOT NULL UNIQUE,
+      health_score INTEGER NOT NULL DEFAULT 100,
+      tests_passing INTEGER NOT NULL DEFAULT 0,
+      tests_failing INTEGER NOT NULL DEFAULT 0,
+      test_coverage_pct REAL,
+      modifications_since_test INTEGER NOT NULL DEFAULT 0,
+      last_modified TEXT,
+      last_tested TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_fh_feature ON feature_health(feature_key);
+    CREATE INDEX IF NOT EXISTS idx_fh_health ON feature_health(health_score);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tool_cost_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      estimated_input_tokens INTEGER DEFAULT 0,
+      estimated_output_tokens INTEGER DEFAULT 0,
+      model TEXT DEFAULT '',
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_tce_session ON tool_cost_events(session_id);
+    CREATE INDEX IF NOT EXISTS idx_tce_tool ON tool_cost_events(tool_name);
+    CREATE INDEX IF NOT EXISTS idx_tce_created ON tool_cost_events(created_at DESC);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS quality_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      details TEXT DEFAULT '',
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_qe_session ON quality_events(session_id);
+    CREATE INDEX IF NOT EXISTS idx_qe_event_type ON quality_events(event_type);
+    CREATE INDEX IF NOT EXISTS idx_qe_created ON quality_events(created_at DESC);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS pending_sync (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      payload TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      retry_count INTEGER NOT NULL DEFAULT 0,
+      last_error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_pending_sync_created ON pending_sync(created_at ASC);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS license_cache (
+      api_key_hash TEXT PRIMARY KEY,
+      tier TEXT NOT NULL,
+      valid_until TEXT NOT NULL,
+      last_validated TEXT NOT NULL,
+      features TEXT DEFAULT '[]'
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS failure_classes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT NOT NULL,
+      diff_patterns TEXT NOT NULL DEFAULT '[]',
+      file_patterns TEXT NOT NULL DEFAULT '[]',
+      prompt_keywords TEXT NOT NULL DEFAULT '[]',
+      incidents TEXT NOT NULL DEFAULT '[]',
+      rules TEXT NOT NULL DEFAULT '[]',
+      scanner_checks TEXT NOT NULL DEFAULT '[]',
+      known_message TEXT NOT NULL DEFAULT '',
+      needs_review INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_fc_name ON failure_classes(name);
+    CREATE INDEX IF NOT EXISTS idx_fc_needs_review ON failure_classes(needs_review);
+  `);
+}
+function addFailureClass(db, opts) {
+  const result = db.prepare(`
+    INSERT OR IGNORE INTO failure_classes (name, description, diff_patterns, file_patterns, prompt_keywords, incidents, rules, scanner_checks, known_message, needs_review)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    opts.name,
+    opts.description,
+    JSON.stringify(opts.diffPatterns ?? []),
+    JSON.stringify(opts.filePatterns ?? []),
+    JSON.stringify(opts.promptKeywords ?? []),
+    JSON.stringify(opts.incidents ?? []),
+    JSON.stringify(opts.rules ?? []),
+    JSON.stringify(opts.scannerChecks ?? []),
+    opts.knownMessage ?? "",
+    opts.needsReview ? 1 : 0
+  );
+  return Number(result.lastInsertRowid);
+}
+function getFailureClasses(db) {
+  const rows = db.prepare("SELECT * FROM failure_classes ORDER BY name").all();
+  return rows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    diff_patterns: JSON.parse(row.diff_patterns || "[]"),
+    file_patterns: JSON.parse(row.file_patterns || "[]"),
+    prompt_keywords: JSON.parse(row.prompt_keywords || "[]"),
+    incidents: JSON.parse(row.incidents || "[]"),
+    rules: JSON.parse(row.rules || "[]"),
+    scanner_checks: JSON.parse(row.scanner_checks || "[]"),
+    known_message: row.known_message,
+    needs_review: !!row.needs_review
+  }));
+}
+function appendIncidentToFailureClass(db, className, incidentId) {
+  const row = db.prepare("SELECT incidents FROM failure_classes WHERE name = ?").get(className);
+  if (!row) return;
+  const incidents = JSON.parse(row.incidents || "[]");
+  if (!incidents.includes(incidentId)) {
+    incidents.push(incidentId);
+    db.prepare("UPDATE failure_classes SET incidents = ?, updated_at = datetime('now') WHERE name = ?").run(JSON.stringify(incidents), className);
+  }
+}
+function scoreFailureClasses(db, matchText, filePath, promptContext, weights) {
+  const classes = getFailureClasses(db);
+  if (classes.length === 0) return null;
+  const diffWeight = weights?.diffPatternWeight ?? 3;
+  const fileWeight = weights?.filePatternWeight ?? 2;
+  const promptWeight = weights?.promptKeywordWeight ?? 2;
+  let bestMatch = null;
+  for (const fc of classes) {
+    let score = 0;
+    for (const pattern of fc.diff_patterns) {
+      if (!pattern) continue;
+      try {
+        if (new RegExp(pattern, "i").test(matchText)) {
+          score += diffWeight;
+        }
+      } catch {
+        if (matchText.toLowerCase().includes(pattern.toLowerCase())) {
+          score += diffWeight;
+        }
+      }
+    }
+    for (const pattern of fc.file_patterns) {
+      if (!pattern) continue;
+      try {
+        if (new RegExp(pattern).test(filePath)) {
+          score += fileWeight;
+        }
+      } catch {
+        if (filePath.includes(pattern)) {
+          score += fileWeight;
+        }
+      }
+    }
+    if (promptContext) {
+      for (const keyword of fc.prompt_keywords) {
+        if (!keyword) continue;
+        try {
+          if (new RegExp(keyword, "i").test(promptContext)) {
+            score += promptWeight;
+          }
+        } catch {
+          if (promptContext.toLowerCase().includes(keyword.toLowerCase())) {
+            score += promptWeight;
+          }
+        }
+      }
+    }
+    if (!bestMatch || score > bestMatch.score) {
+      bestMatch = {
+        name: fc.name,
+        score,
+        incidentCount: fc.incidents.length,
+        rules: fc.rules,
+        knownMessage: fc.known_message
+      };
+    }
+  }
+  return bestMatch;
+}
 
 // src/hooks/incident-pipeline.ts
 async function main() {
@@ -347,17 +1008,17 @@ async function main() {
       process.exit(0);
       return;
     }
-    if (!existsSync2(filePath)) {
+    if (!existsSync3(filePath)) {
       process.exit(0);
       return;
     }
     const content = readFileSync2(filePath, "utf-8");
     const titleMatch = content.match(/^#\s+(.+)/m);
-    const title = titleMatch?.[1] ?? basename(filePath, ".md");
-    const slug = basename(filePath, ".md").replace(/^\d{4}-\d{2}-\d{2}-?/, "").toLowerCase();
-    const memoryDirAbs = resolve2(root, memoryDir);
+    const title = titleMatch?.[1] ?? basename2(filePath, ".md");
+    const slug = basename2(filePath, ".md").replace(/^\d{4}-\d{2}-\d{2}-?/, "").toLowerCase();
+    const memoryDirAbs = resolve3(root, memoryDir);
     let hasExistingRule = false;
-    if (existsSync2(memoryDirAbs)) {
+    if (existsSync3(memoryDirAbs)) {
       const ruleFiles = readdirSync(memoryDirAbs).filter((f) => f.startsWith("feedback_"));
       for (const ruleFile of ruleFiles) {
         if (ruleFile.toLowerCase().includes(slug.slice(0, 20))) {
@@ -408,19 +1069,46 @@ async function main() {
     lines.push("============================================================================");
     lines.push("");
     console.log(lines.join("\n"));
+    try {
+      const taxonomyConfig = config.autoLearning?.failureClassification;
+      if (taxonomyConfig?.enabled !== false) {
+        const db = getMemoryDb();
+        try {
+          const thresholds = taxonomyConfig?.thresholds ?? { known: 5, similar: 3 };
+          const scoringWeights = taxonomyConfig?.scoring;
+          const incidentNumMatch = basename2(filePath, ".md").match(/(\d+)/);
+          const incidentId = incidentNumMatch ? incidentNumMatch[1] : basename2(filePath, ".md");
+          const bestMatch = scoreFailureClasses(db, content, filePath, title, scoringWeights);
+          if (bestMatch && bestMatch.score >= thresholds.similar) {
+            appendIncidentToFailureClass(db, bestMatch.name, incidentId);
+          } else {
+            const stubName = `auto_${slug.replace(/[^a-z0-9_]/g, "_").slice(0, 50)}`;
+            addFailureClass(db, {
+              name: stubName,
+              description: `Auto-created from incident ${incidentId}: ${title.slice(0, 100)}`,
+              incidents: [incidentId],
+              needsReview: true
+            });
+          }
+        } finally {
+          db.close();
+        }
+      }
+    } catch {
+    }
   } catch {
   }
   process.exit(0);
 }
 function readStdin() {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve3(data));
-    setTimeout(() => resolve3(data), 3e3);
+    process.stdin.on("end", () => resolve4(data));
+    setTimeout(() => resolve4(data), 3e3);
   });
 }
 main();