@a-company/paradigm 3.8.0 → 3.11.0

package/dist/chunk-4ZO3ZOPM.js

@@ -0,0 +1,4879 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/rng.js
+import crypto from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../paradigm-mcp/node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+// ../paradigm-mcp/node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/native.js
+import crypto2 from "crypto";
+var native_default = {
+  randomUUID: crypto2.randomUUID
+};
+
+// ../paradigm-mcp/node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+sentinel@3.5.0/node_modules/@a-company/sentinel/dist/chunk-VQ3SIN7S.js
+var DEFAULTS = {
+  url: "http://localhost:3838",
+  batchSize: 50,
+  flushIntervalMs: 5e3,
+  maxBufferSize: 1e3,
+  maxRetries: 3,
+  retryBackoffMs: 1e3
+};
+var SentinelClient = class {
+  url;
+  service;
+  version;
+  environment;
+  token;
+  batchSize;
+  maxBufferSize;
+  maxRetries;
+  retryBackoffMs;
+  onDrop;
+  onError;
+  sessionId;
+  logBuffer = [];
+  metricsBuffer = [];
+  flushTimer = null;
+  closed = false;
+  beforeUnloadHandler = null;
+  constructor(options) {
+    this.url = (options.url ?? DEFAULTS.url).replace(/\/+$/, "");
+    this.service = options.service;
+    this.version = options.version;
+    this.environment = options.environment;
+    this.token = options.token;
+    this.batchSize = options.batchSize ?? DEFAULTS.batchSize;
+    this.maxBufferSize = options.maxBufferSize ?? DEFAULTS.maxBufferSize;
+    this.maxRetries = options.maxRetries ?? DEFAULTS.maxRetries;
+    this.retryBackoffMs = options.retryBackoffMs ?? DEFAULTS.retryBackoffMs;
+    this.onDrop = options.onDrop;
+    this.onError = options.onError;
+    this.sessionId = v4_default();
+    const intervalMs = options.flushIntervalMs ?? DEFAULTS.flushIntervalMs;
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((err) => {
+        this.handleError(err);
+      });
+    }, intervalMs);
+    if (this.flushTimer && typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
+      this.flushTimer.unref();
+    }
+    if (typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
+      this.beforeUnloadHandler = () => {
+        this.flushSync();
+      };
+      globalThis.addEventListener("beforeunload", this.beforeUnloadHandler);
+    }
+    this.registerService();
+  }
+  // ── Logging Methods ──────────────────────────────────────────────
+  /** Log a debug-level message */
+  debug(symbol, message, data) {
+    this.log("debug", symbol, message, data);
+  }
+  /** Log an info-level message */
+  info(symbol, message, data) {
+    this.log("info", symbol, message, data);
+  }
+  /** Log a warn-level message */
+  warn(symbol, message, data) {
+    this.log("warn", symbol, message, data);
+  }
+  /** Log an error-level message */
+  error(symbol, message, data) {
+    this.log("error", symbol, message, data);
+  }
+  /** Log a message at the specified level */
+  log(level, symbol, message, data) {
+    if (this.closed) return;
+    const entry = {
+      level,
+      symbol,
+      message,
+      service: this.service,
+      sessionId: this.sessionId,
+      environment: this.environment,
+      data
+    };
+    this.pushToLogBuffer(entry);
+  }
+  // ── Metrics Methods ──────────────────────────────────────────────
+  /** Record a counter metric (increments) */
+  counter(name, value, tags) {
+    this.metric({ name, type: "counter", value: value ?? 1, tags });
+  }
+  /** Record a gauge metric (current value) */
+  gauge(name, value, tags) {
+    this.metric({ name, type: "gauge", value, tags });
+  }
+  /** Record a histogram metric (distribution) */
+  histogram(name, value, tags) {
+    this.metric({ name, type: "histogram", value, tags });
+  }
+  /** Record a metric of any type */
+  metric(input) {
+    if (this.closed) return;
+    const entry = {
+      ...input,
+      service: this.service,
+      environment: this.environment
+    };
+    this.pushToMetricsBuffer(entry);
+  }
+  // ── State Push ───────────────────────────────────────────────────
+  /** Push an application state snapshot to the server */
+  async pushState(state, activeFlows, activeGates) {
+    if (this.closed) return;
+    await this.post("/api/state", {
+      service: this.service,
+      sessionId: this.sessionId,
+      state,
+      activeFlows,
+      activeGates
+    });
+  }
+  // ── Tracing ──────────────────────────────────────────────────────
+  /** Start a trace span. Call end() on the returned SpanContext when the operation completes. */
+  startSpan(symbol, operation, parentSpanId) {
+    const traceId = parentSpanId ? parentSpanId.split("-")[0] || v4_default() : v4_default();
+    const spanId = v4_default();
+    const startTime = (/* @__PURE__ */ new Date()).toISOString();
+    const startMs = Date.now();
+    const self = this;
+    return {
+      traceId,
+      spanId,
+      async end(status = "ok") {
+        const endTime = (/* @__PURE__ */ new Date()).toISOString();
+        const durationMs = Date.now() - startMs;
+        const span = {
+          traceId,
+          spanId,
+          parentSpanId,
+          service: self.service,
+          symbol,
+          operation,
+          startTime,
+          endTime,
+          durationMs,
+          status
+        };
+        await self.post("/api/traces", span);
+      }
+    };
+  }
+  // ── Buffer Management ────────────────────────────────────────────
+  /** Flush all buffered logs and metrics to the server */
+  async flush() {
+    const logEntries = this.drainLogBuffer();
+    const metricEntries = this.drainMetricsBuffer();
+    const promises = [];
+    if (logEntries.length > 0) {
+      promises.push(this.sendLogs(logEntries));
+    }
+    if (metricEntries.length > 0) {
+      promises.push(this.sendMetrics(metricEntries));
+    }
+    await Promise.allSettled(promises);
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────
+  /** Flush remaining entries and shut down the client */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.beforeUnloadHandler && typeof globalThis !== "undefined" && typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("beforeunload", this.beforeUnloadHandler);
+      this.beforeUnloadHandler = null;
+    }
+    try {
+      await this.flush();
+    } catch {
+    }
+  }
+  /** Get the session ID assigned to this client instance */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Synchronous best-effort flush using sendBeacon (browser) or sync XHR fallback.
+   * Used in beforeunload where async is unreliable.
+   */
+  flushSync() {
+    const logEntries = this.drainLogBuffer();
+    const metricEntries = this.drainMetricsBuffer();
+    const sendBeacon = typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function" ? navigator.sendBeacon.bind(navigator) : void 0;
+    if (sendBeacon) {
+      if (logEntries.length > 0) {
+        sendBeacon(`${this.url}/api/logs`, JSON.stringify({ entries: logEntries }));
+      }
+      if (metricEntries.length > 0) {
+        sendBeacon(`${this.url}/api/metrics`, JSON.stringify({ entries: metricEntries }));
+      }
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE METHODS
+  // ═══════════════════════════════════════════════════════════════════
+  /** Register this service with the Sentinel server (fire-and-forget) */
+  registerService() {
+    const registration = {
+      name: this.service,
+      version: this.version,
+      pid: typeof process !== "undefined" ? process.pid : void 0,
+      environment: this.environment
+    };
+    this.post("/api/services", registration).catch(() => {
+    });
+  }
+  /** Push a log entry into the ring buffer, enforcing maxBufferSize */
+  pushToLogBuffer(entry) {
+    if (this.logBuffer.length >= this.maxBufferSize) {
+      const dropCount = Math.max(1, Math.floor(this.maxBufferSize * 0.1));
+      this.logBuffer.splice(0, dropCount);
+      if (this.onDrop) {
+        this.onDrop(dropCount);
+      }
+    }
+    this.logBuffer.push(entry);
+    if (this.logBuffer.length >= this.batchSize) {
+      this.flush().catch((err) => {
+        this.handleError(err);
+      });
+    }
+  }
+  /** Push a metric entry into the ring buffer, enforcing maxBufferSize */
+  pushToMetricsBuffer(entry) {
+    if (this.metricsBuffer.length >= this.maxBufferSize) {
+      const dropCount = Math.max(1, Math.floor(this.maxBufferSize * 0.1));
+      this.metricsBuffer.splice(0, dropCount);
+      if (this.onDrop) {
+        this.onDrop(dropCount);
+      }
+    }
+    this.metricsBuffer.push(entry);
+    if (this.metricsBuffer.length >= this.batchSize) {
+      this.flush().catch((err) => {
+        this.handleError(err);
+      });
+    }
+  }
+  /** Drain and return all entries from the log buffer */
+  drainLogBuffer() {
+    const entries = this.logBuffer;
+    this.logBuffer = [];
+    return entries;
+  }
+  /** Drain and return all entries from the metrics buffer */
+  drainMetricsBuffer() {
+    const entries = this.metricsBuffer;
+    this.metricsBuffer = [];
+    return entries;
+  }
+  /** Send log entries to the server with retry */
+  async sendLogs(entries) {
+    try {
+      await this.post("/api/logs", { entries });
+    } catch (err) {
+      const capacity = this.maxBufferSize - this.logBuffer.length;
+      if (capacity > 0) {
+        const toRestore = entries.slice(0, capacity);
+        this.logBuffer.unshift(...toRestore);
+        const dropped = entries.length - toRestore.length;
+        if (dropped > 0 && this.onDrop) {
+          this.onDrop(dropped);
+        }
+      } else if (this.onDrop) {
+        this.onDrop(entries.length);
+      }
+      throw err;
+    }
+  }
+  /** Send metric entries to the server with retry */
+  async sendMetrics(entries) {
+    try {
+      await this.post("/api/metrics", { entries });
+    } catch (err) {
+      const capacity = this.maxBufferSize - this.metricsBuffer.length;
+      if (capacity > 0) {
+        const toRestore = entries.slice(0, capacity);
+        this.metricsBuffer.unshift(...toRestore);
+        const dropped = entries.length - toRestore.length;
+        if (dropped > 0 && this.onDrop) {
+          this.onDrop(dropped);
+        }
+      } else if (this.onDrop) {
+        this.onDrop(entries.length);
+      }
+      throw err;
+    }
+  }
+  /**
+   * POST JSON to the Sentinel server with exponential backoff retry.
+   * Retries on network errors and 5xx responses. Does NOT retry on 4xx.
+   */
+  async post(path4, body) {
+    const fetchFn = this.getFetch();
+    if (!fetchFn) {
+      return void 0;
+    }
+    const url = `${this.url}${path4}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await fetchFn(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        });
+        if (response.status >= 400 && response.status < 500) {
+          const text = await response.text().catch(() => "");
+          const err = new Error(`Sentinel server returned ${response.status}: ${text}`);
+          this.handleError(err);
+          return void 0;
+        }
+        if (response.status >= 500) {
+          const text = await response.text().catch(() => "");
+          lastError = new Error(`Sentinel server returned ${response.status}: ${text}`);
+          if (attempt < this.maxRetries) {
+            await this.backoff(attempt);
+            continue;
+          }
+          this.handleError(lastError);
+          throw lastError;
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          return await response.json();
+        }
+        return void 0;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < this.maxRetries) {
+          await this.backoff(attempt);
+          continue;
+        }
+        this.handleError(lastError);
+        throw lastError;
+      }
+    }
+    if (lastError) throw lastError;
+    return void 0;
+  }
+  /** Get the fetch function, falling back to globalThis.fetch */
+  getFetch() {
+    if (typeof globalThis !== "undefined" && typeof globalThis.fetch === "function") {
+      return globalThis.fetch;
+    }
+    return void 0;
+  }
+  /** Wait with exponential backoff */
+  backoff(attempt) {
+    const delayMs = this.retryBackoffMs * Math.pow(2, attempt);
+    const jitter = Math.floor(Math.random() * delayMs * 0.25);
+    return new Promise((resolve) => setTimeout(resolve, delayMs + jitter));
+  }
+  /** Handle an error, calling the onError callback if provided */
+  handleError(err) {
+    if (this.onError) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.onError(error);
+    }
+  }
+};
+function createSentinelClient(options) {
+  return new SentinelClient(options);
+}
+var SentinelTransport = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  send(entry) {
+    this.client.log(
+      entry.level,
+      entry.symbol,
+      entry.message,
+      {
+        ...entry.data,
+        symbolType: entry.symbolType,
+        correlationId: entry.correlationId
+      }
+    );
+  }
+};
+function createSentinelTransport(clientOrOptions) {
+  const client = clientOrOptions instanceof SentinelClient ? clientOrOptions : new SentinelClient(clientOrOptions);
+  return new SentinelTransport(client);
+}
+function enableSentinel(logger, clientOrOptions) {
+  const transport = createSentinelTransport(clientOrOptions);
+  logger.addTransport(transport);
+  return transport;
+}
+
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+sentinel@3.5.0/node_modules/@a-company/sentinel/dist/chunk-FOF7CPJ6.js
+import initSqlJs from "sql.js";
+import * as path from "path";
+import * as fs from "fs";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var SCHEMA_VERSION = 4;
+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
+      );
+
+      -- Structured logs table
+      CREATE TABLE IF NOT EXISTS logs (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        level TEXT NOT NULL CHECK (level IN ('debug','info','warn','error')),
+        symbol TEXT NOT NULL,
+        symbol_type TEXT NOT NULL DEFAULT 'raw',
+        message TEXT NOT NULL,
+        data_json TEXT,
+        service TEXT NOT NULL,
+        session_id TEXT,
+        correlation_id TEXT,
+        duration_ms REAL,
+        environment TEXT
+      );
+
+      -- Service registry
+      CREATE TABLE IF NOT EXISTS services (
+        name TEXT PRIMARY KEY,
+        version TEXT,
+        pid INTEGER,
+        started_at TEXT NOT NULL,
+        last_seen_at TEXT NOT NULL,
+        environment TEXT,
+        metadata_json TEXT
+      );
+
+      -- Live app state snapshots (latest-wins per service+session)
+      CREATE TABLE IF NOT EXISTS app_state (
+        service TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        state_json TEXT NOT NULL,
+        active_flows_json TEXT,
+        active_gates_json TEXT,
+        PRIMARY KEY (service, session_id)
+      );
+
+      -- Metrics table
+      CREATE TABLE IF NOT EXISTS metrics (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL CHECK (type IN ('counter','gauge','histogram')),
+        value REAL NOT NULL,
+        tags_json TEXT DEFAULT '{}',
+        service TEXT NOT NULL,
+        environment TEXT
+      );
+
+      -- Traces table
+      CREATE TABLE IF NOT EXISTS traces (
+        trace_id TEXT NOT NULL,
+        span_id TEXT PRIMARY KEY,
+        parent_span_id TEXT,
+        service TEXT NOT NULL,
+        symbol TEXT NOT NULL,
+        operation TEXT NOT NULL,
+        start_time TEXT NOT NULL,
+        end_time TEXT,
+        duration_ms REAL,
+        status TEXT NOT NULL DEFAULT 'ok',
+        tags_json TEXT DEFAULT '{}',
+        log_ids_json TEXT DEFAULT '[]'
+      );
+
+      -- 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);
+      CREATE INDEX IF NOT EXISTS idx_logs_timestamp ON logs(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level);
+      CREATE INDEX IF NOT EXISTS idx_logs_symbol ON logs(symbol);
+      CREATE INDEX IF NOT EXISTS idx_logs_service ON logs(service);
+      CREATE INDEX IF NOT EXISTS idx_logs_session_id ON logs(session_id);
+      CREATE INDEX IF NOT EXISTS idx_logs_correlation_id ON logs(correlation_id);
+      CREATE INDEX IF NOT EXISTS idx_metrics_timestamp ON metrics(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_metrics_name ON metrics(name);
+      CREATE INDEX IF NOT EXISTS idx_metrics_service ON metrics(service);
+      CREATE INDEX IF NOT EXISTS idx_traces_trace_id ON traces(trace_id);
+      CREATE INDEX IF NOT EXISTS idx_traces_service ON traces(service);
+      CREATE INDEX IF NOT EXISTS idx_traces_start_time ON traces(start_time);
+    `);
+    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')"
+      );
+      currentVersion = 2;
+    }
+    if (currentVersion < 3) {
+      try {
+        this.db.run(`
+          CREATE TABLE IF NOT EXISTS logs (
+            id TEXT PRIMARY KEY,
+            timestamp TEXT NOT NULL,
+            level TEXT NOT NULL CHECK (level IN ('debug','info','warn','error')),
+            symbol TEXT NOT NULL,
+            symbol_type TEXT NOT NULL DEFAULT 'raw',
+            message TEXT NOT NULL,
+            data_json TEXT,
+            service TEXT NOT NULL,
+            session_id TEXT,
+            correlation_id TEXT,
+            duration_ms REAL,
+            environment TEXT
+          );
+
+          CREATE TABLE IF NOT EXISTS services (
+            name TEXT PRIMARY KEY,
+            version TEXT,
+            pid INTEGER,
+            started_at TEXT NOT NULL,
+            last_seen_at TEXT NOT NULL,
+            environment TEXT,
+            metadata_json TEXT
+          );
+
+          CREATE TABLE IF NOT EXISTS app_state (
+            service TEXT NOT NULL,
+            session_id TEXT NOT NULL,
+            timestamp TEXT NOT NULL,
+            state_json TEXT NOT NULL,
+            active_flows_json TEXT,
+            active_gates_json TEXT,
+            PRIMARY KEY (service, session_id)
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_logs_timestamp ON logs(timestamp);
+          CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level);
+          CREATE INDEX IF NOT EXISTS idx_logs_symbol ON logs(symbol);
+          CREATE INDEX IF NOT EXISTS idx_logs_service ON logs(service);
+          CREATE INDEX IF NOT EXISTS idx_logs_session_id ON logs(session_id);
+          CREATE INDEX IF NOT EXISTS idx_logs_correlation_id ON logs(correlation_id);
+        `);
+      } catch {
+      }
+      this.db.run(
+        "INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', '3')"
+      );
+      currentVersion = 3;
+    }
+    if (currentVersion < 4) {
+      try {
+        this.db.run(`
+          CREATE TABLE IF NOT EXISTS metrics (
+            id TEXT PRIMARY KEY,
+            timestamp TEXT NOT NULL,
+            name TEXT NOT NULL,
+            type TEXT NOT NULL CHECK (type IN ('counter','gauge','histogram')),
+            value REAL NOT NULL,
+            tags_json TEXT DEFAULT '{}',
+            service TEXT NOT NULL,
+            environment TEXT
+          );
+
+          CREATE TABLE IF NOT EXISTS traces (
+            trace_id TEXT NOT NULL,
+            span_id TEXT PRIMARY KEY,
+            parent_span_id TEXT,
+            service TEXT NOT NULL,
+            symbol TEXT NOT NULL,
+            operation TEXT NOT NULL,
+            start_time TEXT NOT NULL,
+            end_time TEXT,
+            duration_ms REAL,
+            status TEXT NOT NULL DEFAULT 'ok',
+            tags_json TEXT DEFAULT '{}',
+            log_ids_json TEXT DEFAULT '[]'
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_metrics_timestamp ON metrics(timestamp);
+          CREATE INDEX IF NOT EXISTS idx_metrics_name ON metrics(name);
+          CREATE INDEX IF NOT EXISTS idx_metrics_service ON metrics(service);
+          CREATE INDEX IF NOT EXISTS idx_traces_trace_id ON traces(trace_id);
+          CREATE INDEX IF NOT EXISTS idx_traces_service ON traces(service);
+          CREATE INDEX IF NOT EXISTS idx_traces_start_time ON traces(start_time);
+        `);
+      } catch {
+      }
+      this.db.run(
+        "INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', '4')"
+      );
+    }
+  }
+  /**
+   * 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: v4_default(),
+      ...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-${v4_default().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 = v4_default();
+    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-${v4_default().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
+    };
+  }
+  // ─── Structured Logs ─────────────────────────────────────────────
+  inferSymbolType(symbol) {
+    if (symbol.startsWith("#")) return "component";
+    if (symbol.startsWith("^")) return "gate";
+    if (symbol.startsWith("!")) return "signal";
+    if (symbol.startsWith("$")) return "flow";
+    if (symbol.startsWith("~")) return "aspect";
+    return "raw";
+  }
+  insertLog(input) {
+    this.initializeSync();
+    const id = input.id || v4_default();
+    const timestamp = input.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    const symbolType = input.symbolType || this.inferSymbolType(input.symbol);
+    this.db.run(
+      `INSERT INTO logs (
+        id, timestamp, level, symbol, symbol_type, message, data_json,
+        service, session_id, correlation_id, duration_ms, environment
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        timestamp,
+        input.level,
+        input.symbol,
+        symbolType,
+        input.message,
+        input.data ? JSON.stringify(input.data) : null,
+        input.service,
+        input.sessionId || null,
+        input.correlationId || null,
+        input.durationMs ?? null,
+        input.environment || null
+      ]
+    );
+    this.save();
+    return id;
+  }
+  insertLogBatch(entries) {
+    this.initializeSync();
+    let accepted = 0;
+    const errors = [];
+    for (const input of entries) {
+      try {
+        const id = input.id || v4_default();
+        const timestamp = input.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+        const symbolType = input.symbolType || this.inferSymbolType(input.symbol);
+        this.db.run(
+          `INSERT INTO logs (
+            id, timestamp, level, symbol, symbol_type, message, data_json,
+            service, session_id, correlation_id, duration_ms, environment
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            id,
+            timestamp,
+            input.level,
+            input.symbol,
+            symbolType,
+            input.message,
+            input.data ? JSON.stringify(input.data) : null,
+            input.service,
+            input.sessionId || null,
+            input.correlationId || null,
+            input.durationMs ?? null,
+            input.environment || null
+          ]
+        );
+        accepted++;
+      } catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    this.save();
+    return { accepted, errors };
+  }
+  queryLogs(options = {}) {
+    this.initializeSync();
+    const { limit = 100, offset = 0 } = options;
+    const conditions = [];
+    const params = [];
+    if (options.level) {
+      conditions.push("level = ?");
+      params.push(options.level);
+    }
+    if (options.symbol) {
+      conditions.push("symbol LIKE ?");
+      params.push(`%${options.symbol}%`);
+    }
+    if (options.service) {
+      conditions.push("service = ?");
+      params.push(options.service);
+    }
+    if (options.sessionId) {
+      conditions.push("session_id = ?");
+      params.push(options.sessionId);
+    }
+    if (options.correlationId) {
+      conditions.push("correlation_id = ?");
+      params.push(options.correlationId);
+    }
+    if (options.search) {
+      conditions.push("message LIKE ?");
+      params.push(`%${options.search}%`);
+    }
+    if (options.since) {
+      conditions.push("timestamp >= ?");
+      params.push(options.since);
+    }
+    if (options.until) {
+      conditions.push("timestamp <= ?");
+      params.push(options.until);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT * FROM logs ${whereClause} ORDER BY timestamp DESC LIMIT ? OFFSET ?`,
+      [...params, limit, offset]
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToLogEntry(result[0].columns, row)
+    );
+  }
+  getLogCount(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.level) {
+      conditions.push("level = ?");
+      params.push(options.level);
+    }
+    if (options.symbol) {
+      conditions.push("symbol LIKE ?");
+      params.push(`%${options.symbol}%`);
+    }
+    if (options.service) {
+      conditions.push("service = ?");
+      params.push(options.service);
+    }
+    if (options.since) {
+      conditions.push("timestamp >= ?");
+      params.push(options.since);
+    }
+    if (options.until) {
+      conditions.push("timestamp <= ?");
+      params.push(options.until);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT COUNT(*) as count FROM logs ${whereClause}`,
+      params
+    );
+    if (result.length === 0 || result[0].values.length === 0) return 0;
+    return result[0].values[0][0];
+  }
+  pruneLogs(maxCount) {
+    this.initializeSync();
+    if (maxCount <= 0) return 0;
+    const currentCount = this.getLogCount();
+    if (currentCount <= maxCount) return 0;
+    const deleteCount = currentCount - maxCount;
+    this.db.run(
+      `DELETE FROM logs WHERE id IN (
+        SELECT id FROM logs ORDER BY timestamp ASC LIMIT ?
+      )`,
+      [deleteCount]
+    );
+    this.save();
+    return deleteCount;
+  }
+  rowToLogEntry(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      id: obj.id,
+      timestamp: obj.timestamp,
+      level: obj.level,
+      symbol: obj.symbol,
+      symbolType: obj.symbol_type || "raw",
+      message: obj.message,
+      data: obj.data_json ? JSON.parse(obj.data_json) : void 0,
+      service: obj.service,
+      sessionId: obj.session_id || void 0,
+      correlationId: obj.correlation_id || void 0,
+      durationMs: obj.duration_ms || void 0,
+      environment: obj.environment || void 0
+    };
+  }
+  // ─── Service Registry ──────────────────────────────────────────
+  registerService(reg) {
+    this.initializeSync();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      `INSERT INTO services (name, version, pid, started_at, last_seen_at, environment, metadata_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(name) DO UPDATE SET
+         version = excluded.version,
+         pid = excluded.pid,
+         last_seen_at = excluded.last_seen_at,
+         environment = excluded.environment,
+         metadata_json = excluded.metadata_json`,
+      [
+        reg.name,
+        reg.version || null,
+        reg.pid ?? null,
+        now,
+        now,
+        reg.environment || null,
+        reg.metadata ? JSON.stringify(reg.metadata) : null
+      ]
+    );
+    this.save();
+  }
+  updateServiceLastSeen(name) {
+    this.initializeSync();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      "UPDATE services SET last_seen_at = ? WHERE name = ?",
+      [now, name]
+    );
+    this.save();
+  }
+  getServices() {
+    this.initializeSync();
+    const result = this.db.exec(
+      "SELECT * FROM services ORDER BY last_seen_at DESC"
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map((row) => {
+      const obj = {};
+      result[0].columns.forEach((col, i) => {
+        obj[col] = row[i];
+      });
+      return {
+        name: obj.name,
+        version: obj.version || void 0,
+        pid: obj.pid || void 0,
+        startedAt: obj.started_at,
+        lastSeenAt: obj.last_seen_at,
+        environment: obj.environment || void 0,
+        metadata: obj.metadata_json ? JSON.parse(obj.metadata_json) : void 0
+      };
+    });
+  }
+  // ─── App State ──────────────────────────────────────────────────
+  upsertAppState(state) {
+    this.initializeSync();
+    this.db.run(
+      `INSERT INTO app_state (service, session_id, timestamp, state_json, active_flows_json, active_gates_json)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(service, session_id) DO UPDATE SET
+         timestamp = excluded.timestamp,
+         state_json = excluded.state_json,
+         active_flows_json = excluded.active_flows_json,
+         active_gates_json = excluded.active_gates_json`,
+      [
+        state.service,
+        state.sessionId,
+        state.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        JSON.stringify(state.state),
+        state.activeFlows ? JSON.stringify(state.activeFlows) : null,
+        state.activeGates ? JSON.stringify(state.activeGates) : null
+      ]
+    );
+    this.save();
+  }
+  getAppState(service, sessionId) {
+    this.initializeSync();
+    let query = "SELECT * FROM app_state WHERE service = ?";
+    const params = [service];
+    if (sessionId) {
+      query += " AND session_id = ?";
+      params.push(sessionId);
+    }
+    query += " ORDER BY timestamp DESC";
+    const result = this.db.exec(query, params);
+    if (result.length === 0) return [];
+    return result[0].values.map((row) => this.rowToAppState(result[0].columns, row));
+  }
+  getAllAppStates() {
+    this.initializeSync();
+    const result = this.db.exec(
+      "SELECT * FROM app_state ORDER BY timestamp DESC"
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map((row) => this.rowToAppState(result[0].columns, row));
+  }
+  rowToAppState(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      service: obj.service,
+      sessionId: obj.session_id,
+      timestamp: obj.timestamp,
+      state: JSON.parse(obj.state_json),
+      activeFlows: obj.active_flows_json ? JSON.parse(obj.active_flows_json) : void 0,
+      activeGates: obj.active_gates_json ? JSON.parse(obj.active_gates_json) : void 0
+    };
+  }
+  // ─── Metrics ───────────────────────────────────────────────────
+  insertMetric(input) {
+    this.initializeSync();
+    const id = v4_default();
+    const timestamp = input.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      `INSERT INTO metrics (
+        id, timestamp, name, type, value, tags_json, service, environment
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        timestamp,
+        input.name,
+        input.type,
+        input.value,
+        JSON.stringify(input.tags || {}),
+        input.service,
+        input.environment || null
+      ]
+    );
+    this.save();
+    return id;
+  }
+  insertMetricBatch(entries) {
+    this.initializeSync();
+    let accepted = 0;
+    const errors = [];
+    for (const input of entries) {
+      try {
+        const id = v4_default();
+        const timestamp = input.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+        this.db.run(
+          `INSERT INTO metrics (
+            id, timestamp, name, type, value, tags_json, service, environment
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            id,
+            timestamp,
+            input.name,
+            input.type,
+            input.value,
+            JSON.stringify(input.tags || {}),
+            input.service,
+            input.environment || null
+          ]
+        );
+        accepted++;
+      } catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    this.save();
+    return { accepted, errors };
+  }
+  queryMetrics(options = {}) {
+    this.initializeSync();
+    const { limit = 100, offset = 0 } = options;
+    const conditions = [];
+    const params = [];
+    if (options.name) {
+      conditions.push("name = ?");
+      params.push(options.name);
+    }
+    if (options.type) {
+      conditions.push("type = ?");
+      params.push(options.type);
+    }
+    if (options.service) {
+      conditions.push("service = ?");
+      params.push(options.service);
+    }
+    if (options.tag) {
+      const eqIdx = options.tag.indexOf("=");
+      if (eqIdx > 0) {
+        const tagKey = options.tag.substring(0, eqIdx);
+        const tagValue = options.tag.substring(eqIdx + 1);
+        conditions.push("tags_json LIKE ?");
+        params.push(`%"${tagKey}":"${tagValue}"%`);
+      }
+    }
+    if (options.since) {
+      conditions.push("timestamp >= ?");
+      params.push(options.since);
+    }
+    if (options.until) {
+      conditions.push("timestamp <= ?");
+      params.push(options.until);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT * FROM metrics ${whereClause} ORDER BY timestamp DESC LIMIT ? OFFSET ?`,
+      [...params, limit, offset]
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToMetricEntry(result[0].columns, row)
+    );
+  }
+  getMetricCount(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.name) {
+      conditions.push("name = ?");
+      params.push(options.name);
+    }
+    if (options.type) {
+      conditions.push("type = ?");
+      params.push(options.type);
+    }
+    if (options.service) {
+      conditions.push("service = ?");
+      params.push(options.service);
+    }
+    if (options.tag) {
+      const eqIdx = options.tag.indexOf("=");
+      if (eqIdx > 0) {
+        const tagKey = options.tag.substring(0, eqIdx);
+        const tagValue = options.tag.substring(eqIdx + 1);
+        conditions.push("tags_json LIKE ?");
+        params.push(`%"${tagKey}":"${tagValue}"%`);
+      }
+    }
+    if (options.since) {
+      conditions.push("timestamp >= ?");
+      params.push(options.since);
+    }
+    if (options.until) {
+      conditions.push("timestamp <= ?");
+      params.push(options.until);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT COUNT(*) as count FROM metrics ${whereClause}`,
+      params
+    );
+    if (result.length === 0 || result[0].values.length === 0) return 0;
+    return result[0].values[0][0];
+  }
+  aggregateMetric(name, options) {
+    this.initializeSync();
+    const conditions = ["name = ?"];
+    const params = [name];
+    if (options?.service) {
+      conditions.push("service = ?");
+      params.push(options.service);
+    }
+    if (options?.since) {
+      conditions.push("timestamp >= ?");
+      params.push(options.since);
+    }
+    if (options?.until) {
+      conditions.push("timestamp <= ?");
+      params.push(options.until);
+    }
+    const whereClause = `WHERE ${conditions.join(" AND ")}`;
+    const result = this.db.exec(
+      `SELECT COUNT(*) as count, SUM(value) as sum, MIN(value) as min, MAX(value) as max, AVG(value) as avg
+       FROM metrics ${whereClause}`,
+      params
+    );
+    if (result.length === 0 || result[0].values.length === 0) {
+      return { name, count: 0, sum: 0, min: 0, max: 0, avg: 0 };
+    }
+    const row = result[0].values[0];
+    return {
+      name,
+      count: row[0] || 0,
+      sum: row[1] || 0,
+      min: row[2] || 0,
+      max: row[3] || 0,
+      avg: row[4] || 0
+    };
+  }
+  pruneMetrics(maxCount) {
+    this.initializeSync();
+    if (maxCount <= 0) return 0;
+    const currentCount = this.getMetricCount();
+    if (currentCount <= maxCount) return 0;
+    const deleteCount = currentCount - maxCount;
+    this.db.run(
+      `DELETE FROM metrics WHERE id IN (
+        SELECT id FROM metrics ORDER BY timestamp ASC LIMIT ?
+      )`,
+      [deleteCount]
+    );
+    this.save();
+    return deleteCount;
+  }
+  rowToMetricEntry(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      id: obj.id,
+      timestamp: obj.timestamp,
+      name: obj.name,
+      type: obj.type,
+      value: obj.value,
+      tags: obj.tags_json ? JSON.parse(obj.tags_json) : {},
+      service: obj.service,
+      environment: obj.environment || void 0
+    };
+  }
+  // ─── Traces ───────────────────────────────────────────────────
+  insertSpan(input) {
+    this.initializeSync();
+    const spanId = input.spanId || v4_default();
+    const startTime = input.startTime || (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      `INSERT INTO traces (
+        trace_id, span_id, parent_span_id, service, symbol, operation,
+        start_time, end_time, duration_ms, status, tags_json, log_ids_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        input.traceId,
+        spanId,
+        input.parentSpanId || null,
+        input.service,
+        input.symbol,
+        input.operation,
+        startTime,
+        input.endTime || null,
+        input.durationMs ?? null,
+        input.status || "ok",
+        JSON.stringify(input.tags || {}),
+        JSON.stringify(input.logIds || [])
+      ]
+    );
+    this.save();
+    return spanId;
+  }
+  getTrace(traceId) {
+    this.initializeSync();
+    const result = this.db.exec(
+      "SELECT * FROM traces WHERE trace_id = ? ORDER BY start_time ASC",
+      [traceId]
+    );
+    if (result.length === 0 || result[0].values.length === 0) return null;
+    const spans = result[0].values.map(
+      (row) => this.rowToTraceSpan(result[0].columns, row)
+    );
+    const services = [...new Set(spans.map((s) => s.service))];
+    const startTimes = spans.map((s) => s.startTime);
+    const endTimes = spans.filter((s) => s.endTime).map((s) => s.endTime);
+    const startTime = startTimes.sort()[0];
+    const endTime = endTimes.length > 0 ? endTimes.sort().reverse()[0] : startTime;
+    const startMs = new Date(startTime).getTime();
+    const endMs = new Date(endTime).getTime();
+    const totalDurationMs = endMs - startMs;
+    return {
+      traceId,
+      spans,
+      services,
+      totalDurationMs: totalDurationMs > 0 ? totalDurationMs : 0,
+      startTime,
+      endTime
+    };
+  }
+  queryTraces(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.service) {
+      conditions.push("service = ?");
+      params.push(options.service);
+    }
+    if (options.symbol) {
+      conditions.push("symbol = ?");
+      params.push(options.symbol);
+    }
+    if (options.since) {
+      conditions.push("start_time >= ?");
+      params.push(options.since);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const traceLimit = Math.min(options.limit || 20, 20);
+    const result = this.db.exec(
+      `SELECT DISTINCT trace_id FROM traces ${whereClause} ORDER BY start_time DESC LIMIT ?`,
+      [...params, traceLimit]
+    );
+    if (result.length === 0) return [];
+    const traces = [];
+    for (const row of result[0].values) {
+      const traceId = row[0];
+      const trace = this.getTrace(traceId);
+      if (trace) {
+        traces.push(trace);
+      }
+    }
+    return traces;
+  }
+  rowToTraceSpan(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      traceId: obj.trace_id,
+      spanId: obj.span_id,
+      parentSpanId: obj.parent_span_id || void 0,
+      service: obj.service,
+      symbol: obj.symbol,
+      operation: obj.operation,
+      startTime: obj.start_time,
+      endTime: obj.end_time || void 0,
+      durationMs: obj.duration_ms || void 0,
+      status: obj.status || "ok",
+      tags: obj.tags_json ? JSON.parse(obj.tags_json) : {},
+      logs: obj.log_ids_json ? JSON.parse(obj.log_ids_json) : []
+    };
+  }
+  close() {
+    if (this.db) {
+      this.save();
+      this.db.close();
+      this.db = null;
+    }
+  }
+};
+var DEFAULT_AUTH_CONFIG = {
+  enabled: false,
+  tokens: []
+};
+var DEFAULT_RATE_LIMIT_CONFIG = {
+  enabled: false,
+  global: {
+    maxRequestsPerMinute: 600,
+    maxEntriesPerBatch: 500,
+    samplingRate: 1
+  },
+  perService: {}
+};
+var DEFAULT_SERVER_CONFIG = {
+  port: 3838,
+  maxLogs: 1e4,
+  maxBatchSize: 500,
+  wsMaxSubscribers: 256,
+  pruneIntervalInserts: 100,
+  logRetentionDays: 0,
+  auth: DEFAULT_AUTH_CONFIG,
+  rateLimit: DEFAULT_RATE_LIMIT_CONFIG
+};
+var CONFIG_FILES = [".sentinel.yaml", ".sentinel.yml"];
+function loadConfig(projectDir) {
+  for (const filename of CONFIG_FILES) {
+    const filePath = path2.join(projectDir, filename);
+    if (fs2.existsSync(filePath)) {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      return parseSimpleYaml(content);
+    }
+  }
+  return null;
+}
+function writeConfig(projectDir, config) {
+  const filePath = path2.join(projectDir, ".sentinel.yaml");
+  const content = serializeSimpleYaml(config);
+  fs2.writeFileSync(filePath, content, "utf-8");
+}
+function parseSimpleYaml(content) {
+  const config = { version: "1.0", project: "" };
+  const lines = content.split("\n");
+  let currentSection = null;
+  let currentSubSection = null;
+  for (const line of lines) {
+    const trimmed = line.trimEnd();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const topMatch = trimmed.match(/^(\w+):\s*(.+)$/);
+    if (topMatch) {
+      const [, key, value] = topMatch;
+      if (key === "version") config.version = value.replace(/['"]/g, "");
+      else if (key === "project") config.project = value.replace(/['"]/g, "");
+      else if (key === "environment") config.environment = value.replace(/['"]/g, "");
+      currentSection = null;
+      currentSubSection = null;
+      continue;
+    }
+    const sectionMatch = trimmed.match(/^(\w+):$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      currentSubSection = null;
+      if (currentSection === "symbols" && !config.symbols) {
+        config.symbols = {};
+      }
+      if (currentSection === "routes" && !config.routes) {
+        config.routes = {};
+      }
+      if (currentSection === "scrub" && !config.scrub) {
+        config.scrub = {};
+      }
+      if (currentSection === "server" && !config.server) {
+        config.server = {};
+      }
+      continue;
+    }
+    const subMatch = trimmed.match(/^\s{2}(\w+):$/);
+    if (subMatch && currentSection) {
+      currentSubSection = subMatch[1];
+      if (currentSection === "symbols" && config.symbols) {
+        config.symbols[currentSubSection] = [];
+      }
+      if (currentSection === "scrub" && config.scrub) {
+        config.scrub[currentSubSection] = [];
+      }
+      continue;
+    }
+    const listMatch = trimmed.match(/^\s+-\s+(.+)$/);
+    if (listMatch && currentSection && currentSubSection) {
+      const value = listMatch[1].replace(/['"]/g, "");
+      if (currentSection === "symbols" && config.symbols) {
+        const arr = config.symbols[currentSubSection];
+        if (Array.isArray(arr)) arr.push(value);
+      }
+      if (currentSection === "scrub" && config.scrub) {
+        const arr = config.scrub[currentSubSection];
+        if (Array.isArray(arr)) arr.push(value);
+      }
+      continue;
+    }
+    const routeMatch = trimmed.match(/^\s+(['"]?\/[^'"]+['"]?):\s+['"]?([^'"]+)['"]?$/);
+    if (routeMatch && currentSection === "routes" && config.routes) {
+      const route = routeMatch[1].replace(/['"]/g, "");
+      config.routes[route] = routeMatch[2];
+      continue;
+    }
+    const serverKvMatch = trimmed.match(/^\s+(\w+):\s+(\d+)$/);
+    if (serverKvMatch && currentSection === "server" && config.server) {
+      const key = serverKvMatch[1];
+      const value = parseInt(serverKvMatch[2], 10);
+      if (key in { port: 1, maxLogs: 1, maxBatchSize: 1, wsMaxSubscribers: 1, pruneIntervalInserts: 1, logRetentionDays: 1 }) {
+        config.server[key] = value;
+      }
+      continue;
+    }
+  }
+  return config;
+}
+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}`);
+      }
+    }
+  }
+  if (config.server && Object.keys(config.server).length > 0) {
+    lines.push("");
+    lines.push("server:");
+    for (const [key, value] of Object.entries(config.server)) {
+      if (value !== void 0) {
+        lines.push(`  ${key}: ${value}`);
+      }
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function loadServerConfig(projectDir) {
+  const config = { ...DEFAULT_SERVER_CONFIG };
+  const yamlConfig = projectDir ? loadConfig(projectDir) : null;
+  const globalDir = path2.join(process.env.HOME || "~", ".paradigm");
+  const globalConfig = loadConfig(globalDir);
+  for (const src of [globalConfig, yamlConfig]) {
+    if (src?.server) {
+      if (src.server.port !== void 0) config.port = src.server.port;
+      if (src.server.maxLogs !== void 0) config.maxLogs = src.server.maxLogs;
+      if (src.server.maxBatchSize !== void 0) config.maxBatchSize = src.server.maxBatchSize;
+      if (src.server.wsMaxSubscribers !== void 0) config.wsMaxSubscribers = src.server.wsMaxSubscribers;
+      if (src.server.pruneIntervalInserts !== void 0) config.pruneIntervalInserts = src.server.pruneIntervalInserts;
+      if (src.server.logRetentionDays !== void 0) config.logRetentionDays = src.server.logRetentionDays;
+    }
+  }
+  if (process.env.SENTINEL_PORT) config.port = parseInt(process.env.SENTINEL_PORT, 10);
+  if (process.env.SENTINEL_MAX_LOGS) config.maxLogs = parseInt(process.env.SENTINEL_MAX_LOGS, 10);
+  return config;
+}
+
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+sentinel@3.5.0/node_modules/@a-company/sentinel/dist/index.js
+import * as path3 from "path";
+import * as fs3 from "fs";
+import { fileURLToPath } from "url";
+import * as fs22 from "fs";
+import * as path22 from "path";
+import * as fs32 from "fs";
+import * as path32 from "path";
+import * as fs4 from "fs";
+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);
+  }
+};
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+function loadUniversalPatterns() {
+  const filePath = path3.join(__dirname, "universal-patterns.json");
+  const content = fs3.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function loadParadigmPatterns() {
+  const filePath = path3.join(__dirname, "paradigm-patterns.json");
+  const content = fs3.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]
+  };
+}
+function ensurePrefix(id, prefix) {
+  return id.startsWith(prefix) ? id : `${prefix}${id}`;
+}
+var FlowTracker = class {
+  flowId;
+  sentinel;
+  actual = [];
+  expected = [];
+  completed = false;
+  constructor(flowId, sentinel) {
+    this.flowId = ensurePrefix(flowId, "$");
+    this.sentinel = sentinel;
+  }
+  /** Declare which signals/gates are expected in this flow */
+  expect(...symbols) {
+    this.expected.push(...symbols);
+    return this;
+  }
+  /** Record a generic step in the flow */
+  step(symbol) {
+    this.actual.push(symbol);
+    return this;
+  }
+  /** Record a gate check result */
+  gate(id, passed) {
+    const gateId = ensurePrefix(id, "^");
+    this.actual.push(gateId);
+    if (!passed) {
+      this.fail(new Error(`Gate ${gateId} failed`));
+    }
+    return this;
+  }
+  /** Record a signal emission */
+  signal(id, _data) {
+    this.actual.push(ensurePrefix(id, "!"));
+    return this;
+  }
+  /** Mark the flow as successfully completed */
+  complete() {
+    this.completed = true;
+  }
+  /** Capture an error with full flow position context */
+  fail(error) {
+    if (this.completed) return;
+    this.completed = true;
+    const missing = this.expected.filter((s) => !this.actual.includes(s));
+    const failedAt = this.actual.length > 0 ? this.actual[this.actual.length - 1] : void 0;
+    const flowPosition = {
+      flowId: this.flowId,
+      expected: this.expected,
+      actual: this.actual,
+      missing,
+      failedAt
+    };
+    this.sentinel.capture(error, { flow: this.flowId }, flowPosition);
+  }
+};
+var Sentinel = class {
+  storage;
+  matcher;
+  config;
+  ready = false;
+  readyPromise = null;
+  seeded = false;
+  constructor(config) {
+    this.config = config;
+    this.storage = new SentinelStorage(config.dbPath);
+    this.matcher = new PatternMatcher(this.storage);
+  }
+  /** Explicitly initialize storage. Optional — auto-called on first capture. */
+  async init() {
+    if (this.ready) return;
+    if (this.readyPromise) return this.readyPromise;
+    this.readyPromise = this.doInit();
+    return this.readyPromise;
+  }
+  async doInit() {
+    await this.storage.ensureReady();
+    if (!this.seeded) {
+      try {
+        const { patterns } = loadAllSeedPatterns();
+        for (const pattern of patterns) {
+          try {
+            this.storage.addPattern(pattern);
+          } catch {
+          }
+        }
+      } catch {
+      }
+      this.seeded = true;
+    }
+    this.ready = true;
+  }
+  ensureReady() {
+    if (!this.ready) {
+      if (!this.readyPromise) {
+        this.readyPromise = this.doInit();
+      }
+    }
+  }
+  // ── Symbol Context ──────────────────────────────────────────────
+  /**
+   * Create a component context for scoped error capture.
+   *
+   * @param id - Component symbol (e.g. '#checkout' or 'checkout')
+   * @returns ComponentContext with capture() and wrap() methods
+   */
+  component(id) {
+    const componentId = ensurePrefix(id, "#");
+    const self = this;
+    return {
+      id: componentId,
+      capture(error, extra) {
+        return self.capture(error, { component: componentId, ...extra });
+      },
+      wrap(fn) {
+        const wrapped = ((...args) => {
+          try {
+            const result = fn(...args);
+            if (result && typeof result.catch === "function") {
+              return result.catch((err) => {
+                self.capture(err, { component: componentId });
+                throw err;
+              });
+            }
+            return result;
+          } catch (err) {
+            if (err instanceof Error) {
+              self.capture(err, { component: componentId });
+            }
+            throw err;
+          }
+        });
+        return wrapped;
+      }
+    };
+  }
+  /**
+   * Record a gate check result.
+   * If the gate fails, auto-captures an incident.
+   *
+   * @param id - Gate symbol (e.g. '^authenticated' or 'authenticated')
+   * @param passed - Whether the gate passed
+   */
+  gate(id, passed) {
+    if (!passed) {
+      const gateId = ensurePrefix(id, "^");
+      this.capture(new Error(`Gate ${gateId} failed`), { gate: gateId });
+    }
+  }
+  /**
+   * Record a signal emission. Primarily for flow tracking context.
+   *
+   * @param id - Signal symbol (e.g. '!payment-authorized' or 'payment-authorized')
+   */
+  signal(id, _data) {
+    void ensurePrefix(id, "!");
+  }
+  // ── Flow Tracking ───────────────────────────────────────────────
+  /**
+   * Create a flow tracker for monitoring multi-step operations.
+   *
+   * @param id - Flow symbol (e.g. '$checkout-flow' or 'checkout-flow')
+   * @returns FlowTracker instance
+   */
+  flow(id) {
+    return new FlowTracker(id, this);
+  }
+  // ── Error Capture ───────────────────────────────────────────────
+  /**
+   * Capture an error with symbolic context.
+   *
+   * @param error - The error to capture
+   * @param context - Symbolic context (component, gate, flow, signal)
+   * @param flowPosition - Optional flow position data
+   * @returns Incident ID (e.g. 'INC-001')
+   */
+  capture(error, context, flowPosition) {
+    this.ensureReady();
+    const input = {
+      error: {
+        message: error.message,
+        stack: error.stack,
+        type: error.constructor.name !== "Error" ? error.constructor.name : void 0
+      },
+      symbols: context || {},
+      environment: this.config.environment || "development",
+      service: this.config.service,
+      version: this.config.version,
+      flowPosition
+    };
+    const incidentId = this.storage.recordIncident(input);
+    const incident = this.storage.getIncident(incidentId);
+    if (incident && this.config.onCapture) {
+      this.config.onCapture(incident);
+    }
+    return incidentId;
+  }
+  /**
+   * Get pattern matches for a captured incident.
+   *
+   * @param incidentId - The incident ID to match
+   * @returns Array of pattern matches sorted by confidence
+   */
+  match(incidentId) {
+    const incident = this.storage.getIncident(incidentId);
+    if (!incident) return [];
+    return this.matcher.match(incident);
+  }
+  // ── Framework Integration ───────────────────────────────────────
+  /**
+   * Create Express error-handling middleware.
+   *
+   * Usage:
+   *   app.use(sentinel.express());
+   */
+  express() {
+    const self = this;
+    return (err, req, res, next) => {
+      const context = {};
+      const routeParts = (req.path || req.url || "").split("/").filter(Boolean);
+      if (routeParts.length >= 2) {
+        context.component = `#${routeParts[1]}`;
+      }
+      const incidentId = self.capture(err, context);
+      if (res.setHeader) {
+        res.setHeader("X-Sentinel-Incident", incidentId);
+      }
+      next(err);
+    };
+  }
+  // ── Lifecycle ───────────────────────────────────────────────────
+  /** Close the database connection. Call when shutting down. */
+  close() {
+    this.storage.close();
+    this.ready = false;
+    this.readyPromise = null;
+  }
+  /** Get the underlying storage instance (for advanced usage). */
+  getStorage() {
+    return this.storage;
+  }
+  /** Get the underlying pattern matcher (for advanced usage). */
+  getMatcher() {
+    return this.matcher;
+  }
+};
+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 = path22.join(projectDir, dir);
+      if (!fs22.existsSync(fullPath)) continue;
+      const files = safeReaddir(fullPath);
+      for (const file of files) {
+        const ext = path22.extname(file);
+        if (!CODE_EXTENSIONS.has(ext)) continue;
+        const name = path22.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: path22.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 = path22.join(projectDir, ".paradigm");
+  if (!fs22.existsSync(paradigmDir)) return null;
+  const result = {
+    components: [],
+    gates: [],
+    flows: [],
+    signals: [],
+    routes: {}
+  };
+  const purposeFiles = findFiles(projectDir, ".purpose");
+  for (const file of purposeFiles) {
+    try {
+      const content = fs22.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 = path22.join(projectDir, dir);
+    if (!fs22.existsSync(fullPath)) continue;
+    const files = safeReaddir(fullPath);
+    for (const file of files) {
+      const ext = path22.extname(file);
+      if (!CODE_EXTENSIONS.has(ext)) continue;
+      const name = path22.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 fs22.readdirSync(dir).filter((f) => {
+      const fullPath = path22.join(dir, f);
+      try {
+        return fs22.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 = fs22.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === filename) {
+        results.push(path22.join(dir, entry.name));
+      } else if (entry.isDirectory() && !skipDirs.has(entry.name)) {
+        results.push(...findFiles(path22.join(dir, entry.name), filename, maxDepth, depth + 1));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+var DEFAULT_SIMILARITY_THRESHOLD = 0.6;
+var DECAY_HALF_LIFE_DAYS = 14;
+var IncidentGrouper = class {
+  constructor(storage, config) {
+    this.storage = storage;
+    this.similarityThreshold = config?.similarityThreshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+    this.decayHalfLifeDays = config?.decayHalfLifeDays ?? DECAY_HALF_LIFE_DAYS;
+    this.useStackFingerprint = config?.useStackFingerprint ?? true;
+  }
+  similarityThreshold;
+  decayHalfLifeDays;
+  useStackFingerprint;
+  /**
+   * Try to find or create a group for an incident
+   * Returns the group ID if grouped, null if no suitable group
+   */
+  group(incident) {
+    const groups = this.storage.getGroups({ limit: 100 });
+    for (const group of groups) {
+      if (this.shouldJoinGroup(incident, group)) {
+        this.storage.addToGroup(group.id, incident.id);
+        return group.id;
+      }
+    }
+    const similar = this.findSimilar(incident, 10);
+    if (similar.length >= 1) {
+      const commonSymbols = this.extractCommonSymbols([incident, ...similar]);
+      const commonErrorPatterns = this.extractCommonErrorPatterns([
+        incident,
+        ...similar
+      ]);
+      const groupId = this.storage.createGroup({
+        incidents: [incident.id, ...similar.map((i) => i.id)],
+        commonSymbols,
+        commonErrorPatterns,
+        firstSeen: this.getEarliestTimestamp([incident, ...similar]),
+        lastSeen: incident.timestamp,
+        environments: this.getUniqueEnvironments([incident, ...similar])
+      });
+      return groupId;
+    }
+    return null;
+  }
+  /**
+   * Find incidents similar to the given one
+   */
+  findSimilar(incident, limit = 10) {
+    const candidates = this.storage.getRecentIncidents({
+      limit: 500,
+      status: "all"
+    });
+    const similar = [];
+    for (const candidate of candidates) {
+      if (candidate.id === incident.id) {
+        continue;
+      }
+      const score = this.calculateSimilarity(incident, candidate);
+      if (score >= this.similarityThreshold) {
+        similar.push({ incident: candidate, score });
+      }
+    }
+    return similar.sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.incident);
+  }
+  /**
+   * Analyze ungrouped incidents and create groups automatically
+   */
+  analyzeAndGroup(options = {}) {
+    const minSize = options.minSize || 3;
+    const ungrouped = this.storage.getRecentIncidents({
+      limit: 1e3
+    }).filter((i) => !i.groupId);
+    const newGroups = [];
+    const processed = /* @__PURE__ */ new Set();
+    for (const incident of ungrouped) {
+      if (processed.has(incident.id)) {
+        continue;
+      }
+      const similar = ungrouped.filter(
+        (other) => other.id !== incident.id && !processed.has(other.id) && this.calculateSimilarity(incident, other) >= this.similarityThreshold
+      );
+      if (similar.length + 1 >= minSize) {
+        const members = [incident, ...similar];
+        const commonSymbols = this.extractCommonSymbols(members);
+        const commonErrorPatterns = this.extractCommonErrorPatterns(members);
+        const groupId = this.storage.createGroup({
+          incidents: members.map((m) => m.id),
+          commonSymbols,
+          commonErrorPatterns,
+          firstSeen: this.getEarliestTimestamp(members),
+          lastSeen: this.getLatestTimestamp(members),
+          environments: this.getUniqueEnvironments(members)
+        });
+        for (const m of members) {
+          processed.add(m.id);
+        }
+        const group = this.storage.getGroup(groupId);
+        if (group) {
+          newGroups.push(group);
+        }
+      }
+    }
+    return newGroups;
+  }
+  /**
+   * Calculate similarity between two incidents (0-1)
+   * Applies time-decay so older incidents contribute less, and optionally
+   * uses stack trace fingerprinting for more accurate grouping.
+   */
+  calculateSimilarity(a, b) {
+    let score = 0;
+    let maxScore = 0;
+    const hasStacks = this.useStackFingerprint && a.error.stack && b.error.stack;
+    const symbolWeight = hasStacks ? 0.45 : 0.6;
+    const errorWeight = hasStacks ? 0.25 : 0.3;
+    const envWeight = 0.1;
+    const stackWeight = hasStacks ? 0.2 : 0;
+    const symbolTypes = [
+      "feature",
+      "component",
+      "flow",
+      "gate",
+      "signal",
+      "state",
+      "integration"
+    ];
+    for (const type of symbolTypes) {
+      const aValue = a.symbols[type];
+      const bValue = b.symbols[type];
+      if (aValue || bValue) {
+        maxScore += symbolWeight / symbolTypes.length;
+        if (aValue === bValue) {
+          score += symbolWeight / symbolTypes.length;
+        }
+      }
+    }
+    const errorSimilarity = this.stringSimilarity(
+      a.error.message,
+      b.error.message
+    );
+    score += errorWeight * errorSimilarity;
+    maxScore += errorWeight;
+    if (a.environment === b.environment) {
+      score += envWeight;
+    }
+    maxScore += envWeight;
+    if (hasStacks) {
+      const aFingerprint = this.fingerprintStack(a.error.stack);
+      const bFingerprint = this.fingerprintStack(b.error.stack);
+      const stackSimilarity = this.compareFingerprints(aFingerprint, bFingerprint);
+      score += stackWeight * stackSimilarity;
+      maxScore += stackWeight;
+    }
+    const rawScore = maxScore > 0 ? score / maxScore : 0;
+    const timeDelta = Math.abs(
+      new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    const daysDelta = timeDelta / (1e3 * 60 * 60 * 24);
+    const decayFactor = Math.pow(0.5, daysDelta / this.decayHalfLifeDays);
+    return rawScore * decayFactor;
+  }
+  /**
+   * Extract a fingerprint from a stack trace by normalizing frames.
+   * Strips line numbers, column numbers, and absolute paths to capture
+   * the structural signature of the call stack.
+   */
+  fingerprintStack(stack) {
+    return stack.split("\n").filter((line) => line.trim().startsWith("at ")).slice(0, 10).map((frame) => {
+      return frame.trim().replace(/:\d+:\d+\)?$/, "").replace(/\(.*[/\\]/, "(").replace(/^\s*at\s+/, "");
+    });
+  }
+  /**
+   * Compare two stack fingerprints (0-1 similarity)
+   */
+  compareFingerprints(a, b) {
+    if (a.length === 0 && b.length === 0) return 1;
+    if (a.length === 0 || b.length === 0) return 0;
+    let matches = 0;
+    const maxLen = Math.max(a.length, b.length);
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+      if (a[i] === b[i]) {
+        matches++;
+      }
+    }
+    return matches / maxLen;
+  }
+  /**
+   * Calculate string similarity using Levenshtein distance
+   */
+  stringSimilarity(a, b) {
+    const maxLen = Math.max(a.length, b.length);
+    if (maxLen === 0) return 1;
+    const distance = this.levenshteinDistance(
+      a.toLowerCase(),
+      b.toLowerCase()
+    );
+    return 1 - distance / maxLen;
+  }
+  /**
+   * Levenshtein distance for string comparison
+   */
+  levenshteinDistance(a, b) {
+    if (a.length === 0) return b.length;
+    if (b.length === 0) return a.length;
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+      matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+      matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+      for (let j = 1; j <= a.length; j++) {
+        const cost = a[j - 1] === b[i - 1] ? 0 : 1;
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j - 1] + cost
+        );
+      }
+    }
+    return matrix[b.length][a.length];
+  }
+  /**
+   * Check if incident should join existing group
+   */
+  shouldJoinGroup(incident, group) {
+    let matchCount = 0;
+    let totalCommon = 0;
+    for (const [key, value] of Object.entries(group.commonSymbols)) {
+      if (value) {
+        totalCommon++;
+        const incidentValue = incident.symbols[key];
+        if (incidentValue === value) {
+          matchCount++;
+        }
+      }
+    }
+    if (totalCommon === 0) {
+      return false;
+    }
+    const symbolMatch = matchCount / totalCommon;
+    const errorLower = incident.error.message.toLowerCase();
+    const errorMatch = group.commonErrorPatterns.some(
+      (pattern) => errorLower.includes(pattern.toLowerCase())
+    );
+    return symbolMatch >= 0.5 || errorMatch;
+  }
+  /**
+   * Extract symbols common to all incidents
+   */
+  extractCommonSymbols(incidents) {
+    if (incidents.length === 0) return {};
+    const first = incidents[0].symbols;
+    const common = {};
+    for (const [key, value] of Object.entries(first)) {
+      if (!value) continue;
+      const allMatch = incidents.every(
+        (i) => i.symbols[key] === value
+      );
+      if (allMatch) {
+        common[key] = value;
+      }
+    }
+    return common;
+  }
+  /**
+   * Extract common error patterns from incidents
+   */
+  extractCommonErrorPatterns(incidents) {
+    if (incidents.length === 0) return [];
+    const wordCounts = /* @__PURE__ */ new Map();
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "of",
+      "with",
+      "error",
+      "failed",
+      "cannot"
+    ]);
+    for (const incident of incidents) {
+      const words = incident.error.message.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+      const uniqueWords = new Set(words);
+      for (const word of uniqueWords) {
+        wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
+      }
+    }
+    const threshold = Math.ceil(incidents.length * 0.6);
+    const commonPatterns = Array.from(wordCounts.entries()).filter(([, count]) => count >= threshold).map(([word]) => word).slice(0, 5);
+    return commonPatterns;
+  }
+  getEarliestTimestamp(incidents) {
+    return incidents.reduce(
+      (earliest, i) => i.timestamp < earliest ? i.timestamp : earliest,
+      incidents[0].timestamp
+    );
+  }
+  getLatestTimestamp(incidents) {
+    return incidents.reduce(
+      (latest, i) => i.timestamp > latest ? i.timestamp : latest,
+      incidents[0].timestamp
+    );
+  }
+  getUniqueEnvironments(incidents) {
+    return [...new Set(incidents.map((i) => i.environment))];
+  }
+};
+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}`;
+  }
+};
+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;
+  }
+};
+var ContextEnricher = class {
+  constructor(projectRoot = process.cwd()) {
+    this.projectRoot = projectRoot;
+  }
+  symbolCache = /* @__PURE__ */ new Map();
+  purposeCache = /* @__PURE__ */ new Map();
+  /**
+   * Enrich an incident with symbol context
+   */
+  enrich(incident) {
+    const symbolEnrichments = {};
+    for (const [, value] of Object.entries(incident.symbols)) {
+      if (value) {
+        const enrichment = this.getSymbolContext(value);
+        if (enrichment && Object.keys(enrichment).length > 0) {
+          symbolEnrichments[value] = enrichment;
+        }
+      }
+    }
+    let flowDescription;
+    if (incident.symbols.flow) {
+      const flowContext = this.getSymbolContext(incident.symbols.flow);
+      flowDescription = flowContext?.description;
+    }
+    return {
+      ...incident,
+      enriched: {
+        symbols: symbolEnrichments,
+        flowDescription
+      }
+    };
+  }
+  /**
+   * Get symbol metadata from index or .purpose files
+   */
+  getSymbolContext(symbol) {
+    const cached = this.symbolCache.get(symbol);
+    if (cached) {
+      return cached;
+    }
+    const enrichment = {};
+    const indexEntry = this.findInSymbolIndex(symbol);
+    if (indexEntry) {
+      enrichment.description = indexEntry.description;
+      enrichment.definedIn = indexEntry.file;
+      enrichment.references = indexEntry.references;
+      enrichment.referencedBy = indexEntry.referencedBy;
+    }
+    const purposeEntry = this.findInPurposeFiles(symbol);
+    if (purposeEntry) {
+      if (!enrichment.description && purposeEntry.description) {
+        enrichment.description = purposeEntry.description;
+      }
+      if (purposeEntry.references) {
+        enrichment.references = [
+          .../* @__PURE__ */ new Set([...enrichment.references || [], ...purposeEntry.references])
+        ];
+      }
+      if (purposeEntry.referencedBy) {
+        enrichment.referencedBy = [
+          .../* @__PURE__ */ new Set([...enrichment.referencedBy || [], ...purposeEntry.referencedBy])
+        ];
+      }
+    }
+    this.symbolCache.set(symbol, enrichment);
+    return enrichment;
+  }
+  /**
+   * Find symbol in premise index
+   */
+  findInSymbolIndex(symbol) {
+    const indexPath = path32.join(this.projectRoot, ".paradigm", "index.json");
+    if (!fs32.existsSync(indexPath)) {
+      return null;
+    }
+    try {
+      const indexContent = fs32.readFileSync(indexPath, "utf-8");
+      const index = JSON.parse(indexContent);
+      if (index.symbols && Array.isArray(index.symbols)) {
+        return index.symbols.find(
+          (s) => s.id === symbol
+        ) || null;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Find symbol in .purpose files
+   */
+  findInPurposeFiles(symbol) {
+    const searchPaths = this.getSearchPathsForSymbol(symbol);
+    for (const searchPath of searchPaths) {
+      const fullPath = path32.join(this.projectRoot, searchPath);
+      if (!fs32.existsSync(fullPath)) {
+        continue;
+      }
+      const cached = this.purposeCache.get(fullPath);
+      if (cached) {
+        if (cached.symbol === symbol) {
+          return cached;
+        }
+        continue;
+      }
+      try {
+        const content = fs32.readFileSync(fullPath, "utf-8");
+        const purpose = this.parsePurposeFile(content);
+        this.purposeCache.set(fullPath, purpose);
+        if (purpose.symbol === symbol) {
+          return purpose;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get potential file paths for a symbol
+   */
+  getSearchPathsForSymbol(symbol) {
+    const paths = [];
+    const cleanSymbol = symbol.replace(/^[@#$%^!&~?]/, "");
+    const prefixDirs = {
+      "@": ["features", "src/features"],
+      "#": ["components", "src/components"],
+      "$": ["flows", "src/flows"],
+      "^": ["middleware", "gates", "src/middleware"],
+      "!": ["signals", "events", "src/signals"],
+      "%": ["state", "store", "src/state"],
+      "&": ["integrations", "services", "src/integrations"]
+    };
+    const prefix = symbol[0];
+    const dirs = prefixDirs[prefix] || [];
+    for (const dir of dirs) {
+      paths.push(path32.join(dir, cleanSymbol, ".purpose"));
+      paths.push(path32.join(dir, `${cleanSymbol}.purpose`));
+    }
+    paths.push(path32.join(".paradigm", "purposes", `${cleanSymbol}.yaml`));
+    paths.push(path32.join(".paradigm", "purposes", `${cleanSymbol}.json`));
+    return paths;
+  }
+  /**
+   * Parse a .purpose file
+   */
+  parsePurposeFile(content) {
+    const result = {};
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("symbol:")) {
+        result.symbol = trimmed.substring(7).trim();
+      } else if (trimmed.startsWith("description:")) {
+        result.description = trimmed.substring(12).trim();
+      } else if (trimmed.startsWith("purpose:")) {
+        result.description = trimmed.substring(8).trim();
+      }
+    }
+    if (!result.description) {
+      const firstLine = lines.find((l) => l.trim() && !l.startsWith("#"));
+      if (firstLine) {
+        result.description = firstLine.trim();
+      }
+    }
+    return result;
+  }
+  /**
+   * Clear caches
+   */
+  clearCache() {
+    this.symbolCache.clear();
+    this.purposeCache.clear();
+  }
+  /**
+   * Batch enrich multiple incidents
+   */
+  enrichBatch(incidents) {
+    return incidents.map((i) => this.enrich(i));
+  }
+};
+var PatternSuggester = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * Suggest a pattern from a resolved incident
+   */
+  suggestFromIncident(incident) {
+    const baseId = this.generatePatternId(incident);
+    const symbols = this.buildSymbolCriteria(incident.symbols);
+    const errorKeywords = this.extractErrorKeywords(incident.error.message);
+    const pattern = {
+      id: baseId,
+      name: this.generatePatternName(incident),
+      description: `Auto-suggested pattern from incident ${incident.id}`,
+      pattern: {
+        symbols,
+        errorContains: errorKeywords.length > 0 ? errorKeywords : void 0,
+        missingSignals: incident.flowPosition?.missing
+      },
+      resolution: {
+        description: incident.resolution?.notes || "Resolution approach TBD",
+        strategy: this.inferStrategy([incident]),
+        priority: "medium"
+      },
+      source: "suggested",
+      private: false,
+      tags: this.generateTags(incident)
+    };
+    return pattern;
+  }
+  /**
+   * Suggest a pattern from an incident group
+   */
+  suggestFromGroup(group) {
+    const baseId = `group-${group.id.toLowerCase().replace(/[^a-z0-9]/g, "-")}`;
+    const symbols = this.buildSymbolCriteria(group.commonSymbols);
+    const groupIncidents = group.incidents.slice(0, 20).map((id) => this.storage.getIncident(id)).filter((i) => i != null);
+    const pattern = {
+      id: baseId,
+      name: group.name || `Pattern from group ${group.id}`,
+      description: `Auto-suggested pattern from incident group with ${group.count} incidents`,
+      pattern: {
+        symbols,
+        errorContains: group.commonErrorPatterns.length > 0 ? group.commonErrorPatterns : void 0
+      },
+      resolution: {
+        description: "Resolution approach TBD based on grouped incidents",
+        strategy: groupIncidents.length > 0 ? this.inferStrategy(groupIncidents) : "fix-code",
+        priority: this.getPriorityFromCount(group.count)
+      },
+      source: "suggested",
+      private: false,
+      tags: this.generateTagsFromGroup(group)
+    };
+    return pattern;
+  }
+  /**
+   * Find incidents that could become patterns
+   */
+  findPatternCandidates(minOccurrences = 3) {
+    const incidents = this.storage.getRecentIncidents({
+      limit: 1e3,
+      status: "resolved"
+    });
+    const signatureGroups = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      const signature = this.getSymbolSignature(incident.symbols);
+      const existing = signatureGroups.get(signature) || [];
+      existing.push(incident);
+      signatureGroups.set(signature, existing);
+    }
+    const candidates = [];
+    for (const [, groupIncidents] of signatureGroups) {
+      if (groupIncidents.length >= minOccurrences) {
+        const hasPattern = this.hasMatchingPattern(groupIncidents[0]);
+        if (hasPattern) continue;
+        const suggestedPattern = this.suggestFromIncidents(groupIncidents);
+        candidates.push({
+          incidents: groupIncidents,
+          suggestedPattern,
+          occurrenceCount: groupIncidents.length
+        });
+      }
+    }
+    return candidates.sort((a, b) => b.occurrenceCount - a.occurrenceCount);
+  }
+  /**
+   * Generate pattern from multiple similar incidents
+   */
+  suggestFromIncidents(incidents) {
+    const commonSymbols = this.extractCommonSymbols(incidents);
+    const symbols = this.buildSymbolCriteria(commonSymbols);
+    const errorKeywords = this.extractCommonErrorKeywords(incidents);
+    const missingSignals = this.extractCommonMissingSignals(incidents);
+    const baseId = this.generatePatternId(incidents[0]);
+    return {
+      id: baseId,
+      name: this.generatePatternName(incidents[0]),
+      description: `Auto-suggested pattern from ${incidents.length} similar incidents`,
+      pattern: {
+        symbols,
+        errorContains: errorKeywords.length > 0 ? errorKeywords : void 0,
+        missingSignals: missingSignals.length > 0 ? missingSignals : void 0
+      },
+      resolution: {
+        description: "Resolution approach based on previous resolutions",
+        strategy: this.inferStrategy(incidents),
+        priority: this.getPriorityFromCount(incidents.length)
+      },
+      source: "suggested",
+      private: false,
+      tags: this.generateTagsFromIncidents(incidents)
+    };
+  }
+  /**
+   * Build symbol criteria for pattern, adding wildcards where appropriate
+   */
+  buildSymbolCriteria(symbols) {
+    const criteria = {};
+    for (const [key, value] of Object.entries(symbols)) {
+      if (value) {
+        criteria[key] = value;
+      }
+    }
+    return criteria;
+  }
+  /**
+   * Extract keywords from error message
+   */
+  extractErrorKeywords(message) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "of",
+      "with",
+      "and",
+      "or",
+      "but",
+      "not",
+      "no",
+      "be",
+      "been",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did"
+    ]);
+    const words = message.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+    const unique = [...new Set(words)];
+    return unique.slice(0, 5);
+  }
+  /**
+   * Extract common error keywords from multiple incidents
+   */
+  extractCommonErrorKeywords(incidents) {
+    const wordCounts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      const keywords = this.extractErrorKeywords(incident.error.message);
+      for (const keyword of keywords) {
+        wordCounts.set(keyword, (wordCounts.get(keyword) || 0) + 1);
+      }
+    }
+    const threshold = Math.ceil(incidents.length * 0.5);
+    return Array.from(wordCounts.entries()).filter(([, count]) => count >= threshold).map(([word]) => word).slice(0, 5);
+  }
+  /**
+   * Extract symbols common to all incidents
+   */
+  extractCommonSymbols(incidents) {
+    if (incidents.length === 0) return {};
+    const first = incidents[0].symbols;
+    const common = {};
+    for (const [key, value] of Object.entries(first)) {
+      if (!value) continue;
+      const allMatch = incidents.every(
+        (i) => i.symbols[key] === value
+      );
+      if (allMatch) {
+        common[key] = value;
+      }
+    }
+    return common;
+  }
+  /**
+   * Extract missing signals common to multiple incidents
+   */
+  extractCommonMissingSignals(incidents) {
+    const signalCounts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      if (!incident.flowPosition?.missing) continue;
+      for (const signal of incident.flowPosition.missing) {
+        signalCounts.set(signal, (signalCounts.get(signal) || 0) + 1);
+      }
+    }
+    const threshold = Math.ceil(incidents.length * 0.5);
+    return Array.from(signalCounts.entries()).filter(([, count]) => count >= threshold).map(([signal]) => signal);
+  }
+  /**
+   * Generate a pattern ID from incident
+   */
+  generatePatternId(incident) {
+    const parts = [];
+    if (incident.symbols.gate) {
+      parts.push(incident.symbols.gate.replace(/[^a-z0-9]/gi, ""));
+    } else if (incident.symbols.feature) {
+      parts.push(incident.symbols.feature.replace(/[^a-z0-9]/gi, ""));
+    } else if (incident.symbols.component) {
+      parts.push(incident.symbols.component.replace(/[^a-z0-9]/gi, ""));
+    } else if (incident.symbols.integration) {
+      parts.push(incident.symbols.integration.replace(/[^a-z0-9]/gi, ""));
+    } else {
+      parts.push("unknown");
+    }
+    const errorType = incident.error.type?.toLowerCase() || "error";
+    parts.push(errorType.replace(/[^a-z0-9]/gi, ""));
+    parts.push(String(Date.now() % 1e3).padStart(3, "0"));
+    return parts.join("-");
+  }
+  /**
+   * Generate a human-readable pattern name
+   */
+  generatePatternName(incident) {
+    const parts = [];
+    if (incident.symbols.feature) {
+      parts.push(
+        incident.symbols.feature.replace("@", "").replace(/-/g, " ")
+      );
+    }
+    if (incident.symbols.gate) {
+      parts.push("gate " + incident.symbols.gate.replace("^", ""));
+    }
+    if (incident.error.type) {
+      parts.push(incident.error.type);
+    }
+    if (parts.length === 0) {
+      return "Unnamed Pattern";
+    }
+    const name = parts.join(" - ");
+    return name.charAt(0).toUpperCase() + name.slice(1);
+  }
+  /**
+   * Generate tags from incident
+   */
+  generateTags(incident) {
+    const tags = [];
+    if (incident.symbols.feature) {
+      tags.push("feature");
+    }
+    if (incident.symbols.gate) {
+      tags.push("gate");
+    }
+    if (incident.symbols.integration) {
+      tags.push("integration");
+      tags.push(incident.symbols.integration.replace("&", ""));
+    }
+    if (incident.error.type) {
+      tags.push(incident.error.type.toLowerCase());
+    }
+    tags.push(incident.environment);
+    return [...new Set(tags)].slice(0, 5);
+  }
+  /**
+   * Generate tags from incident group
+   */
+  generateTagsFromGroup(group) {
+    const tags = ["grouped"];
+    if (group.commonSymbols.feature) {
+      tags.push("feature");
+    }
+    if (group.commonSymbols.gate) {
+      tags.push("gate");
+    }
+    if (group.commonSymbols.integration) {
+      tags.push("integration");
+    }
+    for (const env of group.environments) {
+      tags.push(env);
+    }
+    return [...new Set(tags)].slice(0, 5);
+  }
+  /**
+   * Generate tags from multiple incidents
+   */
+  generateTagsFromIncidents(incidents) {
+    const tagCounts = /* @__PURE__ */ new Map();
+    for (const incident of incidents) {
+      const tags = this.generateTags(incident);
+      for (const tag of tags) {
+        tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+      }
+    }
+    return Array.from(tagCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([tag]) => tag);
+  }
+  /**
+   * Get symbol signature for grouping
+   */
+  getSymbolSignature(symbols) {
+    const parts = [];
+    if (symbols.feature) parts.push(`f:${symbols.feature}`);
+    if (symbols.component) parts.push(`c:${symbols.component}`);
+    if (symbols.flow) parts.push(`fl:${symbols.flow}`);
+    if (symbols.gate) parts.push(`g:${symbols.gate}`);
+    if (symbols.integration) parts.push(`i:${symbols.integration}`);
+    return parts.sort().join("|");
+  }
+  /**
+   * Check if there's already a pattern matching this incident
+   */
+  hasMatchingPattern(incident) {
+    const patterns = this.storage.getAllPatterns({ includePrivate: true });
+    for (const pattern of patterns) {
+      let matchCount = 0;
+      const symbolTypes = [
+        "feature",
+        "component",
+        "flow",
+        "gate",
+        "signal",
+        "integration"
+      ];
+      for (const type of symbolTypes) {
+        const patternValue = pattern.pattern.symbols[type];
+        const incidentValue = incident.symbols[type];
+        if (patternValue && incidentValue && patternValue === incidentValue) {
+          matchCount++;
+        }
+      }
+      if (matchCount >= 2) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Infer resolution strategy from incident error patterns and context.
+   * Uses keyword heuristics across all incident messages to pick the
+   * most likely resolution approach.
+   */
+  inferStrategy(incidents) {
+    const messages = incidents.map((i) => i.error.message.toLowerCase());
+    const hasKeyword = (keywords) => messages.some((m) => keywords.some((k) => m.includes(k)));
+    if (hasKeyword(["revert", "rollback", "regression", "broke after deploy", "since deploy"])) {
+      return "rollback";
+    }
+    if (hasKeyword(["config", "environment variable", "env var", "missing key", "secret", "credential"])) {
+      return "config-change";
+    }
+    if (hasKeyword(["out of memory", "oom", "heap", "memory limit", "capacity", "too many connections", "pool exhausted"])) {
+      return "scale-up";
+    }
+    if (hasKeyword(["timeout", "network", "econnrefused", "econnreset", "dns", "socket hang up"])) {
+      return "retry";
+    }
+    if (hasKeyword(["unavailable", "service down", "circuit breaker", "fallback", "503", "502"])) {
+      return "fallback";
+    }
+    if (hasKeyword(["validation", "invalid", "required", "constraint", "duplicate", "not found", "404"])) {
+      return "fix-data";
+    }
+    if (hasKeyword(["permission", "forbidden", "403", "401", "unauthorized", "access denied"])) {
+      return "escalate";
+    }
+    const uniqueTypes = new Set(incidents.map((i) => i.error.type).filter(Boolean));
+    if (uniqueTypes.size > 2) {
+      return "investigate";
+    }
+    return "fix-code";
+  }
+  /**
+   * Get priority based on occurrence count
+   */
+  getPriorityFromCount(count) {
+    if (count >= 20) return "critical";
+    if (count >= 10) return "high";
+    if (count >= 5) return "medium";
+    return "low";
+  }
+};
+var PatternImporter = class {
+  /**
+   * Validate a pattern export file
+   */
+  validate(data) {
+    const errors = [];
+    const warnings = [];
+    if (!data || typeof data !== "object") {
+      return { valid: false, errors: ["Invalid data: expected object"], warnings: [] };
+    }
+    const obj = data;
+    if (!obj.version) {
+      errors.push("Missing version field");
+    }
+    if (!Array.isArray(obj.patterns)) {
+      errors.push("Missing or invalid patterns array");
+      return { valid: false, errors, warnings };
+    }
+    for (let i = 0; i < obj.patterns.length; i++) {
+      const pattern = obj.patterns[i];
+      const patternErrors = this.validatePattern(pattern, i);
+      errors.push(...patternErrors.errors);
+      warnings.push(...patternErrors.warnings);
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Validate a single pattern
+   */
+  validatePattern(pattern, index) {
+    const errors = [];
+    const warnings = [];
+    const prefix = `Pattern[${index}]`;
+    if (!pattern.id || typeof pattern.id !== "string") {
+      errors.push(`${prefix}: Missing or invalid id`);
+    } else if (!/^[a-z0-9-]+$/.test(pattern.id)) {
+      warnings.push(`${prefix}: ID "${pattern.id}" should be kebab-case`);
+    }
+    if (!pattern.name || typeof pattern.name !== "string") {
+      errors.push(`${prefix}: Missing or invalid name`);
+    }
+    if (!pattern.pattern || typeof pattern.pattern !== "object") {
+      errors.push(`${prefix}: Missing or invalid pattern criteria`);
+    } else {
+      const criteria = pattern.pattern;
+      const hasSymbols = criteria.symbols && typeof criteria.symbols === "object" && Object.keys(criteria.symbols).length > 0;
+      const hasErrorContains = Array.isArray(criteria.errorContains) && criteria.errorContains.length > 0;
+      const hasErrorMatches = criteria.errorMatches && typeof criteria.errorMatches === "string";
+      const hasMissingSignals = Array.isArray(criteria.missingSignals) && criteria.missingSignals.length > 0;
+      if (!hasSymbols && !hasErrorContains && !hasErrorMatches && !hasMissingSignals) {
+        errors.push(`${prefix}: Pattern must have at least one matching criteria`);
+      }
+    }
+    if (!pattern.resolution || typeof pattern.resolution !== "object") {
+      errors.push(`${prefix}: Missing or invalid resolution`);
+    } else {
+      const resolution = pattern.resolution;
+      if (!resolution.description || typeof resolution.description !== "string") {
+        errors.push(`${prefix}: Missing resolution description`);
+      }
+      if (!resolution.strategy || typeof resolution.strategy !== "string") {
+        errors.push(`${prefix}: Missing resolution strategy`);
+      } else {
+        const validStrategies = [
+          "retry",
+          "fallback",
+          "fix-data",
+          "fix-code",
+          "ignore",
+          "escalate"
+        ];
+        if (!validStrategies.includes(resolution.strategy)) {
+          errors.push(`${prefix}: Invalid strategy "${resolution.strategy}"`);
+        }
+      }
+      if (!resolution.priority || typeof resolution.priority !== "string") {
+        warnings.push(`${prefix}: Missing priority, will default to medium`);
+      } else {
+        const validPriorities = ["low", "medium", "high", "critical"];
+        if (!validPriorities.includes(resolution.priority)) {
+          warnings.push(`${prefix}: Invalid priority "${resolution.priority}"`);
+        }
+      }
+    }
+    return { errors, warnings };
+  }
+  /**
+   * Load patterns from a JSON file
+   */
+  loadFromFile(filePath) {
+    if (!fs4.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const content = fs4.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    const validation = this.validate(data);
+    if (!validation.valid) {
+      throw new Error(`Invalid pattern file: ${validation.errors.join(", ")}`);
+    }
+    return this.normalizeExport(data);
+  }
+  /**
+   * Load patterns from a URL
+   */
+  async loadFromUrl(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch patterns: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const validation = this.validate(data);
+    if (!validation.valid) {
+      throw new Error(`Invalid pattern data: ${validation.errors.join(", ")}`);
+    }
+    return this.normalizeExport(data);
+  }
+  /**
+   * Normalize raw data to PatternExport
+   */
+  normalizeExport(data) {
+    const patterns = data.patterns.map(
+      (p) => this.normalizePattern(p)
+    );
+    return {
+      version: data.version || "1.0.0",
+      exportedAt: data.exportedAt || (/* @__PURE__ */ new Date()).toISOString(),
+      patterns
+    };
+  }
+  /**
+   * Normalize a raw pattern object
+   */
+  normalizePattern(data) {
+    const pattern = data.pattern;
+    const resolution = data.resolution;
+    const confidence = data.confidence || {};
+    return {
+      id: data.id,
+      name: data.name,
+      description: data.description || "",
+      pattern: {
+        symbols: pattern.symbols || {},
+        errorContains: pattern.errorContains,
+        errorMatches: pattern.errorMatches,
+        errorType: pattern.errorType,
+        missingSignals: pattern.missingSignals,
+        environment: pattern.environment
+      },
+      resolution: {
+        description: resolution.description,
+        strategy: resolution.strategy,
+        priority: resolution.priority || "medium",
+        codeHint: resolution.codeHint,
+        codeSnippet: resolution.codeSnippet,
+        symbolsToModify: resolution.symbolsToModify,
+        filesLikelyInvolved: resolution.filesLikelyInvolved,
+        commitRef: resolution.commitRef,
+        prRef: resolution.prRef,
+        docsRef: resolution.docsRef
+      },
+      confidence: {
+        score: confidence.score || 50,
+        timesMatched: confidence.timesMatched || 0,
+        timesResolved: confidence.timesResolved || 0,
+        timesRecurred: confidence.timesRecurred || 0,
+        avgTimeToResolve: confidence.avgTimeToResolve,
+        lastMatched: confidence.lastMatched,
+        lastResolved: confidence.lastResolved
+      },
+      source: data.source || "imported",
+      private: Boolean(data.private),
+      tags: data.tags || [],
+      createdAt: data.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: data.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Merge patterns from multiple sources
+   */
+  mergePatterns(...exports) {
+    const patternMap = /* @__PURE__ */ new Map();
+    for (const exp of exports) {
+      for (const pattern of exp.patterns) {
+        patternMap.set(pattern.id, pattern);
+      }
+    }
+    return {
+      version: "1.0.0",
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      patterns: Array.from(patternMap.values())
+    };
+  }
+};
+
+export {
+  SentinelClient,
+  createSentinelClient,
+  SentinelTransport,
+  createSentinelTransport,
+  enableSentinel,
+  SentinelStorage,
+  DEFAULT_AUTH_CONFIG,
+  DEFAULT_RATE_LIMIT_CONFIG,
+  DEFAULT_SERVER_CONFIG,
+  loadConfig,
+  writeConfig,
+  loadServerConfig,
+  PatternMatcher,
+  loadUniversalPatterns,
+  loadParadigmPatterns,
+  loadAllSeedPatterns,
+  FlowTracker,
+  Sentinel,
+  detectSymbols,
+  generateConfig,
+  IncidentGrouper,
+  TimelineBuilder,
+  StatsCalculator,
+  ContextEnricher,
+  PatternSuggester,
+  PatternImporter
+};