@a-company/sentinel 0.2.0 → 3.6.0

package/dist/index.js

@@ -1,6 +1,19 @@
 import {
-  SentinelStorage
-} from "./chunk-KPMG4XED.js";
+  SentinelClient,
+  SentinelTransport,
+  createSentinelClient,
+  createSentinelTransport,
+  enableSentinel
+} from "./chunk-VQ3SIN7S.js";
+import {
+  DEFAULT_AUTH_CONFIG,
+  DEFAULT_RATE_LIMIT_CONFIG,
+  DEFAULT_SERVER_CONFIG,
+  SentinelStorage,
+  loadConfig,
+  loadServerConfig,
+  writeConfig
+} from "./chunk-NTX74ZPM.js";
 
 // src/matcher.ts
 var DEFAULT_CONFIG = {
@@ -498,143 +511,9 @@ var Sentinel = class {
   }
 };
 
-// src/config.ts
+// src/detector.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-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");
-}
-
-// src/detector.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
 var DIR_PATTERNS = [
   { dirs: ["services", "src/services"], prefix: "#", type: "components" },
   { dirs: ["routes", "src/routes", "api", "src/api"], prefix: "#", type: "components" },
@@ -669,13 +548,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)) {
@@ -691,7 +570,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,
@@ -702,8 +581,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: [],
@@ -714,7 +593,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 {
     }
@@ -767,13 +646,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)}`;
@@ -786,10 +665,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;
       }
@@ -803,12 +682,12 @@ 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 {
@@ -817,11 +696,18 @@ function findFiles(dir, filename, maxDepth = 4, depth = 0) {
 }
 
 // src/grouper.ts
-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
@@ -867,7 +753,7 @@ var IncidentGrouper = class {
         continue;
       }
       const score = this.calculateSimilarity(incident, candidate);
-      if (score >= SIMILARITY_THRESHOLD) {
+      if (score >= this.similarityThreshold) {
         similar.push({ incident: candidate, score });
       }
     }
@@ -888,7 +774,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];
@@ -915,11 +801,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",
@@ -939,19 +831,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
@@ -1491,8 +1419,8 @@ var StatsCalculator = class {
 };
 
 // src/enricher.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 var ContextEnricher = class {
   constructor(projectRoot = process.cwd()) {
     this.projectRoot = projectRoot;
@@ -1564,12 +1492,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(
@@ -1587,8 +1515,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);
@@ -1599,7 +1527,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) {
@@ -1629,11 +1557,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;
   }
   /**
@@ -1698,7 +1626,7 @@ var PatternSuggester = class {
       },
       resolution: {
         description: incident.resolution?.notes || "Resolution approach TBD",
-        strategy: "fix-code",
+        strategy: this.inferStrategy([incident]),
         priority: "medium"
       },
       source: "suggested",
@@ -1713,6 +1641,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}`,
@@ -1723,7 +1652,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",
@@ -2022,21 +1951,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";
   }
   /**
@@ -2051,7 +1997,7 @@ var PatternSuggester = class {
 };
 
 // src/importer.ts
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 var PatternImporter = class {
   /**
    * Validate a pattern export file
@@ -2146,10 +2092,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) {
@@ -2249,22 +2195,178 @@ var PatternImporter = class {
     };
   }
 };
+
+// src/schema/builtin-paradigm.ts
+var PARADIGM_SCHEMA = {
+  id: "paradigm-logger",
+  version: "1.0.0",
+  name: "Paradigm Logger",
+  description: "Structured logs from @a-company/paradigm-logger with symbolic context",
+  scope: {
+    field: "correlationId",
+    type: "string",
+    label: "Correlation",
+    ordering: "independent",
+    sessionField: "sessionId"
+  },
+  eventTypes: [
+    {
+      type: "log:debug",
+      category: "logs",
+      label: "Debug Log",
+      severity: "debug",
+      frequency: "high",
+      fields: [
+        { name: "symbol", type: "string", indexed: true, display: true },
+        { name: "symbolType", type: "string", indexed: true, display: true },
+        { name: "message", type: "string", display: true },
+        { name: "service", type: "string", indexed: true, display: true },
+        { name: "durationMs", type: "number", display: true }
+      ]
+    },
+    {
+      type: "log:info",
+      category: "logs",
+      label: "Info Log",
+      severity: "info",
+      frequency: "high",
+      fields: [
+        { name: "symbol", type: "string", indexed: true, display: true },
+        { name: "symbolType", type: "string", indexed: true, display: true },
+        { name: "message", type: "string", display: true },
+        { name: "service", type: "string", indexed: true, display: true },
+        { name: "durationMs", type: "number", display: true }
+      ]
+    },
+    {
+      type: "log:warn",
+      category: "logs",
+      label: "Warning Log",
+      severity: "warn",
+      frequency: "medium",
+      fields: [
+        { name: "symbol", type: "string", indexed: true, display: true },
+        { name: "symbolType", type: "string", indexed: true, display: true },
+        { name: "message", type: "string", display: true },
+        { name: "service", type: "string", indexed: true, display: true }
+      ]
+    },
+    {
+      type: "log:error",
+      category: "logs",
+      label: "Error Log",
+      severity: "error",
+      frequency: "low",
+      fields: [
+        { name: "symbol", type: "string", indexed: true, display: true },
+        { name: "symbolType", type: "string", indexed: true, display: true },
+        { name: "message", type: "string", display: true },
+        { name: "service", type: "string", indexed: true, display: true }
+      ]
+    },
+    {
+      type: "metric:counter",
+      category: "metrics",
+      label: "Counter Metric",
+      severity: "info",
+      frequency: "high",
+      fields: [
+        { name: "name", type: "string", indexed: true, display: true },
+        { name: "value", type: "number", display: true },
+        { name: "tags", type: "object" }
+      ]
+    },
+    {
+      type: "metric:gauge",
+      category: "metrics",
+      label: "Gauge Metric",
+      severity: "info",
+      frequency: "medium",
+      fields: [
+        { name: "name", type: "string", indexed: true, display: true },
+        { name: "value", type: "number", display: true },
+        { name: "tags", type: "object" }
+      ]
+    },
+    {
+      type: "metric:histogram",
+      category: "metrics",
+      label: "Histogram Metric",
+      severity: "info",
+      frequency: "medium",
+      fields: [
+        { name: "name", type: "string", indexed: true, display: true },
+        { name: "value", type: "number", display: true },
+        { name: "tags", type: "object" }
+      ]
+    },
+    {
+      type: "trace:span",
+      category: "traces",
+      label: "Trace Span",
+      severity: "info",
+      frequency: "medium",
+      fields: [
+        { name: "traceId", type: "string", indexed: true, display: true },
+        { name: "spanId", type: "string", indexed: true },
+        { name: "operation", type: "string", display: true },
+        { name: "durationMs", type: "number", display: true },
+        { name: "status", type: "string", display: true }
+      ]
+    },
+    {
+      type: "incident:recorded",
+      category: "incidents",
+      label: "Incident Recorded",
+      severity: "error",
+      frequency: "low",
+      fields: [
+        { name: "incidentId", type: "string", indexed: true, display: true },
+        { name: "errorMessage", type: "string", display: true },
+        { name: "symbols", type: "object" },
+        { name: "environment", type: "string", display: true }
+      ]
+    }
+  ],
+  visualization: {
+    defaultView: "table",
+    categoryColors: {
+      logs: "#3b82f6",
+      metrics: "#22c55e",
+      traces: "#a855f7",
+      incidents: "#ef4444"
+    },
+    summaryFields: ["symbol", "message", "service"],
+    defaultExcluded: ["log:debug"]
+  },
+  tags: ["builtin", "paradigm"]
+};
 export {
   ContextEnricher,
+  DEFAULT_AUTH_CONFIG,
+  DEFAULT_RATE_LIMIT_CONFIG,
+  DEFAULT_SERVER_CONFIG,
   FlowTracker,
   IncidentGrouper,
+  PARADIGM_SCHEMA,
   PatternImporter,
   PatternMatcher,
   PatternSuggester,
   Sentinel,
+  SentinelClient,
   SentinelStorage,
+  SentinelTransport,
   StatsCalculator,
   TimelineBuilder,
+  createSentinelClient,
+  createSentinelTransport,
   detectSymbols,
+  enableSentinel,
   generateConfig,
   loadAllSeedPatterns,
   loadConfig,
   loadParadigmPatterns,
+  loadServerConfig,
   loadUniversalPatterns,
   writeConfig
 };