@a-company/sentinel 0.2.0

package/dist/mcp.js

@@ -0,0 +1,2767 @@
+#!/usr/bin/env node
+
+// src/mcp.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/storage.ts
+import initSqlJs from "sql.js";
+import { v4 as uuidv4 } from "uuid";
+import * as path from "path";
+import * as fs from "fs";
+var SCHEMA_VERSION = 2;
+var DEFAULT_CONFIDENCE = {
+  score: 50,
+  timesMatched: 0,
+  timesResolved: 0,
+  timesRecurred: 0
+};
+var SQL = null;
+var SentinelStorage = class {
+  db = null;
+  dbPath;
+  incidentCounter = 0;
+  initialized = false;
+  constructor(dbPath) {
+    this.dbPath = dbPath || this.getDefaultDbPath();
+  }
+  getDefaultDbPath() {
+    const dataDir = process.env.SENTINEL_DATA_DIR || process.env.PARADIGM_DATA_DIR || path.join(process.cwd(), ".paradigm", "sentinel");
+    return path.join(dataDir, "sentinel.db");
+  }
+  createSchema() {
+    if (!this.db) return;
+    this.db.run(`
+      -- Metadata table for schema versioning
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      -- Incidents table
+      CREATE TABLE IF NOT EXISTS incidents (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'open',
+        error_message TEXT NOT NULL,
+        error_stack TEXT,
+        error_code TEXT,
+        error_type TEXT,
+        symbols TEXT NOT NULL,
+        flow_position TEXT,
+        environment TEXT NOT NULL,
+        service TEXT,
+        version TEXT,
+        user_id TEXT,
+        request_id TEXT,
+        group_id TEXT,
+        notes TEXT DEFAULT '[]',
+        related_incidents TEXT DEFAULT '[]',
+        resolved_at TEXT,
+        resolved_by TEXT,
+        resolution TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      -- Patterns table
+      CREATE TABLE IF NOT EXISTS patterns (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        pattern TEXT NOT NULL,
+        resolution TEXT NOT NULL,
+        confidence TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'manual',
+        private INTEGER NOT NULL DEFAULT 0,
+        tags TEXT DEFAULT '[]',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      -- Incident groups
+      CREATE TABLE IF NOT EXISTS groups (
+        id TEXT PRIMARY KEY,
+        name TEXT,
+        common_symbols TEXT,
+        common_error_patterns TEXT,
+        suggested_pattern_id TEXT,
+        first_seen TEXT NOT NULL,
+        last_seen TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      -- Group members
+      CREATE TABLE IF NOT EXISTS group_members (
+        group_id TEXT NOT NULL,
+        incident_id TEXT NOT NULL,
+        added_at TEXT NOT NULL,
+        PRIMARY KEY (group_id, incident_id)
+      );
+
+      -- Resolutions history
+      CREATE TABLE IF NOT EXISTS resolutions (
+        id TEXT PRIMARY KEY,
+        incident_id TEXT NOT NULL,
+        pattern_id TEXT,
+        commit_hash TEXT,
+        pr_url TEXT,
+        notes TEXT,
+        resolved_at TEXT NOT NULL,
+        recurred INTEGER DEFAULT 0
+      );
+
+      -- Practice events (habits system)
+      CREATE TABLE IF NOT EXISTS practice_events (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        habit_id TEXT NOT NULL,
+        habit_category TEXT NOT NULL,
+        result TEXT NOT NULL CHECK (result IN ('followed', 'skipped', 'partial')),
+        engineer TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        lore_entry_id TEXT,
+        task_description TEXT,
+        symbols_touched TEXT DEFAULT '[]',
+        files_modified TEXT DEFAULT '[]',
+        related_incident_id TEXT,
+        notes TEXT
+      );
+
+      -- Indexes
+      CREATE INDEX IF NOT EXISTS idx_incidents_timestamp ON incidents(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_incidents_status ON incidents(status);
+      CREATE INDEX IF NOT EXISTS idx_incidents_environment ON incidents(environment);
+      CREATE INDEX IF NOT EXISTS idx_patterns_source ON patterns(source);
+      CREATE INDEX IF NOT EXISTS idx_practice_events_timestamp ON practice_events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_practice_events_habit_id ON practice_events(habit_id);
+      CREATE INDEX IF NOT EXISTS idx_practice_events_engineer ON practice_events(engineer);
+      CREATE INDEX IF NOT EXISTS idx_practice_events_session_id ON practice_events(session_id);
+    `);
+    this.db.run(
+      "INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', ?)",
+      [String(SCHEMA_VERSION)]
+    );
+  }
+  save() {
+    if (!this.db) return;
+    const data = this.db.export();
+    const buffer = Buffer.from(data);
+    fs.writeFileSync(this.dbPath, buffer);
+  }
+  // ─── Incidents ───────────────────────────────────────────────────
+  recordIncident(input) {
+    const db = this.db;
+    if (!db) {
+      this.initializeSync();
+    }
+    this.incidentCounter++;
+    const id = `INC-${String(this.incidentCounter).padStart(3, "0")}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      `INSERT INTO incidents (
+        id, timestamp, status, error_message, error_stack, error_code, error_type,
+        symbols, flow_position, environment, service, version, user_id, request_id,
+        group_id, notes, related_incidents, resolved_at, resolved_by, resolution,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        input.timestamp || now,
+        input.status || "open",
+        input.error.message,
+        input.error.stack || null,
+        input.error.code || null,
+        input.error.type || null,
+        JSON.stringify(input.symbols),
+        input.flowPosition ? JSON.stringify(input.flowPosition) : null,
+        input.environment,
+        input.service || null,
+        input.version || null,
+        input.userId || null,
+        input.requestId || null,
+        input.groupId || null,
+        "[]",
+        "[]",
+        input.resolvedAt || null,
+        input.resolvedBy || null,
+        input.resolution ? JSON.stringify(input.resolution) : null,
+        now,
+        now
+      ]
+    );
+    this.save();
+    return id;
+  }
+  initializeSync() {
+    if (this.initialized && this.db) return;
+    if (!this.db && SQL) {
+      const dir = path.dirname(this.dbPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      if (fs.existsSync(this.dbPath)) {
+        const fileData = fs.readFileSync(this.dbPath);
+        this.db = new SQL.Database(fileData);
+      } else {
+        this.db = new SQL.Database();
+        this.createSchema();
+      }
+      try {
+        const result = this.db.exec(
+          "SELECT MAX(CAST(SUBSTR(id, 5) AS INTEGER)) as max FROM incidents"
+        );
+        if (result.length > 0 && result[0].values.length > 0 && result[0].values[0][0]) {
+          this.incidentCounter = result[0].values[0][0];
+        }
+      } catch {
+        this.incidentCounter = 0;
+      }
+      this.migrateSchema();
+      this.initialized = true;
+      this.save();
+    }
+  }
+  /**
+   * Run schema migrations from older versions
+   */
+  migrateSchema() {
+    if (!this.db) return;
+    let currentVersion = 1;
+    try {
+      const result = this.db.exec(
+        "SELECT value FROM metadata WHERE key = 'schema_version'"
+      );
+      if (result.length > 0 && result[0].values.length > 0) {
+        currentVersion = parseInt(result[0].values[0][0], 10) || 1;
+      }
+    } catch {
+    }
+    if (currentVersion < 2) {
+      try {
+        this.db.run(`
+          CREATE TABLE IF NOT EXISTS practice_events (
+            id TEXT PRIMARY KEY,
+            timestamp TEXT NOT NULL,
+            habit_id TEXT NOT NULL,
+            habit_category TEXT NOT NULL,
+            result TEXT NOT NULL CHECK (result IN ('followed', 'skipped', 'partial')),
+            engineer TEXT NOT NULL,
+            session_id TEXT NOT NULL,
+            lore_entry_id TEXT,
+            task_description TEXT,
+            symbols_touched TEXT DEFAULT '[]',
+            files_modified TEXT DEFAULT '[]',
+            related_incident_id TEXT,
+            notes TEXT
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_practice_events_timestamp ON practice_events(timestamp);
+          CREATE INDEX IF NOT EXISTS idx_practice_events_habit_id ON practice_events(habit_id);
+          CREATE INDEX IF NOT EXISTS idx_practice_events_engineer ON practice_events(engineer);
+          CREATE INDEX IF NOT EXISTS idx_practice_events_session_id ON practice_events(session_id);
+        `);
+      } catch {
+      }
+      this.db.run(
+        "INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', '2')"
+      );
+    }
+  }
+  /**
+   * Ensure the storage is ready for use. Must be called once before using storage methods.
+   */
+  async ensureReady() {
+    if (!SQL) {
+      SQL = await initSqlJs();
+    }
+    this.initializeSync();
+  }
+  getIncident(id) {
+    this.initializeSync();
+    const result = this.db.exec("SELECT * FROM incidents WHERE id = ?", [id]);
+    if (result.length === 0 || result[0].values.length === 0) return null;
+    return this.rowToIncident(result[0].columns, result[0].values[0]);
+  }
+  getRecentIncidents(options = {}) {
+    this.initializeSync();
+    const { limit = 50, offset = 0 } = options;
+    const conditions = [];
+    const params = [];
+    if (options.status && options.status !== "all") {
+      conditions.push("status = ?");
+      params.push(options.status);
+    }
+    if (options.environment) {
+      conditions.push("environment = ?");
+      params.push(options.environment);
+    }
+    if (options.symbol) {
+      conditions.push("symbols LIKE ?");
+      params.push(`%${options.symbol}%`);
+    }
+    if (options.search) {
+      conditions.push("(error_message LIKE ? OR notes LIKE ?)");
+      params.push(`%${options.search}%`, `%${options.search}%`);
+    }
+    if (options.dateFrom) {
+      conditions.push("timestamp >= ?");
+      params.push(options.dateFrom);
+    }
+    if (options.dateTo) {
+      conditions.push("timestamp <= ?");
+      params.push(options.dateTo);
+    }
+    if (options.groupId) {
+      conditions.push("group_id = ?");
+      params.push(options.groupId);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT * FROM incidents ${whereClause} ORDER BY timestamp DESC LIMIT ? OFFSET ?`,
+      [...params, limit, offset]
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToIncident(result[0].columns, row)
+    );
+  }
+  updateIncident(id, updates) {
+    this.initializeSync();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const setClauses = ["updated_at = ?"];
+    const params = [now];
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      params.push(updates.status);
+    }
+    if (updates.error !== void 0) {
+      setClauses.push("error_message = ?");
+      params.push(updates.error.message);
+      if (updates.error.stack !== void 0) {
+        setClauses.push("error_stack = ?");
+        params.push(updates.error.stack || null);
+      }
+    }
+    if (updates.symbols !== void 0) {
+      setClauses.push("symbols = ?");
+      params.push(JSON.stringify(updates.symbols));
+    }
+    if (updates.flowPosition !== void 0) {
+      setClauses.push("flow_position = ?");
+      params.push(
+        updates.flowPosition ? JSON.stringify(updates.flowPosition) : null
+      );
+    }
+    if (updates.groupId !== void 0) {
+      setClauses.push("group_id = ?");
+      params.push(updates.groupId || null);
+    }
+    if (updates.resolvedAt !== void 0) {
+      setClauses.push("resolved_at = ?");
+      params.push(updates.resolvedAt || null);
+    }
+    if (updates.resolvedBy !== void 0) {
+      setClauses.push("resolved_by = ?");
+      params.push(updates.resolvedBy || null);
+    }
+    if (updates.resolution !== void 0) {
+      setClauses.push("resolution = ?");
+      params.push(
+        updates.resolution ? JSON.stringify(updates.resolution) : null
+      );
+    }
+    params.push(id);
+    this.db.run(
+      `UPDATE incidents SET ${setClauses.join(", ")} WHERE id = ?`,
+      params
+    );
+    this.save();
+  }
+  addIncidentNote(incidentId, note) {
+    this.initializeSync();
+    const incident = this.getIncident(incidentId);
+    if (!incident) return;
+    const newNote = {
+      id: uuidv4(),
+      ...note
+    };
+    const notes = [...incident.notes, newNote];
+    this.db.run(
+      "UPDATE incidents SET notes = ?, updated_at = ? WHERE id = ?",
+      [JSON.stringify(notes), (/* @__PURE__ */ new Date()).toISOString(), incidentId]
+    );
+    this.save();
+  }
+  linkIncidents(incidentId, relatedId) {
+    this.initializeSync();
+    const incident = this.getIncident(incidentId);
+    if (!incident) return;
+    if (!incident.relatedIncidents.includes(relatedId)) {
+      const related = [...incident.relatedIncidents, relatedId];
+      this.db.run(
+        "UPDATE incidents SET related_incidents = ?, updated_at = ? WHERE id = ?",
+        [JSON.stringify(related), (/* @__PURE__ */ new Date()).toISOString(), incidentId]
+      );
+    }
+    const relatedIncident = this.getIncident(relatedId);
+    if (relatedIncident && !relatedIncident.relatedIncidents.includes(incidentId)) {
+      const related = [...relatedIncident.relatedIncidents, incidentId];
+      this.db.run(
+        "UPDATE incidents SET related_incidents = ?, updated_at = ? WHERE id = ?",
+        [JSON.stringify(related), (/* @__PURE__ */ new Date()).toISOString(), relatedId]
+      );
+    }
+    this.save();
+  }
+  getIncidentCount(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.status && options.status !== "all") {
+      conditions.push("status = ?");
+      params.push(options.status);
+    }
+    if (options.environment) {
+      conditions.push("environment = ?");
+      params.push(options.environment);
+    }
+    if (options.dateFrom) {
+      conditions.push("timestamp >= ?");
+      params.push(options.dateFrom);
+    }
+    if (options.dateTo) {
+      conditions.push("timestamp <= ?");
+      params.push(options.dateTo);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT COUNT(*) as count FROM incidents ${whereClause}`,
+      params
+    );
+    if (result.length === 0 || result[0].values.length === 0) return 0;
+    return result[0].values[0][0];
+  }
+  // ─── Patterns ────────────────────────────────────────────────────
+  addPattern(input) {
+    this.initializeSync();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const confidence = {
+      ...DEFAULT_CONFIDENCE,
+      ...input.confidence
+    };
+    this.db.run(
+      `INSERT INTO patterns (
+        id, name, description, pattern, resolution, confidence,
+        source, private, tags, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        input.id,
+        input.name,
+        input.description || null,
+        JSON.stringify(input.pattern),
+        JSON.stringify(input.resolution),
+        JSON.stringify(confidence),
+        input.source,
+        input.private ? 1 : 0,
+        JSON.stringify(input.tags || []),
+        now,
+        now
+      ]
+    );
+    this.save();
+    return input.id;
+  }
+  getPattern(id) {
+    this.initializeSync();
+    const result = this.db.exec("SELECT * FROM patterns WHERE id = ?", [id]);
+    if (result.length === 0 || result[0].values.length === 0) return null;
+    return this.rowToPattern(result[0].columns, result[0].values[0]);
+  }
+  getAllPatterns(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.source) {
+      conditions.push("source = ?");
+      params.push(options.source);
+    }
+    if (options.minConfidence !== void 0) {
+      conditions.push("json_extract(confidence, '$.score') >= ?");
+      params.push(options.minConfidence);
+    }
+    if (!options.includePrivate) {
+      conditions.push("private = 0");
+    }
+    if (options.tags && options.tags.length > 0) {
+      const tagConditions = options.tags.map(() => "tags LIKE ?");
+      conditions.push(`(${tagConditions.join(" OR ")})`);
+      params.push(...options.tags.map((tag) => `%"${tag}"%`));
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT * FROM patterns ${whereClause} ORDER BY json_extract(confidence, '$.score') DESC`,
+      params
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToPattern(result[0].columns, row)
+    );
+  }
+  updatePattern(id, updates) {
+    this.initializeSync();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const setClauses = ["updated_at = ?"];
+    const params = [now];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      params.push(updates.description || null);
+    }
+    if (updates.pattern !== void 0) {
+      setClauses.push("pattern = ?");
+      params.push(JSON.stringify(updates.pattern));
+    }
+    if (updates.resolution !== void 0) {
+      setClauses.push("resolution = ?");
+      params.push(JSON.stringify(updates.resolution));
+    }
+    if (updates.confidence !== void 0) {
+      setClauses.push("confidence = ?");
+      params.push(JSON.stringify(updates.confidence));
+    }
+    if (updates.source !== void 0) {
+      setClauses.push("source = ?");
+      params.push(updates.source);
+    }
+    if (updates.private !== void 0) {
+      setClauses.push("private = ?");
+      params.push(updates.private ? 1 : 0);
+    }
+    if (updates.tags !== void 0) {
+      setClauses.push("tags = ?");
+      params.push(JSON.stringify(updates.tags));
+    }
+    params.push(id);
+    this.db.run(
+      `UPDATE patterns SET ${setClauses.join(", ")} WHERE id = ?`,
+      params
+    );
+    this.save();
+  }
+  deletePattern(id) {
+    this.initializeSync();
+    this.db.run("DELETE FROM patterns WHERE id = ?", [id]);
+    this.save();
+  }
+  updatePatternConfidence(patternId, event) {
+    const pattern = this.getPattern(patternId);
+    if (!pattern) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const confidence = { ...pattern.confidence };
+    switch (event) {
+      case "matched":
+        confidence.timesMatched++;
+        confidence.lastMatched = now;
+        break;
+      case "resolved":
+        confidence.timesResolved++;
+        confidence.lastResolved = now;
+        confidence.score = Math.min(100, confidence.score + 2);
+        break;
+      case "recurred":
+        confidence.timesRecurred++;
+        confidence.score = Math.max(10, confidence.score - 5);
+        break;
+    }
+    this.updatePattern(patternId, { confidence });
+  }
+  // ─── Groups ──────────────────────────────────────────────────────
+  createGroup(input) {
+    this.initializeSync();
+    const id = `GRP-${uuidv4().substring(0, 8)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      `INSERT INTO groups (
+        id, name, common_symbols, common_error_patterns,
+        suggested_pattern_id, first_seen, last_seen, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        input.name || null,
+        JSON.stringify(input.commonSymbols),
+        JSON.stringify(input.commonErrorPatterns),
+        input.suggestedPattern?.id || null,
+        input.firstSeen,
+        input.lastSeen,
+        now,
+        now
+      ]
+    );
+    for (const incidentId of input.incidents) {
+      this.addToGroup(id, incidentId);
+    }
+    this.save();
+    return id;
+  }
+  getGroup(id) {
+    this.initializeSync();
+    const result = this.db.exec("SELECT * FROM groups WHERE id = ?", [id]);
+    if (result.length === 0 || result[0].values.length === 0) return null;
+    return this.rowToGroup(result[0].columns, result[0].values[0]);
+  }
+  getGroups(options = {}) {
+    this.initializeSync();
+    const limit = options.limit || 100;
+    const result = this.db.exec(
+      "SELECT * FROM groups ORDER BY last_seen DESC LIMIT ?",
+      [limit]
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToGroup(result[0].columns, row)
+    );
+  }
+  addToGroup(groupId, incidentId) {
+    this.initializeSync();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      "INSERT OR IGNORE INTO group_members (group_id, incident_id, added_at) VALUES (?, ?, ?)",
+      [groupId, incidentId, now]
+    );
+    this.db.run("UPDATE incidents SET group_id = ? WHERE id = ?", [
+      groupId,
+      incidentId
+    ]);
+    this.db.run(
+      "UPDATE groups SET last_seen = ?, updated_at = ? WHERE id = ?",
+      [now, now, groupId]
+    );
+    this.save();
+  }
+  // ─── Resolutions ─────────────────────────────────────────────────
+  recordResolution(resolution) {
+    this.initializeSync();
+    const id = uuidv4();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      `INSERT INTO resolutions (id, incident_id, pattern_id, commit_hash, pr_url, notes, resolved_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        resolution.incidentId,
+        resolution.patternId || null,
+        resolution.commitHash || null,
+        resolution.prUrl || null,
+        resolution.notes || null,
+        now
+      ]
+    );
+    this.updateIncident(resolution.incidentId, {
+      status: "resolved",
+      resolvedAt: now,
+      resolvedBy: resolution.patternId || "manual",
+      resolution: {
+        patternId: resolution.patternId,
+        commitHash: resolution.commitHash,
+        prUrl: resolution.prUrl,
+        notes: resolution.notes
+      }
+    });
+    if (resolution.patternId) {
+      this.updatePatternConfidence(resolution.patternId, "resolved");
+    }
+    this.save();
+  }
+  markRecurred(incidentId) {
+    this.initializeSync();
+    this.db.run(
+      "UPDATE resolutions SET recurred = 1 WHERE incident_id = ?",
+      [incidentId]
+    );
+    const result = this.db.exec(
+      "SELECT pattern_id FROM resolutions WHERE incident_id = ?",
+      [incidentId]
+    );
+    if (result.length > 0 && result[0].values.length > 0 && result[0].values[0][0]) {
+      this.updatePatternConfidence(result[0].values[0][0], "recurred");
+    }
+    this.save();
+  }
+  getResolutionHistory(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.patternId) {
+      conditions.push("pattern_id = ?");
+      params.push(options.patternId);
+    }
+    if (options.symbol) {
+      conditions.push(`incident_id IN (
+        SELECT id FROM incidents WHERE symbols LIKE ?
+      )`);
+      params.push(`%${options.symbol}%`);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = options.limit || 100;
+    const result = this.db.exec(
+      `SELECT * FROM resolutions ${whereClause} ORDER BY resolved_at DESC LIMIT ?`,
+      [...params, limit]
+    );
+    if (result.length === 0) return [];
+    const columns = result[0].columns;
+    return result[0].values.map((row) => {
+      const obj = {};
+      columns.forEach((col, i) => {
+        obj[col] = row[i];
+      });
+      return {
+        id: obj.id,
+        incidentId: obj.incident_id,
+        patternId: obj.pattern_id || void 0,
+        commitHash: obj.commit_hash || void 0,
+        prUrl: obj.pr_url || void 0,
+        notes: obj.notes || void 0,
+        resolvedAt: obj.resolved_at,
+        recurred: obj.recurred === 1
+      };
+    });
+  }
+  // ─── Stats ───────────────────────────────────────────────────────
+  getStats(period) {
+    this.initializeSync();
+    const { start, end } = period;
+    const total = this.getIncidentCount({ dateFrom: start, dateTo: end });
+    const open = this.getIncidentCount({
+      dateFrom: start,
+      dateTo: end,
+      status: "open"
+    });
+    const resolved = this.getIncidentCount({
+      dateFrom: start,
+      dateTo: end,
+      status: "resolved"
+    });
+    const envResult = this.db.exec(
+      `SELECT environment, COUNT(*) as count
+      FROM incidents
+      WHERE timestamp >= ? AND timestamp <= ?
+      GROUP BY environment`,
+      [start, end]
+    );
+    const byEnvironment = {};
+    if (envResult.length > 0) {
+      for (const row of envResult[0].values) {
+        byEnvironment[row[0]] = row[1];
+      }
+    }
+    const dayResult = this.db.exec(
+      `SELECT DATE(timestamp) as date, COUNT(*) as count
+      FROM incidents
+      WHERE timestamp >= ? AND timestamp <= ?
+      GROUP BY DATE(timestamp)
+      ORDER BY date`,
+      [start, end]
+    );
+    const byDay = [];
+    if (dayResult.length > 0) {
+      for (const row of dayResult[0].values) {
+        byDay.push({ date: row[0], count: row[1] });
+      }
+    }
+    const patterns = this.getAllPatterns({ includePrivate: true });
+    const avgConfidence = patterns.length > 0 ? patterns.reduce((sum, p) => sum + p.confidence.score, 0) / patterns.length : 0;
+    const mostEffective = patterns.sort((a, b) => b.confidence.timesResolved - a.confidence.timesResolved).slice(0, 5).map((p) => ({ patternId: p.id, resolvedCount: p.confidence.timesResolved }));
+    const leastEffective = patterns.filter((p) => p.confidence.timesMatched > 0).map((p) => ({
+      patternId: p.id,
+      recurrenceRate: p.confidence.timesRecurred / Math.max(1, p.confidence.timesResolved)
+    })).sort((a, b) => b.recurrenceRate - a.recurrenceRate).slice(0, 5);
+    const symbolCounts = /* @__PURE__ */ new Map();
+    const incidents = this.getRecentIncidents({
+      dateFrom: start,
+      dateTo: end,
+      limit: 1e3
+    });
+    for (const incident of incidents) {
+      for (const [, value] of Object.entries(incident.symbols)) {
+        if (value) {
+          symbolCounts.set(value, (symbolCounts.get(value) || 0) + 1);
+        }
+      }
+    }
+    const mostIncidents = Array.from(symbolCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([symbol, count]) => ({ symbol, count }));
+    const resolutions = this.getResolutionHistory({ limit: 1e3 });
+    const periodResolutions = resolutions.filter(
+      (r) => r.resolvedAt >= start && r.resolvedAt <= end
+    );
+    const resolvedWithPattern = periodResolutions.filter(
+      (r) => r.patternId
+    ).length;
+    const resolvedManually = periodResolutions.length - resolvedWithPattern;
+    return {
+      period: { start, end },
+      incidents: {
+        total,
+        open,
+        resolved,
+        byEnvironment,
+        byDay
+      },
+      patterns: {
+        total: patterns.length,
+        avgConfidence: Math.round(avgConfidence),
+        mostEffective,
+        leastEffective
+      },
+      symbols: {
+        mostIncidents,
+        mostResolved: [],
+        hotspots: mostIncidents.slice(0, 5).map((s) => ({
+          symbol: s.symbol,
+          incidentRate: s.count / Math.max(1, total)
+        }))
+      },
+      resolution: {
+        avgTimeToResolve: 0,
+        resolvedWithPattern,
+        resolvedManually,
+        resolutionRate: total > 0 ? resolved / total * 100 : 0
+      }
+    };
+  }
+  getSymbolHealth(symbol) {
+    const incidents = this.getRecentIncidents({ symbol, limit: 1e3 });
+    const incidentCount = incidents.length;
+    const patternCounts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      if (incident.resolution?.patternId) {
+        const count = patternCounts.get(incident.resolution.patternId) || 0;
+        patternCounts.set(incident.resolution.patternId, count + 1);
+      }
+    }
+    const topPatterns = Array.from(patternCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([patternId, count]) => ({ patternId, count }));
+    return {
+      incidentCount,
+      avgTimeToResolve: 0,
+      topPatterns
+    };
+  }
+  // ─── Import/Export ───────────────────────────────────────────────
+  exportPatterns(options = {}) {
+    const patterns = this.getAllPatterns({
+      includePrivate: options.includePrivate
+    });
+    return {
+      version: "1.0.0",
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      patterns
+    };
+  }
+  importPatterns(data, options = {}) {
+    let imported = 0;
+    let skipped = 0;
+    for (const pattern of data.patterns) {
+      const existing = this.getPattern(pattern.id);
+      if (existing && !options.overwrite) {
+        skipped++;
+        continue;
+      }
+      if (existing) {
+        this.updatePattern(pattern.id, pattern);
+      } else {
+        this.addPattern({
+          ...pattern,
+          source: "imported"
+        });
+      }
+      imported++;
+    }
+    return { imported, skipped };
+  }
+  exportBackup() {
+    const incidents = this.getRecentIncidents({ limit: 1e5 });
+    const patterns = this.getAllPatterns({ includePrivate: true });
+    const groups = this.getGroups({ limit: 1e4 });
+    return {
+      version: "1.0.0",
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      incidents,
+      patterns,
+      groups
+    };
+  }
+  importBackup(data) {
+    this.initializeSync();
+    this.db.run("DELETE FROM group_members");
+    this.db.run("DELETE FROM resolutions");
+    this.db.run("DELETE FROM groups");
+    this.db.run("DELETE FROM incidents");
+    this.db.run("DELETE FROM patterns");
+    for (const pattern of data.patterns) {
+      this.addPattern(pattern);
+    }
+    for (const incident of data.incidents) {
+      const now2 = incident.timestamp;
+      this.db.run(
+        `INSERT INTO incidents (
+          id, timestamp, status, error_message, error_stack, error_code, error_type,
+          symbols, flow_position, environment, service, version, user_id, request_id,
+          group_id, notes, related_incidents, resolved_at, resolved_by, resolution,
+          created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          incident.id,
+          incident.timestamp,
+          incident.status,
+          incident.error.message,
+          incident.error.stack || null,
+          incident.error.code || null,
+          incident.error.type || null,
+          JSON.stringify(incident.symbols),
+          incident.flowPosition ? JSON.stringify(incident.flowPosition) : null,
+          incident.environment,
+          incident.service || null,
+          incident.version || null,
+          incident.userId || null,
+          incident.requestId || null,
+          incident.groupId || null,
+          JSON.stringify(incident.notes),
+          JSON.stringify(incident.relatedIncidents),
+          incident.resolvedAt || null,
+          incident.resolvedBy || null,
+          incident.resolution ? JSON.stringify(incident.resolution) : null,
+          now2,
+          now2
+        ]
+      );
+    }
+    const result = this.db.exec(
+      "SELECT MAX(CAST(SUBSTR(id, 5) AS INTEGER)) as max FROM incidents"
+    );
+    if (result.length > 0 && result[0].values.length > 0 && result[0].values[0][0]) {
+      this.incidentCounter = result[0].values[0][0];
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const group of data.groups) {
+      this.db.run(
+        `INSERT INTO groups (
+          id, name, common_symbols, common_error_patterns,
+          suggested_pattern_id, first_seen, last_seen, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          group.id,
+          group.name || null,
+          JSON.stringify(group.commonSymbols),
+          JSON.stringify(group.commonErrorPatterns),
+          group.suggestedPattern?.id || null,
+          group.firstSeen,
+          group.lastSeen,
+          now,
+          now
+        ]
+      );
+      for (const incidentId of group.incidents) {
+        this.db.run(
+          "INSERT OR IGNORE INTO group_members (group_id, incident_id, added_at) VALUES (?, ?, ?)",
+          [group.id, incidentId, now]
+        );
+      }
+    }
+    this.save();
+  }
+  // ─── Helper Methods ──────────────────────────────────────────────
+  rowToIncident(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      id: obj.id,
+      timestamp: obj.timestamp,
+      status: obj.status,
+      error: {
+        message: obj.error_message,
+        stack: obj.error_stack || void 0,
+        code: obj.error_code || void 0,
+        type: obj.error_type || void 0
+      },
+      symbols: JSON.parse(obj.symbols || "{}"),
+      flowPosition: obj.flow_position ? JSON.parse(obj.flow_position) : void 0,
+      environment: obj.environment,
+      service: obj.service || void 0,
+      version: obj.version || void 0,
+      userId: obj.user_id || void 0,
+      requestId: obj.request_id || void 0,
+      groupId: obj.group_id || void 0,
+      notes: JSON.parse(obj.notes || "[]"),
+      relatedIncidents: JSON.parse(obj.related_incidents || "[]"),
+      resolvedAt: obj.resolved_at || void 0,
+      resolvedBy: obj.resolved_by || void 0,
+      resolution: obj.resolution ? JSON.parse(obj.resolution) : void 0
+    };
+  }
+  rowToPattern(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      id: obj.id,
+      name: obj.name,
+      description: obj.description || "",
+      pattern: JSON.parse(obj.pattern),
+      resolution: JSON.parse(obj.resolution),
+      confidence: JSON.parse(obj.confidence),
+      source: obj.source,
+      private: obj.private === 1,
+      tags: JSON.parse(obj.tags || "[]"),
+      createdAt: obj.created_at,
+      updatedAt: obj.updated_at
+    };
+  }
+  rowToGroup(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    const membersResult = this.db.exec(
+      "SELECT incident_id FROM group_members WHERE group_id = ?",
+      [obj.id]
+    );
+    const incidents = [];
+    if (membersResult.length > 0) {
+      for (const r of membersResult[0].values) {
+        incidents.push(r[0]);
+      }
+    }
+    const envResult = this.db.exec(
+      `SELECT DISTINCT environment FROM incidents
+      WHERE id IN (SELECT incident_id FROM group_members WHERE group_id = ?)`,
+      [obj.id]
+    );
+    const environments = [];
+    if (envResult.length > 0) {
+      for (const r of envResult[0].values) {
+        environments.push(r[0]);
+      }
+    }
+    return {
+      id: obj.id,
+      name: obj.name || void 0,
+      incidents,
+      commonSymbols: JSON.parse(obj.common_symbols || "{}"),
+      commonErrorPatterns: JSON.parse(
+        obj.common_error_patterns || "[]"
+      ),
+      count: incidents.length,
+      firstSeen: obj.first_seen,
+      lastSeen: obj.last_seen,
+      environments,
+      suggestedPattern: obj.suggested_pattern_id ? this.getPattern(obj.suggested_pattern_id) || void 0 : void 0
+    };
+  }
+  // ─── Practice Events ─────────────────────────────────────────────
+  recordPracticeEvent(input) {
+    this.initializeSync();
+    const id = `PE-${uuidv4().substring(0, 8)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      `INSERT INTO practice_events (
+        id, timestamp, habit_id, habit_category, result,
+        engineer, session_id, lore_entry_id, task_description,
+        symbols_touched, files_modified, related_incident_id, notes
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        now,
+        input.habitId,
+        input.habitCategory,
+        input.result,
+        input.engineer,
+        input.sessionId,
+        input.loreEntryId || null,
+        input.taskDescription || null,
+        JSON.stringify(input.symbolsTouched || []),
+        JSON.stringify(input.filesModified || []),
+        input.relatedIncidentId || null,
+        input.notes || null
+      ]
+    );
+    this.save();
+    return id;
+  }
+  getPracticeEvents(options = {}) {
+    this.initializeSync();
+    const { limit = 100, offset = 0 } = options;
+    const conditions = [];
+    const params = [];
+    if (options.habitId) {
+      conditions.push("habit_id = ?");
+      params.push(options.habitId);
+    }
+    if (options.habitCategory) {
+      conditions.push("habit_category = ?");
+      params.push(options.habitCategory);
+    }
+    if (options.result) {
+      conditions.push("result = ?");
+      params.push(options.result);
+    }
+    if (options.engineer) {
+      conditions.push("engineer = ?");
+      params.push(options.engineer);
+    }
+    if (options.sessionId) {
+      conditions.push("session_id = ?");
+      params.push(options.sessionId);
+    }
+    if (options.dateFrom) {
+      conditions.push("timestamp >= ?");
+      params.push(options.dateFrom);
+    }
+    if (options.dateTo) {
+      conditions.push("timestamp <= ?");
+      params.push(options.dateTo);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT * FROM practice_events ${whereClause} ORDER BY timestamp DESC LIMIT ? OFFSET ?`,
+      [...params, limit, offset]
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToPracticeEvent(result[0].columns, row)
+    );
+  }
+  getPracticeEventCount(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.habitId) {
+      conditions.push("habit_id = ?");
+      params.push(options.habitId);
+    }
+    if (options.habitCategory) {
+      conditions.push("habit_category = ?");
+      params.push(options.habitCategory);
+    }
+    if (options.result) {
+      conditions.push("result = ?");
+      params.push(options.result);
+    }
+    if (options.engineer) {
+      conditions.push("engineer = ?");
+      params.push(options.engineer);
+    }
+    if (options.dateFrom) {
+      conditions.push("timestamp >= ?");
+      params.push(options.dateFrom);
+    }
+    if (options.dateTo) {
+      conditions.push("timestamp <= ?");
+      params.push(options.dateTo);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT COUNT(*) as count FROM practice_events ${whereClause}`,
+      params
+    );
+    if (result.length === 0 || result[0].values.length === 0) return 0;
+    return result[0].values[0][0];
+  }
+  getComplianceRate(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.habitId) {
+      conditions.push("habit_id = ?");
+      params.push(options.habitId);
+    }
+    if (options.habitCategory) {
+      conditions.push("habit_category = ?");
+      params.push(options.habitCategory);
+    }
+    if (options.engineer) {
+      conditions.push("engineer = ?");
+      params.push(options.engineer);
+    }
+    if (options.dateFrom) {
+      conditions.push("timestamp >= ?");
+      params.push(options.dateFrom);
+    }
+    if (options.dateTo) {
+      conditions.push("timestamp <= ?");
+      params.push(options.dateTo);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT result, COUNT(*) as count
+       FROM practice_events ${whereClause}
+       GROUP BY result`,
+      params
+    );
+    let followed = 0;
+    let skipped = 0;
+    let partial = 0;
+    if (result.length > 0) {
+      for (const row of result[0].values) {
+        const r = row[0];
+        const count = row[1];
+        if (r === "followed") followed = count;
+        else if (r === "skipped") skipped = count;
+        else if (r === "partial") partial = count;
+      }
+    }
+    const total = followed + skipped + partial;
+    const rate = total > 0 ? (followed + partial * 0.5) / total * 100 : 100;
+    return { total, followed, skipped, partial, rate: Math.round(rate) };
+  }
+  rowToPracticeEvent(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      id: obj.id,
+      timestamp: obj.timestamp,
+      habitId: obj.habit_id,
+      habitCategory: obj.habit_category,
+      result: obj.result,
+      engineer: obj.engineer,
+      sessionId: obj.session_id,
+      loreEntryId: obj.lore_entry_id || void 0,
+      taskDescription: obj.task_description || void 0,
+      symbolsTouched: JSON.parse(obj.symbols_touched || "[]"),
+      filesModified: JSON.parse(obj.files_modified || "[]"),
+      relatedIncidentId: obj.related_incident_id || void 0,
+      notes: obj.notes || void 0
+    };
+  }
+  close() {
+    if (this.db) {
+      this.save();
+      this.db.close();
+      this.db = null;
+    }
+  }
+};
+
+// src/matcher.ts
+var DEFAULT_CONFIG = {
+  minScore: 30,
+  maxResults: 5,
+  boostConfidence: true
+};
+var PatternMatcher = class {
+  constructor(storage2) {
+    this.storage = storage2;
+  }
+  /**
+   * Match an incident against all patterns and return ranked results
+   */
+  match(incident, config = {}) {
+    const { minScore, maxResults, boostConfidence } = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    const patterns = this.storage.getAllPatterns({ includePrivate: true });
+    const matches = [];
+    for (const pattern of patterns) {
+      if (!this.matchEnvironment(pattern, incident)) {
+        continue;
+      }
+      const { score, matchedCriteria } = this.scoreMatch(pattern, incident);
+      if (score >= minScore) {
+        let confidence = score;
+        if (boostConfidence) {
+          const confidenceFactor = pattern.confidence.score / 100;
+          confidence = score * (0.5 + 0.5 * confidenceFactor);
+        }
+        matches.push({
+          pattern,
+          score,
+          matchedCriteria,
+          confidence: Math.round(confidence)
+        });
+        this.storage.updatePatternConfidence(pattern.id, "matched");
+      }
+    }
+    return matches.sort((a, b) => b.confidence - a.confidence).slice(0, maxResults);
+  }
+  /**
+   * Test a pattern against historical incidents
+   */
+  testPattern(pattern, limit = 100) {
+    const incidents = this.storage.getRecentIncidents({ limit });
+    const wouldMatch = [];
+    let totalScore = 0;
+    for (const incident of incidents) {
+      if (!this.matchEnvironment(pattern, incident)) {
+        continue;
+      }
+      const { score } = this.scoreMatch(pattern, incident);
+      if (score >= 30) {
+        wouldMatch.push(incident);
+        totalScore += score;
+      }
+    }
+    return {
+      wouldMatch,
+      matchCount: wouldMatch.length,
+      avgScore: wouldMatch.length > 0 ? Math.round(totalScore / wouldMatch.length) : 0
+    };
+  }
+  /**
+   * Score how well a pattern matches an incident
+   */
+  scoreMatch(pattern, incident) {
+    let score = 0;
+    const matchedCriteria = {
+      symbols: [],
+      errorKeywords: [],
+      missingSignals: []
+    };
+    const symbolScore = this.matchSymbols(
+      pattern.pattern.symbols,
+      incident.symbols,
+      matchedCriteria.symbols
+    );
+    score += Math.min(symbolScore, 50);
+    const errorScore = this.matchErrorText(
+      pattern,
+      incident,
+      matchedCriteria.errorKeywords
+    );
+    score += Math.min(errorScore, 25);
+    const signalScore = this.matchMissingSignals(
+      pattern,
+      incident,
+      matchedCriteria.missingSignals
+    );
+    score += Math.min(signalScore, 25);
+    score = Math.min(score, 100);
+    return { score, matchedCriteria };
+  }
+  /**
+   * Match symbols between pattern and incident
+   */
+  matchSymbols(patternSymbols, incidentSymbols, matched) {
+    let score = 0;
+    const symbolTypes = [
+      "feature",
+      "component",
+      "flow",
+      "gate",
+      "signal",
+      "state",
+      "integration"
+    ];
+    for (const type of symbolTypes) {
+      const patternValue = patternSymbols[type];
+      const incidentValue = incidentSymbols[type];
+      if (!patternValue || !incidentValue) {
+        continue;
+      }
+      if (typeof patternValue === "string") {
+        if (this.matchSingleSymbol(patternValue, incidentValue)) {
+          score += patternValue.includes("*") ? 5 : 10;
+          matched.push(type);
+        }
+      } else if (Array.isArray(patternValue)) {
+        for (const pv of patternValue) {
+          if (this.matchSingleSymbol(pv, incidentValue)) {
+            score += 7;
+            matched.push(type);
+            break;
+          }
+        }
+      }
+    }
+    return score;
+  }
+  /**
+   * Match a single symbol value (supports wildcards)
+   */
+  matchSingleSymbol(pattern, value) {
+    if (pattern === "*") {
+      return true;
+    }
+    if (pattern.endsWith("*")) {
+      const prefix = pattern.slice(0, -1);
+      return value.startsWith(prefix);
+    }
+    if (pattern.startsWith("*")) {
+      const suffix = pattern.slice(1);
+      return value.endsWith(suffix);
+    }
+    if (pattern.includes("*")) {
+      const regex = new RegExp(
+        "^" + pattern.replace(/\*/g, ".*") + "$"
+      );
+      return regex.test(value);
+    }
+    return pattern === value;
+  }
+  /**
+   * Match error text keywords and regex
+   */
+  matchErrorText(pattern, incident, matched) {
+    let score = 0;
+    const errorMessage = incident.error.message.toLowerCase();
+    const errorType = incident.error.type?.toLowerCase();
+    if (pattern.pattern.errorContains) {
+      for (const keyword of pattern.pattern.errorContains) {
+        if (errorMessage.includes(keyword.toLowerCase())) {
+          score += 5;
+          matched.push(keyword);
+        }
+      }
+    }
+    if (pattern.pattern.errorMatches) {
+      try {
+        const regex = new RegExp(pattern.pattern.errorMatches, "i");
+        if (regex.test(incident.error.message)) {
+          score += 10;
+          matched.push(`regex:${pattern.pattern.errorMatches}`);
+        }
+      } catch {
+      }
+    }
+    if (pattern.pattern.errorType && errorType) {
+      for (const type of pattern.pattern.errorType) {
+        if (errorType.includes(type.toLowerCase())) {
+          score += 5;
+          matched.push(`type:${type}`);
+        }
+      }
+    }
+    return score;
+  }
+  /**
+   * Match missing signals from flow position
+   */
+  matchMissingSignals(pattern, incident, matched) {
+    if (!pattern.pattern.missingSignals || !incident.flowPosition?.missing) {
+      return 0;
+    }
+    let score = 0;
+    for (const expectedSignal of pattern.pattern.missingSignals) {
+      for (const missingSignal of incident.flowPosition.missing) {
+        if (this.matchSingleSymbol(expectedSignal, missingSignal)) {
+          score += 12;
+          matched.push(missingSignal);
+          break;
+        }
+      }
+    }
+    return score;
+  }
+  /**
+   * Check if pattern's environment filter matches incident
+   */
+  matchEnvironment(pattern, incident) {
+    if (!pattern.pattern.environment || pattern.pattern.environment.length === 0) {
+      return true;
+    }
+    return pattern.pattern.environment.includes(incident.environment);
+  }
+};
+
+// src/timeline.ts
+var TimelineBuilder = class {
+  /**
+   * Build a timeline from an incident with flow position
+   */
+  build(incident) {
+    if (!incident.flowPosition) {
+      return null;
+    }
+    const events = [];
+    const baseTime = new Date(incident.timestamp).getTime();
+    events.push({
+      timestamp: new Date(baseTime - 5e3).toISOString(),
+      symbol: incident.flowPosition.flowId,
+      type: "flow-started"
+    });
+    let eventOffset = 1e3;
+    for (const signal of incident.flowPosition.actual) {
+      const type = this.inferEventType(signal);
+      events.push({
+        timestamp: new Date(baseTime - 4e3 + eventOffset).toISOString(),
+        symbol: signal,
+        type
+      });
+      eventOffset += Math.random() * 1e3 + 500;
+    }
+    const failedSymbol = incident.flowPosition.failedAt || incident.flowPosition.missing[0] || incident.symbols.gate || incident.symbols.signal || "unknown";
+    events.push({
+      timestamp: incident.timestamp,
+      symbol: failedSymbol,
+      type: "error",
+      data: {
+        message: incident.error.message,
+        missing: incident.flowPosition.missing
+      }
+    });
+    return {
+      incidentId: incident.id,
+      flowId: incident.flowPosition.flowId,
+      events,
+      failure: {
+        at: incident.timestamp,
+        symbol: failedSymbol,
+        reason: incident.error.message
+      }
+    };
+  }
+  /**
+   * Render timeline as ASCII art
+   */
+  renderAscii(timeline) {
+    const lines = [];
+    lines.push(`${timeline.flowId} Timeline`);
+    lines.push("\u2550".repeat(40));
+    lines.push("");
+    for (const event of timeline.events) {
+      const time = this.formatTime(event.timestamp);
+      const icon = this.getEventIcon(event.type);
+      const status = this.getEventStatus(event.type);
+      let line = `${time}  ${icon} ${event.symbol}`;
+      if (status) {
+        line += ` (${status})`;
+      }
+      lines.push(line);
+      if (event.type === "error" && event.data) {
+        lines.push(`             \u2514\u2500 ${event.data.message}`);
+        if (event.data.missing && Array.isArray(event.data.missing) && event.data.missing.length > 0) {
+          lines.push(
+            `             \u2514\u2500 Expected: ${event.data.missing.join(", ")}`
+          );
+        }
+      }
+    }
+    const missing = timeline.events.find((e) => e.type === "error")?.data?.missing;
+    if (missing && missing.length > 0) {
+      lines.push("");
+      lines.push(`Missing signals: ${missing.join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Render timeline as structured data (for MCP/JSON output)
+   */
+  renderStructured(timeline) {
+    return {
+      incidentId: timeline.incidentId,
+      flow: {
+        id: timeline.flowId,
+        eventCount: timeline.events.length
+      },
+      events: timeline.events.map((event) => ({
+        time: this.formatTime(event.timestamp),
+        symbol: event.symbol,
+        type: event.type,
+        status: this.getEventStatus(event.type),
+        data: event.data
+      })),
+      failure: {
+        at: this.formatTime(timeline.failure.at),
+        symbol: timeline.failure.symbol,
+        reason: timeline.failure.reason
+      }
+    };
+  }
+  /**
+   * Infer event type from symbol prefix
+   */
+  inferEventType(symbol) {
+    if (symbol.startsWith("^")) {
+      return "gate-passed";
+    }
+    if (symbol.startsWith("!")) {
+      return "signal-emitted";
+    }
+    if (symbol.startsWith("%")) {
+      return "state-changed";
+    }
+    return "signal-emitted";
+  }
+  /**
+   * Get icon for event type
+   */
+  getEventIcon(type) {
+    switch (type) {
+      case "flow-started":
+        return "\u25B6";
+      case "flow-ended":
+        return "\u25A0";
+      case "gate-passed":
+        return "\u2713";
+      case "gate-failed":
+        return "\u2717";
+      case "signal-emitted":
+        return "\u26A1";
+      case "state-changed":
+        return "\u25C6";
+      case "error":
+        return "\u2717";
+      default:
+        return "\u2022";
+    }
+  }
+  /**
+   * Get status text for event type
+   */
+  getEventStatus(type) {
+    switch (type) {
+      case "gate-passed":
+        return "PASSED";
+      case "gate-failed":
+        return "FAILED";
+      case "signal-emitted":
+        return "EMITTED";
+      case "state-changed":
+        return "CHANGED";
+      case "error":
+        return "ERROR";
+      default:
+        return "";
+    }
+  }
+  /**
+   * Format timestamp for display
+   */
+  formatTime(timestamp) {
+    const date = new Date(timestamp);
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    const millis = String(date.getMilliseconds()).padStart(3, "0");
+    return `${hours}:${minutes}:${seconds}.${millis}`;
+  }
+};
+
+// src/stats.ts
+var StatsCalculator = class {
+  constructor(storage2) {
+    this.storage = storage2;
+  }
+  /**
+   * Get comprehensive statistics for a time period
+   */
+  getStats(periodDays = 7) {
+    const end = (/* @__PURE__ */ new Date()).toISOString();
+    const start = new Date(
+      Date.now() - periodDays * 24 * 60 * 60 * 1e3
+    ).toISOString();
+    return this.storage.getStats({ start, end });
+  }
+  /**
+   * Get health metrics for a specific symbol
+   */
+  getSymbolHealth(symbol) {
+    return this.storage.getSymbolHealth(symbol);
+  }
+  /**
+   * Get trending issues (symbols with increasing incident rates)
+   */
+  getTrendingIssues(days = 7) {
+    const now = Date.now();
+    const halfPeriod = days * 24 * 60 * 60 * 1e3 / 2;
+    const firstHalfStart = new Date(now - days * 24 * 60 * 60 * 1e3).toISOString();
+    const midpoint = new Date(now - halfPeriod).toISOString();
+    const secondHalfEnd = new Date(now).toISOString();
+    const firstHalfIncidents = this.storage.getRecentIncidents({
+      dateFrom: firstHalfStart,
+      dateTo: midpoint,
+      limit: 1e3
+    });
+    const secondHalfIncidents = this.storage.getRecentIncidents({
+      dateFrom: midpoint,
+      dateTo: secondHalfEnd,
+      limit: 1e3
+    });
+    const firstHalfCounts = this.countSymbols(firstHalfIncidents);
+    const secondHalfCounts = this.countSymbols(secondHalfIncidents);
+    const trends = [];
+    const allSymbols = /* @__PURE__ */ new Set([
+      ...firstHalfCounts.keys(),
+      ...secondHalfCounts.keys()
+    ]);
+    for (const symbol of allSymbols) {
+      const first = firstHalfCounts.get(symbol) || 0;
+      const second = secondHalfCounts.get(symbol) || 0;
+      if (first === 0 && second > 0) {
+        trends.push({ symbol, trend: second * 100 });
+      } else if (first > 0) {
+        const change = (second - first) / first * 100;
+        trends.push({ symbol, trend: change });
+      }
+    }
+    return trends.filter((t) => t.trend > 0).sort((a, b) => b.trend - a.trend).slice(0, 10);
+  }
+  /**
+   * Get resolution metrics
+   */
+  getResolutionMetrics() {
+    const stats = this.getStats(30);
+    return {
+      avgTimeToResolve: stats.resolution.avgTimeToResolve,
+      resolvedWithPattern: stats.resolution.resolvedWithPattern,
+      resolvedManually: stats.resolution.resolvedManually,
+      totalResolved: stats.incidents.resolved,
+      resolutionRate: stats.resolution.resolutionRate
+    };
+  }
+  /**
+   * Get pattern effectiveness metrics
+   */
+  getPatternEffectiveness() {
+    const patterns = this.storage.getAllPatterns({ includePrivate: true });
+    return patterns.filter((p) => p.confidence.timesMatched > 0).map((p) => ({
+      patternId: p.id,
+      name: p.name,
+      matches: p.confidence.timesMatched,
+      resolutions: p.confidence.timesResolved,
+      recurrences: p.confidence.timesRecurred,
+      effectiveness: p.confidence.timesMatched > 0 ? Math.round(
+        (p.confidence.timesResolved - p.confidence.timesRecurred) / p.confidence.timesMatched * 100
+      ) : 0
+    })).sort((a, b) => b.effectiveness - a.effectiveness);
+  }
+  /**
+   * Get incident rate by hour of day
+   */
+  getIncidentsByHour(days = 7) {
+    const start = new Date(
+      Date.now() - days * 24 * 60 * 60 * 1e3
+    ).toISOString();
+    const incidents = this.storage.getRecentIncidents({
+      dateFrom: start,
+      limit: 1e4
+    });
+    const hourCounts = /* @__PURE__ */ new Map();
+    for (let i = 0; i < 24; i++) {
+      hourCounts.set(i, 0);
+    }
+    for (const incident of incidents) {
+      const hour = new Date(incident.timestamp).getHours();
+      hourCounts.set(hour, (hourCounts.get(hour) || 0) + 1);
+    }
+    return Array.from(hourCounts.entries()).map(([hour, count]) => ({
+      hour,
+      count
+    }));
+  }
+  /**
+   * Get incident rate by environment
+   */
+  getIncidentsByEnvironment() {
+    const stats = this.getStats(30);
+    const total = stats.incidents.total;
+    return Object.entries(stats.incidents.byEnvironment).map(([environment, count]) => ({
+      environment,
+      count,
+      percentage: total > 0 ? Math.round(count / total * 100) : 0
+    })).sort((a, b) => b.count - a.count);
+  }
+  /**
+   * Get symbol correlation matrix (which symbols fail together)
+   */
+  getSymbolCorrelation() {
+    const incidents = this.storage.getRecentIncidents({ limit: 1e3 });
+    const correlations = /* @__PURE__ */ new Map();
+    const symbolCounts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      const symbols = this.getSymbolsFromIncident(incident);
+      for (const symbol of symbols) {
+        symbolCounts.set(symbol, (symbolCounts.get(symbol) || 0) + 1);
+      }
+      for (let i = 0; i < symbols.length; i++) {
+        for (let j = i + 1; j < symbols.length; j++) {
+          const key = [symbols[i], symbols[j]].sort().join("|");
+          correlations.set(key, (correlations.get(key) || 0) + 1);
+        }
+      }
+    }
+    const results = [];
+    for (const [key, count] of correlations) {
+      const [symbol1, symbol2] = key.split("|");
+      const count1 = symbolCounts.get(symbol1) || 1;
+      const count2 = symbolCounts.get(symbol2) || 1;
+      const correlation = count / Math.max(count1, count2);
+      if (correlation > 0.3) {
+        results.push({
+          symbol1,
+          symbol2,
+          correlation: Math.round(correlation * 100) / 100
+        });
+      }
+    }
+    return results.sort((a, b) => b.correlation - a.correlation).slice(0, 20);
+  }
+  /**
+   * Generate a summary dashboard string
+   */
+  generateDashboard(periodDays = 7) {
+    const stats = this.getStats(periodDays);
+    const lines = [];
+    lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+    lines.push("\u2551                    PARADIGM SENTINEL DASHBOARD                  \u2551");
+    lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+    const todayCount = stats.incidents.byDay[stats.incidents.byDay.length - 1]?.count || 0;
+    lines.push(
+      `\u2551  Open: ${String(stats.incidents.open).padEnd(4)} \u2502  Investigating: ${String(stats.incidents.total - stats.incidents.open - stats.incidents.resolved).padEnd(3)} \u2502  Resolved: ${String(stats.incidents.resolved).padEnd(4)} \u2502  Today: +${todayCount}   \u2551`
+    );
+    lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+    lines.push("");
+    lines.push("Incidents by Day (last 7 days):");
+    lines.push("\u2500".repeat(50));
+    const maxDayCount = Math.max(...stats.incidents.byDay.map((d) => d.count), 1);
+    for (const day of stats.incidents.byDay.slice(-7)) {
+      const barLength = Math.round(day.count / maxDayCount * 30);
+      const bar = "\u2588".repeat(barLength);
+      lines.push(`${day.date.substring(5)}  ${bar} ${day.count}`);
+    }
+    lines.push("");
+    lines.push("Most Affected Symbols:");
+    lines.push("\u2500".repeat(50));
+    for (const { symbol, count } of stats.symbols.mostIncidents.slice(0, 5)) {
+      lines.push(`  ${symbol.padEnd(25)} ${count} incidents`);
+    }
+    lines.push("");
+    lines.push("Top Patterns:");
+    lines.push("\u2500".repeat(50));
+    for (const { patternId, resolvedCount } of stats.patterns.mostEffective.slice(0, 5)) {
+      lines.push(`  ${patternId.padEnd(25)} ${resolvedCount} resolved`);
+    }
+    lines.push("");
+    lines.push("Resolution Stats:");
+    lines.push("\u2500".repeat(50));
+    lines.push(`  Resolution rate: ${Math.round(stats.resolution.resolutionRate)}%`);
+    lines.push(`  With pattern: ${stats.resolution.resolvedWithPattern}`);
+    lines.push(`  Manual: ${stats.resolution.resolvedManually}`);
+    return lines.join("\n");
+  }
+  /**
+   * Helper: Count symbols across incidents
+   */
+  countSymbols(incidents) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      for (const [, value] of Object.entries(incident.symbols)) {
+        if (value) {
+          counts.set(value, (counts.get(value) || 0) + 1);
+        }
+      }
+    }
+    return counts;
+  }
+  /**
+   * Helper: Get all symbols from incident
+   */
+  getSymbolsFromIncident(incident) {
+    const symbols = [];
+    for (const [, value] of Object.entries(incident.symbols)) {
+      if (value) {
+        symbols.push(value);
+      }
+    }
+    return symbols;
+  }
+};
+
+// src/suggester.ts
+var PatternSuggester = class {
+  constructor(storage2) {
+    this.storage = storage2;
+  }
+  /**
+   * Suggest a pattern from a resolved incident
+   */
+  suggestFromIncident(incident) {
+    const baseId = this.generatePatternId(incident);
+    const symbols = this.buildSymbolCriteria(incident.symbols);
+    const errorKeywords = this.extractErrorKeywords(incident.error.message);
+    const pattern = {
+      id: baseId,
+      name: this.generatePatternName(incident),
+      description: `Auto-suggested pattern from incident ${incident.id}`,
+      pattern: {
+        symbols,
+        errorContains: errorKeywords.length > 0 ? errorKeywords : void 0,
+        missingSignals: incident.flowPosition?.missing
+      },
+      resolution: {
+        description: incident.resolution?.notes || "Resolution approach TBD",
+        strategy: "fix-code",
+        priority: "medium"
+      },
+      source: "suggested",
+      private: false,
+      tags: this.generateTags(incident)
+    };
+    return pattern;
+  }
+  /**
+   * Suggest a pattern from an incident group
+   */
+  suggestFromGroup(group) {
+    const baseId = `group-${group.id.toLowerCase().replace(/[^a-z0-9]/g, "-")}`;
+    const symbols = this.buildSymbolCriteria(group.commonSymbols);
+    const pattern = {
+      id: baseId,
+      name: group.name || `Pattern from group ${group.id}`,
+      description: `Auto-suggested pattern from incident group with ${group.count} incidents`,
+      pattern: {
+        symbols,
+        errorContains: group.commonErrorPatterns.length > 0 ? group.commonErrorPatterns : void 0
+      },
+      resolution: {
+        description: "Resolution approach TBD based on grouped incidents",
+        strategy: "fix-code",
+        priority: this.getPriorityFromCount(group.count)
+      },
+      source: "suggested",
+      private: false,
+      tags: this.generateTagsFromGroup(group)
+    };
+    return pattern;
+  }
+  /**
+   * Find incidents that could become patterns
+   */
+  findPatternCandidates(minOccurrences = 3) {
+    const incidents = this.storage.getRecentIncidents({
+      limit: 1e3,
+      status: "resolved"
+    });
+    const signatureGroups = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      const signature = this.getSymbolSignature(incident.symbols);
+      const existing = signatureGroups.get(signature) || [];
+      existing.push(incident);
+      signatureGroups.set(signature, existing);
+    }
+    const candidates = [];
+    for (const [, groupIncidents] of signatureGroups) {
+      if (groupIncidents.length >= minOccurrences) {
+        const hasPattern = this.hasMatchingPattern(groupIncidents[0]);
+        if (hasPattern) continue;
+        const suggestedPattern = this.suggestFromIncidents(groupIncidents);
+        candidates.push({
+          incidents: groupIncidents,
+          suggestedPattern,
+          occurrenceCount: groupIncidents.length
+        });
+      }
+    }
+    return candidates.sort((a, b) => b.occurrenceCount - a.occurrenceCount);
+  }
+  /**
+   * Generate pattern from multiple similar incidents
+   */
+  suggestFromIncidents(incidents) {
+    const commonSymbols = this.extractCommonSymbols(incidents);
+    const symbols = this.buildSymbolCriteria(commonSymbols);
+    const errorKeywords = this.extractCommonErrorKeywords(incidents);
+    const missingSignals = this.extractCommonMissingSignals(incidents);
+    const baseId = this.generatePatternId(incidents[0]);
+    return {
+      id: baseId,
+      name: this.generatePatternName(incidents[0]),
+      description: `Auto-suggested pattern from ${incidents.length} similar incidents`,
+      pattern: {
+        symbols,
+        errorContains: errorKeywords.length > 0 ? errorKeywords : void 0,
+        missingSignals: missingSignals.length > 0 ? missingSignals : void 0
+      },
+      resolution: {
+        description: "Resolution approach based on previous resolutions",
+        strategy: this.inferStrategy(incidents),
+        priority: this.getPriorityFromCount(incidents.length)
+      },
+      source: "suggested",
+      private: false,
+      tags: this.generateTagsFromIncidents(incidents)
+    };
+  }
+  /**
+   * Build symbol criteria for pattern, adding wildcards where appropriate
+   */
+  buildSymbolCriteria(symbols) {
+    const criteria = {};
+    for (const [key, value] of Object.entries(symbols)) {
+      if (value) {
+        criteria[key] = value;
+      }
+    }
+    return criteria;
+  }
+  /**
+   * Extract keywords from error message
+   */
+  extractErrorKeywords(message) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "of",
+      "with",
+      "and",
+      "or",
+      "but",
+      "not",
+      "no",
+      "be",
+      "been",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did"
+    ]);
+    const words = message.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+    const unique = [...new Set(words)];
+    return unique.slice(0, 5);
+  }
+  /**
+   * Extract common error keywords from multiple incidents
+   */
+  extractCommonErrorKeywords(incidents) {
+    const wordCounts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      const keywords = this.extractErrorKeywords(incident.error.message);
+      for (const keyword of keywords) {
+        wordCounts.set(keyword, (wordCounts.get(keyword) || 0) + 1);
+      }
+    }
+    const threshold = Math.ceil(incidents.length * 0.5);
+    return Array.from(wordCounts.entries()).filter(([, count]) => count >= threshold).map(([word]) => word).slice(0, 5);
+  }
+  /**
+   * Extract symbols common to all incidents
+   */
+  extractCommonSymbols(incidents) {
+    if (incidents.length === 0) return {};
+    const first = incidents[0].symbols;
+    const common = {};
+    for (const [key, value] of Object.entries(first)) {
+      if (!value) continue;
+      const allMatch = incidents.every(
+        (i) => i.symbols[key] === value
+      );
+      if (allMatch) {
+        common[key] = value;
+      }
+    }
+    return common;
+  }
+  /**
+   * Extract missing signals common to multiple incidents
+   */
+  extractCommonMissingSignals(incidents) {
+    const signalCounts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      if (!incident.flowPosition?.missing) continue;
+      for (const signal of incident.flowPosition.missing) {
+        signalCounts.set(signal, (signalCounts.get(signal) || 0) + 1);
+      }
+    }
+    const threshold = Math.ceil(incidents.length * 0.5);
+    return Array.from(signalCounts.entries()).filter(([, count]) => count >= threshold).map(([signal]) => signal);
+  }
+  /**
+   * Generate a pattern ID from incident
+   */
+  generatePatternId(incident) {
+    const parts = [];
+    if (incident.symbols.gate) {
+      parts.push(incident.symbols.gate.replace(/[^a-z0-9]/gi, ""));
+    } else if (incident.symbols.feature) {
+      parts.push(incident.symbols.feature.replace(/[^a-z0-9]/gi, ""));
+    } else if (incident.symbols.component) {
+      parts.push(incident.symbols.component.replace(/[^a-z0-9]/gi, ""));
+    } else if (incident.symbols.integration) {
+      parts.push(incident.symbols.integration.replace(/[^a-z0-9]/gi, ""));
+    } else {
+      parts.push("unknown");
+    }
+    const errorType = incident.error.type?.toLowerCase() || "error";
+    parts.push(errorType.replace(/[^a-z0-9]/gi, ""));
+    parts.push(String(Date.now() % 1e3).padStart(3, "0"));
+    return parts.join("-");
+  }
+  /**
+   * Generate a human-readable pattern name
+   */
+  generatePatternName(incident) {
+    const parts = [];
+    if (incident.symbols.feature) {
+      parts.push(
+        incident.symbols.feature.replace("@", "").replace(/-/g, " ")
+      );
+    }
+    if (incident.symbols.gate) {
+      parts.push("gate " + incident.symbols.gate.replace("^", ""));
+    }
+    if (incident.error.type) {
+      parts.push(incident.error.type);
+    }
+    if (parts.length === 0) {
+      return "Unnamed Pattern";
+    }
+    const name = parts.join(" - ");
+    return name.charAt(0).toUpperCase() + name.slice(1);
+  }
+  /**
+   * Generate tags from incident
+   */
+  generateTags(incident) {
+    const tags = [];
+    if (incident.symbols.feature) {
+      tags.push("feature");
+    }
+    if (incident.symbols.gate) {
+      tags.push("gate");
+    }
+    if (incident.symbols.integration) {
+      tags.push("integration");
+      tags.push(incident.symbols.integration.replace("&", ""));
+    }
+    if (incident.error.type) {
+      tags.push(incident.error.type.toLowerCase());
+    }
+    tags.push(incident.environment);
+    return [...new Set(tags)].slice(0, 5);
+  }
+  /**
+   * Generate tags from incident group
+   */
+  generateTagsFromGroup(group) {
+    const tags = ["grouped"];
+    if (group.commonSymbols.feature) {
+      tags.push("feature");
+    }
+    if (group.commonSymbols.gate) {
+      tags.push("gate");
+    }
+    if (group.commonSymbols.integration) {
+      tags.push("integration");
+    }
+    for (const env of group.environments) {
+      tags.push(env);
+    }
+    return [...new Set(tags)].slice(0, 5);
+  }
+  /**
+   * Generate tags from multiple incidents
+   */
+  generateTagsFromIncidents(incidents) {
+    const tagCounts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      const tags = this.generateTags(incident);
+      for (const tag of tags) {
+        tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+      }
+    }
+    return Array.from(tagCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([tag]) => tag);
+  }
+  /**
+   * Get symbol signature for grouping
+   */
+  getSymbolSignature(symbols) {
+    const parts = [];
+    if (symbols.feature) parts.push(`f:${symbols.feature}`);
+    if (symbols.component) parts.push(`c:${symbols.component}`);
+    if (symbols.flow) parts.push(`fl:${symbols.flow}`);
+    if (symbols.gate) parts.push(`g:${symbols.gate}`);
+    if (symbols.integration) parts.push(`i:${symbols.integration}`);
+    return parts.sort().join("|");
+  }
+  /**
+   * Check if there's already a pattern matching this incident
+   */
+  hasMatchingPattern(incident) {
+    const patterns = this.storage.getAllPatterns({ includePrivate: true });
+    for (const pattern of patterns) {
+      let matchCount = 0;
+      const symbolTypes = [
+        "feature",
+        "component",
+        "flow",
+        "gate",
+        "signal",
+        "integration"
+      ];
+      for (const type of symbolTypes) {
+        const patternValue = pattern.pattern.symbols[type];
+        const incidentValue = incident.symbols[type];
+        if (patternValue && incidentValue && patternValue === incidentValue) {
+          matchCount++;
+        }
+      }
+      if (matchCount >= 2) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Infer resolution strategy from incidents
+   */
+  inferStrategy(incidents) {
+    const messages = incidents.map((i) => i.error.message.toLowerCase());
+    if (messages.some((m) => m.includes("timeout") || m.includes("network"))) {
+      return "retry";
+    }
+    if (messages.some(
+      (m) => m.includes("validation") || m.includes("invalid") || m.includes("required")
+    )) {
+      return "fix-data";
+    }
+    if (messages.some((m) => m.includes("permission") || m.includes("403"))) {
+      return "escalate";
+    }
+    return "fix-code";
+  }
+  /**
+   * Get priority based on occurrence count
+   */
+  getPriorityFromCount(count) {
+    if (count >= 20) return "critical";
+    if (count >= 10) return "high";
+    if (count >= 5) return "medium";
+    return "low";
+  }
+};
+
+// src/seeds/loader.ts
+import * as path2 from "path";
+import * as fs2 from "fs";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+function loadUniversalPatterns() {
+  const filePath = path2.join(__dirname, "universal-patterns.json");
+  const content = fs2.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function loadParadigmPatterns() {
+  const filePath = path2.join(__dirname, "paradigm-patterns.json");
+  const content = fs2.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function loadAllSeedPatterns() {
+  const universal = loadUniversalPatterns();
+  const paradigm = loadParadigmPatterns();
+  return {
+    version: "1.0.0",
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    patterns: [...universal.patterns, ...paradigm.patterns]
+  };
+}
+
+// src/mcp.ts
+var storage = null;
+var initialized = false;
+function getStorage() {
+  if (!storage) {
+    storage = new SentinelStorage();
+  }
+  if (!initialized) {
+    try {
+      const { patterns } = loadAllSeedPatterns();
+      for (const pattern of patterns) {
+        try {
+          storage.addPattern(pattern);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    initialized = true;
+  }
+  return storage;
+}
+function getToolsList() {
+  return [
+    {
+      name: "sentinel_triage",
+      description: "View and filter incidents with pattern matches. Returns recent errors with symbolic context and resolution suggestions.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Filter by symbol (e.g., #checkout, ^auth)" },
+          status: {
+            type: "string",
+            enum: ["open", "investigating", "resolved", "wont-fix", "all"],
+            description: "Filter by status (default: all)"
+          },
+          environment: { type: "string", description: "Filter by environment" },
+          search: { type: "string", description: "Search in error messages" },
+          limit: { type: "number", description: "Max results (default: 10)" }
+        }
+      }
+    },
+    {
+      name: "sentinel_show",
+      description: "Get full details of a specific incident including timeline and matched patterns.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          incidentId: { type: "string", description: "Incident ID (e.g., INC-001)" },
+          includeTimeline: { type: "boolean", description: "Include flow timeline" },
+          includeSimilar: { type: "boolean", description: "Include similar incidents" }
+        },
+        required: ["incidentId"]
+      }
+    },
+    {
+      name: "sentinel_resolve",
+      description: "Mark an incident as resolved with optional pattern and commit reference.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          incidentId: { type: "string", description: "Incident ID" },
+          patternId: { type: "string", description: "Pattern that led to resolution" },
+          commitHash: { type: "string", description: "Fix commit hash" },
+          prUrl: { type: "string", description: "PR URL" },
+          notes: { type: "string", description: "Resolution notes" },
+          wontFix: { type: "boolean", description: "Mark as wont-fix instead of resolved" }
+        },
+        required: ["incidentId"]
+      }
+    },
+    {
+      name: "sentinel_patterns",
+      description: "List and filter failure patterns with confidence scores.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Filter patterns for this symbol" },
+          minConfidence: { type: "number", description: "Minimum confidence score" },
+          source: {
+            type: "string",
+            enum: ["manual", "suggested", "imported", "community"],
+            description: "Filter by source"
+          }
+        }
+      }
+    },
+    {
+      name: "sentinel_add_pattern",
+      description: "Create a new failure pattern.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Pattern ID (kebab-case)" },
+          name: { type: "string", description: "Human-readable name" },
+          description: { type: "string", description: "What this pattern matches" },
+          pattern: {
+            type: "object",
+            properties: {
+              symbols: { type: "object", description: "Symbol criteria" },
+              errorContains: { type: "array", items: { type: "string" }, description: "Error keywords" },
+              missingSignals: { type: "array", items: { type: "string" }, description: "Expected missing signals" }
+            }
+          },
+          resolution: {
+            type: "object",
+            properties: {
+              description: { type: "string", description: "Resolution steps" },
+              strategy: {
+                type: "string",
+                enum: ["retry", "fallback", "fix-data", "fix-code", "ignore", "escalate"]
+              },
+              priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+              codeHint: { type: "string", description: "Code fix hint" }
+            },
+            required: ["description", "strategy"]
+          },
+          tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" }
+        },
+        required: ["id", "name", "pattern", "resolution"]
+      }
+    },
+    {
+      name: "sentinel_record",
+      description: "Manually record a new incident.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          error: {
+            type: "object",
+            properties: {
+              message: { type: "string", description: "Error message" },
+              stack: { type: "string", description: "Stack trace" },
+              code: { type: "string", description: "Error code" },
+              type: { type: "string", description: "Error type" }
+            },
+            required: ["message"]
+          },
+          symbols: {
+            type: "object",
+            properties: {
+              component: { type: "string" },
+              flow: { type: "string" },
+              gate: { type: "string" },
+              signal: { type: "string" }
+            }
+          },
+          environment: { type: "string", description: "Environment (required)" },
+          service: { type: "string", description: "Service name" },
+          version: { type: "string", description: "App version" },
+          flowPosition: {
+            type: "object",
+            properties: {
+              flowId: { type: "string" },
+              expected: { type: "array", items: { type: "string" } },
+              actual: { type: "array", items: { type: "string" } },
+              missing: { type: "array", items: { type: "string" } },
+              failedAt: { type: "string" }
+            }
+          }
+        },
+        required: ["error", "symbols", "environment"]
+      }
+    },
+    {
+      name: "sentinel_stats",
+      description: "Get statistics and health metrics.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          period: { type: "string", description: "Period: 1d, 7d, 30d, 90d (default: 7d)" },
+          symbol: { type: "string", description: "Get health for specific symbol" }
+        }
+      }
+    },
+    {
+      name: "sentinel_suggest_pattern",
+      description: "Get AI suggestions for patterns based on incidents.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          incidentId: { type: "string", description: "Suggest from specific incident" },
+          minOccurrences: { type: "number", description: "Min similar incidents for suggestion" }
+        }
+      }
+    }
+  ];
+}
+async function handleTool(name, args) {
+  const store = getStorage();
+  const matcher = new PatternMatcher(store);
+  switch (name) {
+    case "sentinel_triage": {
+      const { symbol, status = "all", environment, search, limit = 10 } = args;
+      const incidents = store.getRecentIncidents({
+        limit,
+        status,
+        symbol,
+        environment,
+        search
+      });
+      if (incidents.length === 0) {
+        return JSON.stringify({
+          count: 0,
+          incidents: [],
+          tip: "No incidents recorded yet. Use sentinel_record to create incidents or integrate the SDK."
+        }, null, 2);
+      }
+      const results = incidents.map((incident) => {
+        const matches = matcher.match(incident, { maxResults: 3 });
+        return {
+          id: incident.id,
+          timestamp: incident.timestamp,
+          status: incident.status,
+          error: incident.error.message,
+          symbols: incident.symbols,
+          environment: incident.environment,
+          matches: matches.map((m) => ({
+            patternId: m.pattern.id,
+            name: m.pattern.name,
+            confidence: m.confidence,
+            strategy: m.pattern.resolution.strategy,
+            description: m.pattern.resolution.description
+          }))
+        };
+      });
+      return JSON.stringify({ count: results.length, incidents: results }, null, 2);
+    }
+    case "sentinel_show": {
+      const { incidentId, includeTimeline, includeSimilar } = args;
+      const incident = store.getIncident(incidentId);
+      if (!incident) {
+        return JSON.stringify({ error: `Incident ${incidentId} not found` });
+      }
+      const matches = matcher.match(incident, { maxResults: 5 });
+      const result = {
+        incident,
+        matches: matches.map((m) => ({
+          patternId: m.pattern.id,
+          name: m.pattern.name,
+          confidence: m.confidence,
+          matchedCriteria: m.matchedCriteria,
+          resolution: m.pattern.resolution
+        }))
+      };
+      if (includeTimeline && incident.flowPosition) {
+        const timeline = new TimelineBuilder().build(incident);
+        if (timeline) {
+          result.timeline = new TimelineBuilder().renderStructured(timeline);
+        }
+      }
+      if (includeSimilar) {
+        const similar = store.getRecentIncidents({ symbol: Object.values(incident.symbols)[0], limit: 5 }).filter((i) => i.id !== incidentId);
+        result.similar = similar.map((i) => ({
+          id: i.id,
+          error: i.error.message,
+          status: i.status
+        }));
+      }
+      return JSON.stringify(result, null, 2);
+    }
+    case "sentinel_resolve": {
+      const { incidentId, patternId, commitHash, prUrl, notes, wontFix } = args;
+      const incident = store.getIncident(incidentId);
+      if (!incident) {
+        return JSON.stringify({ error: `Incident ${incidentId} not found` });
+      }
+      if (wontFix) {
+        store.updateIncident(incidentId, {
+          status: "wont-fix",
+          resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          resolvedBy: "manual",
+          resolution: { notes }
+        });
+        return JSON.stringify({
+          success: true,
+          message: `Incident ${incidentId} marked as won't fix`
+        });
+      }
+      store.recordResolution({ incidentId, patternId, commitHash, prUrl, notes });
+      return JSON.stringify({
+        success: true,
+        message: `Incident ${incidentId} resolved`,
+        patternId,
+        commitHash,
+        prUrl
+      });
+    }
+    case "sentinel_patterns": {
+      const { symbol, minConfidence, source } = args;
+      const patterns = store.getAllPatterns({
+        source,
+        minConfidence,
+        includePrivate: false
+      });
+      let filtered = patterns;
+      if (symbol) {
+        filtered = patterns.filter((p) => {
+          const symbols = p.pattern.symbols;
+          return Object.values(symbols).some((v) => {
+            if (!v) return false;
+            if (Array.isArray(v)) return v.includes(symbol) || v.some((s) => symbol.match(s.replace("*", ".*")));
+            return v === symbol || symbol.match(v.replace("*", ".*"));
+          });
+        });
+      }
+      return JSON.stringify(
+        {
+          count: filtered.length,
+          patterns: filtered.map((p) => ({
+            id: p.id,
+            name: p.name,
+            description: p.description,
+            confidence: p.confidence.score,
+            resolution: p.resolution,
+            tags: p.tags
+          }))
+        },
+        null,
+        2
+      );
+    }
+    case "sentinel_add_pattern": {
+      const { id, name: name2, description, pattern, resolution, tags } = args;
+      const input = {
+        id,
+        name: name2,
+        description: description || "",
+        pattern: {
+          symbols: pattern.symbols || {},
+          errorContains: pattern.errorContains,
+          missingSignals: pattern.missingSignals
+        },
+        resolution: {
+          description: resolution.description,
+          strategy: resolution.strategy,
+          priority: resolution.priority || "medium",
+          codeHint: resolution.codeHint
+        },
+        source: "manual",
+        private: false,
+        tags: tags || []
+      };
+      store.addPattern(input);
+      return JSON.stringify({
+        success: true,
+        message: `Pattern ${id} created`,
+        pattern: input
+      });
+    }
+    case "sentinel_record": {
+      const { error, symbols, environment, service, version, flowPosition } = args;
+      const incidentId = store.recordIncident({
+        error,
+        symbols,
+        environment,
+        service,
+        version,
+        flowPosition
+      });
+      const incident = store.getIncident(incidentId);
+      const matches = incident ? matcher.match(incident, { maxResults: 3 }) : [];
+      return JSON.stringify(
+        {
+          success: true,
+          incidentId,
+          matches: matches.map((m) => ({
+            patternId: m.pattern.id,
+            confidence: m.confidence,
+            resolution: m.pattern.resolution.description
+          }))
+        },
+        null,
+        2
+      );
+    }
+    case "sentinel_stats": {
+      const { period = "7d", symbol } = args;
+      const calculator = new StatsCalculator(store);
+      if (symbol) {
+        const health = calculator.getSymbolHealth(symbol);
+        return JSON.stringify({ symbol, health }, null, 2);
+      }
+      const match = period.match(/^(\d+)d$/);
+      const periodDays = match ? parseInt(match[1], 10) : 7;
+      const stats = calculator.getStats(periodDays);
+      return JSON.stringify({ period: `${periodDays}d`, stats }, null, 2);
+    }
+    case "sentinel_suggest_pattern": {
+      const { incidentId, minOccurrences } = args;
+      const suggester = new PatternSuggester(store);
+      if (incidentId) {
+        const incident = store.getIncident(incidentId);
+        if (!incident) {
+          return JSON.stringify({ error: `Incident ${incidentId} not found` });
+        }
+        const suggestion = suggester.suggestFromIncident(incident);
+        return JSON.stringify({ source: "incident", incidentId, suggestion }, null, 2);
+      }
+      const candidates = suggester.findPatternCandidates(minOccurrences || 3);
+      return JSON.stringify(
+        {
+          source: "analysis",
+          candidates: candidates.slice(0, 5).map((c) => ({
+            occurrences: c.occurrenceCount,
+            sampleIncidents: c.incidents.slice(0, 3).map((i) => i.id),
+            suggestion: c.suggestedPattern
+          }))
+        },
+        null,
+        2
+      );
+    }
+    default:
+      return JSON.stringify({ error: `Unknown tool: ${name}` });
+  }
+}
+async function main() {
+  console.error("[sentinel-mcp] Starting...");
+  const store = getStorage();
+  await store.ensureReady();
+  console.error("[sentinel-mcp] Storage initialized");
+  const server = new Server(
+    { name: "sentinel", version: "0.2.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: getToolsList()
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      const text = await handleTool(name, args || {});
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+        isError: true
+      };
+    }
+  });
+  server.onerror = (error) => {
+    console.error("[sentinel-mcp] Server error:", error);
+  };
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[sentinel-mcp] Running on stdio");
+}
+main().catch((err) => {
+  console.error("[sentinel-mcp] Fatal:", err);
+  process.exit(1);
+});