@a-company/paradigm 3.12.0 → 3.13.0

package/dist/server-CAXNYVV7.js

@@ -0,0 +1,1616 @@
+#!/usr/bin/env node
+import {
+  SentinelStorage,
+  loadServerConfig
+} from "./chunk-R2SGQ22F.js";
+import "./chunk-ZXMDA7VB.js";
+
+// ../sentinel/dist/server/index.js
+import express from "express";
+import * as http from "http";
+import * as path3 from "path";
+import * as fs2 from "fs";
+import { fileURLToPath } from "url";
+import chalk3 from "chalk";
+import { WebSocketServer, WebSocket } from "ws";
+import { Router } from "express";
+import chalk2 from "chalk";
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { Router as Router2 } from "express";
+import { Router as Router3 } from "express";
+import simpleGit from "simple-git";
+import * as path2 from "path";
+import { Router as Router4 } from "express";
+import { Router as Router5 } from "express";
+import { Router as Router6 } from "express";
+import { v4 as uuidv4 } from "uuid";
+import { Router as Router7 } from "express";
+import { Router as Router8 } from "express";
+import { Router as Router9 } from "express";
+import { Router as Router10 } from "express";
+import { Router as Router11 } from "express";
+var LOG_LEVEL = process.env.SENTINEL_LOG_LEVEL || process.env.LOG_LEVEL || "info";
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[LOG_LEVEL];
+}
+function formatData(data) {
+  if (!data) return "";
+  const entries = Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+  return chalk.gray(` ${entries}`);
+}
+var log = {
+  component(name) {
+    const symbol = chalk.magenta(`#${name}`);
+    return {
+      debug: (msg, data) => {
+        if (shouldLog("debug")) console.log(`${chalk.gray("\u25CB")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      info: (msg, data) => {
+        if (shouldLog("info")) console.log(`${chalk.blue("\u2139")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      warn: (msg, data) => {
+        if (shouldLog("warn")) console.log(`${chalk.yellow("\u26A0")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      error: (msg, data) => {
+        if (shouldLog("error")) console.error(`${chalk.red("\u2716")} ${symbol} ${msg}${formatData(data)}`);
+      }
+    };
+  },
+  flow(name) {
+    const symbol = chalk.yellow(`$${name}`);
+    return {
+      debug: (msg, data) => {
+        if (shouldLog("debug")) console.log(`${chalk.gray("\u25CB")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      info: (msg, data) => {
+        if (shouldLog("info")) console.log(`${chalk.blue("\u2139")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      warn: (msg, data) => {
+        if (shouldLog("warn")) console.log(`${chalk.yellow("\u26A0")} ${symbol} ${msg}${formatData(data)}`);
+      },
+      error: (msg, data) => {
+        if (shouldLog("error")) console.error(`${chalk.red("\u2716")} ${symbol} ${msg}${formatData(data)}`);
+      }
+    };
+  }
+};
+var SYMBOL_BLOCKLIST = /* @__PURE__ */ new Set([
+  "$lib",
+  "$env",
+  "$app",
+  "$service-worker",
+  "$virtual",
+  "$schema",
+  "$ref",
+  "$id",
+  "$type"
+]);
+async function loadParadigmConfig(projectDir) {
+  const configPath = path.join(projectDir, ".paradigm", "config.yaml");
+  if (!fs.existsSync(configPath)) {
+    const packagePath = path.join(projectDir, "package.json");
+    if (fs.existsSync(packagePath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+        return { name: pkg.name };
+      } catch {
+      }
+    }
+    return {};
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const config = {};
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    if (nameMatch) config.name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+    const disciplineMatch = content.match(/^discipline:\s*(.+)$/m);
+    if (disciplineMatch) config.discipline = disciplineMatch[1].trim();
+    const versionMatch = content.match(/^version:\s*(.+)$/m);
+    if (versionMatch) config.version = versionMatch[1].trim();
+    return config;
+  } catch (error) {
+    log.component("config-loader").error("Failed to load Paradigm config", { error: String(error) });
+    return {};
+  }
+}
+async function loadWithPremiseCore(projectDir) {
+  try {
+    const { aggregateFromDirectory } = await import("./dist-AG5JNIZU-HW2FWNTZ.js");
+    log.flow("load-symbols").info("Using premise-core aggregator", { path: projectDir });
+    const result = await aggregateFromDirectory(projectDir);
+    const counts = {};
+    for (const sym of result.symbols) {
+      counts[sym.type] = (counts[sym.type] || 0) + 1;
+    }
+    log.flow("load-symbols").info("Aggregation complete", {
+      total: result.symbols.length,
+      ...counts,
+      purposeFiles: result.purposeFiles.length,
+      portalFiles: result.portalFiles.length
+    });
+    if (result.errors.length > 0) {
+      for (const err of result.errors) {
+        log.component("aggregator").warn("Aggregation error", {
+          source: err.source,
+          file: err.filePath,
+          message: err.message
+        });
+      }
+    }
+    for (const file of result.purposeFiles) {
+      log.component("purpose-loader").info("Loaded .purpose file", { file: path.relative(projectDir, file) });
+    }
+    for (const file of result.portalFiles) {
+      log.component("gate-loader").info("Loaded portal.yaml", { file: path.relative(projectDir, file) });
+    }
+    return result.symbols;
+  } catch (error) {
+    log.component("premise-core").warn("premise-core not available, using fallback scanner", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function loadSymbolIndex(projectDir) {
+  log.flow("load-symbols").info("Loading symbols", { projectDir });
+  const indexPath = path.join(projectDir, ".paradigm", "index.json");
+  if (fs.existsSync(indexPath)) {
+    try {
+      log.component("index-loader").info("Found cached index", { path: indexPath });
+      const content = fs.readFileSync(indexPath, "utf-8");
+      const index = JSON.parse(content);
+      const entries = Array.isArray(index.entries) ? index.entries : Array.isArray(index) ? index : null;
+      if (entries) {
+        log.flow("load-symbols").info("Loaded from cached index", { count: entries.length });
+        return entries;
+      }
+    } catch (error) {
+      log.component("index-loader").error("Failed to load cached index", { error: String(error) });
+    }
+  }
+  const premiseResult = await loadWithPremiseCore(projectDir);
+  if (premiseResult) {
+    return premiseResult;
+  }
+  log.flow("load-symbols").info("Using fallback scanner");
+  return scanPurposeFiles(projectDir);
+}
+async function scanPurposeFiles(projectDir) {
+  const symbols = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const scanDirs = ["src", "lib", "packages", "apps", "."];
+  for (const dir of scanDirs) {
+    const fullPath = path.join(projectDir, dir);
+    if (fs.existsSync(fullPath)) {
+      await scanDirectory(fullPath, symbols, seenIds, projectDir);
+    }
+  }
+  const portalPath = path.join(projectDir, "portal.yaml");
+  if (fs.existsSync(portalPath)) {
+    log.component("gate-loader").debug("Found portal.yaml", { path: "portal.yaml" });
+    try {
+      const content = fs.readFileSync(portalPath, "utf-8");
+      const gatesSection = content.match(/^gates:\s*\n((?:  .+\n)*)/m);
+      if (gatesSection) {
+        const gateMatches = gatesSection[1].matchAll(/^  ([a-z][a-z0-9-]*):/gm);
+        for (const match of gateMatches) {
+          const gateName = match[1];
+          const id = `gate-${gateName}`;
+          if (!seenIds.has(id)) {
+            seenIds.add(id);
+            symbols.push({
+              id,
+              symbol: `^${gateName}`,
+              type: "gate",
+              source: "portal",
+              filePath: "portal.yaml",
+              data: {},
+              references: [],
+              referencedBy: []
+            });
+            log.component("gate-loader").debug("Extracted gate", { symbol: `^${gateName}` });
+          }
+        }
+      }
+    } catch (error) {
+      log.component("gate-loader").error("Failed to parse portal.yaml", { error: String(error) });
+    }
+  }
+  log.flow("load-symbols").info("Fallback scan complete", { count: symbols.length });
+  return symbols;
+}
+async function scanDirectory(dir, symbols, seenIds, projectDir) {
+  const skipDirs = ["node_modules", ".git", "dist", "build", ".paradigm", "coverage", ".next", ".svelte-kit"];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!skipDirs.includes(entry.name)) {
+        await scanDirectory(fullPath, symbols, seenIds, projectDir);
+      }
+    } else if (entry.name === ".purpose") {
+      const relativePath = path.relative(projectDir, fullPath);
+      log.component("purpose-loader").debug("Scanning .purpose file", { path: relativePath });
+      try {
+        const content = fs.readFileSync(fullPath, "utf-8");
+        const parsed = parsePurposeFile(content, fullPath, projectDir);
+        for (const symbol of parsed) {
+          if (!seenIds.has(symbol.id)) {
+            seenIds.add(symbol.id);
+            symbols.push(symbol);
+            log.component("purpose-loader").debug("Extracted symbol", {
+              symbol: symbol.symbol,
+              type: symbol.type,
+              file: relativePath
+            });
+          }
+        }
+      } catch (error) {
+        log.component("purpose-loader").error("Failed to parse .purpose file", {
+          path: relativePath,
+          error: String(error)
+        });
+      }
+    }
+  }
+}
+function parsePurposeFile(content, filePath, projectDir) {
+  const symbols = [];
+  const relativePath = path.relative(projectDir, filePath);
+  const componentMatches = content.matchAll(/(?:^|\s)#([a-z][a-z0-9-]*)/gm);
+  for (const match of componentMatches) {
+    const name = match[1];
+    symbols.push({
+      id: `component-${name}`,
+      symbol: `#${name}`,
+      type: "component",
+      source: "purpose",
+      filePath: relativePath,
+      data: {},
+      description: extractDescription(content, `#${name}`),
+      references: extractReferences(content),
+      referencedBy: [],
+      tags: extractTags(content)
+    });
+  }
+  const flowMatches = content.matchAll(/\$([a-z][a-z0-9-]*)/gm);
+  for (const match of flowMatches) {
+    const name = match[1];
+    const symbol = `$${name}`;
+    if (SYMBOL_BLOCKLIST.has(symbol)) {
+      log.component("purpose-loader").debug("Skipping blocklisted symbol", { symbol });
+      continue;
+    }
+    if (!symbols.find((s) => s.symbol === symbol)) {
+      symbols.push({
+        id: `flow-${name}`,
+        symbol,
+        type: "flow",
+        source: "purpose",
+        filePath: relativePath,
+        data: {},
+        references: [],
+        referencedBy: []
+      });
+    }
+  }
+  const signalMatches = content.matchAll(/!([a-z][a-z0-9-]*)/gm);
+  for (const match of signalMatches) {
+    const name = match[1];
+    if (!symbols.find((s) => s.symbol === `!${name}`)) {
+      symbols.push({
+        id: `signal-${name}`,
+        symbol: `!${name}`,
+        type: "signal",
+        source: "purpose",
+        filePath: relativePath,
+        data: {},
+        references: [],
+        referencedBy: []
+      });
+    }
+  }
+  const gateMatches = content.matchAll(/\^([a-z][a-z0-9-]*)/gm);
+  for (const match of gateMatches) {
+    const name = match[1];
+    if (!symbols.find((s) => s.symbol === `^${name}`)) {
+      symbols.push({
+        id: `gate-${name}`,
+        symbol: `^${name}`,
+        type: "gate",
+        source: "purpose",
+        filePath: relativePath,
+        data: {},
+        references: [],
+        referencedBy: []
+      });
+    }
+  }
+  const aspectMatches = content.matchAll(/~([a-z][a-z0-9-]*)/gm);
+  for (const match of aspectMatches) {
+    const name = match[1];
+    if (!symbols.find((s) => s.symbol === `~${name}`)) {
+      symbols.push({
+        id: `aspect-${name}`,
+        symbol: `~${name}`,
+        type: "aspect",
+        source: "purpose",
+        filePath: relativePath,
+        data: {},
+        references: [],
+        referencedBy: []
+      });
+    }
+  }
+  return symbols;
+}
+function extractDescription(content, symbol) {
+  const regex = new RegExp(`${symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*[-:]?\\s*(.+)`, "m");
+  const match = content.match(regex);
+  if (match && match[1]) {
+    return match[1].trim();
+  }
+  return void 0;
+}
+function extractReferences(content) {
+  const refs = /* @__PURE__ */ new Set();
+  const refMatches = content.matchAll(/[@#$!^~]([a-z][a-z0-9-]*)/g);
+  for (const match of refMatches) {
+    const symbol = match[0];
+    if (!SYMBOL_BLOCKLIST.has(symbol)) {
+      refs.add(symbol);
+    }
+  }
+  return Array.from(refs);
+}
+function extractTags(content) {
+  const tagMatch = content.match(/tags:\s*\[([^\]]+)\]/);
+  if (tagMatch) {
+    return tagMatch[1].split(",").map((t) => t.trim().replace(/^["']|["']$/g, ""));
+  }
+  return [];
+}
+async function getSymbolCount(projectDir) {
+  const symbols = await loadSymbolIndex(projectDir);
+  return symbols.length;
+}
+async function updateSymbol(projectDir, symbolId, updates) {
+  const symbols = await loadSymbolIndex(projectDir);
+  const symbol = symbols.find((s) => s.id === symbolId);
+  if (!symbol) {
+    return { success: false, error: "Symbol not found" };
+  }
+  const filePath = path.join(projectDir, symbol.filePath);
+  if (!fs.existsSync(filePath)) {
+    return { success: false, error: "Source file not found" };
+  }
+  try {
+    let content = fs.readFileSync(filePath, "utf-8");
+    let modified = false;
+    if (updates.description !== void 0) {
+      const symbolPattern = symbol.symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const descRegex = new RegExp(`(${symbolPattern})\\s*[-:]?\\s*(.*)`, "m");
+      const match = content.match(descRegex);
+      if (match) {
+        const newLine = updates.description ? `${symbol.symbol}: ${updates.description}` : symbol.symbol;
+        content = content.replace(descRegex, newLine);
+        modified = true;
+      }
+    }
+    if (updates.tags !== void 0) {
+      const tagsStr = updates.tags.length > 0 ? `tags: [${updates.tags.map((t) => `"${t}"`).join(", ")}]` : "";
+      const tagsRegex = /^tags:\s*\[[^\]]*\]\s*$/m;
+      if (tagsRegex.test(content)) {
+        if (tagsStr) {
+          content = content.replace(tagsRegex, tagsStr);
+        } else {
+          content = content.replace(tagsRegex, "");
+        }
+        modified = true;
+      } else if (tagsStr) {
+        const symbolPattern = symbol.symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const symbolLineRegex = new RegExp(`(${symbolPattern}[^\\n]*\\n)`, "m");
+        const symbolMatch = content.match(symbolLineRegex);
+        if (symbolMatch) {
+          content = content.replace(symbolLineRegex, `$1${tagsStr}
+`);
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      content = content.replace(/\n{3,}/g, "\n\n");
+      fs.writeFileSync(filePath, content, "utf-8");
+      log.component("symbol-updater").info("Updated symbol", { symbol: symbol.symbol, file: symbol.filePath });
+      const indexPath = path.join(projectDir, ".paradigm", "index.json");
+      if (fs.existsSync(indexPath)) {
+        try {
+          const indexContent = fs.readFileSync(indexPath, "utf-8");
+          const index = JSON.parse(indexContent);
+          const entries = Array.isArray(index.entries) ? index.entries : index;
+          const entryIndex = entries.findIndex((e) => e.id === symbolId);
+          if (entryIndex >= 0) {
+            if (updates.description !== void 0) {
+              entries[entryIndex].description = updates.description;
+            }
+            if (updates.tags !== void 0) {
+              entries[entryIndex].tags = updates.tags;
+            }
+            if (Array.isArray(index.entries)) {
+              index.entries = entries;
+              fs.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
+            } else {
+              fs.writeFileSync(indexPath, JSON.stringify(entries, null, 2), "utf-8");
+            }
+          }
+        } catch {
+        }
+      }
+      return { success: true };
+    }
+    return { success: true };
+  } catch (error) {
+    log.component("symbol-updater").error("Failed to update symbol", { error: String(error) });
+    return { success: false, error: "Failed to write file" };
+  }
+}
+var LOG_LEVEL2 = process.env.SENTINEL_LOG_LEVEL || process.env.LOG_LEVEL || "info";
+var shouldLog2 = (level) => {
+  const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+  return levels[level] >= levels[LOG_LEVEL2];
+};
+var log2 = {
+  gate(name) {
+    const symbol = chalk2.cyan(`^${name}`);
+    return {
+      info: (msg, data) => {
+        if (shouldLog2("info")) {
+          const dataStr = data ? chalk2.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+          console.log(`${chalk2.blue("\u2139")} ${symbol} ${msg}${dataStr}`);
+        }
+      },
+      error: (msg, data) => {
+        if (shouldLog2("error")) {
+          const dataStr = data ? chalk2.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+          console.error(`${chalk2.red("\u2716")} ${symbol} ${msg}${dataStr}`);
+        }
+      }
+    };
+  }
+};
+function createSymbolsRouter(projectDir) {
+  const router = Router();
+  router.get("/", async (_req, res) => {
+    try {
+      const symbols = await loadSymbolIndex(projectDir);
+      log2.gate("api-symbols").info("Symbols loaded", { count: symbols.length });
+      res.json({ symbols });
+    } catch (error) {
+      log2.gate("api-symbols").error("Failed to load symbols", { error: String(error) });
+      res.status(500).json({ error: "Failed to load symbols" });
+    }
+  });
+  router.put("/:id", async (req, res) => {
+    try {
+      const { id } = req.params;
+      const updates = req.body;
+      log2.gate("api-symbols").info("Update requested", { id, updates: JSON.stringify(updates) });
+      if (updates.tags && !Array.isArray(updates.tags)) {
+        res.status(400).json({ error: "Tags must be an array" });
+        return;
+      }
+      const result = await updateSymbol(projectDir, id, updates);
+      if (result.success) {
+        const symbols = await loadSymbolIndex(projectDir);
+        const updatedSymbol = symbols.find((s) => s.id === id);
+        log2.gate("api-symbols").info("Symbol updated", { id });
+        res.json({ success: true, symbol: updatedSymbol });
+      } else {
+        log2.gate("api-symbols").error("Update failed", { id, error: result.error });
+        res.status(400).json({ success: false, error: result.error });
+      }
+    } catch (error) {
+      log2.gate("api-symbols").error("Failed to update symbol", { error: String(error) });
+      res.status(500).json({ error: "Failed to update symbol" });
+    }
+  });
+  return router;
+}
+function createInfoRouter(projectDir) {
+  const router = Router2();
+  router.get("/", async (_req, res) => {
+    try {
+      const config = await loadParadigmConfig(projectDir);
+      const symbolCount = await getSymbolCount(projectDir);
+      res.json({
+        projectName: config.name || null,
+        discipline: config.discipline || null,
+        symbolCount,
+        projectDir
+      });
+    } catch (error) {
+      console.error("Failed to load project info:", error);
+      res.status(500).json({ error: "Failed to load project info" });
+    }
+  });
+  return router;
+}
+function extractSymbolsFromFiles(files) {
+  const symbols = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (file.endsWith(".purpose")) {
+      const dir = path2.dirname(file);
+      const name = path2.basename(dir);
+      if (dir.includes("features/") || dir.includes("routes/") || dir.includes("api/")) {
+        symbols.add(`@${name}`);
+      } else if (dir.includes("components/") || dir.includes("lib/") || dir.includes("utils/")) {
+        symbols.add(`#${name}`);
+      } else if (dir.includes("middleware/") || dir.includes("auth/") || dir.includes("guards/")) {
+        symbols.add(`^${name}`);
+      } else if (dir.includes("flows/") || dir.includes("workflows/")) {
+        symbols.add(`$${name}`);
+      }
+    }
+    if (file.includes("portal.yaml")) {
+      symbols.add("^portal");
+    }
+    const featureMatch = file.match(/features\/([^/]+)/);
+    if (featureMatch) {
+      symbols.add(`@${featureMatch[1]}`);
+    }
+    const componentMatch = file.match(/components\/([^/]+)/);
+    if (componentMatch) {
+      symbols.add(`#${componentMatch[1]}`);
+    }
+  }
+  return Array.from(symbols);
+}
+async function loadGitHistory(projectDir, options = {}) {
+  const git = simpleGit(projectDir);
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    return [];
+  }
+  try {
+    const logOptions = {
+      maxCount: options.limit || 100
+    };
+    if (options.since) {
+      logOptions["--since"] = options.since;
+    }
+    const log4 = await git.log(logOptions);
+    const commits = [];
+    for (const commit of log4.all) {
+      let filesChanged = [];
+      let symbolsModified = [];
+      try {
+        const diff = await git.diffSummary([`${commit.hash}^`, commit.hash]);
+        filesChanged = diff.files.map((f) => f.file);
+        symbolsModified = extractSymbolsFromFiles(filesChanged);
+      } catch {
+      }
+      commits.push({
+        hash: commit.hash,
+        shortHash: commit.hash.slice(0, 7),
+        date: commit.date,
+        author: commit.author_name,
+        message: commit.message.split("\n")[0],
+        // First line only
+        symbolsModified,
+        filesChanged
+      });
+    }
+    return commits;
+  } catch (error) {
+    console.error("Failed to load git history:", error);
+    return [];
+  }
+}
+async function getSymbolsAtCommit(projectDir, commitHash) {
+  const git = simpleGit(projectDir);
+  try {
+    const result = await git.raw(["ls-tree", "-r", "--name-only", commitHash]);
+    const files = result.split("\n").filter(Boolean);
+    const purposeFiles = files.filter((f) => f.endsWith(".purpose"));
+    return extractSymbolsFromFiles(purposeFiles);
+  } catch (error) {
+    console.error("Failed to get symbols at commit:", error);
+    return [];
+  }
+}
+function createCommitsRouter(projectDir) {
+  const router = Router3();
+  router.get("/", async (req, res) => {
+    try {
+      const limit = parseInt(req.query.limit) || 100;
+      const since = req.query.since;
+      const commits = await loadGitHistory(projectDir, { limit, since });
+      res.json({ commits });
+    } catch (error) {
+      console.error("Failed to load commits:", error);
+      res.status(500).json({ error: "Failed to load commits" });
+    }
+  });
+  return router;
+}
+function createIncidentsRouter(_projectDir) {
+  const router = Router4();
+  const storage = new SentinelStorage();
+  router.get("/", async (req, res) => {
+    try {
+      const limit = parseInt(req.query.limit) || 50;
+      const status = req.query.status;
+      const environment = req.query.environment;
+      const symbol = req.query.symbol;
+      const options = { limit };
+      if (status && ["open", "investigating", "resolved", "wont-fix"].includes(status)) {
+        options.status = status;
+      }
+      if (environment) options.environment = environment;
+      if (symbol) options.symbol = symbol;
+      const incidents = storage.getRecentIncidents(options);
+      const summaries = incidents.map((incident) => ({
+        id: incident.id,
+        timestamp: incident.timestamp,
+        status: incident.status,
+        error: {
+          message: incident.error.message,
+          type: incident.error.type
+        },
+        symbols: incident.symbols,
+        environment: incident.environment,
+        patternMatches: []
+        // Would need PatternMatcher to populate
+      }));
+      res.json({ incidents: summaries });
+    } catch (error) {
+      console.error("Failed to load incidents:", error);
+      res.status(500).json({ error: "Failed to load incidents" });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const incident = storage.getIncident(req.params.id);
+      if (!incident) {
+        res.status(404).json({ error: "Incident not found" });
+        return;
+      }
+      res.json({ incident });
+    } catch (error) {
+      console.error("Failed to load incident:", error);
+      res.status(500).json({ error: "Failed to load incident" });
+    }
+  });
+  router.post("/:id/resolve", async (req, res) => {
+    try {
+      const incident = storage.getIncident(req.params.id);
+      if (!incident) {
+        res.status(404).json({ error: "Incident not found" });
+        return;
+      }
+      storage.resolveIncident(req.params.id, {
+        notes: req.body.notes,
+        patternId: req.body.patternId
+      });
+      res.json({ success: true });
+    } catch (error) {
+      console.error("Failed to resolve incident:", error);
+      res.status(500).json({ error: "Failed to resolve incident" });
+    }
+  });
+  return router;
+}
+function createPatternsRouter(_projectDir) {
+  const router = Router5();
+  const storage = new SentinelStorage();
+  router.get("/", async (req, res) => {
+    try {
+      const source = req.query.source;
+      const symbol = req.query.symbol;
+      const minConfidence = parseInt(req.query.minConfidence) || void 0;
+      const options = {};
+      if (source && ["manual", "suggested", "imported", "community"].includes(source)) {
+        options.source = source;
+      }
+      if (symbol) options.symbol = symbol;
+      if (minConfidence) options.minConfidence = minConfidence;
+      const patterns = storage.getAllPatterns(options);
+      const summaries = patterns.map((pattern) => ({
+        id: pattern.id,
+        name: pattern.name,
+        description: pattern.description,
+        confidence: {
+          score: pattern.confidence.score,
+          timesMatched: pattern.confidence.timesMatched,
+          timesResolved: pattern.confidence.timesResolved
+        },
+        tags: pattern.tags
+      }));
+      res.json({ patterns: summaries });
+    } catch (error) {
+      console.error("Failed to load patterns:", error);
+      res.status(500).json({ error: "Failed to load patterns" });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const pattern = storage.getPattern(req.params.id);
+      if (!pattern) {
+        res.status(404).json({ error: "Pattern not found" });
+        return;
+      }
+      res.json({ pattern });
+    } catch (error) {
+      console.error("Failed to load pattern:", error);
+      res.status(500).json({ error: "Failed to load pattern" });
+    }
+  });
+  return router;
+}
+function inferSymbolType(symbol) {
+  if (symbol.startsWith("#")) return "component";
+  if (symbol.startsWith("^")) return "gate";
+  if (symbol.startsWith("!")) return "signal";
+  if (symbol.startsWith("$")) return "flow";
+  if (symbol.startsWith("~")) return "aspect";
+  return "raw";
+}
+function validateSymbol(symbol, index) {
+  const entry = index.find((e) => e.symbol === symbol);
+  if (entry) return { known: true };
+  const symbolName = symbol.replace(/^[#^!$~]/, "");
+  let bestMatch;
+  let bestScore = 0;
+  for (const e of index) {
+    const eName = e.symbol.replace(/^[#^!$~]/, "");
+    let shared = 0;
+    for (let i = 0; i < Math.min(symbolName.length, eName.length); i++) {
+      if (symbolName[i] === eName[i]) shared++;
+      else break;
+    }
+    const score = shared / Math.max(symbolName.length, eName.length);
+    if (score > bestScore && score > 0.5) {
+      bestScore = score;
+      bestMatch = e.symbol;
+    }
+  }
+  return { known: false, suggestion: bestMatch };
+}
+function autoPromoteToIncident(entry, storage) {
+  try {
+    const symbolType = inferSymbolType(entry.symbol);
+    const symbols = {};
+    if (symbolType === "component") symbols.component = entry.symbol;
+    else if (symbolType === "gate") symbols.gate = entry.symbol;
+    else if (symbolType === "signal") symbols.signal = entry.symbol;
+    else if (symbolType === "flow") symbols.flow = entry.symbol;
+    else symbols.component = entry.symbol;
+    storage.recordIncident({
+      error: {
+        message: entry.message,
+        type: "LogError"
+      },
+      symbols,
+      environment: entry.environment || "unknown",
+      service: entry.service
+    });
+  } catch {
+  }
+}
+var insertsSincePrune = 0;
+function createLogsRouter(options) {
+  const router = Router6();
+  const { storage, serverConfig, onLogReceived, symbolIndex } = options;
+  router.post("/", async (req, res) => {
+    try {
+      const body = req.body;
+      let entries;
+      if (Array.isArray(body.entries)) {
+        entries = body.entries;
+      } else if (body.level && body.symbol && body.message && body.service) {
+        entries = [body];
+      } else {
+        res.status(400).json({ error: "Expected {entries: [...]} or a single log entry with level, symbol, message, service" });
+        return;
+      }
+      if (entries.length > serverConfig.maxBatchSize) {
+        res.status(413).json({
+          error: `Batch too large: ${entries.length} entries, max ${serverConfig.maxBatchSize}`
+        });
+        return;
+      }
+      for (let i = 0; i < entries.length; i++) {
+        const e = entries[i];
+        if (!e.level || !e.symbol || !e.message || !e.service) {
+          res.status(400).json({
+            error: `Entry ${i}: missing required fields (level, symbol, message, service)`
+          });
+          return;
+        }
+        if (!["debug", "info", "warn", "error"].includes(e.level)) {
+          res.status(400).json({
+            error: `Entry ${i}: invalid level "${e.level}", must be debug|info|warn|error`
+          });
+          return;
+        }
+      }
+      const result = storage.insertLogBatch(entries);
+      for (const input of entries) {
+        const entry = {
+          id: input.id || uuidv4(),
+          timestamp: input.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+          level: input.level,
+          symbol: input.symbol,
+          symbolType: input.symbolType || inferSymbolType(input.symbol),
+          message: input.message,
+          data: input.data,
+          service: input.service,
+          sessionId: input.sessionId,
+          correlationId: input.correlationId,
+          durationMs: input.durationMs,
+          environment: input.environment
+        };
+        let validation;
+        if (symbolIndex) {
+          validation = validateSymbol(entry.symbol, symbolIndex);
+        }
+        if (entry.level === "error") {
+          autoPromoteToIncident(entry, storage);
+        }
+        if (onLogReceived) {
+          onLogReceived(entry, validation);
+        }
+      }
+      insertsSincePrune += result.accepted;
+      if (serverConfig.maxLogs > 0 && insertsSincePrune >= serverConfig.pruneIntervalInserts) {
+        insertsSincePrune = 0;
+        storage.pruneLogs(serverConfig.maxLogs);
+      }
+      res.json({ accepted: result.accepted, errors: result.errors.length > 0 ? result.errors : void 0 });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to insert logs" });
+    }
+  });
+  router.get("/", async (req, res) => {
+    try {
+      const options2 = {
+        level: req.query.level,
+        symbol: req.query.symbol,
+        service: req.query.service,
+        sessionId: req.query.sessionId,
+        correlationId: req.query.correlationId,
+        search: req.query.search,
+        since: req.query.since,
+        until: req.query.until,
+        limit: req.query.limit ? parseInt(req.query.limit) : 100,
+        offset: req.query.offset ? parseInt(req.query.offset) : 0
+      };
+      const logs = storage.queryLogs(options2);
+      const total = storage.getLogCount(options2);
+      res.json({ count: logs.length, total, logs });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to query logs" });
+    }
+  });
+  return router;
+}
+function createServicesRouter(options) {
+  const router = Router7();
+  const { storage } = options;
+  router.post("/", async (req, res) => {
+    try {
+      const { name, version, pid, environment, metadata } = req.body;
+      if (!name) {
+        res.status(400).json({ error: "Missing required field: name" });
+        return;
+      }
+      storage.registerService({ name, version, pid, environment, metadata });
+      res.json({ success: true, service: name });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to register service" });
+    }
+  });
+  router.get("/", async (_req, res) => {
+    try {
+      const services = storage.getServices();
+      res.json({ count: services.length, services });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to list services" });
+    }
+  });
+  return router;
+}
+function createStateRouter(options) {
+  const router = Router7();
+  const { storage } = options;
+  router.post("/", async (req, res) => {
+    try {
+      const { service, sessionId, state, activeFlows, activeGates } = req.body;
+      if (!service || !sessionId || !state) {
+        res.status(400).json({ error: "Missing required fields: service, sessionId, state" });
+        return;
+      }
+      storage.upsertAppState({
+        service,
+        sessionId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        state,
+        activeFlows,
+        activeGates
+      });
+      storage.updateServiceLastSeen(service);
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to update state" });
+    }
+  });
+  router.get("/", async (_req, res) => {
+    try {
+      const states = storage.getAllAppStates();
+      res.json({ count: states.length, states });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to get states" });
+    }
+  });
+  router.get("/:service", async (req, res) => {
+    try {
+      const states = storage.getAppState(req.params.service);
+      res.json({ count: states.length, states });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to get service state" });
+    }
+  });
+  return router;
+}
+var VALID_METRIC_TYPES = ["counter", "gauge", "histogram"];
+function createMetricsRouter(options) {
+  const router = Router8();
+  const { storage, serverConfig } = options;
+  router.post("/", (req, res) => {
+    try {
+      const body = req.body;
+      let entries;
+      if (Array.isArray(body.entries)) {
+        entries = body.entries;
+      } else if (body.name && body.type && body.value !== void 0 && body.service) {
+        entries = [body];
+      } else {
+        res.status(400).json({
+          error: "Expected {entries: [...]} or a single metric with name, type, value, service"
+        });
+        return;
+      }
+      if (entries.length > serverConfig.maxBatchSize) {
+        res.status(413).json({
+          error: `Batch too large: ${entries.length} entries, max ${serverConfig.maxBatchSize}`
+        });
+        return;
+      }
+      for (let i = 0; i < entries.length; i++) {
+        const e = entries[i];
+        if (!e.name || !e.type || e.value === void 0 || !e.service) {
+          res.status(400).json({
+            error: `Entry ${i}: missing required fields (name, type, value, service)`
+          });
+          return;
+        }
+        if (!VALID_METRIC_TYPES.includes(e.type)) {
+          res.status(400).json({
+            error: `Entry ${i}: invalid type "${e.type}", must be counter|gauge|histogram`
+          });
+          return;
+        }
+      }
+      const result = storage.insertMetricBatch(entries);
+      res.json({
+        accepted: result.accepted,
+        errors: result.errors.length > 0 ? result.errors : void 0
+      });
+    } catch {
+      res.status(500).json({ error: "Failed to insert metrics" });
+    }
+  });
+  router.get("/", (req, res) => {
+    try {
+      const options2 = {
+        name: req.query.name,
+        type: req.query.type,
+        service: req.query.service,
+        tag: req.query.tag,
+        since: req.query.since,
+        until: req.query.until,
+        limit: req.query.limit ? parseInt(req.query.limit) : 100,
+        offset: req.query.offset ? parseInt(req.query.offset) : 0
+      };
+      const metrics = storage.queryMetrics(options2);
+      const total = storage.getMetricCount(options2);
+      res.json({ count: metrics.length, total, metrics });
+    } catch {
+      res.status(500).json({ error: "Failed to query metrics" });
+    }
+  });
+  router.get("/aggregate/:name", (req, res) => {
+    try {
+      const aggregation = storage.aggregateMetric(req.params.name, {
+        service: req.query.service,
+        since: req.query.since,
+        until: req.query.until
+      });
+      res.json(aggregation);
+    } catch {
+      res.status(500).json({ error: "Failed to aggregate metric" });
+    }
+  });
+  return router;
+}
+function createTracesRouter(options) {
+  const router = Router9();
+  const { storage } = options;
+  router.post("/", (req, res) => {
+    try {
+      const body = req.body;
+      if (!body.traceId || !body.service || !body.symbol || !body.operation) {
+        res.status(400).json({
+          error: "Missing required fields: traceId, service, symbol, operation"
+        });
+        return;
+      }
+      const spanId = storage.insertSpan(body);
+      res.json({ spanId, traceId: body.traceId });
+    } catch {
+      res.status(500).json({ error: "Failed to insert trace span" });
+    }
+  });
+  router.get("/", (req, res) => {
+    try {
+      const traces = storage.queryTraces({
+        service: req.query.service,
+        symbol: req.query.symbol,
+        since: req.query.since,
+        limit: req.query.limit ? parseInt(req.query.limit) : 20
+      });
+      res.json({ count: traces.length, traces });
+    } catch {
+      res.status(500).json({ error: "Failed to query traces" });
+    }
+  });
+  router.get("/:traceId", (req, res) => {
+    try {
+      const trace = storage.getTrace(req.params.traceId);
+      if (!trace) {
+        res.status(404).json({ error: "Trace not found" });
+        return;
+      }
+      res.json(trace);
+    } catch {
+      res.status(500).json({ error: "Failed to get trace" });
+    }
+  });
+  return router;
+}
+function createSchemasRouter(options) {
+  const router = Router10();
+  const { storage } = options;
+  router.post("/", (req, res) => {
+    try {
+      const body = req.body;
+      if (!body.id || !body.version || !body.name || !body.scope || !body.eventTypes) {
+        res.status(400).json({
+          error: "Missing required fields: id, version, name, scope, eventTypes"
+        });
+        return;
+      }
+      if (!body.scope.field || !body.scope.type || !body.scope.label || !body.scope.ordering) {
+        res.status(400).json({
+          error: "Invalid scope: requires field, type, label, ordering"
+        });
+        return;
+      }
+      if (!Array.isArray(body.eventTypes) || body.eventTypes.length === 0) {
+        res.status(400).json({
+          error: "eventTypes must be a non-empty array"
+        });
+        return;
+      }
+      for (let i = 0; i < body.eventTypes.length; i++) {
+        const et = body.eventTypes[i];
+        if (!et.type || !et.category) {
+          res.status(400).json({
+            error: `eventTypes[${i}]: missing required fields (type, category)`
+          });
+          return;
+        }
+      }
+      const schema = storage.registerSchema(body);
+      res.status(201).json(schema);
+    } catch (error) {
+      res.status(500).json({ error: "Failed to register schema" });
+    }
+  });
+  router.get("/", (_req, res) => {
+    try {
+      const schemas = storage.listSchemas();
+      res.json({ count: schemas.length, schemas });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to list schemas" });
+    }
+  });
+  router.get("/:id", (req, res) => {
+    try {
+      const schema = storage.getSchema(req.params.id);
+      if (!schema) {
+        res.status(404).json({ error: "Schema not found" });
+        return;
+      }
+      res.json(schema);
+    } catch (error) {
+      res.status(500).json({ error: "Failed to get schema" });
+    }
+  });
+  return router;
+}
+function createEventsRouter(options) {
+  const router = Router11();
+  const { storage, serverConfig, onEventReceived } = options;
+  let insertsSincePrune2 = 0;
+  router.post("/", (req, res) => {
+    try {
+      const body = req.body;
+      if (!body.schemaId || !body.service || !Array.isArray(body.events)) {
+        res.status(400).json({
+          error: "Expected { schemaId, service, events: [...] }"
+        });
+        return;
+      }
+      const { schemaId, service, events } = body;
+      const schema = storage.getSchema(schemaId);
+      if (!schema) {
+        res.status(404).json({
+          error: `Schema "${schemaId}" not found. Register it first via POST /api/schemas.`
+        });
+        return;
+      }
+      if (events.length > serverConfig.maxBatchSize) {
+        res.status(413).json({
+          error: `Batch too large: ${events.length} events, max ${serverConfig.maxBatchSize}`
+        });
+        return;
+      }
+      for (let i = 0; i < events.length; i++) {
+        const e = events[i];
+        if (!e.type) {
+          res.status(400).json({
+            error: `events[${i}]: missing required field "type"`
+          });
+          return;
+        }
+      }
+      const result = storage.insertEventBatch(schemaId, service, events);
+      if (onEventReceived) {
+        const typeMap = /* @__PURE__ */ new Map();
+        for (const et of schema.eventTypes) {
+          typeMap.set(et.type, et.category);
+        }
+        for (const input of events) {
+          const evt = {
+            id: input.id || "",
+            schemaId,
+            eventType: input.type,
+            category: typeMap.get(input.type) || "unknown",
+            timestamp: input.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+            scopeValue: input.scopeValue != null ? String(input.scopeValue) : void 0,
+            sessionId: input.sessionId,
+            service,
+            data: input.data,
+            severity: input.severity || "info",
+            parentEventId: input.parentEventId,
+            depth: input.depth
+          };
+          onEventReceived(evt);
+        }
+      }
+      insertsSincePrune2 += result.accepted;
+      if (serverConfig.maxLogs > 0 && insertsSincePrune2 >= serverConfig.pruneIntervalInserts) {
+        insertsSincePrune2 = 0;
+        storage.pruneEvents(serverConfig.maxLogs);
+      }
+      res.json({
+        accepted: result.accepted,
+        errors: result.errors.length > 0 ? result.errors : void 0
+      });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to ingest events" });
+    }
+  });
+  router.get("/", (req, res) => {
+    try {
+      const query = {
+        schemaId: req.query.schemaId,
+        eventType: req.query.eventType,
+        category: req.query.category,
+        service: req.query.service,
+        sessionId: req.query.sessionId,
+        scopeValue: req.query.scopeValue,
+        scopeFrom: req.query.scopeFrom,
+        scopeTo: req.query.scopeTo,
+        severity: req.query.severity,
+        since: req.query.since,
+        until: req.query.until,
+        search: req.query.search,
+        limit: req.query.limit ? parseInt(req.query.limit) : 100,
+        offset: req.query.offset ? parseInt(req.query.offset) : 0
+      };
+      const events = storage.queryEvents(query);
+      const total = storage.getEventCount(query);
+      res.json({ count: events.length, total, events });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to query events" });
+    }
+  });
+  router.get("/scopes", (req, res) => {
+    try {
+      const schemaId = req.query.schemaId;
+      if (!schemaId) {
+        res.status(400).json({ error: "schemaId query parameter is required" });
+        return;
+      }
+      const scopes = storage.getEventScopes(schemaId, {
+        limit: req.query.limit ? parseInt(req.query.limit) : 100,
+        offset: req.query.offset ? parseInt(req.query.offset) : 0,
+        sessionId: req.query.sessionId
+      });
+      res.json({ count: scopes.length, scopes });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to query scopes" });
+    }
+  });
+  router.get("/scope/:value", (req, res) => {
+    try {
+      const schemaId = req.query.schemaId;
+      if (!schemaId) {
+        res.status(400).json({ error: "schemaId query parameter is required" });
+        return;
+      }
+      const events = storage.queryEventsByScope(schemaId, req.params.value);
+      res.json({ count: events.length, events });
+    } catch (error) {
+      res.status(500).json({ error: "Failed to query scope events" });
+    }
+  });
+  return router;
+}
+function createAuthMiddleware(config) {
+  return function authMiddleware(requiredPermission) {
+    return (req, res, next) => {
+      if (!config.enabled) {
+        next();
+        return;
+      }
+      const authHeader = req.headers.authorization;
+      if (!authHeader) {
+        res.status(401).json({ error: "Authentication required. Provide Authorization: Bearer <token>" });
+        return;
+      }
+      const match = authHeader.match(/^Bearer\s+(.+)$/i);
+      if (!match) {
+        res.status(401).json({ error: "Invalid authorization format. Use: Bearer <token>" });
+        return;
+      }
+      const tokenValue = match[1];
+      const tokenEntry = config.tokens.find((t) => t.token === tokenValue);
+      if (!tokenEntry) {
+        res.status(401).json({ error: "Invalid token" });
+        return;
+      }
+      if (tokenEntry.expiresAt && new Date(tokenEntry.expiresAt) < /* @__PURE__ */ new Date()) {
+        res.status(401).json({ error: "Token expired" });
+        return;
+      }
+      const permissionLevel = { read: 1, write: 2, admin: 3 };
+      const hasPermission = tokenEntry.permissions.some(
+        (p) => permissionLevel[p] >= permissionLevel[requiredPermission]
+      );
+      if (!hasPermission) {
+        res.status(403).json({ error: `Insufficient permissions. Required: ${requiredPermission}` });
+        return;
+      }
+      req.authToken = tokenEntry;
+      next();
+    };
+  };
+}
+var serviceWindows = /* @__PURE__ */ new Map();
+var globalWindow = { count: 0, windowStart: Date.now() };
+var WINDOW_MS = 6e4;
+function getOrResetWindow(entry) {
+  const now = Date.now();
+  if (now - entry.windowStart > WINDOW_MS) {
+    entry.count = 0;
+    entry.windowStart = now;
+  }
+  return entry;
+}
+function createRateLimiter(config) {
+  return (req, res, next) => {
+    if (!config.enabled) {
+      next();
+      return;
+    }
+    const service = req.body?.service || req.body?.entries?.[0]?.service || req.query.service || "_unknown";
+    const rule = config.perService[service] || config.global;
+    if (rule.samplingRate < 1 && Math.random() > rule.samplingRate) {
+      res.status(200).json({ accepted: 0, sampled: true, message: "Request dropped by sampling" });
+      return;
+    }
+    const gw = getOrResetWindow(globalWindow);
+    if (gw.count >= config.global.maxRequestsPerMinute) {
+      res.status(429).json({
+        error: "Global rate limit exceeded",
+        retryAfterMs: WINDOW_MS - (Date.now() - gw.windowStart)
+      });
+      return;
+    }
+    if (!serviceWindows.has(service)) {
+      serviceWindows.set(service, { count: 0, windowStart: Date.now() });
+    }
+    const sw = getOrResetWindow(serviceWindows.get(service));
+    if (sw.count >= rule.maxRequestsPerMinute) {
+      res.status(429).json({
+        error: `Rate limit exceeded for service: ${service}`,
+        retryAfterMs: WINDOW_MS - (Date.now() - sw.windowStart)
+      });
+      return;
+    }
+    const batchSize = req.body?.entries?.length || 1;
+    if (batchSize > rule.maxEntriesPerBatch) {
+      res.status(413).json({
+        error: `Batch too large: ${batchSize} entries, max ${rule.maxEntriesPerBatch} for service ${service}`
+      });
+      return;
+    }
+    gw.count++;
+    sw.count++;
+    next();
+  };
+}
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+var log3 = {
+  component(name) {
+    const symbol = chalk3.magenta(`#${name}`);
+    return {
+      info: (msg, data) => {
+        const dataStr = data ? chalk3.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk3.blue("\u2139")} ${symbol} ${msg}${dataStr}`);
+      },
+      success: (msg, data) => {
+        const dataStr = data ? chalk3.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk3.green("\u2714")} ${symbol} ${msg}${dataStr}`);
+      },
+      warn: (msg, data) => {
+        const dataStr = data ? chalk3.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk3.yellow("\u26A0")} ${symbol} ${msg}${dataStr}`);
+      },
+      error: (msg, data) => {
+        const dataStr = data ? chalk3.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.error(`${chalk3.red("\u2716")} ${symbol} ${msg}${dataStr}`);
+      }
+    };
+  }
+};
+function createApp(options) {
+  const app = express();
+  app.use(express.json({ limit: "5mb" }));
+  app.use((_req, res, next) => {
+    const corsOrigin = options.serverConfig?.cors?.origin;
+    const origin = Array.isArray(corsOrigin) ? corsOrigin.join(", ") : corsOrigin ?? "*";
+    res.header("Access-Control-Allow-Origin", origin);
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (options.serverConfig?.cors?.credentials) {
+      res.header("Access-Control-Allow-Credentials", "true");
+    }
+    if (_req.method === "OPTIONS") {
+      res.sendStatus(204);
+      return;
+    }
+    next();
+  });
+  app.use("/api/symbols", createSymbolsRouter(options.projectDir));
+  app.use("/api/info", createInfoRouter(options.projectDir));
+  app.use("/api/commits", createCommitsRouter(options.projectDir));
+  app.use("/api/incidents", createIncidentsRouter(options.projectDir));
+  app.use("/api/patterns", createPatternsRouter(options.projectDir));
+  if (options.storage && options.serverConfig) {
+    const config = options.serverConfig;
+    const auth = createAuthMiddleware(config.auth);
+    const rateLimiter = createRateLimiter(config.rateLimit);
+    app.use("/api/logs", rateLimiter, auth("write"), createLogsRouter({
+      storage: options.storage,
+      serverConfig: config,
+      onLogReceived: options.onLogReceived,
+      symbolIndex: options.symbolIndex
+    }));
+    app.use("/api/services", rateLimiter, auth("write"), createServicesRouter({ storage: options.storage }));
+    app.use("/api/state", rateLimiter, auth("write"), createStateRouter({ storage: options.storage }));
+    app.use("/api/metrics", rateLimiter, auth("write"), createMetricsRouter({
+      storage: options.storage,
+      serverConfig: config
+    }));
+    app.use("/api/traces", rateLimiter, auth("write"), createTracesRouter({
+      storage: options.storage
+    }));
+    app.use("/api/schemas", rateLimiter, auth("write"), createSchemasRouter({
+      storage: options.storage
+    }));
+    app.use("/api/events", rateLimiter, auth("write"), createEventsRouter({
+      storage: options.storage,
+      serverConfig: config,
+      onEventReceived: options.onEventReceived
+    }));
+  }
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  const uiDistPath = path3.join(__dirname, "..", "..", "ui", "dist");
+  if (fs2.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+    app.get("{*path}", (req, res) => {
+      if (!req.path.startsWith("/api")) {
+        res.sendFile(path3.join(uiDistPath, "index.html"));
+      }
+    });
+  }
+  return app;
+}
+async function startServer(options) {
+  const serverConfig = loadServerConfig(options.projectDir);
+  if (options.logPruneLimit !== void 0) {
+    serverConfig.maxLogs = options.logPruneLimit;
+  }
+  const storage = new SentinelStorage(options.dbPath);
+  await storage.ensureReady();
+  let symbolIndex = [];
+  try {
+    symbolIndex = await loadSymbolIndex(options.projectDir);
+  } catch {
+    log3.component("sentinel-server").warn("Could not load symbol index for validation");
+  }
+  const wsClients = /* @__PURE__ */ new Set();
+  function broadcast(message) {
+    const data = JSON.stringify(message);
+    for (const client of wsClients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    }
+  }
+  function onLogReceived(entry, validation) {
+    const message = { type: "log", entry };
+    if (validation && !validation.known) {
+      message.validation = validation;
+    }
+    broadcast(message);
+    if (entry.symbolType === "signal" || entry.symbolType === "gate" || entry.symbolType === "flow") {
+      broadcast({
+        type: "flow_event",
+        flowId: entry.symbolType === "flow" ? entry.symbol : void 0,
+        nodeSymbol: entry.symbol,
+        event: entry.symbolType,
+        timestamp: entry.timestamp,
+        service: entry.service
+      });
+    }
+  }
+  function onEventReceived(event) {
+    broadcast({ type: "event", event });
+  }
+  const app = createApp({
+    ...options,
+    storage,
+    serverConfig,
+    symbolIndex,
+    onLogReceived,
+    onEventReceived
+  });
+  log3.component("sentinel-server").info("Starting server", { port: options.port });
+  log3.component("sentinel-server").info("Project directory", { path: options.projectDir });
+  return new Promise((resolve, reject) => {
+    const httpServer = http.createServer(app);
+    const wss = new WebSocketServer({ server: httpServer });
+    wss.on("connection", (ws) => {
+      if (wsClients.size >= serverConfig.wsMaxSubscribers) {
+        ws.close(1013, "Max subscribers reached");
+        return;
+      }
+      wsClients.add(ws);
+      log3.component("sentinel-ws").info("Client connected", { total: wsClients.size });
+      ws.on("message", (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+          if (msg.method === "ping") {
+            ws.send(JSON.stringify({
+              jsonrpc: "2.0",
+              result: { pong: true, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+              id: msg.id
+            }));
+          } else if (msg.method === "subscribe") {
+            ws.send(JSON.stringify({
+              jsonrpc: "2.0",
+              result: { subscribed: true },
+              id: msg.id
+            }));
+          } else if (msg.method === "query_logs") {
+            const logs = storage.queryLogs(msg.params || {});
+            ws.send(JSON.stringify({
+              jsonrpc: "2.0",
+              result: { logs },
+              id: msg.id
+            }));
+          } else if (msg.method === "query_events") {
+            const events = storage.queryEvents(msg.params || {});
+            ws.send(JSON.stringify({
+              jsonrpc: "2.0",
+              result: { events },
+              id: msg.id
+            }));
+          } else if (msg.method === "query_scopes") {
+            const { schemaId, ...rest } = msg.params || {};
+            const scopes = schemaId ? storage.getEventScopes(schemaId, rest) : [];
+            ws.send(JSON.stringify({
+              jsonrpc: "2.0",
+              result: { scopes },
+              id: msg.id
+            }));
+          }
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        wsClients.delete(ws);
+        log3.component("sentinel-ws").info("Client disconnected", { total: wsClients.size });
+      });
+      ws.on("error", () => {
+        wsClients.delete(ws);
+      });
+    });
+    httpServer.listen(options.port, () => {
+      log3.component("sentinel-server").success("Server running", { url: `http://localhost:${options.port}` });
+      log3.component("sentinel-ws").success("WebSocket ready", { url: `ws://localhost:${options.port}` });
+      if (options.open) {
+        import("open").then((openModule) => {
+          openModule.default(`http://localhost:${options.port}`);
+          log3.component("sentinel-server").info("Opened browser");
+        }).catch(() => {
+          log3.component("sentinel-server").warn("Could not open browser automatically");
+        });
+      }
+      resolve();
+    });
+    httpServer.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        log3.component("sentinel-server").error("Port already in use", { port: options.port });
+      } else {
+        log3.component("sentinel-server").error("Server error", { error: err.message });
+      }
+      reject(err);
+    });
+  });
+}
+export {
+  createApp,
+  getSymbolCount,
+  getSymbolsAtCommit,
+  loadGitHistory,
+  loadParadigmConfig,
+  loadSymbolIndex,
+  startServer
+};