@a-company/paradigm 3.34.0 → 3.43.0

package/dist/platform-server-KK4OCRTV.js

@@ -0,0 +1,891 @@
+#!/usr/bin/env node
+import {
+  createInfoRouter,
+  createLoreRouter,
+  createSessionsRouter
+} from "./chunk-RAB5IKPR.js";
+import {
+  createGraphsRouter,
+  createSymbolsRouter
+} from "./chunk-F3BCHPYT.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/platform-server/index.ts
+import express from "express";
+import * as http from "http";
+import * as path2 from "path";
+import * as fs2 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/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.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", "git"];
+  const requested = options.sections ?? [...always, "sentinel", "university", "symphony"];
+  const enabled = /* @__PURE__ */ new Set();
+  for (const section of requested) {
+    if (always.includes(section)) {
+      enabled.add(section);
+      continue;
+    }
+    if (section === "sentinel") {
+      const sentinelRoutesPath = path2.join(options.projectDir, ".paradigm");
+      if (fs2.existsSync(sentinelRoutesPath)) {
+        enabled.add(section);
+      }
+    } else if (section === "university") {
+      enabled.add(section);
+    } else if (section === "symphony") {
+      const mailDir = path2.join(process.env.HOME || "~", ".paradigm", "score");
+      if (fs2.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/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 = path2.join(__dirname, "..", "platform-ui", "dist");
+  if (!fs2.existsSync(uiDistPath)) {
+    uiDistPath = path2.join(__dirname, "..", "..", "platform-ui", "dist");
+  }
+  if (fs2.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+    app.get("{*path}", (req, res) => {
+      if (!req.path.startsWith("/api")) {
+        res.sendFile(path2.join(uiDistPath, "index.html"));
+      }
+    });
+  } 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));
+  if (sections.has("sentinel")) {
+    try {
+      const { createSentinelBridge } = await import("./sentinel-bridge-IZTXYS5M.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");
+    }
+  }
+  return new Promise((resolve, 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");
+        });
+      }
+      resolve();
+    });
+    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
+};