@a-company/sentinel 0.2.0

package/dist/commands-KIMGFR2I.js

@@ -0,0 +1,3278 @@
+#!/usr/bin/env node
+
+// src/cli/commands.ts
+import chalk5 from "chalk";
+
+// 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(storage) {
+    this.storage = storage;
+  }
+  /**
+   * 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/stats.ts
+var StatsCalculator = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * 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/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/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/server/index.ts
+import express from "express";
+import * as path5 from "path";
+import * as fs4 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk3 from "chalk";
+
+// src/server/routes/symbols.ts
+import { Router } from "express";
+import chalk2 from "chalk";
+
+// src/server/loaders/symbols.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import chalk from "chalk";
+var LOG_LEVEL = process.env.SENTINEL_LOG_LEVEL || process.env.LOG_LEVEL || "info";
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[LOG_LEVEL];
+}
+function formatData(data) {
+  if (!data) return "";
+  const entries = Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+  return chalk.gray(` ${entries}`);
+}
+var log = {
+  component(name) {
+    const symbol = chalk.magenta(`#${name}`);
+    return {
+      debug: (msg, data) => {
+        if (shouldLog("debug")) console.log(`${chalk.gray("\u25CB")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      info: (msg, data) => {
+        if (shouldLog("info")) console.log(`${chalk.blue("\u2139")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      warn: (msg, data) => {
+        if (shouldLog("warn")) console.log(`${chalk.yellow("\u26A0")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      error: (msg, data) => {
+        if (shouldLog("error")) console.error(`${chalk.red("\u2716")} ${symbol} ${msg}${formatData(data)}`);
+      }
+    };
+  },
+  flow(name) {
+    const symbol = chalk.yellow(`$${name}`);
+    return {
+      debug: (msg, data) => {
+        if (shouldLog("debug")) console.log(`${chalk.gray("\u25CB")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      info: (msg, data) => {
+        if (shouldLog("info")) console.log(`${chalk.blue("\u2139")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      warn: (msg, data) => {
+        if (shouldLog("warn")) console.log(`${chalk.yellow("\u26A0")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      error: (msg, data) => {
+        if (shouldLog("error")) console.error(`${chalk.red("\u2716")} ${symbol} ${msg}${formatData(data)}`);
+      }
+    };
+  }
+};
+var SYMBOL_BLOCKLIST = /* @__PURE__ */ new Set([
+  "$lib",
+  "$env",
+  "$app",
+  "$service-worker",
+  "$virtual",
+  "$schema",
+  "$ref",
+  "$id",
+  "$type"
+]);
+async function loadParadigmConfig(projectDir) {
+  const configPath = path3.join(projectDir, ".paradigm", "config.yaml");
+  if (!fs3.existsSync(configPath)) {
+    const packagePath = path3.join(projectDir, "package.json");
+    if (fs3.existsSync(packagePath)) {
+      try {
+        const pkg = JSON.parse(fs3.readFileSync(packagePath, "utf-8"));
+        return { name: pkg.name };
+      } catch {
+      }
+    }
+    return {};
+  }
+  try {
+    const content = fs3.readFileSync(configPath, "utf-8");
+    const config = {};
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    if (nameMatch) config.name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+    const disciplineMatch = content.match(/^discipline:\s*(.+)$/m);
+    if (disciplineMatch) config.discipline = disciplineMatch[1].trim();
+    const versionMatch = content.match(/^version:\s*(.+)$/m);
+    if (versionMatch) config.version = versionMatch[1].trim();
+    return config;
+  } catch (error) {
+    log.component("config-loader").error("Failed to load Paradigm config", { error: String(error) });
+    return {};
+  }
+}
+async function loadWithPremiseCore(projectDir) {
+  try {
+    const { aggregateFromDirectory } = await import("./dist-BPWLYV4U.js");
+    log.flow("load-symbols").info("Using premise-core aggregator", { path: projectDir });
+    const result = await aggregateFromDirectory(projectDir);
+    const counts = {};
+    for (const sym of result.symbols) {
+      counts[sym.type] = (counts[sym.type] || 0) + 1;
+    }
+    log.flow("load-symbols").info("Aggregation complete", {
+      total: result.symbols.length,
+      ...counts,
+      purposeFiles: result.purposeFiles.length,
+      portalFiles: result.portalFiles.length
+    });
+    if (result.errors.length > 0) {
+      for (const err of result.errors) {
+        log.component("aggregator").warn("Aggregation error", {
+          source: err.source,
+          file: err.filePath,
+          message: err.message
+        });
+      }
+    }
+    for (const file of result.purposeFiles) {
+      log.component("purpose-loader").info("Loaded .purpose file", { file: path3.relative(projectDir, file) });
+    }
+    for (const file of result.portalFiles) {
+      log.component("gate-loader").info("Loaded portal.yaml", { file: path3.relative(projectDir, file) });
+    }
+    return result.symbols;
+  } catch (error) {
+    log.component("premise-core").warn("premise-core not available, using fallback scanner", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function loadSymbolIndex(projectDir) {
+  log.flow("load-symbols").info("Loading symbols", { projectDir });
+  const indexPath = path3.join(projectDir, ".paradigm", "index.json");
+  if (fs3.existsSync(indexPath)) {
+    try {
+      log.component("index-loader").info("Found cached index", { path: indexPath });
+      const content = fs3.readFileSync(indexPath, "utf-8");
+      const index = JSON.parse(content);
+      const entries = Array.isArray(index.entries) ? index.entries : Array.isArray(index) ? index : null;
+      if (entries) {
+        log.flow("load-symbols").info("Loaded from cached index", { count: entries.length });
+        return entries;
+      }
+    } catch (error) {
+      log.component("index-loader").error("Failed to load cached index", { error: String(error) });
+    }
+  }
+  const premiseResult = await loadWithPremiseCore(projectDir);
+  if (premiseResult) {
+    return premiseResult;
+  }
+  log.flow("load-symbols").info("Using fallback scanner");
+  return scanPurposeFiles(projectDir);
+}
+async function scanPurposeFiles(projectDir) {
+  const symbols = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const scanDirs = ["src", "lib", "packages", "apps", "."];
+  for (const dir of scanDirs) {
+    const fullPath = path3.join(projectDir, dir);
+    if (fs3.existsSync(fullPath)) {
+      await scanDirectory(fullPath, symbols, seenIds, projectDir);
+    }
+  }
+  const portalPath = path3.join(projectDir, "portal.yaml");
+  if (fs3.existsSync(portalPath)) {
+    log.component("gate-loader").debug("Found portal.yaml", { path: "portal.yaml" });
+    try {
+      const content = fs3.readFileSync(portalPath, "utf-8");
+      const gatesSection = content.match(/^gates:\s*\n((?:  .+\n)*)/m);
+      if (gatesSection) {
+        const gateMatches = gatesSection[1].matchAll(/^  ([a-z][a-z0-9-]*):/gm);
+        for (const match of gateMatches) {
+          const gateName = match[1];
+          const id = `gate-${gateName}`;
+          if (!seenIds.has(id)) {
+            seenIds.add(id);
+            symbols.push({
+              id,
+              symbol: `^${gateName}`,
+              type: "gate",
+              source: "portal",
+              filePath: "portal.yaml",
+              data: {},
+              references: [],
+              referencedBy: []
+            });
+            log.component("gate-loader").debug("Extracted gate", { symbol: `^${gateName}` });
+          }
+        }
+      }
+    } catch (error) {
+      log.component("gate-loader").error("Failed to parse portal.yaml", { error: String(error) });
+    }
+  }
+  log.flow("load-symbols").info("Fallback scan complete", { count: symbols.length });
+  return symbols;
+}
+async function scanDirectory(dir, symbols, seenIds, projectDir) {
+  const skipDirs = ["node_modules", ".git", "dist", "build", ".paradigm", "coverage", ".next", ".svelte-kit"];
+  let entries;
+  try {
+    entries = fs3.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!skipDirs.includes(entry.name)) {
+        await scanDirectory(fullPath, symbols, seenIds, projectDir);
+      }
+    } else if (entry.name === ".purpose") {
+      const relativePath = path3.relative(projectDir, fullPath);
+      log.component("purpose-loader").debug("Scanning .purpose file", { path: relativePath });
+      try {
+        const content = fs3.readFileSync(fullPath, "utf-8");
+        const parsed = parsePurposeFile(content, fullPath, projectDir);
+        for (const symbol of parsed) {
+          if (!seenIds.has(symbol.id)) {
+            seenIds.add(symbol.id);
+            symbols.push(symbol);
+            log.component("purpose-loader").debug("Extracted symbol", {
+              symbol: symbol.symbol,
+              type: symbol.type,
+              file: relativePath
+            });
+          }
+        }
+      } catch (error) {
+        log.component("purpose-loader").error("Failed to parse .purpose file", {
+          path: relativePath,
+          error: String(error)
+        });
+      }
+    }
+  }
+}
+function parsePurposeFile(content, filePath, projectDir) {
+  const symbols = [];
+  const relativePath = path3.relative(projectDir, filePath);
+  const componentMatches = content.matchAll(/(?:^|\s)#([a-z][a-z0-9-]*)/gm);
+  for (const match of componentMatches) {
+    const name = match[1];
+    symbols.push({
+      id: `component-${name}`,
+      symbol: `#${name}`,
+      type: "component",
+      source: "purpose",
+      filePath: relativePath,
+      data: {},
+      description: extractDescription(content, `#${name}`),
+      references: extractReferences(content),
+      referencedBy: [],
+      tags: extractTags(content)
+    });
+  }
+  const flowMatches = content.matchAll(/\$([a-z][a-z0-9-]*)/gm);
+  for (const match of flowMatches) {
+    const name = match[1];
+    const symbol = `$${name}`;
+    if (SYMBOL_BLOCKLIST.has(symbol)) {
+      log.component("purpose-loader").debug("Skipping blocklisted symbol", { symbol });
+      continue;
+    }
+    if (!symbols.find((s) => s.symbol === symbol)) {
+      symbols.push({
+        id: `flow-${name}`,
+        symbol,
+        type: "flow",
+        source: "purpose",
+        filePath: relativePath,
+        data: {},
+        references: [],
+        referencedBy: []
+      });
+    }
+  }
+  const signalMatches = content.matchAll(/!([a-z][a-z0-9-]*)/gm);
+  for (const match of signalMatches) {
+    const name = match[1];
+    if (!symbols.find((s) => s.symbol === `!${name}`)) {
+      symbols.push({
+        id: `signal-${name}`,
+        symbol: `!${name}`,
+        type: "signal",
+        source: "purpose",
+        filePath: relativePath,
+        data: {},
+        references: [],
+        referencedBy: []
+      });
+    }
+  }
+  const gateMatches = content.matchAll(/\^([a-z][a-z0-9-]*)/gm);
+  for (const match of gateMatches) {
+    const name = match[1];
+    if (!symbols.find((s) => s.symbol === `^${name}`)) {
+      symbols.push({
+        id: `gate-${name}`,
+        symbol: `^${name}`,
+        type: "gate",
+        source: "purpose",
+        filePath: relativePath,
+        data: {},
+        references: [],
+        referencedBy: []
+      });
+    }
+  }
+  const aspectMatches = content.matchAll(/~([a-z][a-z0-9-]*)/gm);
+  for (const match of aspectMatches) {
+    const name = match[1];
+    if (!symbols.find((s) => s.symbol === `~${name}`)) {
+      symbols.push({
+        id: `aspect-${name}`,
+        symbol: `~${name}`,
+        type: "aspect",
+        source: "purpose",
+        filePath: relativePath,
+        data: {},
+        references: [],
+        referencedBy: []
+      });
+    }
+  }
+  return symbols;
+}
+function extractDescription(content, symbol) {
+  const regex = new RegExp(`${symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*[-:]?\\s*(.+)`, "m");
+  const match = content.match(regex);
+  if (match && match[1]) {
+    return match[1].trim();
+  }
+  return void 0;
+}
+function extractReferences(content) {
+  const refs = /* @__PURE__ */ new Set();
+  const refMatches = content.matchAll(/[@#$!^~]([a-z][a-z0-9-]*)/g);
+  for (const match of refMatches) {
+    const symbol = match[0];
+    if (!SYMBOL_BLOCKLIST.has(symbol)) {
+      refs.add(symbol);
+    }
+  }
+  return Array.from(refs);
+}
+function extractTags(content) {
+  const tagMatch = content.match(/tags:\s*\[([^\]]+)\]/);
+  if (tagMatch) {
+    return tagMatch[1].split(",").map((t) => t.trim().replace(/^["']|["']$/g, ""));
+  }
+  return [];
+}
+async function getSymbolCount(projectDir) {
+  const symbols = await loadSymbolIndex(projectDir);
+  return symbols.length;
+}
+async function updateSymbol(projectDir, symbolId, updates) {
+  const symbols = await loadSymbolIndex(projectDir);
+  const symbol = symbols.find((s) => s.id === symbolId);
+  if (!symbol) {
+    return { success: false, error: "Symbol not found" };
+  }
+  const filePath = path3.join(projectDir, symbol.filePath);
+  if (!fs3.existsSync(filePath)) {
+    return { success: false, error: "Source file not found" };
+  }
+  try {
+    let content = fs3.readFileSync(filePath, "utf-8");
+    let modified = false;
+    if (updates.description !== void 0) {
+      const symbolPattern = symbol.symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const descRegex = new RegExp(`(${symbolPattern})\\s*[-:]?\\s*(.*)`, "m");
+      const match = content.match(descRegex);
+      if (match) {
+        const newLine = updates.description ? `${symbol.symbol}: ${updates.description}` : symbol.symbol;
+        content = content.replace(descRegex, newLine);
+        modified = true;
+      }
+    }
+    if (updates.tags !== void 0) {
+      const tagsStr = updates.tags.length > 0 ? `tags: [${updates.tags.map((t) => `"${t}"`).join(", ")}]` : "";
+      const tagsRegex = /^tags:\s*\[[^\]]*\]\s*$/m;
+      if (tagsRegex.test(content)) {
+        if (tagsStr) {
+          content = content.replace(tagsRegex, tagsStr);
+        } else {
+          content = content.replace(tagsRegex, "");
+        }
+        modified = true;
+      } else if (tagsStr) {
+        const symbolPattern = symbol.symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const symbolLineRegex = new RegExp(`(${symbolPattern}[^\\n]*\\n)`, "m");
+        const symbolMatch = content.match(symbolLineRegex);
+        if (symbolMatch) {
+          content = content.replace(symbolLineRegex, `$1${tagsStr}
+`);
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      content = content.replace(/\n{3,}/g, "\n\n");
+      fs3.writeFileSync(filePath, content, "utf-8");
+      log.component("symbol-updater").info("Updated symbol", { symbol: symbol.symbol, file: symbol.filePath });
+      const indexPath = path3.join(projectDir, ".paradigm", "index.json");
+      if (fs3.existsSync(indexPath)) {
+        try {
+          const indexContent = fs3.readFileSync(indexPath, "utf-8");
+          const index = JSON.parse(indexContent);
+          const entries = Array.isArray(index.entries) ? index.entries : index;
+          const entryIndex = entries.findIndex((e) => e.id === symbolId);
+          if (entryIndex >= 0) {
+            if (updates.description !== void 0) {
+              entries[entryIndex].description = updates.description;
+            }
+            if (updates.tags !== void 0) {
+              entries[entryIndex].tags = updates.tags;
+            }
+            if (Array.isArray(index.entries)) {
+              index.entries = entries;
+              fs3.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
+            } else {
+              fs3.writeFileSync(indexPath, JSON.stringify(entries, null, 2), "utf-8");
+            }
+          }
+        } catch {
+        }
+      }
+      return { success: true };
+    }
+    return { success: true };
+  } catch (error) {
+    log.component("symbol-updater").error("Failed to update symbol", { error: String(error) });
+    return { success: false, error: "Failed to write file" };
+  }
+}
+
+// src/server/routes/symbols.ts
+var LOG_LEVEL2 = process.env.SENTINEL_LOG_LEVEL || process.env.LOG_LEVEL || "info";
+var shouldLog2 = (level) => {
+  const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+  return levels[level] >= levels[LOG_LEVEL2];
+};
+var log2 = {
+  gate(name) {
+    const symbol = chalk2.cyan(`^${name}`);
+    return {
+      info: (msg, data) => {
+        if (shouldLog2("info")) {
+          const dataStr = data ? chalk2.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+          console.log(`${chalk2.blue("\u2139")} ${symbol} ${msg}${dataStr}`);
+        }
+      },
+      error: (msg, data) => {
+        if (shouldLog2("error")) {
+          const dataStr = data ? chalk2.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+          console.error(`${chalk2.red("\u2716")} ${symbol} ${msg}${dataStr}`);
+        }
+      }
+    };
+  }
+};
+function createSymbolsRouter(projectDir) {
+  const router = Router();
+  router.get("/", async (_req, res) => {
+    try {
+      const symbols = await loadSymbolIndex(projectDir);
+      log2.gate("api-symbols").info("Symbols loaded", { count: symbols.length });
+      res.json({ symbols });
+    } catch (error) {
+      log2.gate("api-symbols").error("Failed to load symbols", { error: String(error) });
+      res.status(500).json({ error: "Failed to load symbols" });
+    }
+  });
+  router.put("/:id", async (req, res) => {
+    try {
+      const { id } = req.params;
+      const updates = req.body;
+      log2.gate("api-symbols").info("Update requested", { id, updates: JSON.stringify(updates) });
+      if (updates.tags && !Array.isArray(updates.tags)) {
+        res.status(400).json({ error: "Tags must be an array" });
+        return;
+      }
+      const result = await updateSymbol(projectDir, id, updates);
+      if (result.success) {
+        const symbols = await loadSymbolIndex(projectDir);
+        const updatedSymbol = symbols.find((s) => s.id === id);
+        log2.gate("api-symbols").info("Symbol updated", { id });
+        res.json({ success: true, symbol: updatedSymbol });
+      } else {
+        log2.gate("api-symbols").error("Update failed", { id, error: result.error });
+        res.status(400).json({ success: false, error: result.error });
+      }
+    } catch (error) {
+      log2.gate("api-symbols").error("Failed to update symbol", { error: String(error) });
+      res.status(500).json({ error: "Failed to update symbol" });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/info.ts
+import { Router as Router2 } from "express";
+function createInfoRouter(projectDir) {
+  const router = Router2();
+  router.get("/", async (_req, res) => {
+    try {
+      const config = await loadParadigmConfig(projectDir);
+      const symbolCount = await getSymbolCount(projectDir);
+      res.json({
+        projectName: config.name || null,
+        discipline: config.discipline || null,
+        symbolCount,
+        projectDir
+      });
+    } catch (error) {
+      console.error("Failed to load project info:", error);
+      res.status(500).json({ error: "Failed to load project info" });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/commits.ts
+import { Router as Router3 } from "express";
+
+// src/server/loaders/git.ts
+import simpleGit from "simple-git";
+import * as path4 from "path";
+function extractSymbolsFromFiles(files) {
+  const symbols = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (file.endsWith(".purpose")) {
+      const dir = path4.dirname(file);
+      const name = path4.basename(dir);
+      if (dir.includes("features/") || dir.includes("routes/") || dir.includes("api/")) {
+        symbols.add(`@${name}`);
+      } else if (dir.includes("components/") || dir.includes("lib/") || dir.includes("utils/")) {
+        symbols.add(`#${name}`);
+      } else if (dir.includes("middleware/") || dir.includes("auth/") || dir.includes("guards/")) {
+        symbols.add(`^${name}`);
+      } else if (dir.includes("flows/") || dir.includes("workflows/")) {
+        symbols.add(`$${name}`);
+      }
+    }
+    if (file.includes("portal.yaml")) {
+      symbols.add("^portal");
+    }
+    const featureMatch = file.match(/features\/([^/]+)/);
+    if (featureMatch) {
+      symbols.add(`@${featureMatch[1]}`);
+    }
+    const componentMatch = file.match(/components\/([^/]+)/);
+    if (componentMatch) {
+      symbols.add(`#${componentMatch[1]}`);
+    }
+  }
+  return Array.from(symbols);
+}
+async function loadGitHistory(projectDir, options = {}) {
+  const git = simpleGit(projectDir);
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    return [];
+  }
+  try {
+    const logOptions = {
+      maxCount: options.limit || 100
+    };
+    if (options.since) {
+      logOptions["--since"] = options.since;
+    }
+    const log4 = await git.log(logOptions);
+    const commits = [];
+    for (const commit of log4.all) {
+      let filesChanged = [];
+      let symbolsModified = [];
+      try {
+        const diff = await git.diffSummary([`${commit.hash}^`, commit.hash]);
+        filesChanged = diff.files.map((f) => f.file);
+        symbolsModified = extractSymbolsFromFiles(filesChanged);
+      } catch {
+      }
+      commits.push({
+        hash: commit.hash,
+        shortHash: commit.hash.slice(0, 7),
+        date: commit.date,
+        author: commit.author_name,
+        message: commit.message.split("\n")[0],
+        // First line only
+        symbolsModified,
+        filesChanged
+      });
+    }
+    return commits;
+  } catch (error) {
+    console.error("Failed to load git history:", error);
+    return [];
+  }
+}
+
+// src/server/routes/commits.ts
+function createCommitsRouter(projectDir) {
+  const router = Router3();
+  router.get("/", async (req, res) => {
+    try {
+      const limit = parseInt(req.query.limit) || 100;
+      const since = req.query.since;
+      const commits = await loadGitHistory(projectDir, { limit, since });
+      res.json({ commits });
+    } catch (error) {
+      console.error("Failed to load commits:", error);
+      res.status(500).json({ error: "Failed to load commits" });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/incidents.ts
+import { Router as Router4 } from "express";
+function createIncidentsRouter(_projectDir) {
+  const router = Router4();
+  const storage = new SentinelStorage();
+  router.get("/", async (req, res) => {
+    try {
+      const limit = parseInt(req.query.limit) || 50;
+      const status = req.query.status;
+      const environment = req.query.environment;
+      const symbol = req.query.symbol;
+      const options = { limit };
+      if (status && ["open", "investigating", "resolved", "wont-fix"].includes(status)) {
+        options.status = status;
+      }
+      if (environment) options.environment = environment;
+      if (symbol) options.symbol = symbol;
+      const incidents = storage.getRecentIncidents(options);
+      const summaries = incidents.map((incident) => ({
+        id: incident.id,
+        timestamp: incident.timestamp,
+        status: incident.status,
+        error: {
+          message: incident.error.message,
+          type: incident.error.type
+        },
+        symbols: incident.symbols,
+        environment: incident.environment,
+        patternMatches: []
+        // Would need PatternMatcher to populate
+      }));
+      res.json({ incidents: summaries });
+    } catch (error) {
+      console.error("Failed to load incidents:", error);
+      res.status(500).json({ error: "Failed to load incidents" });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const incident = storage.getIncident(req.params.id);
+      if (!incident) {
+        res.status(404).json({ error: "Incident not found" });
+        return;
+      }
+      res.json({ incident });
+    } catch (error) {
+      console.error("Failed to load incident:", error);
+      res.status(500).json({ error: "Failed to load incident" });
+    }
+  });
+  router.post("/:id/resolve", async (req, res) => {
+    try {
+      const incident = storage.getIncident(req.params.id);
+      if (!incident) {
+        res.status(404).json({ error: "Incident not found" });
+        return;
+      }
+      storage.resolveIncident(req.params.id, {
+        notes: req.body.notes,
+        patternId: req.body.patternId
+      });
+      res.json({ success: true });
+    } catch (error) {
+      console.error("Failed to resolve incident:", error);
+      res.status(500).json({ error: "Failed to resolve incident" });
+    }
+  });
+  return router;
+}
+
+// src/server/routes/patterns.ts
+import { Router as Router5 } from "express";
+function createPatternsRouter(_projectDir) {
+  const router = Router5();
+  const storage = new SentinelStorage();
+  router.get("/", async (req, res) => {
+    try {
+      const source = req.query.source;
+      const symbol = req.query.symbol;
+      const minConfidence = parseInt(req.query.minConfidence) || void 0;
+      const options = {};
+      if (source && ["manual", "suggested", "imported", "community"].includes(source)) {
+        options.source = source;
+      }
+      if (symbol) options.symbol = symbol;
+      if (minConfidence) options.minConfidence = minConfidence;
+      const patterns = storage.getAllPatterns(options);
+      const summaries = patterns.map((pattern) => ({
+        id: pattern.id,
+        name: pattern.name,
+        description: pattern.description,
+        confidence: {
+          score: pattern.confidence.score,
+          timesMatched: pattern.confidence.timesMatched,
+          timesResolved: pattern.confidence.timesResolved
+        },
+        tags: pattern.tags
+      }));
+      res.json({ patterns: summaries });
+    } catch (error) {
+      console.error("Failed to load patterns:", error);
+      res.status(500).json({ error: "Failed to load patterns" });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const pattern = storage.getPattern(req.params.id);
+      if (!pattern) {
+        res.status(404).json({ error: "Pattern not found" });
+        return;
+      }
+      res.json({ pattern });
+    } catch (error) {
+      console.error("Failed to load pattern:", error);
+      res.status(500).json({ error: "Failed to load pattern" });
+    }
+  });
+  return router;
+}
+
+// src/server/index.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
+var log3 = {
+  component(name) {
+    const symbol = chalk3.magenta(`#${name}`);
+    return {
+      info: (msg, data) => {
+        const dataStr = data ? chalk3.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk3.blue("\u2139")} ${symbol} ${msg}${dataStr}`);
+      },
+      success: (msg, data) => {
+        const dataStr = data ? chalk3.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk3.green("\u2714")} ${symbol} ${msg}${dataStr}`);
+      },
+      warn: (msg, data) => {
+        const dataStr = data ? chalk3.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk3.yellow("\u26A0")} ${symbol} ${msg}${dataStr}`);
+      },
+      error: (msg, data) => {
+        const dataStr = data ? chalk3.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.error(`${chalk3.red("\u2716")} ${symbol} ${msg}${dataStr}`);
+      }
+    };
+  }
+};
+function createApp(options) {
+  const app = express();
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    next();
+  });
+  app.use("/api/symbols", createSymbolsRouter(options.projectDir));
+  app.use("/api/info", createInfoRouter(options.projectDir));
+  app.use("/api/commits", createCommitsRouter(options.projectDir));
+  app.use("/api/incidents", createIncidentsRouter(options.projectDir));
+  app.use("/api/patterns", createPatternsRouter(options.projectDir));
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  const uiDistPath = path5.join(__dirname2, "..", "..", "ui", "dist");
+  if (fs4.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+    app.get("{*path}", (req, res) => {
+      if (!req.path.startsWith("/api")) {
+        res.sendFile(path5.join(uiDistPath, "index.html"));
+      }
+    });
+  }
+  return app;
+}
+async function startServer(options) {
+  const app = createApp(options);
+  log3.component("sentinel-server").info("Starting server", { port: options.port });
+  log3.component("sentinel-server").info("Project directory", { path: options.projectDir });
+  return new Promise((resolve, reject) => {
+    const server = app.listen(options.port, () => {
+      log3.component("sentinel-server").success("Server running", { url: `http://localhost:${options.port}` });
+      if (options.open) {
+        import("open").then((openModule) => {
+          openModule.default(`http://localhost:${options.port}`);
+          log3.component("sentinel-server").info("Opened browser");
+        }).catch(() => {
+          log3.component("sentinel-server").warn("Could not open browser automatically");
+        });
+      }
+      resolve();
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        log3.component("sentinel-server").error("Port already in use", { port: options.port });
+      } else {
+        log3.component("sentinel-server").error("Server error", { error: err.message });
+      }
+      reject(err);
+    });
+  });
+}
+
+// src/config.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+function writeConfig(projectDir, config) {
+  const filePath = path6.join(projectDir, ".sentinel.yaml");
+  const content = serializeSimpleYaml(config);
+  fs5.writeFileSync(filePath, content, "utf-8");
+}
+function serializeSimpleYaml(config) {
+  const lines = [];
+  lines.push(`# Sentinel Configuration`);
+  lines.push(`# Auto-generated \u2014 edit freely`);
+  lines.push("");
+  lines.push(`version: "${config.version}"`);
+  lines.push(`project: "${config.project}"`);
+  if (config.environment) {
+    lines.push(`environment: "${config.environment}"`);
+  }
+  if (config.symbols) {
+    lines.push("");
+    lines.push("symbols:");
+    for (const [key, values] of Object.entries(config.symbols)) {
+      if (values && values.length > 0) {
+        lines.push(`  ${key}:`);
+        for (const v of values) {
+          lines.push(`    - ${v}`);
+        }
+      }
+    }
+  }
+  if (config.routes && Object.keys(config.routes).length > 0) {
+    lines.push("");
+    lines.push("routes:");
+    for (const [route, symbol] of Object.entries(config.routes)) {
+      lines.push(`  "${route}": ${symbol}`);
+    }
+  }
+  if (config.scrub) {
+    lines.push("");
+    lines.push("scrub:");
+    if (config.scrub.headers?.length) {
+      lines.push("  headers:");
+      for (const h of config.scrub.headers) {
+        lines.push(`    - ${h}`);
+      }
+    }
+    if (config.scrub.fields?.length) {
+      lines.push("  fields:");
+      for (const f of config.scrub.fields) {
+        lines.push(`    - ${f}`);
+      }
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/detector.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+var DIR_PATTERNS = [
+  { dirs: ["services", "src/services"], prefix: "#", type: "components" },
+  { dirs: ["routes", "src/routes", "api", "src/api"], prefix: "#", type: "components" },
+  { dirs: ["handlers", "src/handlers"], prefix: "#", type: "components" },
+  { dirs: ["controllers", "src/controllers"], prefix: "#", type: "components" },
+  { dirs: ["components", "src/components"], prefix: "#", type: "components" },
+  { dirs: ["lib", "src/lib"], prefix: "#", type: "components" },
+  { dirs: ["middleware", "src/middleware"], prefix: "^", type: "gates" },
+  { dirs: ["guards", "src/guards"], prefix: "^", type: "gates" },
+  { dirs: ["auth", "src/auth"], prefix: "^", type: "gates" },
+  { dirs: ["events", "src/events"], prefix: "!", type: "signals" },
+  { dirs: ["listeners", "src/listeners"], prefix: "!", type: "signals" },
+  { dirs: ["flows", "src/flows"], prefix: "$", type: "flows" },
+  { dirs: ["workflows", "src/workflows"], prefix: "$", type: "flows" },
+  { dirs: ["pipelines", "src/pipelines"], prefix: "$", type: "flows" }
+];
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".tsx", ".jsx", ".mjs", ".mts"]);
+function detectSymbols(projectDir) {
+  const result = {
+    components: [],
+    gates: [],
+    flows: [],
+    signals: [],
+    routes: {}
+  };
+  const purposeSymbols = readPurposeFiles(projectDir);
+  if (purposeSymbols) {
+    result.components.push(...purposeSymbols.components);
+    result.gates.push(...purposeSymbols.gates);
+    result.flows.push(...purposeSymbols.flows);
+    result.signals.push(...purposeSymbols.signals);
+  }
+  for (const pattern of DIR_PATTERNS) {
+    for (const dir of pattern.dirs) {
+      const fullPath = path7.join(projectDir, dir);
+      if (!fs6.existsSync(fullPath)) continue;
+      const files = safeReaddir(fullPath);
+      for (const file of files) {
+        const ext = path7.extname(file);
+        if (!CODE_EXTENSIONS.has(ext)) continue;
+        const name = path7.basename(file, ext);
+        if (name === "index" || name.endsWith(".test") || name.endsWith(".spec")) continue;
+        const symbol = `${pattern.prefix}${toKebabCase(name)}`;
+        if (!result[pattern.type].includes(symbol)) {
+          result[pattern.type].push(symbol);
+        }
+      }
+    }
+  }
+  scanRoutes(projectDir, result);
+  return result;
+}
+function generateConfig(projectDir) {
+  const detected = detectSymbols(projectDir);
+  return {
+    version: "1.0",
+    project: path7.basename(projectDir),
+    symbols: {
+      components: detected.components.length > 0 ? detected.components : void 0,
+      gates: detected.gates.length > 0 ? detected.gates : void 0,
+      flows: detected.flows.length > 0 ? detected.flows : void 0,
+      signals: detected.signals.length > 0 ? detected.signals : void 0
+    },
+    routes: Object.keys(detected.routes).length > 0 ? detected.routes : void 0
+  };
+}
+function readPurposeFiles(projectDir) {
+  const paradigmDir = path7.join(projectDir, ".paradigm");
+  if (!fs6.existsSync(paradigmDir)) return null;
+  const result = {
+    components: [],
+    gates: [],
+    flows: [],
+    signals: [],
+    routes: {}
+  };
+  const purposeFiles = findFiles(projectDir, ".purpose");
+  for (const file of purposeFiles) {
+    try {
+      const content = fs6.readFileSync(file, "utf-8");
+      extractPurposeSymbols(content, result);
+    } catch {
+    }
+  }
+  const hasAny = result.components.length > 0 || result.gates.length > 0 || result.flows.length > 0 || result.signals.length > 0;
+  return hasAny ? result : null;
+}
+function extractPurposeSymbols(content, result) {
+  const lines = content.split("\n");
+  let currentSection = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "components:" || trimmed === "features:") {
+      currentSection = "components";
+      continue;
+    }
+    if (trimmed === "gates:") {
+      currentSection = "gates";
+      continue;
+    }
+    if (trimmed === "flows:") {
+      currentSection = "flows";
+      continue;
+    }
+    if (trimmed === "signals:") {
+      currentSection = "signals";
+      continue;
+    }
+    if (currentSection && /^\s{2}\S/.test(line)) {
+      const idMatch = trimmed.match(/^([a-zA-Z][\w-]*):$/);
+      if (idMatch) {
+        const prefixes = {
+          components: "#",
+          gates: "^",
+          flows: "$",
+          signals: "!"
+        };
+        const prefix = prefixes[currentSection] || "#";
+        const symbol = `${prefix}${idMatch[1]}`;
+        if (!result[currentSection]?.includes(symbol)) {
+          result[currentSection]?.push(symbol);
+        }
+      }
+    }
+    if (trimmed && !line.startsWith(" ") && !trimmed.endsWith(":")) {
+      currentSection = "";
+    }
+  }
+}
+function scanRoutes(projectDir, result) {
+  const routeDirs = ["routes", "src/routes", "api", "src/api"];
+  for (const dir of routeDirs) {
+    const fullPath = path7.join(projectDir, dir);
+    if (!fs6.existsSync(fullPath)) continue;
+    const files = safeReaddir(fullPath);
+    for (const file of files) {
+      const ext = path7.extname(file);
+      if (!CODE_EXTENSIONS.has(ext)) continue;
+      const name = path7.basename(file, ext);
+      if (name === "index") continue;
+      const routePrefix = `/api/${toKebabCase(name)}`;
+      const component = `#${toKebabCase(name)}`;
+      result.routes[routePrefix] = component;
+    }
+  }
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").replace(/\..*$/, "").toLowerCase();
+}
+function safeReaddir(dir) {
+  try {
+    return fs6.readdirSync(dir).filter((f) => {
+      const fullPath = path7.join(dir, f);
+      try {
+        return fs6.statSync(fullPath).isFile();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function findFiles(dir, filename, maxDepth = 4, depth = 0) {
+  if (depth > maxDepth) return [];
+  const results = [];
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".next", ".nuxt"]);
+  try {
+    const entries = fs6.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === filename) {
+        results.push(path7.join(dir, entry.name));
+      } else if (entry.isDirectory() && !skipDirs.has(entry.name)) {
+        results.push(...findFiles(path7.join(dir, entry.name), filename, maxDepth, depth + 1));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+
+// src/cli/format.ts
+import chalk4 from "chalk";
+function formatHeader() {
+  return `
+${chalk4.cyan("\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\u2550\u2550\u2557")}
+${chalk4.cyan("\u2551")}                       ${chalk4.bold.white("SENTINEL TRIAGE")}                              ${chalk4.cyan("\u2551")}
+${chalk4.cyan("\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\u2550\u2550\u255D")}
+`;
+}
+function formatSummaryBar(stats) {
+  return `${chalk4.cyan("\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\u2550\u2550\u2557")}
+${chalk4.cyan("\u2551")}  Open: ${chalk4.yellow(String(stats.open).padEnd(4))} \u2502  Investigating: ${chalk4.blue(String(stats.investigating).padEnd(3))} \u2502  Resolved: ${chalk4.green(String(stats.resolved).padEnd(4))} \u2502  Today: ${chalk4.magenta(`+${stats.today}`)}   ${chalk4.cyan("\u2551")}
+${chalk4.cyan("\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\u2550\u2550\u255D")}
+`;
+}
+function formatIncident(incident, matches) {
+  const lines = [];
+  const statusColor = getStatusColor(incident.status);
+  lines.push(
+    chalk4.gray("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510")
+  );
+  lines.push(
+    chalk4.gray("\u2502 ") + chalk4.bold(`[${incident.id}] `) + statusColor(incident.status.toUpperCase().padEnd(12)) + chalk4.gray(incident.timestamp.substring(0, 19).replace("T", " ").padStart(19)) + chalk4.gray(" \u2502")
+  );
+  lines.push(
+    chalk4.gray("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524")
+  );
+  lines.push(chalk4.gray("\u2502 ") + chalk4.red("Error: ") + truncate(incident.error.message, 55) + chalk4.gray(" \u2502"));
+  lines.push(chalk4.gray("\u2502") + " ".repeat(65) + chalk4.gray("\u2502"));
+  lines.push(chalk4.gray("\u2502 ") + chalk4.cyan("Symbolic Context:") + " ".repeat(47) + chalk4.gray("\u2502"));
+  const symbols = formatSymbols(incident.symbols);
+  for (const sym of symbols) {
+    lines.push(chalk4.gray("\u2502   ") + sym.padEnd(61) + chalk4.gray(" \u2502"));
+  }
+  lines.push(chalk4.gray("\u2502") + " ".repeat(65) + chalk4.gray("\u2502"));
+  const envLine = `Environment: ${chalk4.yellow(incident.environment)}  \u2502  Service: ${chalk4.yellow(incident.service || "N/A")}  \u2502  v${incident.version || "N/A"}`;
+  lines.push(chalk4.gray("\u2502 ") + envLine.substring(0, 63).padEnd(63) + chalk4.gray(" \u2502"));
+  if (matches && matches.length > 0) {
+    lines.push(chalk4.gray("\u2502") + " ".repeat(65) + chalk4.gray("\u2502"));
+    lines.push(
+      chalk4.gray("\u2502 \u250C\u2500 ") + chalk4.cyan("Matched Patterns") + chalk4.gray(" \u2500".repeat(22) + "\u2510 \u2502")
+    );
+    for (let i = 0; i < Math.min(matches.length, 3); i++) {
+      const match = matches[i];
+      const icon = i === 0 ? chalk4.yellow("\u2605") : chalk4.gray("\u25CB");
+      const conf = `${match.confidence}% confidence`;
+      lines.push(
+        chalk4.gray("\u2502 \u2502 ") + icon + " " + chalk4.bold(truncate(match.pattern.id, 30).padEnd(30)) + chalk4.gray(conf.padStart(15)) + chalk4.gray("    \u2502 \u2502")
+      );
+      lines.push(
+        chalk4.gray("\u2502 \u2502   ") + chalk4.italic(truncate(match.pattern.description, 45).padEnd(45)) + chalk4.gray("     \u2502 \u2502")
+      );
+      lines.push(
+        chalk4.gray("\u2502 \u2502   Strategy: ") + chalk4.cyan(match.pattern.resolution.strategy.padEnd(40)) + chalk4.gray("     \u2502 \u2502")
+      );
+      if (i < Math.min(matches.length, 3) - 1) {
+        lines.push(chalk4.gray("\u2502 \u2502") + " ".repeat(59) + chalk4.gray("\u2502 \u2502"));
+      }
+    }
+    lines.push(
+      chalk4.gray("\u2502 \u2514") + "\u2500".repeat(59) + chalk4.gray("\u2518 \u2502")
+    );
+  }
+  lines.push(chalk4.gray("\u2502") + " ".repeat(65) + chalk4.gray("\u2502"));
+  lines.push(chalk4.gray("\u2502 ") + chalk4.dim("Actions:") + " ".repeat(56) + chalk4.gray("\u2502"));
+  lines.push(
+    chalk4.gray("\u2502   ") + chalk4.dim(`sentinel triage resolve ${incident.id}`) + " ".repeat(36 - incident.id.length) + chalk4.gray("\u2502")
+  );
+  lines.push(
+    chalk4.gray("\u2502   ") + chalk4.dim(`sentinel triage show ${incident.id} --timeline`) + " ".repeat(29 - incident.id.length) + chalk4.gray("\u2502")
+  );
+  lines.push(
+    chalk4.gray("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")
+  );
+  return lines.join("\n");
+}
+function formatIncidentCompact(incident) {
+  const statusColor = getStatusColor(incident.status);
+  const status = statusColor(incident.status.substring(0, 4).toUpperCase().padEnd(4));
+  const timestamp = incident.timestamp.substring(5, 16).replace("T", " ");
+  const error = truncate(incident.error.message, 40);
+  const symbols = Object.values(incident.symbols).filter(Boolean).join(" ");
+  return `${chalk4.bold(incident.id)} ${status} ${chalk4.gray(timestamp)} ${error}
+    ${chalk4.cyan(truncate(symbols, 60))}`;
+}
+function formatStats(stats) {
+  const lines = [];
+  lines.push(chalk4.bold.cyan("\nIncident Statistics"));
+  lines.push(chalk4.gray("\u2500".repeat(50)));
+  lines.push(`  Total: ${chalk4.white(stats.incidents.total)}`);
+  lines.push(`  Open: ${chalk4.yellow(stats.incidents.open)}`);
+  lines.push(`  Resolved: ${chalk4.green(stats.incidents.resolved)}`);
+  lines.push("");
+  lines.push(chalk4.bold.cyan("By Environment"));
+  for (const [env, count] of Object.entries(stats.incidents.byEnvironment)) {
+    lines.push(`  ${env}: ${count}`);
+  }
+  lines.push("");
+  lines.push(chalk4.bold.cyan("Resolution Stats"));
+  lines.push(chalk4.gray("\u2500".repeat(50)));
+  lines.push(`  Resolution Rate: ${chalk4.green(Math.round(stats.resolution.resolutionRate) + "%")}`);
+  lines.push(`  Resolved with Pattern: ${stats.resolution.resolvedWithPattern}`);
+  lines.push(`  Resolved Manually: ${stats.resolution.resolvedManually}`);
+  lines.push("");
+  lines.push(chalk4.bold.cyan("Top Affected Symbols"));
+  lines.push(chalk4.gray("\u2500".repeat(50)));
+  for (const { symbol, count } of stats.symbols.mostIncidents.slice(0, 5)) {
+    lines.push(`  ${chalk4.cyan(symbol.padEnd(30))} ${count} incidents`);
+  }
+  lines.push("");
+  lines.push(chalk4.bold.cyan("Most Effective Patterns"));
+  lines.push(chalk4.gray("\u2500".repeat(50)));
+  for (const { patternId, resolvedCount } of stats.patterns.mostEffective.slice(0, 5)) {
+    lines.push(`  ${patternId.padEnd(30)} ${resolvedCount} resolved`);
+  }
+  return lines.join("\n");
+}
+function formatSymbols(symbols) {
+  const result = [];
+  for (const [key, value] of Object.entries(symbols)) {
+    if (value) {
+      const color = getSymbolColor(key);
+      result.push(`${color(value.padEnd(20))} ${chalk4.dim(key)}`);
+    }
+  }
+  return result;
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "open":
+      return chalk4.red;
+    case "investigating":
+      return chalk4.yellow;
+    case "resolved":
+      return chalk4.green;
+    case "wont-fix":
+      return chalk4.gray;
+    default:
+      return chalk4.white;
+  }
+}
+function getSymbolColor(type) {
+  switch (type) {
+    case "feature":
+      return chalk4.magenta;
+    case "component":
+      return chalk4.blue;
+    case "flow":
+      return chalk4.cyan;
+    case "gate":
+      return chalk4.yellow;
+    case "signal":
+      return chalk4.green;
+    case "state":
+      return chalk4.red;
+    case "integration":
+      return chalk4.white;
+    default:
+      return chalk4.gray;
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + "...";
+}
+
+// src/cli/commands.ts
+async function getStorage() {
+  const storage = new SentinelStorage();
+  await storage.ensureReady();
+  try {
+    const { patterns } = loadAllSeedPatterns();
+    for (const pattern of patterns) {
+      try {
+        storage.addPattern(pattern);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return storage;
+}
+async function launchDashboard(opts) {
+  console.log(chalk5.cyan("\n  Sentinel Dashboard\n"));
+  await startServer({
+    port: parseInt(opts.port, 10),
+    projectDir: process.cwd(),
+    open: opts.open
+  });
+}
+async function initProject(opts) {
+  console.log(chalk5.cyan("\n  Initializing Sentinel...\n"));
+  const projectDir = process.cwd();
+  const config = generateConfig(projectDir);
+  writeConfig(projectDir, config);
+  console.log(chalk5.green("  Created .sentinel.yaml"));
+  if (config.symbols) {
+    const total = (config.symbols.components?.length || 0) + (config.symbols.gates?.length || 0) + (config.symbols.flows?.length || 0) + (config.symbols.signals?.length || 0);
+    if (total > 0) {
+      console.log(chalk5.gray(`  Detected ${total} symbols`));
+    }
+  }
+  const storage = new SentinelStorage();
+  await storage.ensureReady();
+  storage.close();
+  console.log(chalk5.green("  Initialized database"));
+  console.log(chalk5.gray("\n  Run `sentinel` to launch the dashboard\n"));
+}
+async function triageList(opts) {
+  const storage = await getStorage();
+  const matcher = new PatternMatcher(storage);
+  const incidents = storage.getRecentIncidents({
+    limit: parseInt(opts.limit, 10),
+    status: opts.status || "all",
+    environment: opts.env,
+    symbol: opts.symbol
+  });
+  console.log(formatHeader());
+  if (incidents.length === 0) {
+    console.log(chalk5.gray("  No incidents found.\n"));
+    console.log(chalk5.dim("  Record incidents via the SDK:"));
+    console.log(chalk5.dim('    sentinel.capture(error, { component: "#checkout" })'));
+    console.log(chalk5.dim("  Or via MCP:"));
+    console.log(chalk5.dim('    sentinel_record({ error: { message: "..." }, symbols: { component: "#checkout" }, environment: "production" })\n'));
+    storage.close();
+    return;
+  }
+  const all = storage.getRecentIncidents({ limit: 1e4 });
+  const today = (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
+  console.log(formatSummaryBar({
+    open: all.filter((i) => i.status === "open").length,
+    investigating: all.filter((i) => i.status === "investigating").length,
+    resolved: all.filter((i) => i.status === "resolved").length,
+    today: all.filter((i) => i.timestamp.startsWith(today)).length
+  }));
+  for (const incident of incidents) {
+    const matches = matcher.match(incident, { maxResults: 3 });
+    console.log(formatIncidentCompact(incident));
+  }
+  console.log("");
+  storage.close();
+}
+async function triageShow(id, opts) {
+  const storage = await getStorage();
+  const matcher = new PatternMatcher(storage);
+  const incident = storage.getIncident(id);
+  if (!incident) {
+    console.log(chalk5.red(`
+  Incident ${id} not found
+`));
+    storage.close();
+    return;
+  }
+  const matches = matcher.match(incident, { maxResults: 5 });
+  console.log("");
+  console.log(formatIncident(incident, matches));
+  if (opts.timeline && incident.flowPosition) {
+    const builder = new TimelineBuilder();
+    const timeline = builder.build(incident);
+    if (timeline) {
+      console.log("\n" + builder.renderAscii(timeline));
+    }
+  }
+  console.log("");
+  storage.close();
+}
+async function triageResolve(id, opts) {
+  const storage = await getStorage();
+  const incident = storage.getIncident(id);
+  if (!incident) {
+    console.log(chalk5.red(`
+  Incident ${id} not found
+`));
+    storage.close();
+    return;
+  }
+  storage.recordResolution({
+    incidentId: id,
+    patternId: opts.pattern,
+    commitHash: opts.commit,
+    notes: opts.notes
+  });
+  console.log(chalk5.green(`
+  Incident ${id} resolved
+`));
+  storage.close();
+}
+async function triageStats(opts) {
+  const storage = await getStorage();
+  const calculator = new StatsCalculator(storage);
+  const match = opts.period.match(/^(\d+)d$/);
+  const days = match ? parseInt(match[1], 10) : 7;
+  const stats = calculator.getStats(days);
+  console.log(formatStats(stats));
+  console.log("");
+  storage.close();
+}
+export {
+  initProject,
+  launchDashboard,
+  triageList,
+  triageResolve,
+  triageShow,
+  triageStats
+};