@a-company/paradigm 3.0.2 → 3.1.0

package/dist/{triage-RM5KNG5V.js → chunk-4LGLU2LO.js}

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import {
   SentinelStorage
-} from "./chunk-S65LENNL.js";
-import "./chunk-MO4EEYFW.js";
-
-// src/commands/triage/index.ts
-import chalk2 from "chalk";
-import ora from "ora";
+} from "./chunk-VZ7CXFRZ.js";
 
 // ../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";
+import * as path4 from "path";
 import * as fs5 from "fs";
 var DEFAULT_CONFIG = {
   minScore: 30,
@@ -19,8 +20,8 @@ var DEFAULT_CONFIG = {
   boostConfidence: true
 };
 var PatternMatcher = class {
-  constructor(storage2) {
-    this.storage = storage2;
+  constructor(storage) {
+    this.storage = storage;
   }
   /**
    * Match an incident against all patterns and return ranked results
@@ -253,6 +254,831 @@ function loadAllSeedPatterns() {
     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 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 = {};
+      }
+      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;
+    }
+  }
+  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}`);
+      }
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+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 = path3.join(projectDir, dir);
+      if (!fs3.existsSync(fullPath)) continue;
+      const files = safeReaddir(fullPath);
+      for (const file of files) {
+        const ext = path3.extname(file);
+        if (!CODE_EXTENSIONS.has(ext)) continue;
+        const name = path3.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: path3.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 = path3.join(projectDir, ".paradigm");
+  if (!fs3.existsSync(paradigmDir)) return null;
+  const result = {
+    components: [],
+    gates: [],
+    flows: [],
+    signals: [],
+    routes: {}
+  };
+  const purposeFiles = findFiles(projectDir, ".purpose");
+  for (const file of purposeFiles) {
+    try {
+      const content = fs3.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 = path3.join(projectDir, dir);
+    if (!fs3.existsSync(fullPath)) continue;
+    const files = safeReaddir(fullPath);
+    for (const file of files) {
+      const ext = path3.extname(file);
+      if (!CODE_EXTENSIONS.has(ext)) continue;
+      const name = path3.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 fs3.readdirSync(dir).filter((f) => {
+      const fullPath = path3.join(dir, f);
+      try {
+        return fs3.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 = fs3.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === filename) {
+        results.push(path3.join(dir, entry.name));
+      } else if (entry.isDirectory() && !skipDirs.has(entry.name)) {
+        results.push(...findFiles(path3.join(dir, entry.name), filename, maxDepth, depth + 1));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+var SIMILARITY_THRESHOLD = 0.6;
+var IncidentGrouper = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * 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 >= SIMILARITY_THRESHOLD) {
+        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) >= SIMILARITY_THRESHOLD
+      );
+      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)
+   */
+  calculateSimilarity(a, b) {
+    let score = 0;
+    let maxScore = 0;
+    const symbolWeight = 0.6;
+    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 errorWeight = 0.3;
+    const errorSimilarity = this.stringSimilarity(
+      a.error.message,
+      b.error.message
+    );
+    score += errorWeight * errorSimilarity;
+    maxScore += errorWeight;
+    const envWeight = 0.1;
+    if (a.environment === b.environment) {
+      score += envWeight;
+    }
+    maxScore += envWeight;
+    return maxScore > 0 ? score / maxScore : 0;
+  }
+  /**
+   * 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
@@ -426,8 +1252,8 @@ var TimelineBuilder = class {
   }
 };
 var StatsCalculator = class {
-  constructor(storage2) {
-    this.storage = storage2;
+  constructor(storage) {
+    this.storage = storage;
   }
   /**
    * Get comprehensive statistics for a time period
@@ -653,9 +1479,190 @@ var StatsCalculator = class {
     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 = path4.join(this.projectRoot, ".paradigm", "index.json");
+    if (!fs4.existsSync(indexPath)) {
+      return null;
+    }
+    try {
+      const indexContent = fs4.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 = path4.join(this.projectRoot, searchPath);
+      if (!fs4.existsSync(fullPath)) {
+        continue;
+      }
+      const cached = this.purposeCache.get(fullPath);
+      if (cached) {
+        if (cached.symbol === symbol) {
+          return cached;
+        }
+        continue;
+      }
+      try {
+        const content = fs4.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(path4.join(dir, cleanSymbol, ".purpose"));
+      paths.push(path4.join(dir, `${cleanSymbol}.purpose`));
+    }
+    paths.push(path4.join(".paradigm", "purposes", `${cleanSymbol}.yaml`));
+    paths.push(path4.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(storage2) {
-    this.storage = storage2;
+  constructor(storage) {
+    this.storage = storage;
   }
   /**
    * Suggest a pattern from a resolved incident
@@ -1224,656 +2231,21 @@ var PatternImporter = class {
   }
 };
 
-// src/commands/triage/utils/format.ts
-import chalk from "chalk";
-function formatHeader() {
-  return `
-${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
-${chalk.cyan("\u2551")}                    ${chalk.bold.white("PARADIGM SENTINEL TRIAGE")}                      ${chalk.cyan("\u2551")}
-${chalk.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
-`;
-}
-function formatSummaryBar(stats) {
-  return `${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
-${chalk.cyan("\u2551")}  Open: ${chalk.yellow(String(stats.open).padEnd(4))} \u2502  Investigating: ${chalk.blue(String(stats.investigating).padEnd(3))} \u2502  Resolved: ${chalk.green(String(stats.resolved).padEnd(4))} \u2502  Today: ${chalk.magenta(`+${stats.today}`)}   ${chalk.cyan("\u2551")}
-${chalk.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
-`;
-}
-function formatIncident(incident, matches) {
-  const lines = [];
-  const statusColor = getStatusColor(incident.status);
-  lines.push(
-    chalk.gray("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510")
-  );
-  lines.push(
-    chalk.gray("\u2502 ") + chalk.bold(`[${incident.id}] `) + statusColor(incident.status.toUpperCase().padEnd(12)) + chalk.gray(incident.timestamp.substring(0, 19).replace("T", " ").padStart(19)) + chalk.gray(" \u2502")
-  );
-  lines.push(
-    chalk.gray("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524")
-  );
-  lines.push(chalk.gray("\u2502 ") + chalk.red("Error: ") + truncate(incident.error.message, 55) + chalk.gray(" \u2502"));
-  lines.push(chalk.gray("\u2502") + " ".repeat(65) + chalk.gray("\u2502"));
-  lines.push(chalk.gray("\u2502 ") + chalk.cyan("Symbolic Context:") + " ".repeat(47) + chalk.gray("\u2502"));
-  const symbols = formatSymbols(incident.symbols);
-  for (const sym of symbols) {
-    lines.push(chalk.gray("\u2502   ") + sym.padEnd(61) + chalk.gray(" \u2502"));
-  }
-  lines.push(chalk.gray("\u2502") + " ".repeat(65) + chalk.gray("\u2502"));
-  const envLine = `Environment: ${chalk.yellow(incident.environment)}  \u2502  Service: ${chalk.yellow(incident.service || "N/A")}  \u2502  v${incident.version || "N/A"}`;
-  lines.push(chalk.gray("\u2502 ") + envLine.substring(0, 63).padEnd(63) + chalk.gray(" \u2502"));
-  if (matches && matches.length > 0) {
-    lines.push(chalk.gray("\u2502") + " ".repeat(65) + chalk.gray("\u2502"));
-    lines.push(
-      chalk.gray("\u2502 \u250C\u2500 ") + chalk.cyan("Matched Patterns") + chalk.gray(" \u2500".repeat(22) + "\u2510 \u2502")
-    );
-    for (let i = 0; i < Math.min(matches.length, 3); i++) {
-      const match = matches[i];
-      const icon = i === 0 ? chalk.yellow("\u2605") : chalk.gray("\u25CB");
-      const conf = `${match.confidence}% confidence`;
-      lines.push(
-        chalk.gray("\u2502 \u2502 ") + icon + " " + chalk.bold(truncate(match.pattern.id, 30).padEnd(30)) + chalk.gray(conf.padStart(15)) + chalk.gray("    \u2502 \u2502")
-      );
-      lines.push(
-        chalk.gray("\u2502 \u2502   ") + chalk.italic(truncate(match.pattern.description, 45).padEnd(45)) + chalk.gray("     \u2502 \u2502")
-      );
-      lines.push(
-        chalk.gray("\u2502 \u2502   Strategy: ") + chalk.cyan(match.pattern.resolution.strategy.padEnd(40)) + chalk.gray("     \u2502 \u2502")
-      );
-      if (i < Math.min(matches.length, 3) - 1) {
-        lines.push(chalk.gray("\u2502 \u2502") + " ".repeat(59) + chalk.gray("\u2502 \u2502"));
-      }
-    }
-    lines.push(
-      chalk.gray("\u2502 \u2514") + "\u2500".repeat(59) + chalk.gray("\u2518 \u2502")
-    );
-  }
-  lines.push(chalk.gray("\u2502") + " ".repeat(65) + chalk.gray("\u2502"));
-  lines.push(chalk.gray("\u2502 ") + chalk.dim("Actions:") + " ".repeat(56) + chalk.gray("\u2502"));
-  lines.push(
-    chalk.gray("\u2502   ") + chalk.dim(`paradigm triage resolve ${incident.id}`) + " ".repeat(35 - incident.id.length) + chalk.gray("\u2502")
-  );
-  lines.push(
-    chalk.gray("\u2502   ") + chalk.dim(`paradigm triage show ${incident.id} --timeline`) + " ".repeat(28 - incident.id.length) + chalk.gray("\u2502")
-  );
-  lines.push(
-    chalk.gray("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")
-  );
-  return lines.join("\n");
-}
-function formatIncidentCompact(incident) {
-  const statusColor = getStatusColor(incident.status);
-  const status = statusColor(incident.status.substring(0, 4).toUpperCase().padEnd(4));
-  const timestamp = incident.timestamp.substring(5, 16).replace("T", " ");
-  const error = truncate(incident.error.message, 40);
-  const symbols = Object.values(incident.symbols).filter(Boolean).join(" ");
-  return `${chalk.bold(incident.id)} ${status} ${chalk.gray(timestamp)} ${error}
-    ${chalk.cyan(truncate(symbols, 60))}`;
-}
-function formatPattern(pattern) {
-  const lines = [];
-  lines.push(chalk.bold.cyan(`Pattern: ${pattern.id}`));
-  lines.push(chalk.white(`  Name: ${pattern.name}`));
-  lines.push(chalk.gray(`  Description: ${pattern.description}`));
-  lines.push("");
-  lines.push(chalk.yellow("  Matching Criteria:"));
-  if (pattern.pattern.symbols) {
-    for (const [key, value] of Object.entries(pattern.pattern.symbols)) {
-      if (value) {
-        const v = Array.isArray(value) ? value.join(", ") : value;
-        lines.push(`    ${chalk.cyan(key)}: ${v}`);
-      }
-    }
-  }
-  if (pattern.pattern.errorContains) {
-    lines.push(
-      `    ${chalk.cyan("errorContains")}: ${pattern.pattern.errorContains.join(", ")}`
-    );
-  }
-  if (pattern.pattern.missingSignals) {
-    lines.push(
-      `    ${chalk.cyan("missingSignals")}: ${pattern.pattern.missingSignals.join(", ")}`
-    );
-  }
-  lines.push("");
-  lines.push(chalk.green("  Resolution:"));
-  lines.push(`    ${chalk.white(pattern.resolution.description)}`);
-  lines.push(
-    `    Strategy: ${chalk.cyan(pattern.resolution.strategy)}  Priority: ${getPriorityColor(pattern.resolution.priority)(pattern.resolution.priority)}`
-  );
-  if (pattern.resolution.codeHint) {
-    lines.push(`    ${chalk.dim("Hint: " + pattern.resolution.codeHint)}`);
-  }
-  lines.push("");
-  lines.push(chalk.blue("  Confidence:"));
-  lines.push(
-    `    Score: ${getConfidenceColor(pattern.confidence.score)(pattern.confidence.score + "%")}  Matched: ${pattern.confidence.timesMatched}  Resolved: ${pattern.confidence.timesResolved}  Recurred: ${pattern.confidence.timesRecurred}`
-  );
-  lines.push("");
-  lines.push(
-    chalk.gray(
-      `  Source: ${pattern.source}  Tags: ${pattern.tags.join(", ") || "none"}`
-    )
-  );
-  return lines.join("\n");
-}
-function formatPatternCompact(pattern) {
-  const confidence = getConfidenceColor(pattern.confidence.score)(
-    `${pattern.confidence.score}%`
-  );
-  const tags = pattern.tags.slice(0, 3).join(", ");
-  return `${chalk.bold(pattern.id.padEnd(30))} ${confidence.padStart(8)}  ${chalk.gray(pattern.source.padEnd(10))} ${chalk.dim(tags)}
-  ${chalk.white(truncate(pattern.name, 60))}`;
-}
-function formatSymbols(symbols) {
-  const result = [];
-  for (const [key, value] of Object.entries(symbols)) {
-    if (value) {
-      const color = getSymbolColor(key);
-      result.push(`${color(value.padEnd(20))} ${chalk.dim(key)}`);
-    }
-  }
-  return result;
-}
-function getStatusColor(status) {
-  switch (status) {
-    case "open":
-      return chalk.red;
-    case "investigating":
-      return chalk.yellow;
-    case "resolved":
-      return chalk.green;
-    case "wont-fix":
-      return chalk.gray;
-    default:
-      return chalk.white;
-  }
-}
-function getSymbolColor(type) {
-  switch (type) {
-    case "feature":
-      return chalk.magenta;
-    case "component":
-      return chalk.blue;
-    case "flow":
-      return chalk.cyan;
-    case "gate":
-      return chalk.yellow;
-    case "signal":
-      return chalk.green;
-    case "state":
-      return chalk.red;
-    case "integration":
-      return chalk.white;
-    default:
-      return chalk.gray;
-  }
-}
-function getPriorityColor(priority) {
-  switch (priority) {
-    case "critical":
-      return chalk.red.bold;
-    case "high":
-      return chalk.red;
-    case "medium":
-      return chalk.yellow;
-    case "low":
-      return chalk.gray;
-    default:
-      return chalk.white;
-  }
-}
-function getConfidenceColor(score) {
-  if (score >= 80) return chalk.green;
-  if (score >= 60) return chalk.yellow;
-  if (score >= 40) return chalk.red;
-  return chalk.gray;
-}
-function truncate(str, maxLen) {
-  if (str.length <= maxLen) return str;
-  return str.substring(0, maxLen - 3) + "...";
-}
-
-// src/commands/triage/index.ts
-import * as fs2 from "fs";
-var storage = null;
-function getStorage() {
-  if (!storage) {
-    storage = new SentinelStorage();
-  }
-  return storage;
-}
-async function triageListCommand(options) {
-  const store = getStorage();
-  const matcher = new PatternMatcher(store);
-  const limit = parseInt(options.limit || "10", 10);
-  const status = options.status;
-  const incidents = store.getRecentIncidents({
-    limit,
-    status: status || "all",
-    symbol: options.symbol,
-    environment: options.env,
-    search: options.search,
-    dateFrom: options.from,
-    dateTo: options.to
-  });
-  if (options.json) {
-    const result = incidents.map((i) => ({
-      incident: i,
-      matches: matcher.match(i, { maxResults: 3 })
-    }));
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-  const stats = new StatsCalculator(store).getStats(7);
-  const todayStart = /* @__PURE__ */ new Date();
-  todayStart.setHours(0, 0, 0, 0);
-  const todayCount = store.getIncidentCount({
-    dateFrom: todayStart.toISOString()
-  });
-  console.log(formatHeader());
-  console.log(
-    formatSummaryBar({
-      open: stats.incidents.open,
-      investigating: stats.incidents.total - stats.incidents.open - stats.incidents.resolved,
-      resolved: stats.incidents.resolved,
-      today: todayCount
-    })
-  );
-  console.log("");
-  if (incidents.length === 0) {
-    console.log(chalk2.gray("No incidents found."));
-    return;
-  }
-  for (const incident of incidents) {
-    const matches = matcher.match(incident, { maxResults: 3 });
-    console.log(formatIncident(incident, matches));
-    console.log("");
-  }
-}
-async function triageShowCommand(incidentId, options) {
-  const store = getStorage();
-  const matcher = new PatternMatcher(store);
-  const incident = store.getIncident(incidentId);
-  if (!incident) {
-    console.log(chalk2.red(`Incident ${incidentId} not found.`));
-    return;
-  }
-  const matches = matcher.match(incident, { maxResults: 5 });
-  if (options.json) {
-    const result = { incident, matches };
-    if (options.timeline && incident.flowPosition) {
-      const timeline = new TimelineBuilder().build(incident);
-      result.timeline = timeline ? new TimelineBuilder().renderStructured(timeline) : null;
-    }
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-  console.log(formatIncident(incident, matches));
-  if (options.timeline && incident.flowPosition) {
-    const timeline = new TimelineBuilder().build(incident);
-    if (timeline) {
-      console.log("");
-      console.log(chalk2.cyan.bold("Flow Timeline"));
-      console.log(chalk2.gray("\u2500".repeat(50)));
-      console.log(new TimelineBuilder().renderAscii(timeline));
-    }
-  }
-  if (incident.notes.length > 0) {
-    console.log("");
-    console.log(chalk2.cyan.bold("Notes"));
-    console.log(chalk2.gray("\u2500".repeat(50)));
-    for (const note of incident.notes) {
-      console.log(
-        chalk2.gray(note.timestamp.substring(0, 16)) + " " + (note.author ? chalk2.yellow(note.author + ": ") : "") + note.content
-      );
-    }
-  }
-  if (incident.relatedIncidents.length > 0) {
-    console.log("");
-    console.log(chalk2.cyan.bold("Related Incidents"));
-    console.log(chalk2.gray("\u2500".repeat(50)));
-    console.log("  " + incident.relatedIncidents.join(", "));
-  }
-}
-async function triageResolveCommand(incidentId, options) {
-  const store = getStorage();
-  const incident = store.getIncident(incidentId);
-  if (!incident) {
-    console.log(chalk2.red(`Incident ${incidentId} not found.`));
-    return;
-  }
-  if (incident.status === "resolved" || incident.status === "wont-fix") {
-    console.log(chalk2.yellow(`Incident ${incidentId} is already ${incident.status}.`));
-    return;
-  }
-  if (options.wontFix) {
-    store.updateIncident(incidentId, {
-      status: "wont-fix",
-      resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      resolvedBy: "manual",
-      resolution: {
-        notes: options.notes
-      }
-    });
-    console.log(chalk2.gray(`Incident ${incidentId} marked as won't fix.`));
-    return;
-  }
-  store.recordResolution({
-    incidentId,
-    patternId: options.pattern,
-    commitHash: options.commit,
-    prUrl: options.pr,
-    notes: options.notes
-  });
-  console.log(chalk2.green(`Incident ${incidentId} resolved.`));
-  if (options.pattern) {
-    console.log(chalk2.gray(`  Pattern: ${options.pattern}`));
-  }
-  if (options.commit) {
-    console.log(chalk2.gray(`  Commit: ${options.commit}`));
-  }
-  if (options.pr) {
-    console.log(chalk2.gray(`  PR: ${options.pr}`));
-  }
-}
-async function triageNoteCommand(incidentId, note) {
-  const store = getStorage();
-  const incident = store.getIncident(incidentId);
-  if (!incident) {
-    console.log(chalk2.red(`Incident ${incidentId} not found.`));
-    return;
-  }
-  store.addIncidentNote(incidentId, {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    content: note
-  });
-  console.log(chalk2.green(`Note added to ${incidentId}.`));
-}
-async function triageLinkCommand(incidentId1, incidentId2) {
-  const store = getStorage();
-  const inc1 = store.getIncident(incidentId1);
-  const inc2 = store.getIncident(incidentId2);
-  if (!inc1) {
-    console.log(chalk2.red(`Incident ${incidentId1} not found.`));
-    return;
-  }
-  if (!inc2) {
-    console.log(chalk2.red(`Incident ${incidentId2} not found.`));
-    return;
-  }
-  store.linkIncidents(incidentId1, incidentId2);
-  console.log(chalk2.green(`Linked ${incidentId1} and ${incidentId2}.`));
-}
-async function triagePatternsListCommand(options) {
-  const store = getStorage();
-  const patterns = store.getAllPatterns({
-    source: options.source,
-    minConfidence: options.minConfidence ? parseInt(options.minConfidence, 10) : void 0,
-    includePrivate: true
-  });
-  if (options.json) {
-    console.log(JSON.stringify(patterns, null, 2));
-    return;
-  }
-  console.log(chalk2.cyan.bold("\nFailure Patterns"));
-  console.log(chalk2.gray("\u2500".repeat(70)));
-  if (patterns.length === 0) {
-    console.log(chalk2.gray("No patterns found. Run `paradigm triage patterns seed` to load defaults."));
-    return;
-  }
-  for (const pattern of patterns) {
-    console.log(formatPatternCompact(pattern));
-    console.log("");
-  }
-}
-async function triagePatternsShowCommand(patternId, options) {
-  const store = getStorage();
-  const pattern = store.getPattern(patternId);
-  if (!pattern) {
-    console.log(chalk2.red(`Pattern ${patternId} not found.`));
-    return;
-  }
-  if (options.json) {
-    console.log(JSON.stringify(pattern, null, 2));
-    return;
-  }
-  console.log(formatPattern(pattern));
-}
-async function triagePatternsAddCommand(options) {
-  const store = getStorage();
-  if (options.fromIncident) {
-    const incident = store.getIncident(options.fromIncident);
-    if (!incident) {
-      console.log(chalk2.red(`Incident ${options.fromIncident} not found.`));
-      return;
-    }
-    const suggester = new PatternSuggester(store);
-    const suggested = suggester.suggestFromIncident(incident);
-    console.log(chalk2.cyan("\nSuggested Pattern:"));
-    console.log(JSON.stringify(suggested, null, 2));
-    console.log(
-      chalk2.gray(
-        '\nEdit and add with: paradigm triage patterns add --id <id> --name "..." ...'
-      )
-    );
-    return;
-  }
-  const symbols = {};
-  if (options.symbols) {
-    const pairs = options.symbols.split(",");
-    for (const pair of pairs) {
-      const [key, value] = pair.split(":").map((s) => s.trim());
-      if (key && value) {
-        symbols[key] = value;
-      }
-    }
-  }
-  const input = {
-    id: options.id,
-    name: options.name,
-    description: options.description || "",
-    pattern: {
-      symbols,
-      errorContains: options.errorContains?.split(",").map((s) => s.trim()),
-      missingSignals: options.missingSignals?.split(",").map((s) => s.trim())
-    },
-    resolution: {
-      description: "Resolution TBD",
-      strategy: options.strategy || "fix-code",
-      priority: options.priority || "medium",
-      codeHint: options.codeHint
-    },
-    source: "manual",
-    private: false,
-    tags: options.tags?.split(",").map((s) => s.trim()) || []
-  };
-  store.addPattern(input);
-  console.log(chalk2.green(`Pattern ${options.id} created.`));
-}
-async function triagePatternsDeleteCommand(patternId) {
-  const store = getStorage();
-  const pattern = store.getPattern(patternId);
-  if (!pattern) {
-    console.log(chalk2.red(`Pattern ${patternId} not found.`));
-    return;
-  }
-  store.deletePattern(patternId);
-  console.log(chalk2.green(`Pattern ${patternId} deleted.`));
-}
-async function triagePatternsTestCommand(patternId, options) {
-  const store = getStorage();
-  const matcher = new PatternMatcher(store);
-  const pattern = store.getPattern(patternId);
-  if (!pattern) {
-    console.log(chalk2.red(`Pattern ${patternId} not found.`));
-    return;
-  }
-  const limit = parseInt(options.limit || "100", 10);
-  const result = matcher.testPattern(pattern, limit);
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-  console.log(chalk2.cyan.bold(`
-Pattern Test: ${patternId}`));
-  console.log(chalk2.gray("\u2500".repeat(50)));
-  console.log(`Would match: ${chalk2.yellow(result.matchCount)} incidents`);
-  console.log(`Average score: ${chalk2.yellow(result.avgScore + "%")}`);
-  if (result.wouldMatch.length > 0) {
-    console.log("");
-    console.log(chalk2.cyan("Sample matches:"));
-    for (const incident of result.wouldMatch.slice(0, 5)) {
-      console.log(formatIncidentCompact(incident));
-    }
-  }
-}
-async function triagePatternsSeedCommand() {
-  const store = getStorage();
-  const spinner = ora("Loading seed patterns...").start();
-  try {
-    const seedData = loadAllSeedPatterns();
-    const result = store.importPatterns(seedData, { overwrite: false });
-    spinner.succeed(
-      `Loaded ${result.imported} patterns (${result.skipped} skipped).`
-    );
-  } catch (error) {
-    spinner.fail(`Failed to load seed patterns: ${error}`);
-  }
-}
-async function triageExportCommand(type, options) {
-  const store = getStorage();
-  let data;
-  let defaultFilename;
-  if (type === "patterns") {
-    data = store.exportPatterns({
-      includePrivate: options.includePrivate
-    });
-    defaultFilename = "sentinel-patterns.json";
-  } else {
-    data = store.exportBackup();
-    defaultFilename = "sentinel-backup.json";
-  }
-  const outputPath = options.output || defaultFilename;
-  fs2.writeFileSync(outputPath, JSON.stringify(data, null, 2));
-  console.log(chalk2.green(`Exported to ${outputPath}`));
-}
-async function triageImportCommand(filePath, options) {
-  const store = getStorage();
-  const importer = new PatternImporter();
-  const spinner = ora(`Importing from ${filePath}...`).start();
-  try {
-    const data = importer.loadFromFile(filePath);
-    const result = store.importPatterns(data, {
-      overwrite: options.overwrite
-    });
-    spinner.succeed(
-      `Imported ${result.imported} patterns (${result.skipped} skipped).`
-    );
-  } catch (error) {
-    spinner.fail(`Import failed: ${error}`);
-  }
-}
-async function triageRestoreCommand(filePath) {
-  const store = getStorage();
-  const spinner = ora(`Restoring from ${filePath}...`).start();
-  try {
-    const content = fs2.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(content);
-    store.importBackup(data);
-    spinner.succeed("Backup restored.");
-  } catch (error) {
-    spinner.fail(`Restore failed: ${error}`);
-  }
-}
-async function triageStatsCommand(options) {
-  const store = getStorage();
-  const calculator = new StatsCalculator(store);
-  let periodDays = 7;
-  if (options.period) {
-    const match = options.period.match(/^(\d+)d$/);
-    if (match) {
-      periodDays = parseInt(match[1], 10);
-    }
-  }
-  if (options.symbol) {
-    const health = calculator.getSymbolHealth(options.symbol);
-    if (options.json) {
-      console.log(JSON.stringify(health, null, 2));
-    } else {
-      console.log(chalk2.cyan.bold(`
-Symbol Health: ${options.symbol}`));
-      console.log(chalk2.gray("\u2500".repeat(50)));
-      console.log(`  Incidents: ${health.incidentCount}`);
-      console.log(`  Avg Time to Resolve: ${health.avgTimeToResolve}m`);
-      console.log("");
-      console.log(chalk2.cyan("  Top Patterns:"));
-      for (const { patternId, count } of health.topPatterns) {
-        console.log(`    ${patternId}: ${count} times`);
-      }
-    }
-    return;
-  }
-  const stats = calculator.getStats(periodDays);
-  if (options.json) {
-    console.log(JSON.stringify(stats, null, 2));
-    return;
-  }
-  console.log(calculator.generateDashboard(periodDays));
-}
-async function triageRecordCommand(options) {
-  const store = getStorage();
-  const matcher = new PatternMatcher(store);
-  const incidentId = store.recordIncident({
-    error: {
-      message: options.error,
-      stack: options.stack
-    },
-    symbols: {
-      feature: options.feature,
-      component: options.component,
-      flow: options.flow,
-      gate: options.gate,
-      signal: options.signal,
-      state: options.state,
-      integration: options.integration
-    },
-    environment: options.env,
-    service: options.service,
-    version: options.version
-  });
-  const incident = store.getIncident(incidentId);
-  const matches = incident ? matcher.match(incident, { maxResults: 3 }) : [];
-  if (options.json) {
-    console.log(JSON.stringify({ incidentId, matches }, null, 2));
-    return;
-  }
-  console.log(chalk2.green(`Recorded incident ${incidentId}`));
-  if (matches.length > 0) {
-    console.log("");
-    console.log(chalk2.cyan("Matched patterns:"));
-    for (const match of matches) {
-      console.log(
-        `  ${chalk2.yellow("\u2605")} ${match.pattern.id} (${match.confidence}% confidence)`
-      );
-      console.log(chalk2.gray(`     ${match.pattern.resolution.description}`));
-    }
-  }
-}
 export {
-  triageExportCommand,
-  triageImportCommand,
-  triageLinkCommand,
-  triageListCommand,
-  triageNoteCommand,
-  triagePatternsAddCommand,
-  triagePatternsDeleteCommand,
-  triagePatternsListCommand,
-  triagePatternsSeedCommand,
-  triagePatternsShowCommand,
-  triagePatternsTestCommand,
-  triageRecordCommand,
-  triageResolveCommand,
-  triageRestoreCommand,
-  triageShowCommand,
-  triageStatsCommand
+  PatternMatcher,
+  loadUniversalPatterns,
+  loadParadigmPatterns,
+  loadAllSeedPatterns,
+  FlowTracker,
+  Sentinel,
+  loadConfig,
+  writeConfig,
+  detectSymbols,
+  generateConfig,
+  IncidentGrouper,
+  TimelineBuilder,
+  StatsCalculator,
+  ContextEnricher,
+  PatternSuggester,
+  PatternImporter
 };