@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-ZSYVKSY6.js

@@ -1,2602 +0,0 @@
-#!/usr/bin/env node
-import {
-  SentinelStorage
-} from "./chunk-FKJUBQU3.js";
-
-// ../sentinel/dist/chunk-VQ3SIN7S.js
-import { v4 as uuidv4 } from "uuid";
-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 = uuidv4();
-    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] || uuidv4() : uuidv4();
-    const spanId = uuidv4();
-    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;
-}
-
-// ../sentinel/dist/index.js
-import * as path from "path";
-import * as fs from "fs";
-import { fileURLToPath } from "url";
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as fs3 from "fs";
-import * as path3 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 = path.dirname(__filename);
-function loadUniversalPatterns() {
-  const filePath = path.join(__dirname, "universal-patterns.json");
-  const content = fs.readFileSync(filePath, "utf-8");
-  return JSON.parse(content);
-}
-function loadParadigmPatterns() {
-  const filePath = path.join(__dirname, "paradigm-patterns.json");
-  const content = fs.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 = path2.join(projectDir, dir);
-      if (!fs2.existsSync(fullPath)) continue;
-      const files = safeReaddir(fullPath);
-      for (const file of files) {
-        const ext = path2.extname(file);
-        if (!CODE_EXTENSIONS.has(ext)) continue;
-        const name = path2.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: path2.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 = path2.join(projectDir, ".paradigm");
-  if (!fs2.existsSync(paradigmDir)) return null;
-  const result = {
-    components: [],
-    gates: [],
-    flows: [],
-    signals: [],
-    routes: {}
-  };
-  const purposeFiles = findFiles(projectDir, ".purpose");
-  for (const file of purposeFiles) {
-    try {
-      const content = fs2.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 = path2.join(projectDir, dir);
-    if (!fs2.existsSync(fullPath)) continue;
-    const files = safeReaddir(fullPath);
-    for (const file of files) {
-      const ext = path2.extname(file);
-      if (!CODE_EXTENSIONS.has(ext)) continue;
-      const name = path2.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 fs2.readdirSync(dir).filter((f) => {
-      const fullPath = path2.join(dir, f);
-      try {
-        return fs2.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 = fs2.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === filename) {
-        results.push(path2.join(dir, entry.name));
-      } else if (entry.isDirectory() && !skipDirs.has(entry.name)) {
-        results.push(...findFiles(path2.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 = path3.join(this.projectRoot, ".paradigm", "index.json");
-    if (!fs3.existsSync(indexPath)) {
-      return null;
-    }
-    try {
-      const indexContent = fs3.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 = path3.join(this.projectRoot, searchPath);
-      if (!fs3.existsSync(fullPath)) {
-        continue;
-      }
-      const cached = this.purposeCache.get(fullPath);
-      if (cached) {
-        if (cached.symbol === symbol) {
-          return cached;
-        }
-        continue;
-      }
-      try {
-        const content = fs3.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(path3.join(dir, cleanSymbol, ".purpose"));
-      paths.push(path3.join(dir, `${cleanSymbol}.purpose`));
-    }
-    paths.push(path3.join(".paradigm", "purposes", `${cleanSymbol}.yaml`));
-    paths.push(path3.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,
-  PatternMatcher,
-  loadUniversalPatterns,
-  loadParadigmPatterns,
-  loadAllSeedPatterns,
-  FlowTracker,
-  Sentinel,
-  detectSymbols,
-  generateConfig,
-  IncidentGrouper,
-  TimelineBuilder,
-  StatsCalculator,
-  ContextEnricher,
-  PatternSuggester,
-  PatternImporter
-};