@a-company/paradigm 5.3.3 → 5.4.0

package/dist/mcp.js

@@ -74,17 +74,13 @@ import {
   validateProtocol,
   validatePurposeFile,
   validateUniversityContent
-} from "./chunk-S6MZ2IEX.js";
+} from "./chunk-7HRBT23N.js";
+import "./chunk-L27I3CPZ.js";
 import {
   getWorkLogSummary,
   loadWorkLogEntries,
   recordWorkLog
 } from "./chunk-TAIJOFOE.js";
-import {
-  getDecisionSummary,
-  loadDecisions,
-  recordDecision
-} from "./chunk-EZ3GOCYC.js";
 import {
   getPluginUpdateNotice,
   schedulePluginUpdateCheck
@@ -115,6 +111,7 @@ import {
   emitAndProcess,
   engageNomination,
   filterContent,
+  getNeverlandMetrics,
   getNominationStats,
   init_data_policy_loader,
   init_event_stream,
@@ -130,13 +127,14 @@ import {
   queryEvents,
   resolveDebate,
   searchNotebooks
-} from "./chunk-GGMI6C2L.js";
+} from "./chunk-ICSLIPUS.js";
 import {
   buildProfileEnrichment,
   init_agent_loader,
   loadAgentProfile,
   loadAllAgentProfiles,
   queryExpertise,
+  saveAgentProfile,
   verifyIntegrity
 } from "./chunk-A2L4TSLZ.js";
 import {
@@ -154,7 +152,11 @@ import {
   TimelineBuilder,
   loadAllSeedPatterns
 } from "./chunk-ZDHLG5VP.js";
-import "./chunk-L27I3CPZ.js";
+import {
+  getDecisionSummary,
+  loadDecisions,
+  recordDecision
+} from "./chunk-EZ3GOCYC.js";
 import {
   __esm,
   __export,
@@ -5917,12 +5919,26 @@ async function handleOrchestrateInline(args, ctx) {
   let agentProfiles = /* @__PURE__ */ new Map();
   try {
     const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-SJPJJS33.js");
+    const { loadDecisions: loadDecisions3 } = await import("./decision-loader-WWCLIQPJ.js");
+    const { loadJournalEntries: loadJournalEntries2 } = await import("./journal-loader-5EYSBFFY.js");
+    const { loadNominations: loadNominations2 } = await import("./nomination-engine-HDWMN4IO.js");
+    const recentDecisions = loadDecisions3(ctx.rootDir, { status: "active", limit: 5 }).map((d) => ({ title: d.title, decision: d.decision.slice(0, 150) }));
+    const pendingNominations = loadNominations2(ctx.rootDir, { pending_only: true, limit: 10 }).map((n) => ({ urgency: n.urgency, brief: n.brief }));
     for (const stage of plan.stages) {
       for (const agentStep of stage.agents) {
         if (!agentProfiles.has(agentStep.name)) {
           const profile = loadAgentProfile2(ctx.rootDir, agentStep.name);
           if (profile) {
-            let enrichment = buildProfileEnrichment2(profile, symbols);
+            if (profile.benched) continue;
+            const journalInsights = loadJournalEntries2(agentStep.name, {
+              transferable: true,
+              limit: 5
+            }).map((j) => ({ trigger: j.trigger, insight: j.insight.slice(0, 150) }));
+            let enrichment = buildProfileEnrichment2(profile, symbols, void 0, {
+              recentDecisions,
+              journalInsights,
+              pendingNominations
+            });
             if (profile.permissions) {
               const constraints = ["\n## Permission Constraints"];
               if (profile.permissions.paths?.deny?.length) {
@@ -5940,7 +5956,10 @@ async function handleOrchestrateInline(args, ctx) {
               enrichment += "\n" + constraints.join("\n");
             }
             if (enrichment.trim()) {
-              agentProfiles.set(agentStep.name, { enrichment });
+              agentProfiles.set(agentStep.name, {
+                enrichment,
+                nickname: profile.nickname
+              });
             }
           }
         }
@@ -5960,7 +5979,8 @@ async function handleOrchestrateInline(args, ctx) {
         task: agentStep.task,
         symbols,
         dependsOn: agentStep.dependsOn,
-        profileEnrichment: profileData?.enrichment
+        profileEnrichment: profileData?.enrichment,
+        nickname: profileData?.nickname
       });
       agentPrompts.push(promptResult);
     }
@@ -5984,7 +6004,9 @@ async function handleOrchestrateInline(args, ctx) {
       "Execute stages in order (stage 0, then stage 1, etc.)",
       "Agents within a stage can be run in parallel if your environment supports it",
       "Pass handoff context between stages",
-      "After each phase, summarize what was done before starting the next"
+      'Present each agent response as an attributed message using the attribution prefix (e.g., "[architect] Rate limiter should go before ^authenticated")',
+      "Do NOT synthesize agent responses \u2014 show them as distinct contributions from each agent",
+      "After all agents in a stage complete, reconcile their outputs before proceeding to the next stage"
     ],
     // Claude Code: Use Task tool for parallel agent spawning
     claudeCode: {
@@ -6010,6 +6032,24 @@ async function handleOrchestrateInline(args, ctx) {
       method: "paradigm team orchestrate",
       command: `paradigm team orchestrate "${task}"`,
       note: "Spawns independent agent processes \u2014 works from any terminal"
+    },
+    // Symphony: Record agent contributions as team thread messages
+    symphony: {
+      enabled: true,
+      orchestrationThread: `thr-${orchestrationId}`,
+      instructions: [
+        "After each agent completes, call paradigm_symphony_send to record the contribution",
+        'Use intent "context" for analysis, "proposal" for recommendations, "decision" for decisions made',
+        `Set threadRoot to "thr-${orchestrationId}" so all contributions are in one thread`,
+        "Include the symbols array from the agent relay output",
+        "This creates a visible team thread that Conductor and other sessions can observe"
+      ],
+      exampleCall: {
+        intent: "context",
+        text: "[architect] Rate limiter should be placed before ^authenticated gate to prevent unauthenticated flood",
+        threadRoot: `thr-${orchestrationId}`,
+        symbols: ["#rate-limiter", "^authenticated"]
+      }
     }
   };
   const text = JSON.stringify(result, null, 2);
@@ -6033,11 +6073,23 @@ async function handleAgentPrompt(args, ctx) {
   };
   const symbols = extractSymbols(task);
   let profileEnrichment;
+  let nickname;
   try {
     const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-SJPJJS33.js");
+    const { loadDecisions: loadDecisions3 } = await import("./decision-loader-WWCLIQPJ.js");
+    const { loadJournalEntries: loadJournalEntries2 } = await import("./journal-loader-5EYSBFFY.js");
+    const { loadNominations: loadNominations2 } = await import("./nomination-engine-HDWMN4IO.js");
     const profile = loadAgentProfile2(ctx.rootDir, agentName);
     if (profile) {
-      let enrichment = buildProfileEnrichment2(profile, symbols);
+      nickname = profile.nickname;
+      const recentDecisions = loadDecisions3(ctx.rootDir, { status: "active", limit: 5 }).map((d) => ({ title: d.title, decision: d.decision.slice(0, 150) }));
+      const journalInsights = loadJournalEntries2(agentName, { transferable: true, limit: 5 }).map((j) => ({ trigger: j.trigger, insight: j.insight.slice(0, 150) }));
+      const pendingNominations = loadNominations2(ctx.rootDir, { pending_only: true, limit: 10 }).map((n) => ({ urgency: n.urgency, brief: n.brief }));
+      let enrichment = buildProfileEnrichment2(profile, symbols, void 0, {
+        recentDecisions,
+        journalInsights,
+        pendingNominations
+      });
       if (profile.permissions) {
         const constraints = ["\n## Permission Constraints"];
         if (profile.permissions.paths?.deny?.length) {
@@ -6064,12 +6116,14 @@ async function handleAgentPrompt(args, ctx) {
     symbols,
     handoffContext,
     previousAgent,
-    profileEnrichment
+    profileEnrichment,
+    nickname
   });
   const result = {
     agent: agentName,
     model: promptResult.model,
     prompt: promptResult.prompt,
+    attribution: promptResult.attribution,
     taskToolParams: {
       description: promptResult.taskDescription,
       prompt: promptResult.prompt,
@@ -6077,7 +6131,7 @@ async function handleAgentPrompt(args, ctx) {
       model: promptResult.model
     },
     focusAreas: promptResult.focusAreas,
-    usage: "Use the Task tool with the taskToolParams to spawn this agent"
+    usage: "Use the Task tool with the taskToolParams to spawn this agent. Present the response with the attribution prefix."
   };
   const text = JSON.stringify(result, null, 2);
   trackToolCall(text.length, "paradigm_agent_prompt");
@@ -6280,12 +6334,14 @@ handoff_context: |
 This structured output helps track progress and pass context between agents.`);
   const prompt = parts.join("\n");
   const model = agent.defaultModel || DEFAULT_MODELS[agent.name] || "sonnet";
+  const attribution = options.nickname ? `[${options.nickname} (${agent.name})]` : `[${agent.name}]`;
   return {
     agent: agent.name,
     model,
     prompt,
     taskDescription: `${agent.name}: ${task.slice(0, 50)}${task.length > 50 ? "..." : ""}`,
     subagentType: "general-purpose",
+    attribution,
     focusAreas: agent.focus
   };
 }
@@ -17861,6 +17917,42 @@ function getAgentToolsList() {
         readOnlyHint: true,
         destructiveHint: false
       }
+    },
+    {
+      name: "paradigm_agent_bench",
+      description: "Bench an agent \u2014 Maestro will skip this agent during orchestration and nomination scoring. Use when an agent is noisy or unhelpful. ~50 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Agent ID to bench (e.g., "architect")'
+          }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_agent_activate",
+      description: "Activate a benched agent \u2014 restore it to active Maestro orchestration. ~50 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Agent ID to activate (e.g., "architect")'
+          }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
     }
   ];
 }
@@ -17885,6 +17977,8 @@ async function handleAgentTool(name, args, ctx) {
           agents: profiles.map((p) => ({
             id: p.id,
             role: p.role,
+            nickname: p.nickname,
+            benched: p.benched || false,
             personality: p.personality,
             topExpertise: (p.expertise || []).sort((a, b) => b.confidence - a.confidence).slice(0, 5).map((e) => ({
               symbol: e.symbol,
@@ -17892,7 +17986,8 @@ async function handleAgentTool(name, args, ctx) {
               sessions: e.sessions
             })),
             projectContexts: Object.keys(p.contexts || {}),
-            transferableCount: (p.transferable || []).length
+            transferableCount: (p.transferable || []).length,
+            ...p.attention?.threshold != null ? { threshold: p.attention.threshold } : {}
           }))
         }, null, 2)
       };
@@ -17972,6 +18067,48 @@ async function handleAgentTool(name, args, ctx) {
         }, null, 2)
       };
     }
+    case "paradigm_agent_bench": {
+      const benchId = args.id;
+      const benchProfile = loadAgentProfile(ctx.rootDir, benchId);
+      if (!benchProfile) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Agent "${benchId}" not found` }, null, 2)
+        };
+      }
+      benchProfile.benched = true;
+      benchProfile.updated = (/* @__PURE__ */ new Date()).toISOString();
+      saveAgentProfile(benchId, benchProfile, "global");
+      return {
+        handled: true,
+        text: JSON.stringify({
+          id: benchId,
+          benched: true,
+          note: `${benchId} is now benched. Maestro will skip this agent during orchestration.`
+        }, null, 2)
+      };
+    }
+    case "paradigm_agent_activate": {
+      const activateId = args.id;
+      const activateProfile = loadAgentProfile(ctx.rootDir, activateId);
+      if (!activateProfile) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Agent "${activateId}" not found` }, null, 2)
+        };
+      }
+      activateProfile.benched = false;
+      activateProfile.updated = (/* @__PURE__ */ new Date()).toISOString();
+      saveAgentProfile(activateId, activateProfile, "global");
+      return {
+        handled: true,
+        text: JSON.stringify({
+          id: activateId,
+          benched: false,
+          note: `${activateId} is now active. Maestro will include this agent in orchestration.`
+        }, null, 2)
+      };
+    }
     default:
       return { handled: false, text: "" };
   }
@@ -19490,6 +19627,18 @@ function getAmbientToolsList() {
         readOnlyHint: false,
         destructiveHint: false
       }
+    },
+    {
+      name: "paradigm_ambient_neverland",
+      description: "Neverland Validation \u2014 aggregate learning metrics across all agents. Shows acceptance rates, threshold drift, expertise growth, notebook counts, cross-project transfer, and overall health status (cold-start \u2192 accumulating \u2192 calibrating \u2192 mature). ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
     }
   ];
 }
@@ -19731,6 +19880,13 @@ async function handleAmbientTool(name, args, ctx) {
         handled: true
       };
     }
+    case "paradigm_ambient_neverland": {
+      const metrics = getNeverlandMetrics(ctx.rootDir);
+      return {
+        text: json(metrics),
+        handled: true
+      };
+    }
     default:
       return { text: `Unknown ambient tool: ${name}`, handled: false };
   }
@@ -20805,7 +20961,7 @@ Update command:
               trackToolCall(noWsText.length, name);
               return { content: [{ type: "text", text: noWsText }] };
             }
-            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-HRA2AUS6.js");
+            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-65H4WULU.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
               const memberAbsPath = path34.resolve(path34.dirname(ctx.workspace.workspacePath), member.path);

package/dist/{nomination-engine-Q4XSXFKT.js → nomination-engine-HDWMN4IO.js}

@@ -7,6 +7,7 @@ import {
   emitAndProcess,
   engageNomination,
   forwardNominationsToRelay,
+  getNeverlandMetrics,
   getNominationStats,
   init_nomination_engine,
   loadDebates,
@@ -16,7 +17,7 @@ import {
   processEvent,
   processPendingEvents,
   resolveDebate
-} from "./chunk-GGMI6C2L.js";
+} from "./chunk-ICSLIPUS.js";
 import "./chunk-A2L4TSLZ.js";
 import "./chunk-MCMOGQMU.js";
 import "./chunk-7N7GSU6K.js";
@@ -29,6 +30,7 @@ export {
   emitAndProcess,
   engageNomination,
   forwardNominationsToRelay,
+  getNeverlandMetrics,
   getNominationStats,
   loadDebates,
   loadNominations,

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-65H4WULU.js}

@@ -3,9 +3,9 @@ import {
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles
-} from "./chunk-S6MZ2IEX.js";
-import "./chunk-5VKJBNJL.js";
+} from "./chunk-7HRBT23N.js";
 import "./chunk-L27I3CPZ.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"));