@a-company/paradigm 3.1.6 → 3.5.0

package/dist/{chunk-4LGLU2LO.js → chunk-2E2RTBSM.js}

@@ -1,7 +1,420 @@
 #!/usr/bin/env node
 import {
-  SentinelStorage
-} from "./chunk-VZ7CXFRZ.js";
+  SentinelStorage,
+  v4_default
+} from "./chunk-CRICL4FQ.js";
+
+// ../sentinel/dist/chunk-VQ3SIN7S.js
+var DEFAULTS = {
+  url: "http://localhost:3838",
+  batchSize: 50,
+  flushIntervalMs: 5e3,
+  maxBufferSize: 1e3,
+  maxRetries: 3,
+  retryBackoffMs: 1e3
+};
+var SentinelClient = class {
+  url;
+  service;
+  version;
+  environment;
+  token;
+  batchSize;
+  maxBufferSize;
+  maxRetries;
+  retryBackoffMs;
+  onDrop;
+  onError;
+  sessionId;
+  logBuffer = [];
+  metricsBuffer = [];
+  flushTimer = null;
+  closed = false;
+  beforeUnloadHandler = null;
+  constructor(options) {
+    this.url = (options.url ?? DEFAULTS.url).replace(/\/+$/, "");
+    this.service = options.service;
+    this.version = options.version;
+    this.environment = options.environment;
+    this.token = options.token;
+    this.batchSize = options.batchSize ?? DEFAULTS.batchSize;
+    this.maxBufferSize = options.maxBufferSize ?? DEFAULTS.maxBufferSize;
+    this.maxRetries = options.maxRetries ?? DEFAULTS.maxRetries;
+    this.retryBackoffMs = options.retryBackoffMs ?? DEFAULTS.retryBackoffMs;
+    this.onDrop = options.onDrop;
+    this.onError = options.onError;
+    this.sessionId = v4_default();
+    const intervalMs = options.flushIntervalMs ?? DEFAULTS.flushIntervalMs;
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((err) => {
+        this.handleError(err);
+      });
+    }, intervalMs);
+    if (this.flushTimer && typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
+      this.flushTimer.unref();
+    }
+    if (typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
+      this.beforeUnloadHandler = () => {
+        this.flushSync();
+      };
+      globalThis.addEventListener("beforeunload", this.beforeUnloadHandler);
+    }
+    this.registerService();
+  }
+  // ── Logging Methods ──────────────────────────────────────────────
+  /** Log a debug-level message */
+  debug(symbol, message, data) {
+    this.log("debug", symbol, message, data);
+  }
+  /** Log an info-level message */
+  info(symbol, message, data) {
+    this.log("info", symbol, message, data);
+  }
+  /** Log a warn-level message */
+  warn(symbol, message, data) {
+    this.log("warn", symbol, message, data);
+  }
+  /** Log an error-level message */
+  error(symbol, message, data) {
+    this.log("error", symbol, message, data);
+  }
+  /** Log a message at the specified level */
+  log(level, symbol, message, data) {
+    if (this.closed) return;
+    const entry = {
+      level,
+      symbol,
+      message,
+      service: this.service,
+      sessionId: this.sessionId,
+      environment: this.environment,
+      data
+    };
+    this.pushToLogBuffer(entry);
+  }
+  // ── Metrics Methods ──────────────────────────────────────────────
+  /** Record a counter metric (increments) */
+  counter(name, value, tags) {
+    this.metric({ name, type: "counter", value: value ?? 1, tags });
+  }
+  /** Record a gauge metric (current value) */
+  gauge(name, value, tags) {
+    this.metric({ name, type: "gauge", value, tags });
+  }
+  /** Record a histogram metric (distribution) */
+  histogram(name, value, tags) {
+    this.metric({ name, type: "histogram", value, tags });
+  }
+  /** Record a metric of any type */
+  metric(input) {
+    if (this.closed) return;
+    const entry = {
+      ...input,
+      service: this.service,
+      environment: this.environment
+    };
+    this.pushToMetricsBuffer(entry);
+  }
+  // ── State Push ───────────────────────────────────────────────────
+  /** Push an application state snapshot to the server */
+  async pushState(state, activeFlows, activeGates) {
+    if (this.closed) return;
+    await this.post("/api/state", {
+      service: this.service,
+      sessionId: this.sessionId,
+      state,
+      activeFlows,
+      activeGates
+    });
+  }
+  // ── Tracing ──────────────────────────────────────────────────────
+  /** Start a trace span. Call end() on the returned SpanContext when the operation completes. */
+  startSpan(symbol, operation, parentSpanId) {
+    const traceId = parentSpanId ? parentSpanId.split("-")[0] || v4_default() : v4_default();
+    const spanId = v4_default();
+    const startTime = (/* @__PURE__ */ new Date()).toISOString();
+    const startMs = Date.now();
+    const self = this;
+    return {
+      traceId,
+      spanId,
+      async end(status = "ok") {
+        const endTime = (/* @__PURE__ */ new Date()).toISOString();
+        const durationMs = Date.now() - startMs;
+        const span = {
+          traceId,
+          spanId,
+          parentSpanId,
+          service: self.service,
+          symbol,
+          operation,
+          startTime,
+          endTime,
+          durationMs,
+          status
+        };
+        await self.post("/api/traces", span);
+      }
+    };
+  }
+  // ── Buffer Management ────────────────────────────────────────────
+  /** Flush all buffered logs and metrics to the server */
+  async flush() {
+    const logEntries = this.drainLogBuffer();
+    const metricEntries = this.drainMetricsBuffer();
+    const promises = [];
+    if (logEntries.length > 0) {
+      promises.push(this.sendLogs(logEntries));
+    }
+    if (metricEntries.length > 0) {
+      promises.push(this.sendMetrics(metricEntries));
+    }
+    await Promise.allSettled(promises);
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────
+  /** Flush remaining entries and shut down the client */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.beforeUnloadHandler && typeof globalThis !== "undefined" && typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("beforeunload", this.beforeUnloadHandler);
+      this.beforeUnloadHandler = null;
+    }
+    try {
+      await this.flush();
+    } catch {
+    }
+  }
+  /** Get the session ID assigned to this client instance */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Synchronous best-effort flush using sendBeacon (browser) or sync XHR fallback.
+   * Used in beforeunload where async is unreliable.
+   */
+  flushSync() {
+    const logEntries = this.drainLogBuffer();
+    const metricEntries = this.drainMetricsBuffer();
+    const sendBeacon = typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function" ? navigator.sendBeacon.bind(navigator) : void 0;
+    if (sendBeacon) {
+      if (logEntries.length > 0) {
+        sendBeacon(`${this.url}/api/logs`, JSON.stringify({ entries: logEntries }));
+      }
+      if (metricEntries.length > 0) {
+        sendBeacon(`${this.url}/api/metrics`, JSON.stringify({ entries: metricEntries }));
+      }
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE METHODS
+  // ═══════════════════════════════════════════════════════════════════
+  /** Register this service with the Sentinel server (fire-and-forget) */
+  registerService() {
+    const registration = {
+      name: this.service,
+      version: this.version,
+      pid: typeof process !== "undefined" ? process.pid : void 0,
+      environment: this.environment
+    };
+    this.post("/api/services", registration).catch(() => {
+    });
+  }
+  /** Push a log entry into the ring buffer, enforcing maxBufferSize */
+  pushToLogBuffer(entry) {
+    if (this.logBuffer.length >= this.maxBufferSize) {
+      const dropCount = Math.max(1, Math.floor(this.maxBufferSize * 0.1));
+      this.logBuffer.splice(0, dropCount);
+      if (this.onDrop) {
+        this.onDrop(dropCount);
+      }
+    }
+    this.logBuffer.push(entry);
+    if (this.logBuffer.length >= this.batchSize) {
+      this.flush().catch((err) => {
+        this.handleError(err);
+      });
+    }
+  }
+  /** Push a metric entry into the ring buffer, enforcing maxBufferSize */
+  pushToMetricsBuffer(entry) {
+    if (this.metricsBuffer.length >= this.maxBufferSize) {
+      const dropCount = Math.max(1, Math.floor(this.maxBufferSize * 0.1));
+      this.metricsBuffer.splice(0, dropCount);
+      if (this.onDrop) {
+        this.onDrop(dropCount);
+      }
+    }
+    this.metricsBuffer.push(entry);
+    if (this.metricsBuffer.length >= this.batchSize) {
+      this.flush().catch((err) => {
+        this.handleError(err);
+      });
+    }
+  }
+  /** Drain and return all entries from the log buffer */
+  drainLogBuffer() {
+    const entries = this.logBuffer;
+    this.logBuffer = [];
+    return entries;
+  }
+  /** Drain and return all entries from the metrics buffer */
+  drainMetricsBuffer() {
+    const entries = this.metricsBuffer;
+    this.metricsBuffer = [];
+    return entries;
+  }
+  /** Send log entries to the server with retry */
+  async sendLogs(entries) {
+    try {
+      await this.post("/api/logs", { entries });
+    } catch (err) {
+      const capacity = this.maxBufferSize - this.logBuffer.length;
+      if (capacity > 0) {
+        const toRestore = entries.slice(0, capacity);
+        this.logBuffer.unshift(...toRestore);
+        const dropped = entries.length - toRestore.length;
+        if (dropped > 0 && this.onDrop) {
+          this.onDrop(dropped);
+        }
+      } else if (this.onDrop) {
+        this.onDrop(entries.length);
+      }
+      throw err;
+    }
+  }
+  /** Send metric entries to the server with retry */
+  async sendMetrics(entries) {
+    try {
+      await this.post("/api/metrics", { entries });
+    } catch (err) {
+      const capacity = this.maxBufferSize - this.metricsBuffer.length;
+      if (capacity > 0) {
+        const toRestore = entries.slice(0, capacity);
+        this.metricsBuffer.unshift(...toRestore);
+        const dropped = entries.length - toRestore.length;
+        if (dropped > 0 && this.onDrop) {
+          this.onDrop(dropped);
+        }
+      } else if (this.onDrop) {
+        this.onDrop(entries.length);
+      }
+      throw err;
+    }
+  }
+  /**
+   * POST JSON to the Sentinel server with exponential backoff retry.
+   * Retries on network errors and 5xx responses. Does NOT retry on 4xx.
+   */
+  async post(path4, body) {
+    const fetchFn = this.getFetch();
+    if (!fetchFn) {
+      return void 0;
+    }
+    const url = `${this.url}${path4}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await fetchFn(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        });
+        if (response.status >= 400 && response.status < 500) {
+          const text = await response.text().catch(() => "");
+          const err = new Error(`Sentinel server returned ${response.status}: ${text}`);
+          this.handleError(err);
+          return void 0;
+        }
+        if (response.status >= 500) {
+          const text = await response.text().catch(() => "");
+          lastError = new Error(`Sentinel server returned ${response.status}: ${text}`);
+          if (attempt < this.maxRetries) {
+            await this.backoff(attempt);
+            continue;
+          }
+          this.handleError(lastError);
+          throw lastError;
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          return await response.json();
+        }
+        return void 0;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < this.maxRetries) {
+          await this.backoff(attempt);
+          continue;
+        }
+        this.handleError(lastError);
+        throw lastError;
+      }
+    }
+    if (lastError) throw lastError;
+    return void 0;
+  }
+  /** Get the fetch function, falling back to globalThis.fetch */
+  getFetch() {
+    if (typeof globalThis !== "undefined" && typeof globalThis.fetch === "function") {
+      return globalThis.fetch;
+    }
+    return void 0;
+  }
+  /** Wait with exponential backoff */
+  backoff(attempt) {
+    const delayMs = this.retryBackoffMs * Math.pow(2, attempt);
+    const jitter = Math.floor(Math.random() * delayMs * 0.25);
+    return new Promise((resolve) => setTimeout(resolve, delayMs + jitter));
+  }
+  /** Handle an error, calling the onError callback if provided */
+  handleError(err) {
+    if (this.onError) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.onError(error);
+    }
+  }
+};
+function createSentinelClient(options) {
+  return new SentinelClient(options);
+}
+var SentinelTransport = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  send(entry) {
+    this.client.log(
+      entry.level,
+      entry.symbol,
+      entry.message,
+      {
+        ...entry.data,
+        symbolType: entry.symbolType,
+        correlationId: entry.correlationId
+      }
+    );
+  }
+};
+function createSentinelTransport(clientOrOptions) {
+  const client = clientOrOptions instanceof SentinelClient ? clientOrOptions : new SentinelClient(clientOrOptions);
+  return new SentinelTransport(client);
+}
+function enableSentinel(logger, clientOrOptions) {
+  const transport = createSentinelTransport(clientOrOptions);
+  logger.addTransport(transport);
+  return transport;
+}
 
 // ../sentinel/dist/index.js
 import * as path from "path";
@@ -12,8 +425,6 @@ 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,
   maxResults: 5,
@@ -501,136 +912,6 @@ var Sentinel = class {
     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" },
@@ -665,13 +946,13 @@ function detectSymbols(projectDir) {
   }
   for (const pattern of DIR_PATTERNS) {
     for (const dir of pattern.dirs) {
-      const fullPath = path3.join(projectDir, dir);
-      if (!fs3.existsSync(fullPath)) continue;
+      const fullPath = path2.join(projectDir, dir);
+      if (!fs2.existsSync(fullPath)) continue;
       const files = safeReaddir(fullPath);
       for (const file of files) {
-        const ext = path3.extname(file);
+        const ext = path2.extname(file);
         if (!CODE_EXTENSIONS.has(ext)) continue;
-        const name = path3.basename(file, ext);
+        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)) {
@@ -687,7 +968,7 @@ function generateConfig(projectDir) {
   const detected = detectSymbols(projectDir);
   return {
     version: "1.0",
-    project: path3.basename(projectDir),
+    project: path2.basename(projectDir),
     symbols: {
       components: detected.components.length > 0 ? detected.components : void 0,
       gates: detected.gates.length > 0 ? detected.gates : void 0,
@@ -698,8 +979,8 @@ function generateConfig(projectDir) {
   };
 }
 function readPurposeFiles(projectDir) {
-  const paradigmDir = path3.join(projectDir, ".paradigm");
-  if (!fs3.existsSync(paradigmDir)) return null;
+  const paradigmDir = path2.join(projectDir, ".paradigm");
+  if (!fs2.existsSync(paradigmDir)) return null;
   const result = {
     components: [],
     gates: [],
@@ -710,7 +991,7 @@ function readPurposeFiles(projectDir) {
   const purposeFiles = findFiles(projectDir, ".purpose");
   for (const file of purposeFiles) {
     try {
-      const content = fs3.readFileSync(file, "utf-8");
+      const content = fs2.readFileSync(file, "utf-8");
       extractPurposeSymbols(content, result);
     } catch {
     }
@@ -763,13 +1044,13 @@ function extractPurposeSymbols(content, result) {
 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 fullPath = path2.join(projectDir, dir);
+    if (!fs2.existsSync(fullPath)) continue;
     const files = safeReaddir(fullPath);
     for (const file of files) {
-      const ext = path3.extname(file);
+      const ext = path2.extname(file);
       if (!CODE_EXTENSIONS.has(ext)) continue;
-      const name = path3.basename(file, ext);
+      const name = path2.basename(file, ext);
       if (name === "index") continue;
       const routePrefix = `/api/${toKebabCase(name)}`;
       const component = `#${toKebabCase(name)}`;
@@ -782,10 +1063,10 @@ function toKebabCase(str) {
 }
 function safeReaddir(dir) {
   try {
-    return fs3.readdirSync(dir).filter((f) => {
-      const fullPath = path3.join(dir, f);
+    return fs2.readdirSync(dir).filter((f) => {
+      const fullPath = path2.join(dir, f);
       try {
-        return fs3.statSync(fullPath).isFile();
+        return fs2.statSync(fullPath).isFile();
       } catch {
         return false;
       }
@@ -799,23 +1080,30 @@ function findFiles(dir, filename, maxDepth = 4, depth = 0) {
   const results = [];
   const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".next", ".nuxt"]);
   try {
-    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        results.push(path3.join(dir, entry.name));
+        results.push(path2.join(dir, entry.name));
       } else if (entry.isDirectory() && !skipDirs.has(entry.name)) {
-        results.push(...findFiles(path3.join(dir, entry.name), filename, maxDepth, depth + 1));
+        results.push(...findFiles(path2.join(dir, entry.name), filename, maxDepth, depth + 1));
       }
     }
   } catch {
   }
   return results;
 }
-var SIMILARITY_THRESHOLD = 0.6;
+var DEFAULT_SIMILARITY_THRESHOLD = 0.6;
+var DECAY_HALF_LIFE_DAYS = 14;
 var IncidentGrouper = class {
-  constructor(storage) {
+  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
@@ -861,7 +1149,7 @@ var IncidentGrouper = class {
         continue;
       }
       const score = this.calculateSimilarity(incident, candidate);
-      if (score >= SIMILARITY_THRESHOLD) {
+      if (score >= this.similarityThreshold) {
         similar.push({ incident: candidate, score });
       }
     }
@@ -882,7 +1170,7 @@ var IncidentGrouper = class {
         continue;
       }
       const similar = ungrouped.filter(
-        (other) => other.id !== incident.id && !processed.has(other.id) && this.calculateSimilarity(incident, other) >= SIMILARITY_THRESHOLD
+        (other) => other.id !== incident.id && !processed.has(other.id) && this.calculateSimilarity(incident, other) >= this.similarityThreshold
       );
       if (similar.length + 1 >= minSize) {
         const members = [incident, ...similar];
@@ -909,11 +1197,17 @@ var IncidentGrouper = class {
   }
   /**
    * 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 symbolWeight = 0.6;
+    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",
@@ -933,19 +1227,55 @@ var IncidentGrouper = class {
         }
       }
     }
-    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;
+    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
@@ -1550,12 +1880,12 @@ var ContextEnricher = class {
    * Find symbol in premise index
    */
   findInSymbolIndex(symbol) {
-    const indexPath = path4.join(this.projectRoot, ".paradigm", "index.json");
-    if (!fs4.existsSync(indexPath)) {
+    const indexPath = path3.join(this.projectRoot, ".paradigm", "index.json");
+    if (!fs3.existsSync(indexPath)) {
       return null;
     }
     try {
-      const indexContent = fs4.readFileSync(indexPath, "utf-8");
+      const indexContent = fs3.readFileSync(indexPath, "utf-8");
       const index = JSON.parse(indexContent);
       if (index.symbols && Array.isArray(index.symbols)) {
         return index.symbols.find(
@@ -1573,8 +1903,8 @@ var ContextEnricher = class {
   findInPurposeFiles(symbol) {
     const searchPaths = this.getSearchPathsForSymbol(symbol);
     for (const searchPath of searchPaths) {
-      const fullPath = path4.join(this.projectRoot, searchPath);
-      if (!fs4.existsSync(fullPath)) {
+      const fullPath = path3.join(this.projectRoot, searchPath);
+      if (!fs3.existsSync(fullPath)) {
         continue;
       }
       const cached = this.purposeCache.get(fullPath);
@@ -1585,7 +1915,7 @@ var ContextEnricher = class {
         continue;
       }
       try {
-        const content = fs4.readFileSync(fullPath, "utf-8");
+        const content = fs3.readFileSync(fullPath, "utf-8");
         const purpose = this.parsePurposeFile(content);
         this.purposeCache.set(fullPath, purpose);
         if (purpose.symbol === symbol) {
@@ -1615,11 +1945,11 @@ var ContextEnricher = class {
     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(path3.join(dir, cleanSymbol, ".purpose"));
+      paths.push(path3.join(dir, `${cleanSymbol}.purpose`));
     }
-    paths.push(path4.join(".paradigm", "purposes", `${cleanSymbol}.yaml`));
-    paths.push(path4.join(".paradigm", "purposes", `${cleanSymbol}.json`));
+    paths.push(path3.join(".paradigm", "purposes", `${cleanSymbol}.yaml`));
+    paths.push(path3.join(".paradigm", "purposes", `${cleanSymbol}.json`));
     return paths;
   }
   /**
@@ -1682,7 +2012,7 @@ var PatternSuggester = class {
       },
       resolution: {
         description: incident.resolution?.notes || "Resolution approach TBD",
-        strategy: "fix-code",
+        strategy: this.inferStrategy([incident]),
         priority: "medium"
       },
       source: "suggested",
@@ -1697,6 +2027,7 @@ var PatternSuggester = class {
   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}`,
@@ -1707,7 +2038,7 @@ var PatternSuggester = class {
       },
       resolution: {
         description: "Resolution approach TBD based on grouped incidents",
-        strategy: "fix-code",
+        strategy: groupIncidents.length > 0 ? this.inferStrategy(groupIncidents) : "fix-code",
         priority: this.getPriorityFromCount(group.count)
       },
       source: "suggested",
@@ -2006,21 +2337,38 @@ var PatternSuggester = class {
     return false;
   }
   /**
-   * Infer resolution strategy from incidents
+   * 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());
-    if (messages.some((m) => m.includes("timeout") || m.includes("network"))) {
+    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 (messages.some(
-      (m) => m.includes("validation") || m.includes("invalid") || m.includes("required")
-    )) {
+    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 (messages.some((m) => m.includes("permission") || m.includes("403"))) {
+    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";
   }
   /**
@@ -2127,10 +2475,10 @@ var PatternImporter = class {
    * Load patterns from a JSON file
    */
   loadFromFile(filePath) {
-    if (!fs5.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const content = fs5.readFileSync(filePath, "utf-8");
+    const content = fs4.readFileSync(filePath, "utf-8");
     const data = JSON.parse(content);
     const validation = this.validate(data);
     if (!validation.valid) {
@@ -2232,14 +2580,17 @@ var PatternImporter = class {
 };
 
 export {
+  SentinelClient,
+  createSentinelClient,
+  SentinelTransport,
+  createSentinelTransport,
+  enableSentinel,
   PatternMatcher,
   loadUniversalPatterns,
   loadParadigmPatterns,
   loadAllSeedPatterns,
   FlowTracker,
   Sentinel,
-  loadConfig,
-  writeConfig,
   detectSymbols,
   generateConfig,
   IncidentGrouper,