@a-company/paradigm 5.3.3 → 5.5.0

package/dist/{platform-server-PMD57BEG.js → platform-server-2D6S6YTK.js}

@@ -13,8 +13,8 @@ import "./chunk-PDX44BCA.js";
 // src/platform-server/index.ts
 import express from "express";
 import * as http from "http";
-import * as path3 from "path";
-import * as fs3 from "fs";
+import * as path4 from "path";
+import * as fs4 from "fs";
 import { fileURLToPath } from "url";
 import chalk from "chalk";
 
@@ -950,9 +950,156 @@ function createAmbientRouter(projectDir, wsContext) {
   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/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
+var __dirname = path4.dirname(__filename);
 var log = {
   component(name) {
     const symbol = chalk.magenta(`#${name}`);
@@ -977,7 +1124,7 @@ var log = {
   }
 };
 function resolveSections(options) {
-  const always = ["overview", "lore", "graph", "git", "ambient"];
+  const always = ["overview", "lore", "graph", "git", "ambient", "team"];
   const requested = options.sections ?? [...always, "sentinel", "university", "symphony", "docs"];
   const enabled = /* @__PURE__ */ new Set();
   for (const section of requested) {
@@ -986,15 +1133,15 @@ function resolveSections(options) {
       continue;
     }
     if (section === "sentinel") {
-      const sentinelRoutesPath = path3.join(options.projectDir, ".paradigm");
-      if (fs3.existsSync(sentinelRoutesPath)) {
+      const sentinelRoutesPath = path4.join(options.projectDir, ".paradigm");
+      if (fs4.existsSync(sentinelRoutesPath)) {
         enabled.add(section);
       }
     } else if (section === "university") {
       enabled.add(section);
     } else if (section === "symphony") {
-      const mailDir = path3.join(process.env.HOME || "~", ".paradigm", "score");
-      if (fs3.existsSync(mailDir)) {
+      const mailDir = path4.join(process.env.HOME || "~", ".paradigm", "score");
+      if (fs4.existsSync(mailDir)) {
         enabled.add(section);
       }
     } else {
@@ -1038,15 +1185,15 @@ function createPlatformApp(options) {
     res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   });
   app.set("agentRouterSlot", true);
-  let uiDistPath = path3.join(__dirname, "..", "platform-ui", "dist");
-  if (!fs3.existsSync(uiDistPath)) {
-    uiDistPath = path3.join(__dirname, "..", "..", "platform-ui", "dist");
+  let uiDistPath = path4.join(__dirname, "..", "platform-ui", "dist");
+  if (!fs4.existsSync(uiDistPath)) {
+    uiDistPath = path4.join(__dirname, "..", "..", "platform-ui", "dist");
   }
-  if (fs3.existsSync(uiDistPath)) {
+  if (fs4.existsSync(uiDistPath)) {
     app.use(express.static(uiDistPath));
     app.get("{*path}", (req, res, next) => {
       if (!req.path.startsWith("/api")) {
-        res.sendFile(path3.join(uiDistPath, "index.html"));
+        res.sendFile(path4.join(uiDistPath, "index.html"));
       } else {
         next();
       }
@@ -1080,6 +1227,7 @@ async function startPlatformServer(options) {
   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");

package/dist/{reindex-HRA2AUS6.js → reindex-J5SEDVTT.js}

@@ -3,9 +3,10 @@ import {
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles
-} from "./chunk-S6MZ2IEX.js";
-import "./chunk-5VKJBNJL.js";
+} from "./chunk-SU3WDCRR.js";
 import "./chunk-L27I3CPZ.js";
+import "./chunk-SDDCVUCV.js";
+import "./chunk-5VKJBNJL.js";
 import "./chunk-7N7GSU6K.js";
 export {
   getReindexToolsList,

package/dist/{serve-FLTFTM3P.js → serve-EFVRS4GA.js}

@@ -10,7 +10,7 @@ async function serveCommand(options) {
   const sections = options.sections ? options.sections.split(",").map((s) => s.trim()) : void 0;
   console.log(chalk.cyan("\n  Starting Paradigm Platform...\n"));
   try {
-    const { startPlatformServer } = await import("./platform-server-PMD57BEG.js");
+    const { startPlatformServer } = await import("./platform-server-2D6S6YTK.js");
     await startPlatformServer({ port, projectDir, open: shouldOpen, sections });
     console.log(chalk.green(`  Platform running at ${chalk.bold(`http://localhost:${port}`)}`));
     console.log(chalk.gray("  Press Ctrl+C to stop\n"));

package/dist/session-work-log-KDOH4GER.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import {
+  appendSessionWorkEntry,
+  clearSessionWorkLog,
+  getAgentEntries,
+  getAgentVerdicts,
+  getContributingAgents,
+  init_session_work_log,
+  readSessionWorkLog
+} from "./chunk-SDDCVUCV.js";
+import "./chunk-7N7GSU6K.js";
+init_session_work_log();
+export {
+  appendSessionWorkEntry,
+  clearSessionWorkLog,
+  getAgentEntries,
+  getAgentVerdicts,
+  getContributingAgents,
+  readSessionWorkLog
+};