@a-company/paradigm 5.10.0 → 5.21.0

package/dist/platform-server-H5YO3DQD.js

@@ -1,1475 +0,0 @@
-#!/usr/bin/env node
-import {
-  createInfoRouter,
-  createLoreRouter,
-  createSessionsRouter
-} from "./chunk-RAB5IKPR.js";
-import {
-  createGraphsRouter,
-  createSymbolsRouter
-} from "./chunk-F3BCHPYT.js";
-import "./chunk-PDX44BCA.js";
-
-// src/platform-server/index.ts
-import express from "express";
-import * as http from "http";
-import * as path5 from "path";
-import * as fs5 from "fs";
-import { fileURLToPath } from "url";
-import chalk from "chalk";
-
-// src/platform-server/ws/index.ts
-import { WebSocketServer, WebSocket } from "ws";
-
-// src/platform-server/ws/agent.ts
-function agentColor(agentId) {
-  const colors = [
-    "#58a6ff",
-    "#3fb950",
-    "#f85149",
-    "#d29922",
-    "#bc8cff",
-    "#f778ba",
-    "#79c0ff",
-    "#56d364"
-  ];
-  let hash = 0;
-  for (let i = 0; i < agentId.length; i++) {
-    hash = (hash << 5) - hash + agentId.charCodeAt(i) | 0;
-  }
-  return colors[Math.abs(hash) % colors.length];
-}
-var annotationCounter = 0;
-var AgentPresenceManager = class {
-  agents = /* @__PURE__ */ new Map();
-  staleTimeout = 2 * 60 * 1e3;
-  // 2 minutes
-  join(agentId) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const presence = {
-      agentId,
-      color: agentColor(agentId),
-      connectedAt: now,
-      lastActivity: now
-    };
-    this.agents.set(agentId, presence);
-    return presence;
-  }
-  touch(agentId) {
-    const agent = this.agents.get(agentId);
-    if (agent) {
-      agent.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
-    }
-  }
-  leave(agentId) {
-    this.agents.delete(agentId);
-  }
-  getAll() {
-    return Array.from(this.agents.values());
-  }
-  pruneStale() {
-    const now = Date.now();
-    const pruned = [];
-    for (const [id, agent] of this.agents) {
-      if (now - new Date(agent.lastActivity).getTime() > this.staleTimeout) {
-        this.agents.delete(id);
-        pruned.push(id);
-      }
-    }
-    return pruned;
-  }
-};
-var UserStateTracker = class {
-  state = {
-    section: "overview",
-    selectedSymbol: null,
-    theme: "dark",
-    lastInteraction: Date.now()
-  };
-  highlights = [];
-  annotations = [];
-  muted = false;
-  updateSection(section) {
-    this.state.section = section;
-    this.state.lastInteraction = Date.now();
-  }
-  updateSelectedSymbol(symbol) {
-    this.state.selectedSymbol = symbol;
-    this.state.lastInteraction = Date.now();
-  }
-  updateTheme(theme) {
-    this.state.theme = theme;
-  }
-  setMuted(muted) {
-    this.muted = muted;
-  }
-  isMuted() {
-    return this.muted;
-  }
-  isUserActive(thresholdMs = 5e3) {
-    return Date.now() - this.state.lastInteraction < thresholdMs;
-  }
-  getState() {
-    return { ...this.state, muted: this.muted };
-  }
-  addHighlight(h) {
-    this.highlights.push(h);
-    if (h.duration > 0) {
-      setTimeout(() => {
-        this.highlights = this.highlights.filter((x) => x !== h);
-      }, h.duration);
-    }
-  }
-  addAnnotation(a) {
-    const annotation = {
-      ...a,
-      id: `ann-${++annotationCounter}`,
-      createdAt: Date.now()
-    };
-    this.annotations.push(annotation);
-    if (annotation.duration > 0) {
-      setTimeout(() => {
-        this.annotations = this.annotations.filter((x) => x !== annotation);
-      }, annotation.duration);
-    }
-    return annotation;
-  }
-  clearHighlights() {
-    this.highlights = [];
-  }
-  clearAnnotations() {
-    this.annotations = [];
-  }
-  clearAll() {
-    this.highlights = [];
-    this.annotations = [];
-  }
-  getHighlights() {
-    return [...this.highlights];
-  }
-  getAnnotations() {
-    return [...this.annotations];
-  }
-};
-
-// src/platform-server/ws/index.ts
-function attachWebSocket(httpServer) {
-  const wsClients = /* @__PURE__ */ new Set();
-  const agentPresence = new AgentPresenceManager();
-  const userState = new UserStateTracker();
-  function broadcast(message) {
-    const data = JSON.stringify(message);
-    for (const client of wsClients) {
-      if (client.readyState === WebSocket.OPEN) {
-        client.send(data);
-      }
-    }
-  }
-  const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
-  wss.on("connection", (ws) => {
-    wsClients.add(ws);
-    ws.on("message", (raw) => {
-      try {
-        const msg = JSON.parse(raw.toString());
-        if (msg.type === "user:navigate") {
-          userState.updateSection(msg.section);
-        } else if (msg.type === "user:select") {
-          userState.updateSelectedSymbol(msg.symbol ?? null);
-        } else if (msg.type === "user:theme") {
-          userState.updateTheme(msg.theme);
-        } else if (msg.type === "user:mute") {
-          userState.setMuted(msg.muted);
-          broadcast({ type: "agent:mute_changed", muted: msg.muted });
-        } else if (msg.type === "ping") {
-          ws.send(JSON.stringify({ type: "pong", timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
-        }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      wsClients.delete(ws);
-    });
-    ws.on("error", () => {
-      wsClients.delete(ws);
-    });
-  });
-  setInterval(() => {
-    const pruned = agentPresence.pruneStale();
-    for (const agentId of pruned) {
-      broadcast({ type: "agent:leave", agentId });
-    }
-  }, 3e4);
-  return {
-    broadcast,
-    agentPresence,
-    userState,
-    clientCount: () => wsClients.size
-  };
-}
-
-// src/platform-server/routes/agent.ts
-import { Router } from "express";
-function createAgentRouter(wsContext) {
-  const router = Router();
-  router.post("/", (req, res) => {
-    const { command, agentId, payload } = req.body;
-    if (!command || !agentId) {
-      res.status(400).json({ error: "Missing command or agentId" });
-      return;
-    }
-    const agents = wsContext.agentPresence.getAll();
-    if (!agents.find((a) => a.agentId === agentId)) {
-      wsContext.agentPresence.join(agentId);
-      wsContext.broadcast({ type: "agent:join", agent: wsContext.agentPresence.getAll().find((a) => a.agentId === agentId) });
-    }
-    wsContext.agentPresence.touch(agentId);
-    switch (command) {
-      case "navigate": {
-        const { section, symbol, loreId } = payload;
-        const userActive = wsContext.userState.isUserActive();
-        const muted = wsContext.userState.isMuted();
-        if (muted) {
-          res.json({ navigated: false, reason: "Agent actions are muted by user" });
-          return;
-        }
-        wsContext.broadcast({
-          type: "agent:navigate",
-          agentId,
-          section,
-          symbol,
-          loreId,
-          userActive
-        });
-        if (section) wsContext.userState.updateSection(section);
-        if (symbol) wsContext.userState.updateSelectedSymbol(symbol);
-        res.json({ navigated: true, section, symbol, userActive });
-        return;
-      }
-      case "highlight": {
-        const { symbols, color, duration, pulse, label } = payload;
-        const muted = wsContext.userState.isMuted();
-        if (muted) {
-          res.json({ highlighted: false, reason: "Agent actions are muted by user" });
-          return;
-        }
-        const symbolList = symbols || [];
-        wsContext.userState.addHighlight({
-          symbols: symbolList,
-          color: color || wsContext.agentPresence.getAll().find((a) => a.agentId === agentId)?.color || "#58a6ff",
-          duration: duration || 5e3,
-          pulse: pulse ?? true,
-          label,
-          createdAt: Date.now()
-        });
-        wsContext.broadcast({
-          type: "agent:highlight",
-          agentId,
-          symbols: symbolList,
-          color: color || "#58a6ff",
-          duration: duration || 5e3,
-          pulse: pulse ?? true,
-          label
-        });
-        res.json({ highlighted: true, count: symbolList.length });
-        return;
-      }
-      case "annotate": {
-        const { type, message, symbol, severity, duration } = payload;
-        const muted = wsContext.userState.isMuted();
-        if (muted) {
-          res.json({ annotated: false, reason: "Agent actions are muted by user" });
-          return;
-        }
-        const annotation = wsContext.userState.addAnnotation({
-          type: type || "toast",
-          message: message || "",
-          symbol,
-          severity: severity || "info",
-          duration: duration || 6e3
-        });
-        wsContext.broadcast({
-          type: "agent:annotate",
-          agentId,
-          annotation
-        });
-        res.json({ annotated: true, id: annotation.id });
-        return;
-      }
-      case "observe": {
-        const state = wsContext.userState.getState();
-        const agentsList = wsContext.agentPresence.getAll();
-        const connected = wsContext.clientCount() > 0;
-        res.json({
-          connected,
-          users: wsContext.clientCount(),
-          agents: agentsList,
-          state: {
-            section: state.section,
-            selectedSymbol: state.selectedSymbol,
-            theme: state.theme,
-            muted: state.muted
-          },
-          highlights: wsContext.userState.getHighlights(),
-          annotations: wsContext.userState.getAnnotations()
-        });
-        return;
-      }
-      case "clear": {
-        const { target } = payload;
-        const clearTarget = target || "all";
-        if (clearTarget === "highlights" || clearTarget === "all") {
-          wsContext.userState.clearHighlights();
-        }
-        if (clearTarget === "annotations" || clearTarget === "all") {
-          wsContext.userState.clearAnnotations();
-        }
-        wsContext.broadcast({
-          type: "agent:clear",
-          agentId,
-          target: clearTarget
-        });
-        res.json({ cleared: true, target: clearTarget });
-        return;
-      }
-      default:
-        res.status(400).json({ error: `Unknown command: ${command}` });
-        return;
-    }
-  });
-  return router;
-}
-
-// src/platform-server/routes/overview.ts
-import * as fs from "fs";
-import * as path from "path";
-import simpleGit from "simple-git";
-import * as yaml from "js-yaml";
-function readJsonSafe(filePath) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function readYamlSafe(filePath) {
-  try {
-    return yaml.load(fs.readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function getSymbolCounts(projectDir) {
-  const indexPath = path.join(projectDir, ".paradigm", "scan-index.json");
-  const data = readJsonSafe(indexPath);
-  if (!data?.symbols) return { total: 0, byType: {} };
-  const byType = {};
-  for (const sym of data.symbols) {
-    const cat = sym.category || "unknown";
-    byType[cat] = (byType[cat] || 0) + 1;
-  }
-  return { total: data.symbols.length, byType };
-}
-function getLoreStats(projectDir) {
-  const entriesDir = path.join(projectDir, ".paradigm", "lore", "entries");
-  if (!fs.existsSync(entriesDir)) {
-    return { total: 0, thisWeek: 0, lastEntry: null, calibrationScore: null, assessed: 0 };
-  }
-  const files = fs.readdirSync(entriesDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
-  const now = Date.now();
-  const weekAgo = now - 7 * 24 * 60 * 60 * 1e3;
-  let lastTimestamp = null;
-  let thisWeek = 0;
-  let assessedCount = 0;
-  let confidenceSum = 0;
-  let deltaSum = 0;
-  let deltaCount = 0;
-  for (const file of files) {
-    try {
-      const entry = readYamlSafe(path.join(entriesDir, file));
-      if (!entry) continue;
-      const ts = entry.timestamp;
-      if (ts) {
-        const entryTime = new Date(ts).getTime();
-        if (!lastTimestamp || entryTime > new Date(lastTimestamp).getTime()) {
-          lastTimestamp = ts;
-        }
-        if (entryTime >= weekAgo) thisWeek++;
-      }
-      if (entry.assessment) {
-        assessedCount++;
-        if (typeof entry.confidence === "number" && typeof entry.assessment_delta === "number") {
-          confidenceSum += entry.confidence;
-          deltaSum += Math.abs(entry.assessment_delta);
-          deltaCount++;
-        }
-      }
-    } catch {
-    }
-  }
-  const calibrationScore = deltaCount > 0 ? Math.max(0, 1 - deltaSum / deltaCount) : null;
-  return {
-    total: files.length,
-    thisWeek,
-    lastEntry: lastTimestamp,
-    calibrationScore,
-    assessed: assessedCount
-  };
-}
-function getTaskCounts(projectDir) {
-  const tasksDir = path.join(projectDir, ".paradigm", "tasks");
-  if (!fs.existsSync(tasksDir)) return { total: 0, inProgress: 0, completed: 0 };
-  const files = fs.readdirSync(tasksDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
-  let inProgress = 0;
-  let completed = 0;
-  for (const file of files) {
-    try {
-      const task = readYamlSafe(path.join(tasksDir, file));
-      if (!task) continue;
-      const status = task.status;
-      if (status === "in-progress" || status === "in_progress") inProgress++;
-      else if (status === "completed" || status === "done") completed++;
-    } catch {
-    }
-  }
-  return { total: files.length, inProgress, completed };
-}
-function getPurposeCoverage(projectDir) {
-  const srcDirs = ["src", "lib", "packages"];
-  let withPurpose = 0;
-  let total = 0;
-  for (const dir of srcDirs) {
-    const fullPath = path.join(projectDir, dir);
-    if (!fs.existsSync(fullPath)) continue;
-    countPurposeCoverage(fullPath, { withPurpose: 0, total: 0 }, (stats) => {
-      withPurpose += stats.withPurpose;
-      total += stats.total;
-    });
-  }
-  if (fs.existsSync(path.join(projectDir, ".purpose"))) {
-    withPurpose++;
-    total++;
-  }
-  return total === 0 ? 1 : withPurpose / total;
-}
-function countPurposeCoverage(dir, _stats, callback) {
-  const stats = { withPurpose: 0, total: 0 };
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const hasSourceFiles = entries.some(
-      (e) => e.isFile() && /\.(ts|tsx|js|jsx|rs|py|go|swift)$/.test(e.name)
-    );
-    if (hasSourceFiles) {
-      stats.total++;
-      if (entries.some((e) => e.isFile() && e.name === ".purpose")) {
-        stats.withPurpose++;
-      }
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist") {
-        countPurposeCoverage(path.join(dir, entry.name), stats, (sub) => {
-          stats.withPurpose += sub.withPurpose;
-          stats.total += sub.total;
-        });
-      }
-    }
-  } catch {
-  }
-  callback(stats);
-}
-function getGateCompliance(projectDir) {
-  const portalPath = path.join(projectDir, "portal.yaml");
-  if (!fs.existsSync(portalPath)) return 1;
-  const portal = readYamlSafe(portalPath);
-  if (!portal?.routes) return 1;
-  const routeCount = Object.keys(portal.routes).length;
-  return routeCount > 0 ? 1 : 0.5;
-}
-function getAspectAnchors(projectDir) {
-  const dbPath = path.join(projectDir, ".paradigm", "aspect-graph.db");
-  if (!fs.existsSync(dbPath)) return 1;
-  return 1;
-}
-function getConfigInfo(projectDir) {
-  const configPath = path.join(projectDir, ".paradigm", "config.yaml");
-  const config = readYamlSafe(configPath);
-  return {
-    name: config?.project || path.basename(projectDir),
-    discipline: config?.discipline || "general"
-  };
-}
-async function getRecentCommits(projectDir, limit) {
-  try {
-    const git = simpleGit(projectDir);
-    const log2 = await git.log({ maxCount: limit });
-    return log2.all.map((c) => ({
-      timestamp: c.date,
-      type: "commit",
-      summary: c.message.split("\n")[0],
-      symbol: extractFirstSymbol(c.message),
-      link: c.hash.substring(0, 7)
-    }));
-  } catch {
-    return [];
-  }
-}
-function extractFirstSymbol(text) {
-  const match = text.match(/[#$^!~][\w-]+/);
-  return match ? match[0] : void 0;
-}
-function getLoreActivity(projectDir, limit) {
-  const entriesDir = path.join(projectDir, ".paradigm", "lore", "entries");
-  if (!fs.existsSync(entriesDir)) return [];
-  const files = fs.readdirSync(entriesDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
-  const items = [];
-  for (const file of files) {
-    try {
-      const entry = readYamlSafe(path.join(entriesDir, file));
-      if (!entry) continue;
-      items.push({
-        timestamp: entry.timestamp || "",
-        type: "lore",
-        summary: entry.title || file,
-        symbol: Array.isArray(entry.symbols_touched) ? entry.symbols_touched[0] : void 0,
-        link: entry.id
-      });
-    } catch {
-    }
-  }
-  return items.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, limit);
-}
-function createOverviewHandler(projectDir) {
-  return async (_req, res) => {
-    try {
-      const configInfo = getConfigInfo(projectDir);
-      const symbolCounts = getSymbolCounts(projectDir);
-      const loreStats = getLoreStats(projectDir);
-      const taskCounts = getTaskCounts(projectDir);
-      const purposeCoverage = getPurposeCoverage(projectDir);
-      const gateCompliance = getGateCompliance(projectDir);
-      const aspectAnchors = getAspectAnchors(projectDir);
-      let branch = "unknown";
-      try {
-        const git = simpleGit(projectDir);
-        const branchInfo = await git.branch();
-        branch = branchInfo.current;
-      } catch {
-      }
-      const [commits, loreActivity] = await Promise.all([
-        getRecentCommits(projectDir, 20),
-        Promise.resolve(getLoreActivity(projectDir, 20))
-      ]);
-      const recentActivity = [...commits, ...loreActivity].sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, 20);
-      const loreFreshnessDays = loreStats.lastEntry ? Math.floor((Date.now() - new Date(loreStats.lastEntry).getTime()) / (1e3 * 60 * 60 * 24)) : 0;
-      const overview = {
-        project: { name: configInfo.name, branch, discipline: configInfo.discipline },
-        symbols: symbolCounts,
-        lore: { total: loreStats.total, thisWeek: loreStats.thisWeek, lastEntry: loreStats.lastEntry },
-        calibration: { score: loreStats.calibrationScore, assessed: loreStats.assessed },
-        tasks: taskCounts,
-        health: {
-          purposeCoverage,
-          aspectAnchors,
-          gateCompliance,
-          calibration: loreStats.calibrationScore ?? 1,
-          loreFreshnessDays
-        },
-        recentActivity
-      };
-      res.json(overview);
-    } catch (err) {
-      res.status(500).json({ error: "Failed to aggregate overview", detail: String(err) });
-    }
-  };
-}
-
-// src/platform-server/routes/git.ts
-import { Router as Router2 } from "express";
-import simpleGit2 from "simple-git";
-var SYMBOL_RE = /[#$^!~][\w-]+/g;
-function extractSymbols(text) {
-  const matches = text.match(SYMBOL_RE);
-  return matches ? [...new Set(matches)] : [];
-}
-function createGitRouter(projectDir) {
-  const router = Router2();
-  const git = simpleGit2(projectDir);
-  router.get("/status", async (_req, res) => {
-    try {
-      const [status, branchInfo] = await Promise.all([
-        git.status(),
-        git.branch()
-      ]);
-      res.json({
-        branch: branchInfo.current,
-        ahead: status.ahead,
-        behind: status.behind,
-        staged: status.staged,
-        unstaged: status.modified.filter((f) => !status.staged.includes(f)),
-        untracked: status.not_added
-      });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to get git status", detail: String(err) });
-    }
-  });
-  router.get("/branches", async (_req, res) => {
-    try {
-      const branchInfo = await git.branch();
-      const branches = Object.values(branchInfo.branches).map((b) => ({
-        name: b.name,
-        current: b.current,
-        commit: b.commit,
-        label: b.label
-      }));
-      res.json({ current: branchInfo.current, branches });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to get branches", detail: String(err) });
-    }
-  });
-  router.get("/log", async (req, res) => {
-    try {
-      const limit = Math.min(parseInt(req.query.limit) || 20, 100);
-      const offset = parseInt(req.query.offset) || 0;
-      const log2 = await git.log({
-        maxCount: limit,
-        "--skip": offset
-      });
-      const commits = log2.all.map((c) => ({
-        hash: c.hash,
-        shortHash: c.hash.substring(0, 7),
-        message: c.message,
-        author: c.author_name,
-        date: c.date,
-        symbols: extractSymbols(c.message)
-      }));
-      res.json({ commits, total: log2.total });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to get git log", detail: String(err) });
-    }
-  });
-  router.get("/diff", async (req, res) => {
-    try {
-      const filePath = req.query.path;
-      const staged = req.query.staged === "true";
-      const args = [];
-      if (staged) args.push("--cached");
-      if (filePath) args.push("--", filePath);
-      const diffText = await git.diff(args);
-      res.json({ diff: diffText });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to get diff", detail: String(err) });
-    }
-  });
-  router.post("/stage", async (req, res) => {
-    try {
-      const { paths } = req.body;
-      if (!paths?.length) {
-        res.status(400).json({ error: "paths is required" });
-        return;
-      }
-      await git.add(paths);
-      res.json({ staged: paths });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to stage files", detail: String(err) });
-    }
-  });
-  router.post("/unstage", async (req, res) => {
-    try {
-      const { paths } = req.body;
-      if (!paths?.length) {
-        res.status(400).json({ error: "paths is required" });
-        return;
-      }
-      await git.reset(["HEAD", "--", ...paths]);
-      res.json({ unstaged: paths });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to unstage files", detail: String(err) });
-    }
-  });
-  router.post("/commit", async (req, res) => {
-    try {
-      const { message } = req.body;
-      if (!message?.trim()) {
-        res.status(400).json({ error: "message is required" });
-        return;
-      }
-      const result = await git.commit(message);
-      res.json({
-        hash: result.commit,
-        summary: result.summary
-      });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to commit", detail: String(err) });
-    }
-  });
-  router.post("/push", async (_req, res) => {
-    try {
-      const result = await git.push();
-      res.json({
-        pushed: true,
-        branch: result.branch,
-        remoteMessages: result.remoteMessages
-      });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to push", detail: String(err) });
-    }
-  });
-  return router;
-}
-
-// src/platform-server/routes/ambient.ts
-import { Router as Router3 } from "express";
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as yaml2 from "js-yaml";
-function readJsonlSafe(filePath) {
-  if (!fs2.existsSync(filePath)) return [];
-  try {
-    const content = fs2.readFileSync(filePath, "utf-8");
-    const lines = content.split("\n").filter((l) => l.trim());
-    const results = [];
-    for (const line of lines) {
-      try {
-        results.push(JSON.parse(line));
-      } catch {
-      }
-    }
-    return results;
-  } catch {
-    return [];
-  }
-}
-function writeJsonl(filePath, items) {
-  const dir = path2.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  const content = items.map((item) => JSON.stringify(item)).join("\n") + "\n";
-  fs2.writeFileSync(filePath, content, "utf-8");
-}
-function parseSince(since) {
-  const match = since.match(/^(\d+)(m|h|d)$/);
-  if (!match) return null;
-  const value = parseInt(match[1], 10);
-  const unit = match[2];
-  const now = Date.now();
-  switch (unit) {
-    case "m":
-      return new Date(now - value * 60 * 1e3);
-    case "h":
-      return new Date(now - value * 60 * 60 * 1e3);
-    case "d":
-      return new Date(now - value * 24 * 60 * 60 * 1e3);
-    default:
-      return null;
-  }
-}
-function createAmbientRouter(projectDir, wsContext) {
-  const router = Router3();
-  const eventsPath = path2.join(projectDir, ".paradigm", "events", "stream.jsonl");
-  const nominationsPath = path2.join(projectDir, ".paradigm", "events", "nominations.jsonl");
-  const debatesPath = path2.join(projectDir, ".paradigm", "events", "debates.jsonl");
-  const policyPath = path2.join(projectDir, ".paradigm", "data-policy.yaml");
-  router.get("/events", (req, res) => {
-    try {
-      const {
-        type: typeFilter,
-        source: sourceFilter,
-        symbol: symbolFilter,
-        agent: agentFilter,
-        since: sinceParam,
-        limit: limitParam
-      } = req.query;
-      const limit = limitParam ? parseInt(limitParam, 10) : 50;
-      const sinceDate = sinceParam ? parseSince(sinceParam) : null;
-      let events = readJsonlSafe(eventsPath);
-      if (typeFilter) {
-        events = events.filter((e) => e.type === typeFilter);
-      }
-      if (sourceFilter) {
-        events = events.filter((e) => e.source === sourceFilter);
-      }
-      if (symbolFilter) {
-        events = events.filter((e) => e.symbol === symbolFilter);
-      }
-      if (agentFilter) {
-        events = events.filter((e) => e.agent === agentFilter);
-      }
-      if (sinceDate) {
-        events = events.filter((e) => {
-          if (!e.timestamp) return false;
-          return new Date(e.timestamp).getTime() >= sinceDate.getTime();
-        });
-      }
-      const result = events.slice(-limit);
-      wsContext.broadcast({ type: "ambient:event", action: "query", count: result.length });
-      res.json(result);
-    } catch (err) {
-      res.status(500).json({ error: "Failed to query events", detail: String(err) });
-    }
-  });
-  router.get("/nominations", (req, res) => {
-    try {
-      const {
-        agent: agentFilter,
-        urgency: urgencyFilter,
-        pending_only: pendingOnlyParam,
-        include_debates: includeDebatesParam,
-        limit: limitParam
-      } = req.query;
-      const limit = limitParam ? parseInt(limitParam, 10) : 20;
-      const pendingOnly = pendingOnlyParam !== "false";
-      const includeDebates = includeDebatesParam === "true";
-      let nominations = readJsonlSafe(nominationsPath);
-      if (agentFilter) {
-        nominations = nominations.filter((n) => n.agent === agentFilter);
-      }
-      if (urgencyFilter) {
-        nominations = nominations.filter((n) => n.urgency === urgencyFilter);
-      }
-      if (pendingOnly) {
-        nominations = nominations.filter((n) => !n.engaged);
-      }
-      nominations = nominations.slice(-limit);
-      let debateMap;
-      if (includeDebates) {
-        const debates = readJsonlSafe(debatesPath);
-        debateMap = /* @__PURE__ */ new Map();
-        for (const debate of debates) {
-          if (debate.nominationId) {
-            const existing = debateMap.get(debate.nominationId) || [];
-            existing.push(debate);
-            debateMap.set(debate.nominationId, existing);
-          }
-        }
-      }
-      const result = nominations.map((n) => {
-        const entry = { ...n };
-        if (includeDebates && debateMap && n.id) {
-          entry.debates = debateMap.get(n.id) || [];
-        }
-        return entry;
-      });
-      res.json(result);
-    } catch (err) {
-      res.status(500).json({ error: "Failed to query nominations", detail: String(err) });
-    }
-  });
-  router.post("/nominations/:id/engage", (req, res) => {
-    try {
-      const { id } = req.params;
-      const { response } = req.body;
-      if (!response || !["accepted", "dismissed", "deferred"].includes(response)) {
-        res.status(400).json({ error: "response must be one of: accepted, dismissed, deferred" });
-        return;
-      }
-      const nominations = readJsonlSafe(nominationsPath);
-      const index = nominations.findIndex((n) => n.id === id);
-      if (index === -1) {
-        res.status(404).json({ error: `Nomination not found: ${id}` });
-        return;
-      }
-      nominations[index] = {
-        ...nominations[index],
-        engaged: true,
-        response
-      };
-      writeJsonl(nominationsPath, nominations);
-      wsContext.broadcast({
-        type: "ambient:nomination",
-        action: "engaged",
-        nominationId: id,
-        response
-      });
-      res.json(nominations[index]);
-    } catch (err) {
-      res.status(500).json({ error: "Failed to engage nomination", detail: String(err) });
-    }
-  });
-  router.get("/stream", (req, res) => {
-    res.setHeader("Content-Type", "text/event-stream");
-    res.setHeader("Cache-Control", "no-cache");
-    res.setHeader("Connection", "keep-alive");
-    res.flushHeaders();
-    let lastSize = 0;
-    try {
-      const stat = fs2.statSync(eventsPath);
-      lastSize = stat.size;
-    } catch {
-    }
-    const pollInterval = 1e3;
-    const watcher = setInterval(() => {
-      try {
-        if (!fs2.existsSync(eventsPath)) return;
-        const stat = fs2.statSync(eventsPath);
-        if (stat.size <= lastSize) {
-          if (stat.size < lastSize) lastSize = 0;
-          else return;
-        }
-        const fd = fs2.openSync(eventsPath, "r");
-        const buffer = Buffer.alloc(stat.size - lastSize);
-        fs2.readSync(fd, buffer, 0, buffer.length, lastSize);
-        fs2.closeSync(fd);
-        lastSize = stat.size;
-        const newContent = buffer.toString("utf-8");
-        const lines = newContent.split("\n").filter((l) => l.trim());
-        for (const line of lines) {
-          try {
-            const event = JSON.parse(line);
-            res.write(`data: ${JSON.stringify(event)}
-
-`);
-          } catch {
-          }
-        }
-      } catch {
-      }
-    }, pollInterval);
-    res.write(": connected\n\n");
-    req.on("close", () => {
-      clearInterval(watcher);
-    });
-  });
-  router.get("/policy", (_req, res) => {
-    try {
-      if (fs2.existsSync(policyPath)) {
-        const content = fs2.readFileSync(policyPath, "utf-8");
-        const policy = yaml2.load(content);
-        res.json(policy);
-      } else {
-        res.json({
-          version: "1.0",
-          retention: { events: "30d", nominations: "90d", debates: "90d" },
-          collection: { telemetry: false, usage: false },
-          sharing: { external: false }
-        });
-      }
-    } catch (err) {
-      res.status(500).json({ error: "Failed to read data policy", detail: String(err) });
-    }
-  });
-  return router;
-}
-
-// src/platform-server/routes/team.ts
-import { Router as Router4 } from "express";
-import * as fs3 from "fs";
-import * as path3 from "path";
-import * as os from "os";
-import * as yaml3 from "js-yaml";
-function readJsonl(filePath) {
-  if (!fs3.existsSync(filePath)) return [];
-  try {
-    return fs3.readFileSync(filePath, "utf-8").trim().split("\n").filter((line) => line.trim()).map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    }).filter((v) => v !== null);
-  } catch {
-    return [];
-  }
-}
-function loadAgentProfiles() {
-  const globalDir = path3.join(os.homedir(), ".paradigm", "agents");
-  const profiles = [];
-  if (!fs3.existsSync(globalDir)) return profiles;
-  for (const file of fs3.readdirSync(globalDir).filter((f) => f.endsWith(".agent"))) {
-    try {
-      const content = fs3.readFileSync(path3.join(globalDir, file), "utf-8");
-      const p = yaml3.load(content);
-      if (!p?.id) continue;
-      const expertise = p.expertise || [];
-      expertise.sort((a, b) => b.confidence - a.confidence);
-      profiles.push({
-        id: p.id,
-        role: p.role || p.id,
-        nickname: p.nickname,
-        benched: p.benched || false,
-        expertiseCount: expertise.length,
-        topExpertise: expertise.slice(0, 3).map((e) => ({
-          symbol: e.symbol,
-          confidence: parseFloat(e.confidence.toFixed(2))
-        })),
-        threshold: p.attention?.threshold
-      });
-    } catch {
-    }
-  }
-  return profiles;
-}
-function loadTeamThreads() {
-  const mailDir = path3.join(os.homedir(), ".paradigm", "mail", "agents");
-  if (!fs3.existsSync(mailDir)) return [];
-  const allMessages = [];
-  try {
-    for (const agentDir of fs3.readdirSync(mailDir, { withFileTypes: true })) {
-      if (!agentDir.isDirectory()) continue;
-      const agentPath = path3.join(mailDir, agentDir.name);
-      for (const file of ["inbox.jsonl", "outbox.jsonl"]) {
-        const filePath = path3.join(agentPath, file);
-        const notes = readJsonl(filePath);
-        for (const note of notes) {
-          if (!note.threadRoot?.startsWith("thr-orch-")) continue;
-          if (allMessages.some((m) => m.id === note.id)) continue;
-          allMessages.push({
-            id: note.id,
-            threadRoot: note.threadRoot,
-            timestamp: note.timestamp,
-            sender: {
-              name: note.sender?.name || "unknown",
-              role: note.sender?.role,
-              project: note.sender?.project
-            },
-            intent: note.intent || "context",
-            text: note.content?.text || "",
-            symbols: note.symbols || [],
-            diff: note.content?.diff,
-            decision: note.content?.decision
-          });
-        }
-      }
-    }
-  } catch {
-  }
-  const threadMap = /* @__PURE__ */ new Map();
-  for (const msg of allMessages) {
-    const threadId = msg.threadRoot;
-    if (!threadMap.has(threadId)) threadMap.set(threadId, []);
-    threadMap.get(threadId).push(msg);
-  }
-  const threads = [];
-  for (const [threadId, messages] of threadMap) {
-    messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    const stripped = threadId.replace("thr-orch-", "");
-    const parts = stripped.split("-");
-    const displayName = parts[0] ? `Team ${parts[0]}` : threadId;
-    threads.push({
-      id: threadId,
-      displayName,
-      messages,
-      lastActivity: messages[messages.length - 1]?.timestamp || ""
-    });
-  }
-  threads.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
-  return threads;
-}
-function createTeamRouter(projectDir) {
-  const router = Router4();
-  router.get("/roster", (_req, res) => {
-    try {
-      const agents = loadAgentProfiles();
-      const active = agents.filter((a) => !a.benched);
-      const benched = agents.filter((a) => a.benched);
-      res.json({ active, benched, total: agents.length });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to load roster", detail: String(err) });
-    }
-  });
-  router.get("/threads", (_req, res) => {
-    try {
-      const threads = loadTeamThreads();
-      res.json({ threads, count: threads.length });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to load threads", detail: String(err) });
-    }
-  });
-  router.patch("/agents/:id/bench", (req, res) => {
-    try {
-      const { id } = req.params;
-      const { benched } = req.body;
-      const globalDir = path3.join(os.homedir(), ".paradigm", "agents");
-      const filePath = path3.join(globalDir, `${id}.agent`);
-      if (!fs3.existsSync(filePath)) {
-        res.status(404).json({ error: `Agent "${id}" not found` });
-        return;
-      }
-      const content = fs3.readFileSync(filePath, "utf-8");
-      const profile = yaml3.load(content);
-      profile.benched = benched;
-      profile.updated = (/* @__PURE__ */ new Date()).toISOString();
-      fs3.writeFileSync(filePath, yaml3.dump(profile, { lineWidth: 120, noRefs: true, sortKeys: false }), "utf-8");
-      res.json({ id, benched, updated: profile.updated });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to update agent", detail: String(err) });
-    }
-  });
-  return router;
-}
-
-// src/platform-server/routes/canvas.ts
-import { Router as Router5 } from "express";
-import * as fs4 from "fs";
-import * as path4 from "path";
-import * as yaml4 from "js-yaml";
-var IGNORE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  ".next",
-  "build",
-  ".paradigm",
-  ".turbo",
-  ".cache",
-  "coverage",
-  ".output"
-]);
-function findCanvasFiles(dir, rootDir) {
-  const results = [];
-  let entries;
-  try {
-    entries = fs4.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (!IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-        results.push(...findCanvasFiles(path4.join(dir, entry.name), rootDir));
-      }
-    } else if (entry.isFile() && entry.name.endsWith(".canvas")) {
-      results.push(path4.relative(rootDir, path4.join(dir, entry.name)));
-    }
-  }
-  return results;
-}
-var cachedFiles = null;
-var cacheTimestamp = 0;
-var CACHE_TTL = 5e3;
-function getCanvasFiles(projectDir) {
-  const now = Date.now();
-  if (cachedFiles && now - cacheTimestamp < CACHE_TTL) {
-    return cachedFiles;
-  }
-  const rootFiles = fs4.readdirSync(projectDir).filter((f) => f.endsWith(".canvas")).map((f) => f);
-  const nestedFiles = findCanvasFiles(projectDir, projectDir).filter((f) => !rootFiles.includes(f));
-  cachedFiles = [...rootFiles, ...nestedFiles];
-  cacheTimestamp = now;
-  return cachedFiles;
-}
-function safePath(projectDir, requestedPath) {
-  const resolved = path4.resolve(projectDir, requestedPath);
-  if (!resolved.startsWith(projectDir + path4.sep) && resolved !== projectDir) {
-    return null;
-  }
-  if (!resolved.endsWith(".canvas")) {
-    return null;
-  }
-  return resolved;
-}
-function createCanvasRouter(projectDir) {
-  const router = Router5();
-  router.get("/files", (_req, res) => {
-    try {
-      const relativePaths = getCanvasFiles(projectDir);
-      const files = relativePaths.map((relPath) => {
-        const absPath = path4.join(projectDir, relPath);
-        try {
-          const stat = fs4.statSync(absPath);
-          let name = path4.basename(relPath, ".canvas");
-          let description = "";
-          try {
-            const raw = yaml4.load(fs4.readFileSync(absPath, "utf8"));
-            if (raw && typeof raw.name === "string") name = raw.name;
-            if (raw && typeof raw.description === "string") description = raw.description;
-          } catch {
-          }
-          return {
-            path: relPath,
-            name,
-            description,
-            modified: stat.mtime.toISOString(),
-            size: stat.size
-          };
-        } catch {
-          return null;
-        }
-      }).filter(Boolean);
-      files.sort((a, b) => b.modified.localeCompare(a.modified));
-      res.json({ files });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to list canvas files", details: err.message });
-    }
-  });
-  router.get("/files/*", (req, res) => {
-    const requestedPath = req.params[0] || req.params["path"] || "";
-    if (!requestedPath) {
-      res.status(400).json({ error: "File path required" });
-      return;
-    }
-    const absPath = safePath(projectDir, requestedPath);
-    if (!absPath) {
-      res.status(400).json({ error: "Invalid path" });
-      return;
-    }
-    if (!fs4.existsSync(absPath)) {
-      res.status(404).json({ error: `Canvas file not found: ${requestedPath}` });
-      return;
-    }
-    try {
-      const raw = fs4.readFileSync(absPath, "utf8");
-      const parsed = yaml4.load(raw);
-      res.json(parsed);
-    } catch (err) {
-      res.status(500).json({ error: "Failed to read canvas file", details: err.message });
-    }
-  });
-  router.put("/files/*", (req, res) => {
-    const requestedPath = req.params[0] || req.params["path"] || "";
-    if (!requestedPath) {
-      res.status(400).json({ error: "File path required" });
-      return;
-    }
-    const absPath = safePath(projectDir, requestedPath);
-    if (!absPath) {
-      res.status(400).json({ error: "Invalid path" });
-      return;
-    }
-    try {
-      const data = req.body;
-      if (!data || typeof data !== "object") {
-        res.status(400).json({ error: "Request body must be a JSON object" });
-        return;
-      }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      if (!data.created) data.created = now;
-      data.updated = now;
-      const dir = path4.dirname(absPath);
-      if (!fs4.existsSync(dir)) {
-        fs4.mkdirSync(dir, { recursive: true });
-      }
-      const yamlStr = yaml4.dump(data, {
-        lineWidth: -1,
-        noRefs: true,
-        quotingType: '"',
-        forceQuotes: false
-      });
-      fs4.writeFileSync(absPath, yamlStr, "utf8");
-      cachedFiles = null;
-      res.json({ saved: true, path: requestedPath });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to save canvas file", details: err.message });
-    }
-  });
-  router.delete("/files/*", (req, res) => {
-    const requestedPath = req.params[0] || req.params["path"] || "";
-    if (!requestedPath) {
-      res.status(400).json({ error: "File path required" });
-      return;
-    }
-    const absPath = safePath(projectDir, requestedPath);
-    if (!absPath) {
-      res.status(400).json({ error: "Invalid path" });
-      return;
-    }
-    if (!fs4.existsSync(absPath)) {
-      res.status(404).json({ error: `Canvas file not found: ${requestedPath}` });
-      return;
-    }
-    try {
-      fs4.unlinkSync(absPath);
-      cachedFiles = null;
-      res.json({ deleted: true, path: requestedPath });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to delete canvas file", details: err.message });
-    }
-  });
-  return router;
-}
-
-// src/platform-server/index.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path5.dirname(__filename);
-var log = {
-  component(name) {
-    const symbol = chalk.magenta(`#${name}`);
-    return {
-      info: (msg, data) => {
-        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
-        console.log(`${chalk.blue("i")} ${symbol} ${msg}${dataStr}`);
-      },
-      success: (msg, data) => {
-        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
-        console.log(`${chalk.green("+")} ${symbol} ${msg}${dataStr}`);
-      },
-      warn: (msg, data) => {
-        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
-        console.log(`${chalk.yellow("!")} ${symbol} ${msg}${dataStr}`);
-      },
-      error: (msg, data) => {
-        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
-        console.error(`${chalk.red("x")} ${symbol} ${msg}${dataStr}`);
-      }
-    };
-  }
-};
-function resolveSections(options) {
-  const always = ["overview", "lore", "graph", "canvas", "git", "ambient", "team"];
-  const requested = options.sections ?? [...always, "sentinel", "university", "symphony", "docs"];
-  const enabled = /* @__PURE__ */ new Set();
-  for (const section of requested) {
-    if (always.includes(section)) {
-      enabled.add(section);
-      continue;
-    }
-    if (section === "sentinel") {
-      const sentinelRoutesPath = path5.join(options.projectDir, ".paradigm");
-      if (fs5.existsSync(sentinelRoutesPath)) {
-        enabled.add(section);
-      }
-    } else if (section === "university") {
-      enabled.add(section);
-    } else if (section === "symphony") {
-      const mailDir = path5.join(process.env.HOME || "~", ".paradigm", "score");
-      if (fs5.existsSync(mailDir)) {
-        enabled.add(section);
-      }
-    } else {
-      enabled.add(section);
-    }
-  }
-  return enabled;
-}
-function createPlatformApp(options) {
-  const app = express();
-  const sections = resolveSections(options);
-  app.use(express.json());
-  app.use((_req, res, next) => {
-    res.header("Access-Control-Allow-Origin", "*");
-    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
-    res.header("Access-Control-Allow-Headers", "Content-Type");
-    if (_req.method === "OPTIONS") {
-      res.sendStatus(204);
-      return;
-    }
-    next();
-  });
-  app.use("/api/lore", createLoreRouter(options.projectDir));
-  app.use("/api/info", createInfoRouter(options.projectDir));
-  app.use("/api/sessions", createSessionsRouter(options.projectDir));
-  app.use("/api/symbols", createSymbolsRouter(options.projectDir));
-  app.use("/api/graphs", createGraphsRouter(options.projectDir));
-  app.get("/api/platform/overview", createOverviewHandler(options.projectDir));
-  app.use("/api/canvas", createCanvasRouter(options.projectDir));
-  app.use("/api/git", createGitRouter(options.projectDir));
-  app.get("/api/platform/health", (_req, res) => {
-    res.json({
-      status: "ok",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      sections: Array.from(sections)
-    });
-  });
-  app.get("/api/platform/sections", (_req, res) => {
-    res.json({ sections: Array.from(sections) });
-  });
-  app.get("/api/health", (_req, res) => {
-    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  });
-  app.set("agentRouterSlot", true);
-  let uiDistPath = path5.join(__dirname, "..", "platform-ui", "dist");
-  if (!fs5.existsSync(uiDistPath)) {
-    uiDistPath = path5.join(__dirname, "..", "..", "platform-ui", "dist");
-  }
-  if (fs5.existsSync(uiDistPath)) {
-    app.use(express.static(uiDistPath));
-    app.get("{*path}", (req, res, next) => {
-      if (!req.path.startsWith("/api")) {
-        res.sendFile(path5.join(uiDistPath, "index.html"));
-      } else {
-        next();
-      }
-    });
-  } else {
-    app.get("/", (_req, res) => {
-      res.send(`
-        <html>
-        <head><title>Paradigm Platform</title></head>
-        <body style="background:#0d1117;color:#e6edf3;font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0">
-          <div style="text-align:center">
-            <h1 style="font-size:2rem;margin-bottom:8px">Paradigm Platform</h1>
-            <p style="color:#8b949e">UI not built yet. Run <code style="background:#21262d;padding:4px 8px;border-radius:4px">cd platform-ui && npx vite build</code></p>
-            <p style="color:#8b949e;margin-top:16px">APIs available:</p>
-            <p><a href="/api/lore" style="color:#58a6ff">/api/lore</a> &middot; <a href="/api/symbols" style="color:#58a6ff">/api/symbols</a> &middot; <a href="/api/platform/health" style="color:#58a6ff">/api/platform/health</a></p>
-          </div>
-        </body>
-        </html>
-      `);
-    });
-  }
-  return app;
-}
-async function startPlatformServer(options) {
-  const app = createPlatformApp(options);
-  const sections = resolveSections(options);
-  log.component("platform-server").info("Starting Paradigm Platform", { port: options.port });
-  log.component("platform-server").info("Project directory", { path: options.projectDir });
-  log.component("platform-server").info("Sections", { enabled: Array.from(sections).join(", ") });
-  const httpServer = http.createServer(app);
-  const wsContext = attachWebSocket(httpServer);
-  app.use("/api/platform/agent-command", createAgentRouter(wsContext));
-  app.use("/api/ambient", createAmbientRouter(options.projectDir, wsContext));
-  app.use("/api/team", createTeamRouter(options.projectDir));
-  if (sections.has("sentinel")) {
-    try {
-      const { createSentinelBridge } = await import("./sentinel-bridge-MDUXTQRL.js");
-      const sentinelRouter = await createSentinelBridge(options.projectDir, wsContext.broadcast);
-      if (sentinelRouter) {
-        app.use("/api/sentinel", sentinelRouter);
-        log.component("platform-server").success("Sentinel routes mounted");
-      }
-    } catch {
-      log.component("platform-server").warn("Sentinel not available");
-    }
-  }
-  if (sections.has("symphony")) {
-    try {
-      const { createSymphonyRouter } = await import("./symphony-B75X2MME.js");
-      app.use("/api/symphony", createSymphonyRouter(options.projectDir, wsContext.broadcast));
-      log.component("platform-server").success("Symphony routes mounted");
-    } catch (err) {
-      log.component("platform-server").warn("Symphony routes failed to mount");
-    }
-  }
-  if (sections.has("docs")) {
-    try {
-      const { createDocsRouter } = await import("./docs-PBZB7LYP.js");
-      app.use("/api/docs", createDocsRouter(options.projectDir));
-      log.component("platform-server").success("Docs routes mounted");
-    } catch (err) {
-      log.component("platform-server").warn("Docs routes failed to mount");
-    }
-  }
-  return new Promise((resolve2, reject) => {
-    httpServer.listen(options.port, () => {
-      log.component("platform-server").success("Platform running", { url: `http://localhost:${options.port}` });
-      log.component("platform-ws").success("WebSocket ready", { url: `ws://localhost:${options.port}/ws` });
-      console.log("");
-      console.log(chalk.gray("  Sections:"));
-      for (const section of sections) {
-        console.log(chalk.gray(`    ${chalk.cyan("\u25CF")} ${section}`));
-      }
-      console.log("");
-      if (options.open) {
-        import("open").then((openModule) => {
-          openModule.default(`http://localhost:${options.port}`);
-          log.component("platform-server").info("Opened browser");
-        }).catch(() => {
-          log.component("platform-server").warn("Could not open browser automatically");
-        });
-      }
-      resolve2();
-    });
-    httpServer.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        log.component("platform-server").error("Port already in use", { port: options.port });
-      } else {
-        log.component("platform-server").error("Server error", { error: err.message });
-      }
-      reject(err);
-    });
-  });
-}
-export {
-  createPlatformApp,
-  startPlatformServer
-};