@a-company/paradigm 5.10.0 → 5.21.0

package/dist/server-54SKYFFY.js

@@ -1,1647 +0,0 @@
-#!/usr/bin/env node
-import {
-  PARADIGM_SCHEMA,
-  SYMPHONY_SCHEMA,
-  SentinelStorage,
-  loadServerConfig
-} from "./chunk-FKJUBQU3.js";
-import "./chunk-PDX44BCA.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-5QE2BB2B-5S3T6Y3T.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 uiCandidates = [
-    path3.join(__dirname, "sentinel-ui"),
-    // bundled: paradigm/dist/sentinel-ui/ (copied during build)
-    path3.join(__dirname, "..", "..", "ui", "dist"),
-    // standalone: sentinel/dist/server/ → sentinel/ui/dist
-    path3.join(__dirname, "..", "ui", "dist")
-    // standalone flat: sentinel/dist/ → sentinel/ui/dist
-  ];
-  const uiDistPath = uiCandidates.find((p) => fs2.existsSync(p));
-  if (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();
-  storage.registerSchema(PARADIGM_SCHEMA);
-  storage.registerSchema(SYMPHONY_SCHEMA);
-  log3.component("sentinel-server").info("Registered builtin schemas", { schemas: "paradigm-logger, paradigm-symphony" });
-  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 {
-  PARADIGM_SCHEMA,
-  SYMPHONY_SCHEMA,
-  SentinelStorage,
-  createApp,
-  createAuthMiddleware,
-  createCommitsRouter,
-  createEventsRouter,
-  createIncidentsRouter,
-  createInfoRouter,
-  createLogsRouter,
-  createMetricsRouter,
-  createPatternsRouter,
-  createRateLimiter,
-  createSchemasRouter,
-  createServicesRouter,
-  createStateRouter,
-  createSymbolsRouter,
-  createTracesRouter,
-  getSymbolCount,
-  getSymbolsAtCommit,
-  loadGitHistory,
-  loadParadigmConfig,
-  loadServerConfig,
-  loadSymbolIndex,
-  startServer
-};