@a-company/paradigm 5.8.1 → 5.9.0

package/dist/mcp.js

@@ -4,6 +4,32 @@ import {
   loadDecisions,
   recordDecision
 } from "./chunk-EZ3GOCYC.js";
+import {
+  acknowledgeMessages,
+  approveFileRequest,
+  buildMessage,
+  cleanStaleAgents,
+  createFileRequest,
+  createThread,
+  denyFileRequest,
+  expireOldRequests,
+  garbageCollect,
+  getMyIdentity,
+  getThreadMessages,
+  isAgentAsleep,
+  isPathDenied,
+  listAgents,
+  listFileRequests,
+  listThreads,
+  loadThread,
+  loadTrustConfig,
+  markAgentPollTime,
+  peekInbox,
+  readInbox,
+  recordAckSize,
+  registerAgent,
+  routeMessage
+} from "./chunk-NQKQG45G.js";
 import {
   addStep,
   addToolBreadcrumb,
@@ -79,7 +105,7 @@ import {
   validateProtocol,
   validatePurposeFile,
   validateUniversityContent
-} from "./chunk-T3YGSZCI.js";
+} from "./chunk-3UCH56D5.js";
 import "./chunk-L27I3CPZ.js";
 import {
   getWorkLogSummary,
@@ -133,16 +159,18 @@ import {
   queryEvents,
   resolveDebate,
   searchNotebooks
-} from "./chunk-B2RC3HEB.js";
+} from "./chunk-V7BZBBI6.js";
 import {
   buildProfileEnrichment,
   init_agent_loader,
+  listAllGlobalAgentIds,
   loadAgentProfile,
   loadAllAgentProfiles,
+  loadProjectRoster,
   queryExpertise,
-  saveAgentProfile,
+  saveProjectRoster,
   verifyIntegrity
-} from "./chunk-ITPJJIHG.js";
+} from "./chunk-MA7G4CTI.js";
 import {
   getJournalStats,
   init_journal_loader,
@@ -2935,7 +2963,7 @@ function registerResources(server, getContext2) {
 
 // ../paradigm-mcp/src/tools/index.ts
 import * as os6 from "os";
-import * as path34 from "path";
+import * as path33 from "path";
 import {
   ListToolsRequestSchema,
   CallToolRequestSchema
@@ -3741,7 +3769,7 @@ function navigateExplore(config, target, rootDir) {
   }
   if (result.paths.length === 0) {
     const areaSymbols = Object.entries(config.symbols).filter(
-      ([sym, path35]) => sym.toLowerCase().includes(targetLower) || path35.toLowerCase().includes(targetLower)
+      ([sym, path34]) => sym.toLowerCase().includes(targetLower) || path34.toLowerCase().includes(targetLower)
     ).slice(0, 10);
     result.paths = [...new Set(areaSymbols.map(([, p]) => p))];
     result.symbols = areaSymbols.map(([s]) => s);
@@ -5684,8 +5712,10 @@ payloads:
 
 // ../paradigm-mcp/src/tools/orchestration.ts
 import * as fs12 from "fs";
+import * as os from "os";
 import * as path13 from "path";
 import * as yaml8 from "js-yaml";
+init_agent_loader();
 var SYMBOL_PATTERN = /[@#$%^!?&~][a-zA-Z0-9_-]+/g;
 var DEFAULT_MODELS = {
   architect: "opus",
@@ -5990,6 +6020,14 @@ async function handleOrchestrateInline(args, ctx) {
     trackToolCall(text2.length, "paradigm_orchestrate_inline");
     return { handled: true, text: text2 };
   }
+  const roster = loadProjectRoster(ctx.rootDir);
+  if (roster && manifest.agents) {
+    const filtered = {};
+    for (const [id, def] of Object.entries(manifest.agents)) {
+      if (roster.includes(id)) filtered[id] = def;
+    }
+    manifest.agents = filtered;
+  }
   const symbols = extractSymbols(task);
   const classification = classifyTaskLocal(task);
   const plan = planAgentSequence(task, manifest.agents, agentOverride, classification);
@@ -6021,10 +6059,10 @@ async function handleOrchestrateInline(args, ctx) {
   }
   let agentProfiles = /* @__PURE__ */ new Map();
   try {
-    const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-DBF4OARL.js");
+    const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-X7TDYLFL.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-LPLCCDW2.js");
+    const { loadNominations: loadNominations2 } = await import("./nomination-engine-LLREC5BZ.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) {
@@ -6120,6 +6158,51 @@ async function handleOrchestrateInline(args, ctx) {
     }
   } catch {
   }
+  const orchestrationThread = `thr-orch-${orchestrationId}`;
+  try {
+    const symphony = await import("./symphony-loader-UZGON56V.js");
+    const projectName = path13.basename(ctx.rootDir);
+    const maestroId = `${projectName}/maestro`;
+    try {
+      const identity = symphony.getMyIdentity(ctx.rootDir);
+      if (!identity) {
+        symphony.registerAgent(ctx.rootDir, "maestro", "Maestro (orchestrator)");
+      }
+    } catch {
+    }
+    symphony.createThread(`Orchestration: ${task.slice(0, 80)}`, {
+      id: maestroId,
+      name: "Maestro",
+      type: "agent",
+      project: projectName,
+      role: "orchestrator"
+    });
+    const threadsDir = path13.join(os.homedir(), ".paradigm", "score", "threads");
+    const existingThreads = fs12.readdirSync(threadsDir).filter((f) => f.endsWith(".json")).sort();
+    const latestThread = existingThreads[existingThreads.length - 1];
+    if (latestThread) {
+      const oldPath = path13.join(threadsDir, latestThread);
+      const newPath = path13.join(threadsDir, `${orchestrationThread}.json`);
+      const threadData = JSON.parse(fs12.readFileSync(oldPath, "utf8"));
+      threadData.id = orchestrationThread;
+      fs12.writeFileSync(newPath, JSON.stringify(threadData, null, 2), "utf8");
+      if (oldPath !== newPath) fs12.unlinkSync(oldPath);
+    }
+    for (const stage of stagePrompts) {
+      for (const agent of stage.agents) {
+        const note = symphony.buildMessage({
+          threadRoot: orchestrationThread,
+          sender: { id: maestroId, name: "Maestro", type: "agent", project: projectName, role: "orchestrator" },
+          intent: "task",
+          text: `[Maestro] Stage ${stage.stage}: Assigned to ${agent.attribution || agent.agent} \u2014 ${agent.taskDescription || task}`,
+          symbols,
+          metadata: { task: { stage: stage.stage, canRunParallel: stage.canRunParallel } }
+        });
+        symphony.routeMessage(note);
+      }
+    }
+  } catch {
+  }
   const result = {
     orchestrationId,
     task,
@@ -6136,6 +6219,12 @@ async function handleOrchestrateInline(args, ctx) {
       "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"
     ],
+    // Symphony thread for live visibility in Conductor
+    symphony: {
+      orchestrationThread,
+      instruction: "After each agent completes, call paradigm_symphony_send to report progress. This makes the work visible in Conductor.",
+      perAgentInstruction: `When each agent finishes, run: paradigm_symphony_send threadId="${orchestrationThread}" intent="task-complete" text="[agentName] Summary of completed work" symbols=[touched symbols]`
+    },
     // Claude Code: Use Task tool for parallel agent spawning
     claudeCode: {
       method: "Task tool",
@@ -6190,6 +6279,16 @@ async function handleAgentPrompt(args, ctx) {
   const handoffContext = args.handoffContext;
   const previousAgent = args.previousAgent;
   const manifest = loadAgentsManifest(ctx.rootDir);
+  const rosterForPrompt = loadProjectRoster(ctx.rootDir);
+  if (rosterForPrompt && !rosterForPrompt.includes(agentName)) {
+    const text2 = JSON.stringify({
+      warning: `Agent "${agentName}" is not on this project's roster`,
+      suggestion: `Run paradigm_agent_activate id="${agentName}" to add it, or check .paradigm/roster.yaml`,
+      activeRoster: rosterForPrompt
+    }, null, 2);
+    trackToolCall(text2.length, "paradigm_agent_prompt");
+    return { handled: true, text: text2 };
+  }
   const manifestAgent = manifest?.agents[agentName];
   const agentDef = {
     name: manifestAgent?.name || agentName,
@@ -6205,10 +6304,10 @@ async function handleAgentPrompt(args, ctx) {
   let profileEnrichment;
   let nickname;
   try {
-    const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-DBF4OARL.js");
+    const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-X7TDYLFL.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-LPLCCDW2.js");
+    const { loadNominations: loadNominations2 } = await import("./nomination-engine-LLREC5BZ.js");
     const profile = loadAgentProfile2(ctx.rootDir, agentName);
     if (profile) {
       nickname = profile.nickname;
@@ -9604,7 +9703,7 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
 // ../paradigm-mcp/src/tools/lore.ts
 init_lore_loader();
 import { execSync as execSync2 } from "child_process";
-import * as os from "os";
+import * as os2 from "os";
 function resolveAuthorForMcp() {
   const envAuthor = process.env.PARADIGM_AUTHOR;
   if (envAuthor) return sanitize(envAuthor);
@@ -9614,7 +9713,7 @@ function resolveAuthorForMcp() {
   } catch {
   }
   try {
-    const username = os.userInfo().username;
+    const username = os2.userInfo().username;
     if (username) return sanitize(username);
   } catch {
   }
@@ -10132,7 +10231,7 @@ async function handleLoreTool(name, args, ctx) {
       try {
         const agentId = process.env.PARADIGM_AGENT_ID;
         if (agentId && symbols_touched && symbols_touched.length > 0) {
-          const { updateExpertiseFromLore } = await import("./agent-loader-DBF4OARL.js");
+          const { updateExpertiseFromLore } = await import("./agent-loader-X7TDYLFL.js");
           updateExpertiseFromLore(ctx.rootDir, agentId, {
             symbols_touched,
             confidence: confidence != null && confidence >= 0 && confidence <= 1 ? confidence : void 0
@@ -10303,7 +10402,7 @@ async function handleLoreTool(name, args, ctx) {
       try {
         const agentId = process.env.PARADIGM_AGENT_ID;
         if (agentId && success && entryToAssess.symbols_touched?.length) {
-          const { updateExpertiseFromAssessment } = await import("./agent-loader-DBF4OARL.js");
+          const { updateExpertiseFromAssessment } = await import("./agent-loader-X7TDYLFL.js");
           updateExpertiseFromAssessment(ctx.rootDir, agentId, {
             symbols_touched: entryToAssess.symbols_touched,
             verdict
@@ -12766,7 +12865,7 @@ async function rebuildAssessmentIndex(rootDir) {
 
 // ../paradigm-mcp/src/tools/assessment.ts
 import { execSync as execSync4 } from "child_process";
-import * as os2 from "os";
+import * as os3 from "os";
 function resolveAuthor() {
   const envAuthor = process.env.PARADIGM_AUTHOR;
   if (envAuthor) return sanitize2(envAuthor);
@@ -12776,7 +12875,7 @@ function resolveAuthor() {
   } catch {
   }
   try {
-    const username = os2.userInfo().username;
+    const username = os3.userInfo().username;
     if (username) return sanitize2(username);
   } catch {
   }
@@ -13097,8 +13196,8 @@ function generateRunId() {
 var TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
 function interpolate(value, scope) {
   if (typeof value === "string") {
-    return value.replace(TEMPLATE_REGEX, (_match, path35) => {
-      const resolved = resolvePath(path35.trim(), scope);
+    return value.replace(TEMPLATE_REGEX, (_match, path34) => {
+      const resolved = resolvePath(path34.trim(), scope);
       return resolved !== void 0 ? String(resolved) : _match;
     });
   }
@@ -13131,8 +13230,8 @@ function resolvePath(dotPath, scope) {
       return void 0;
   }
 }
-function deepGet(obj, path35) {
-  const parts = path35.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path34) {
+  const parts = path34.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -13368,11 +13467,11 @@ async function runPersonaObject(rootDir, persona, options) {
 }
 async function runChain(rootDir, chainId, options) {
   const start = Date.now();
-  const fs31 = await import("fs");
-  const path35 = await import("path");
+  const fs30 = await import("fs");
+  const path34 = await import("path");
   const yaml18 = await import("js-yaml");
-  const chainPath = path35.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
-  if (!fs31.existsSync(chainPath)) {
+  const chainPath = path34.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
+  if (!fs30.existsSync(chainPath)) {
     return {
       chain_id: chainId,
       status: "error",
@@ -13381,7 +13480,7 @@ async function runChain(rootDir, chainId, options) {
       duration_ms: Date.now() - start
     };
   }
-  const chain = yaml18.load(fs31.readFileSync(chainPath, "utf8"));
+  const chain = yaml18.load(fs30.readFileSync(chainPath, "utf8"));
   let permutation;
   if (options.permutation && chain.permutations) {
     permutation = chain.permutations.find((p) => p.id === options.permutation);
@@ -13485,8 +13584,8 @@ function validateInterpolation(persona) {
     const serialized = JSON.stringify(step);
     const templates = serialized.match(TEMPLATE_REGEX) || [];
     for (const template of templates) {
-      const path35 = template.replace("{{", "").replace("}}", "").trim();
-      const [namespace, ...rest] = path35.split(".");
+      const path34 = template.replace("{{", "").replace("}}", "").trim();
+      const [namespace, ...rest] = path34.split(".");
       const key = rest.join(".");
       switch (namespace) {
         case "fixtures":
@@ -15557,9 +15656,9 @@ import { execSync as execSync6 } from "child_process";
 // ../paradigm-mcp/src/utils/conductor-loader.ts
 import * as fs26 from "fs";
 import * as path28 from "path";
-import * as os3 from "os";
+import * as os4 from "os";
 import { execSync as execSync5 } from "child_process";
-var CONDUCTOR_DIR = path28.join(os3.homedir(), ".conductor");
+var CONDUCTOR_DIR = path28.join(os4.homedir(), ".conductor");
 var SESSIONS_DIR = path28.join(CONDUCTOR_DIR, "sessions");
 function ensureSessionsDir() {
   if (!fs26.existsSync(SESSIONS_DIR)) {
@@ -15840,583 +15939,6 @@ This session is no longer visible in the Conductor overlay.`,
   }
 }
 
-// ../paradigm-mcp/src/utils/symphony-loader.ts
-import * as fs27 from "fs";
-import * as path29 from "path";
-import * as os4 from "os";
-import * as crypto from "crypto";
-var SCORE_DIR = path29.join(os4.homedir(), ".paradigm", "score");
-var LEGACY_MAIL_DIR = path29.join(os4.homedir(), ".paradigm", "mail");
-var AGENTS_DIR = path29.join(SCORE_DIR, "agents");
-var THREADS_DIR = path29.join(SCORE_DIR, "threads");
-var FILE_REQUESTS_DIR = path29.join(SCORE_DIR, "file-requests");
-var TRUST_CONFIG_PATH = path29.join(SCORE_DIR, "trust.yaml");
-var FILE_REQUEST_TTL_MS = 60 * 60 * 1e3;
-var DEFAULT_TRUST = {
-  users: {},
-  defaults: {
-    level: "restricted",
-    autoApprove: [],
-    neverApprove: [
-      ".env*",
-      "**/*.key",
-      "**/*.pem",
-      "**/credentials*",
-      "**/secrets/**"
-    ]
-  }
-};
-function migrateFromLegacyMail() {
-  if (fs27.existsSync(LEGACY_MAIL_DIR) && !fs27.existsSync(SCORE_DIR)) {
-    try {
-      fs27.renameSync(LEGACY_MAIL_DIR, SCORE_DIR);
-    } catch {
-    }
-  }
-}
-function ensureScoreDirs() {
-  migrateFromLegacyMail();
-  for (const dir of [AGENTS_DIR, THREADS_DIR, FILE_REQUESTS_DIR]) {
-    if (!fs27.existsSync(dir)) {
-      fs27.mkdirSync(dir, { recursive: true });
-    }
-  }
-}
-function getAgentDir(agentId) {
-  return path29.join(AGENTS_DIR, agentId);
-}
-function ensureAgentDir(agentId) {
-  const dir = getAgentDir(agentId);
-  if (!fs27.existsSync(dir)) {
-    fs27.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function readJsonlFile(filePath) {
-  if (!fs27.existsSync(filePath)) return [];
-  const content = fs27.readFileSync(filePath, "utf-8");
-  const lines = content.split("\n").filter((line) => line.trim().length > 0);
-  const items = [];
-  for (const line of lines) {
-    try {
-      items.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return items;
-}
-function appendJsonlLine(filePath, item) {
-  const dir = path29.dirname(filePath);
-  if (!fs27.existsSync(dir)) {
-    fs27.mkdirSync(dir, { recursive: true });
-  }
-  fs27.appendFileSync(filePath, JSON.stringify(item) + "\n", "utf-8");
-}
-function sanitizeId(name) {
-  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "unknown";
-}
-function resolveProjectName(projectDir2) {
-  try {
-    const configPath = path29.join(projectDir2, ".paradigm", "config.yaml");
-    if (fs27.existsSync(configPath)) {
-      const content = fs27.readFileSync(configPath, "utf-8");
-      const match = content.match(/^project:\s*(.+)$/m);
-      if (match) return sanitizeId(match[1].trim().replace(/["']/g, ""));
-    }
-  } catch {
-  }
-  return sanitizeId(path29.basename(projectDir2));
-}
-function resolveAgentIdentity(projectDir2, role) {
-  const project = resolveProjectName(projectDir2);
-  const agentRole = role || "core";
-  return `${project}/${agentRole}`;
-}
-function registerAgent(projectDir2, role, label) {
-  ensureScoreDirs();
-  const agentId = resolveAgentIdentity(projectDir2, role);
-  const agentDir = ensureAgentDir(agentId);
-  const project = resolveProjectName(projectDir2);
-  const identity = {
-    id: agentId,
-    name: label || `${project} (${role || "core"})`,
-    type: "agent",
-    project,
-    role: role || "core",
-    pid: process.pid,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    label
-  };
-  fs27.writeFileSync(
-    path29.join(agentDir, "identity.json"),
-    JSON.stringify(identity, null, 2),
-    "utf-8"
-  );
-  return identity;
-}
-function unregisterAgent(agentId) {
-  const agentDir = getAgentDir(agentId);
-  if (!fs27.existsSync(agentDir)) return false;
-  try {
-    fs27.rmSync(agentDir, { recursive: true, force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function listAgents() {
-  ensureScoreDirs();
-  if (!fs27.existsSync(AGENTS_DIR)) return [];
-  const agents = [];
-  const projectDirs = fs27.readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
-  for (const projectDir2 of projectDirs) {
-    const projectPath = path29.join(AGENTS_DIR, projectDir2.name);
-    const roleDirs = fs27.readdirSync(projectPath, { withFileTypes: true }).filter((d) => d.isDirectory());
-    for (const roleDir of roleDirs) {
-      const identityPath = path29.join(projectPath, roleDir.name, "identity.json");
-      if (!fs27.existsSync(identityPath)) continue;
-      try {
-        const content = fs27.readFileSync(identityPath, "utf-8");
-        const identity = JSON.parse(content);
-        agents.push(identity);
-      } catch {
-      }
-    }
-  }
-  return agents;
-}
-function cleanStaleAgents() {
-  const agents = listAgents();
-  let cleaned = 0;
-  for (const agent of agents) {
-    if (!isProcessAlive2(agent.pid)) {
-      unregisterAgent(agent.id);
-      cleaned++;
-    }
-  }
-  return cleaned;
-}
-function getMyIdentity(projectDir2) {
-  const agentId = resolveAgentIdentity(projectDir2);
-  const identityPath = path29.join(getAgentDir(agentId), "identity.json");
-  if (!fs27.existsSync(identityPath)) return null;
-  try {
-    return JSON.parse(fs27.readFileSync(identityPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function markAgentPollTime(agentId, statusBlurb) {
-  const identityPath = path29.join(getAgentDir(agentId), "identity.json");
-  if (!fs27.existsSync(identityPath)) return;
-  try {
-    const identity = JSON.parse(fs27.readFileSync(identityPath, "utf-8"));
-    identity.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
-    if (statusBlurb !== void 0) {
-      identity.statusBlurb = statusBlurb || void 0;
-    }
-    fs27.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
-  } catch {
-  }
-}
-function isAgentAsleep(identity, thresholdMs = 6e4) {
-  if (!identity.lastPoll) return true;
-  const lastPoll = new Date(identity.lastPoll).getTime();
-  return Date.now() - lastPoll > thresholdMs;
-}
-function inboxPath(agentId) {
-  return path29.join(getAgentDir(agentId), "inbox.jsonl");
-}
-function outboxPath(agentId) {
-  return path29.join(getAgentDir(agentId), "outbox.jsonl");
-}
-function ackPath(agentId) {
-  return path29.join(getAgentDir(agentId), "ack.json");
-}
-function peekInbox(agentId) {
-  const filePath = inboxPath(agentId);
-  if (!fs27.existsSync(filePath)) return { hasNew: false, inboxSize: 0 };
-  const stat = fs27.statSync(filePath);
-  const inboxSize = stat.size;
-  const ack = readAck(agentId);
-  if (!ack) {
-    return { hasNew: inboxSize > 0, inboxSize };
-  }
-  const ackSizePath = path29.join(getAgentDir(agentId), "ack-size.json");
-  if (fs27.existsSync(ackSizePath)) {
-    try {
-      const ackSize = JSON.parse(fs27.readFileSync(ackSizePath, "utf-8"));
-      return { hasNew: inboxSize > (ackSize.size || 0), inboxSize };
-    } catch {
-    }
-  }
-  return { hasNew: inboxSize > 0, inboxSize };
-}
-function recordAckSize(agentId) {
-  const filePath = inboxPath(agentId);
-  const ackSizePath = path29.join(getAgentDir(agentId), "ack-size.json");
-  try {
-    const size = fs27.existsSync(filePath) ? fs27.statSync(filePath).size : 0;
-    ensureAgentDir(agentId);
-    fs27.writeFileSync(ackSizePath, JSON.stringify({ size }), "utf-8");
-  } catch {
-  }
-}
-function appendToInbox(agentId, message) {
-  ensureAgentDir(agentId);
-  appendJsonlLine(inboxPath(agentId), message);
-}
-function readInbox(agentId, afterAck) {
-  const messages = readJsonlFile(inboxPath(agentId));
-  if (!afterAck) {
-    const ack = readAck(agentId);
-    if (ack) {
-      const ackIndex2 = messages.findIndex((m) => m.id === ack);
-      if (ackIndex2 >= 0) return messages.slice(ackIndex2 + 1);
-    }
-    return messages;
-  }
-  const ackIndex = messages.findIndex((m) => m.id === afterAck);
-  if (ackIndex >= 0) return messages.slice(ackIndex + 1);
-  return messages;
-}
-function appendToOutbox(agentId, message) {
-  ensureAgentDir(agentId);
-  appendJsonlLine(outboxPath(agentId), message);
-}
-function acknowledgeMessages(agentId, lastMessageId) {
-  const filePath = ackPath(agentId);
-  ensureAgentDir(agentId);
-  fs27.writeFileSync(filePath, JSON.stringify({ lastAck: lastMessageId }), "utf-8");
-}
-function readAck(agentId) {
-  const filePath = ackPath(agentId);
-  if (!fs27.existsSync(filePath)) return null;
-  try {
-    const content = JSON.parse(fs27.readFileSync(filePath, "utf-8"));
-    return content.lastAck || null;
-  } catch {
-    return null;
-  }
-}
-function garbageCollect(agentId) {
-  const ack = readAck(agentId);
-  if (!ack) return 0;
-  const filePath = inboxPath(agentId);
-  const messages = readJsonlFile(filePath);
-  const ackIndex = messages.findIndex((m) => m.id === ack);
-  if (ackIndex < 0) return 0;
-  const kept = messages.slice(ackIndex + 1);
-  const removed = messages.length - kept.length;
-  if (kept.length === 0) {
-    if (fs27.existsSync(filePath)) fs27.writeFileSync(filePath, "", "utf-8");
-  } else {
-    fs27.writeFileSync(filePath, kept.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
-  }
-  return removed;
-}
-function threadPath(threadId) {
-  return path29.join(THREADS_DIR, `${threadId}.json`);
-}
-function createThread(topic, initiator) {
-  ensureScoreDirs();
-  const id = "thr-" + crypto.randomBytes(4).toString("hex");
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const thread = {
-    id,
-    topic,
-    initiator,
-    participants: [initiator],
-    status: "active",
-    createdAt: now,
-    lastActivity: now,
-    messageCount: 0
-  };
-  fs27.writeFileSync(threadPath(id), JSON.stringify(thread, null, 2), "utf-8");
-  return thread;
-}
-function loadThread(threadId) {
-  const filePath = threadPath(threadId);
-  if (!fs27.existsSync(filePath)) return null;
-  try {
-    return JSON.parse(fs27.readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function listThreads(status) {
-  ensureScoreDirs();
-  if (!fs27.existsSync(THREADS_DIR)) return [];
-  const files = fs27.readdirSync(THREADS_DIR).filter((f) => f.endsWith(".json"));
-  const threads = [];
-  for (const file of files) {
-    try {
-      const content = fs27.readFileSync(path29.join(THREADS_DIR, file), "utf-8");
-      const thread = JSON.parse(content);
-      if (!status || thread.status === status) {
-        threads.push(thread);
-      }
-    } catch {
-    }
-  }
-  return threads.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
-}
-function updateThread(threadId, partial) {
-  const thread = loadThread(threadId);
-  if (!thread) return false;
-  const updated = { ...thread, ...partial };
-  fs27.writeFileSync(threadPath(threadId), JSON.stringify(updated, null, 2), "utf-8");
-  return true;
-}
-function getThreadMessages(threadId) {
-  const agents = listAgents();
-  const messages = [];
-  for (const agent of agents) {
-    const inbox = readJsonlFile(inboxPath(agent.id));
-    const outbox = readJsonlFile(outboxPath(agent.id));
-    for (const msg of [...inbox, ...outbox]) {
-      if (msg.threadRoot === threadId || msg.id === threadId) {
-        if (!messages.some((m) => m.id === msg.id)) {
-          messages.push(msg);
-        }
-      }
-    }
-  }
-  return messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-}
-function buildMessage(params) {
-  return {
-    id: crypto.randomUUID(),
-    parentId: params.parentId,
-    threadRoot: params.threadRoot,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    sender: params.sender,
-    recipients: params.recipients,
-    intent: params.intent,
-    content: {
-      text: params.text,
-      diff: params.diff,
-      decision: params.decision
-    },
-    symbols: params.symbols || [],
-    attachments: params.attachments,
-    metadata: params.metadata
-  };
-}
-function routeMessage(message) {
-  ensureScoreDirs();
-  appendToOutbox(message.sender.id, message);
-  let deliveryCount = 0;
-  if (message.recipients && message.recipients.length > 0) {
-    for (const recipient of message.recipients) {
-      appendToInbox(recipient.id, message);
-      deliveryCount++;
-    }
-  } else {
-    const agents = listAgents();
-    for (const agent of agents) {
-      if (agent.id !== message.sender.id) {
-        appendToInbox(agent.id, message);
-        deliveryCount++;
-      }
-    }
-  }
-  if (message.threadRoot) {
-    const thread = loadThread(message.threadRoot);
-    if (thread) {
-      const isParticipant = thread.participants.some((p) => p.id === message.sender.id);
-      const updatedParticipants = isParticipant ? thread.participants : [...thread.participants, message.sender];
-      updateThread(message.threadRoot, {
-        participants: updatedParticipants,
-        lastActivity: message.timestamp,
-        messageCount: thread.messageCount + 1
-      });
-    }
-  }
-  return deliveryCount;
-}
-function fileRequestPath(requestId) {
-  return path29.join(FILE_REQUESTS_DIR, `${requestId}.json`);
-}
-function loadTrustConfig() {
-  if (!fs27.existsSync(TRUST_CONFIG_PATH)) return DEFAULT_TRUST;
-  try {
-    const content = fs27.readFileSync(TRUST_CONFIG_PATH, "utf-8");
-    try {
-      return JSON.parse(content);
-    } catch {
-      return DEFAULT_TRUST;
-    }
-  } catch {
-    return DEFAULT_TRUST;
-  }
-}
-function createFileRequest(params) {
-  ensureScoreDirs();
-  const requestId = "freq-" + crypto.randomBytes(4).toString("hex");
-  const record = {
-    request: {
-      requestId,
-      filePath: params.filePath,
-      reason: params.reason,
-      requester: params.requester,
-      urgency: params.urgency || "normal",
-      snippet: params.snippet,
-      threadRoot: params.threadRoot
-    },
-    status: "pending",
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  fs27.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
-  return record;
-}
-function loadFileRequest(requestId) {
-  const filePath = fileRequestPath(requestId);
-  if (!fs27.existsSync(filePath)) return null;
-  try {
-    return JSON.parse(fs27.readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function listFileRequests(status) {
-  ensureScoreDirs();
-  if (!fs27.existsSync(FILE_REQUESTS_DIR)) return [];
-  const files = fs27.readdirSync(FILE_REQUESTS_DIR).filter((f) => f.endsWith(".json"));
-  const requests = [];
-  for (const file of files) {
-    try {
-      const content = fs27.readFileSync(path29.join(FILE_REQUESTS_DIR, file), "utf-8");
-      const record = JSON.parse(content);
-      if (!status || record.status === status) {
-        requests.push(record);
-      }
-    } catch {
-    }
-  }
-  return requests.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-}
-function approveFileRequest(requestId, projectDir2, redact) {
-  const record = loadFileRequest(requestId);
-  if (!record) return { success: false, error: `File request not found: ${requestId}` };
-  if (record.status !== "pending") return { success: false, error: `Request already ${record.status}` };
-  const absolutePath = path29.resolve(projectDir2, record.request.filePath);
-  if (!absolutePath.startsWith(path29.resolve(projectDir2))) {
-    return { success: false, error: "File path escapes project directory" };
-  }
-  if (!fs27.existsSync(absolutePath)) {
-    return { success: false, error: `File not found: ${record.request.filePath}` };
-  }
-  try {
-    let content = fs27.readFileSync(absolutePath, "utf-8");
-    let encoding = "utf8";
-    if (redact) {
-      const secretPatterns = [
-        /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]/i,
-        /(?:^|\s)(?:export\s+)?[A-Z_]+(?:KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL)\s*=/,
-        /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/
-      ];
-      content = content.split("\n").map((line) => {
-        for (const pattern of secretPatterns) {
-          if (pattern.test(line)) return "[REDACTED]";
-        }
-        return line;
-      }).join("\n");
-    }
-    const hash = crypto.createHash("sha256").update(content).digest("hex");
-    const delivery = {
-      requestId,
-      filePath: record.request.filePath,
-      content,
-      encoding,
-      size: Buffer.byteLength(content),
-      hash
-    };
-    record.status = "approved";
-    record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-    record.delivery = delivery;
-    fs27.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
-    const deliveryMessage = buildMessage({
-      sender: { id: "system", name: "File Transfer", type: "human" },
-      recipients: [record.request.requester],
-      intent: "fileDelivery",
-      text: `File delivered: ${record.request.filePath} (${delivery.size} bytes, SHA-256: ${hash.slice(0, 12)}...)`,
-      threadRoot: record.request.threadRoot,
-      symbols: []
-    });
-    deliveryMessage.attachments = [{
-      name: path29.basename(record.request.filePath),
-      type: "file",
-      content: delivery.content,
-      encoding: delivery.encoding
-    }];
-    routeMessage(deliveryMessage);
-    return { success: true, delivery };
-  } catch (err2) {
-    return { success: false, error: `Failed to read file: ${err2.message}` };
-  }
-}
-function denyFileRequest(requestId, reason) {
-  const record = loadFileRequest(requestId);
-  if (!record || record.status !== "pending") return false;
-  record.status = "denied";
-  record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-  record.denyReason = reason;
-  fs27.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
-  const denialMessage = buildMessage({
-    sender: { id: "system", name: "File Transfer", type: "human" },
-    recipients: [record.request.requester],
-    intent: "fileDenied",
-    text: `File request denied: ${record.request.filePath}${reason ? ` \u2014 ${reason}` : ""}`,
-    threadRoot: record.request.threadRoot,
-    symbols: []
-  });
-  routeMessage(denialMessage);
-  return true;
-}
-function matchesGlob(filePath, pattern) {
-  let regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
-  return new RegExp(`^${regex}$`).test(filePath);
-}
-function isPathDenied(filePath, config, user) {
-  const trust = config || loadTrustConfig();
-  if (user && trust.users[user]) {
-    for (const pattern of trust.users[user].neverApprove) {
-      if (matchesGlob(filePath, pattern)) return true;
-    }
-  }
-  for (const pattern of trust.defaults.neverApprove) {
-    if (matchesGlob(filePath, pattern)) return true;
-  }
-  return false;
-}
-function expireOldRequests() {
-  const requests = listFileRequests("pending");
-  let expired = 0;
-  for (const record of requests) {
-    const age = Date.now() - new Date(record.createdAt).getTime();
-    if (age > FILE_REQUEST_TTL_MS) {
-      record.status = "expired";
-      record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-      fs27.writeFileSync(
-        fileRequestPath(record.request.requestId),
-        JSON.stringify(record, null, 2),
-        "utf-8"
-      );
-      expired++;
-    }
-  }
-  return expired;
-}
-function isProcessAlive2(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // ../paradigm-mcp/src/tools/symphony.ts
 function getSymphonyToolsList() {
   return [
@@ -17720,14 +17242,14 @@ async function handleUniversityTool(name, args, ctx) {
 }
 
 // ../paradigm-mcp/src/utils/platform-bridge.ts
-import * as fs28 from "fs";
-import * as path30 from "path";
+import * as fs27 from "fs";
+import * as path29 from "path";
 import * as yaml16 from "js-yaml";
 function resolvePlatformPort(projectDir2) {
   try {
-    const configPath = path30.join(projectDir2, ".paradigm", "config.yaml");
-    if (fs28.existsSync(configPath)) {
-      const config = yaml16.load(fs28.readFileSync(configPath, "utf-8"));
+    const configPath = path29.join(projectDir2, ".paradigm", "config.yaml");
+    if (fs27.existsSync(configPath)) {
+      const config = yaml16.load(fs27.readFileSync(configPath, "utf-8"));
       const platform2 = config.platform;
       if (platform2?.port && typeof platform2.port === "number") {
         return platform2.port;
@@ -17739,16 +17261,16 @@ function resolvePlatformPort(projectDir2) {
 }
 function resolveAgentId(projectDir2) {
   try {
-    const configPath = path30.join(projectDir2, ".paradigm", "config.yaml");
-    if (fs28.existsSync(configPath)) {
-      const config = yaml16.load(fs28.readFileSync(configPath, "utf-8"));
-      const project = config.project || path30.basename(projectDir2);
+    const configPath = path29.join(projectDir2, ".paradigm", "config.yaml");
+    if (fs27.existsSync(configPath)) {
+      const config = yaml16.load(fs27.readFileSync(configPath, "utf-8"));
+      const project = config.project || path29.basename(projectDir2);
       const role = config.role || "core";
       return `${project}/${role}`;
     }
   } catch {
   }
-  return `${path30.basename(projectDir2)}/core`;
+  return `${path29.basename(projectDir2)}/core`;
 }
 async function sendAgentCommand(projectDir2, command, payload) {
   const port = resolvePlatformPort(projectDir2);
@@ -18123,6 +17645,7 @@ async function handleAgentTool(name, args, ctx) {
   switch (name) {
     case "paradigm_agent_list": {
       const profiles = loadAllAgentProfiles(ctx.rootDir);
+      const roster = loadProjectRoster(ctx.rootDir);
       if (profiles.length === 0) {
         return {
           handled: true,
@@ -18133,15 +17656,18 @@ async function handleAgentTool(name, args, ctx) {
           }, null, 2)
         };
       }
+      const activeProfiles = roster ? profiles.filter((p) => roster.includes(p.id)) : profiles;
+      const inactiveCount = roster ? profiles.length - activeProfiles.length : 0;
       return {
         handled: true,
         text: JSON.stringify({
-          count: profiles.length,
-          agents: profiles.map((p) => ({
+          count: activeProfiles.length,
+          totalAvailable: profiles.length,
+          ...roster ? { rosterActive: true, inactiveCount } : { rosterActive: false },
+          agents: activeProfiles.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,
@@ -18239,15 +17765,20 @@ async function handleAgentTool(name, args, ctx) {
           text: JSON.stringify({ error: `Agent "${benchId}" not found` }, null, 2)
         };
       }
-      benchProfile.benched = true;
-      benchProfile.updated = (/* @__PURE__ */ new Date()).toISOString();
-      saveAgentProfile(benchId, benchProfile, "global");
+      let currentRoster = loadProjectRoster(ctx.rootDir);
+      if (currentRoster) {
+        currentRoster = currentRoster.filter((id) => id !== benchId);
+      } else {
+        currentRoster = listAllGlobalAgentIds().filter((id) => id !== benchId);
+      }
+      saveProjectRoster(ctx.rootDir, currentRoster);
       return {
         handled: true,
         text: JSON.stringify({
           id: benchId,
-          benched: true,
-          note: `${benchId} is now benched. Maestro will skip this agent during orchestration.`
+          removedFromRoster: true,
+          rosterCount: currentRoster.length,
+          note: `${benchId} removed from this project's roster. Still available globally.`
         }, null, 2)
       };
     }
@@ -18260,15 +17791,21 @@ async function handleAgentTool(name, args, ctx) {
           text: JSON.stringify({ error: `Agent "${activateId}" not found` }, null, 2)
         };
       }
-      activateProfile.benched = false;
-      activateProfile.updated = (/* @__PURE__ */ new Date()).toISOString();
-      saveAgentProfile(activateId, activateProfile, "global");
+      let activateRoster = loadProjectRoster(ctx.rootDir);
+      if (activateRoster) {
+        if (!activateRoster.includes(activateId)) {
+          activateRoster.push(activateId);
+          saveProjectRoster(ctx.rootDir, activateRoster);
+        }
+      } else {
+      }
       return {
         handled: true,
         text: JSON.stringify({
           id: activateId,
-          benched: false,
-          note: `${activateId} is now active. Maestro will include this agent in orchestration.`
+          addedToRoster: true,
+          rosterCount: activateRoster?.length ?? "all (no roster)",
+          note: `${activateId} is active on this project's roster.`
         }, null, 2)
       };
     }
@@ -18445,7 +17982,7 @@ async function handleNotebookTool(name, args, ctx) {
       const concepts = args.concepts || [];
       const tags = args.tags || [];
       const confidence = args.confidence ?? 0.7;
-      const scope = args.scope || "global";
+      const scope = args.scope || (ctx.rootDir ? "project" : "global");
       const result = addNotebookEntry(
         agentId,
         {
@@ -18474,7 +18011,7 @@ async function handleNotebookTool(name, args, ctx) {
     case "paradigm_notebook_promote": {
       const agentId = args.agentId;
       const loreEntryId = args.loreEntryId;
-      const scope = args.scope || "global";
+      const scope = args.scope || (ctx.rootDir ? "project" : "global");
       const result = await promoteFromLore(agentId, loreEntryId, ctx.rootDir, scope);
       if (!result) {
         return {
@@ -18505,8 +18042,8 @@ async function handleNotebookTool(name, args, ctx) {
 }
 
 // ../paradigm-mcp/src/utils/docs-loader.ts
-import * as fs29 from "fs";
-import * as path31 from "path";
+import * as fs28 from "fs";
+import * as path30 from "path";
 import * as yaml17 from "js-yaml";
 var SCAN_INDEX_PATH = ".paradigm/scan-index.json";
 var FLOW_INDEX_PATH = ".paradigm/flow-index.json";
@@ -18524,12 +18061,12 @@ var DEFAULT_CONFIG = {
   output: ".paradigm/docs-site"
 };
 function loadDocsConfig(rootDir) {
-  const configPath = path31.join(rootDir, CONFIG_PATH);
-  if (!fs29.existsSync(configPath)) {
+  const configPath = path30.join(rootDir, CONFIG_PATH);
+  if (!fs28.existsSync(configPath)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const raw = fs29.readFileSync(configPath, "utf8");
+    const raw = fs28.readFileSync(configPath, "utf8");
     const data = yaml17.load(raw);
     if (!data || !data.docs) return { ...DEFAULT_CONFIG };
     const docs = data.docs;
@@ -18553,40 +18090,40 @@ function loadDocsConfig(rootDir) {
   }
 }
 function loadScanIndex2(rootDir) {
-  const filePath = path31.join(rootDir, SCAN_INDEX_PATH);
-  if (!fs29.existsSync(filePath)) return null;
+  const filePath = path30.join(rootDir, SCAN_INDEX_PATH);
+  if (!fs28.existsSync(filePath)) return null;
   try {
-    const raw = fs29.readFileSync(filePath, "utf8");
+    const raw = fs28.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function loadFlowIndex2(rootDir) {
-  const filePath = path31.join(rootDir, FLOW_INDEX_PATH);
-  if (!fs29.existsSync(filePath)) return null;
+  const filePath = path30.join(rootDir, FLOW_INDEX_PATH);
+  if (!fs28.existsSync(filePath)) return null;
   try {
-    const raw = fs29.readFileSync(filePath, "utf8");
+    const raw = fs28.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function loadPortal(rootDir) {
-  const filePath = path31.join(rootDir, PORTAL_FILE);
-  if (!fs29.existsSync(filePath)) return null;
+  const filePath = path30.join(rootDir, PORTAL_FILE);
+  if (!fs28.existsSync(filePath)) return null;
   try {
-    const raw = fs29.readFileSync(filePath, "utf8");
+    const raw = fs28.readFileSync(filePath, "utf8");
     return yaml17.load(raw);
   } catch {
     return null;
   }
 }
 function loadUniversityIndex(rootDir) {
-  const filePath = path31.join(rootDir, UNIVERSITY_INDEX_PATH);
-  if (!fs29.existsSync(filePath)) return null;
+  const filePath = path30.join(rootDir, UNIVERSITY_INDEX_PATH);
+  if (!fs28.existsSync(filePath)) return null;
   try {
-    const raw = fs29.readFileSync(filePath, "utf8");
+    const raw = fs28.readFileSync(filePath, "utf8");
     return yaml17.load(raw);
   } catch {
     return null;
@@ -18652,14 +18189,14 @@ function isExcluded(entry, config) {
   return false;
 }
 function loadCustomPages(rootDir, customContentDir) {
-  const dir = path31.join(rootDir, customContentDir);
-  if (!fs29.existsSync(dir)) return [];
+  const dir = path30.join(rootDir, customContentDir);
+  if (!fs28.existsSync(dir)) return [];
   const pages = [];
   try {
-    const files = fs29.readdirSync(dir).filter((f) => f.endsWith(".md"));
+    const files = fs28.readdirSync(dir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       try {
-        const raw = fs29.readFileSync(path31.join(dir, file), "utf8");
+        const raw = fs28.readFileSync(path30.join(dir, file), "utf8");
         const slug = file.replace(/\.md$/, "");
         const parsed = parseFrontmatter(raw);
         if (parsed) {
@@ -18692,11 +18229,11 @@ function loadCustomPages(rootDir, customContentDir) {
 }
 function loadCustomPage(rootDir, slug, config) {
   const resolvedConfig = config || loadDocsConfig(rootDir);
-  const dir = path31.join(rootDir, resolvedConfig.customContent);
-  const filePath = path31.join(dir, `${slug}.md`);
-  if (!fs29.existsSync(filePath)) return null;
+  const dir = path30.join(rootDir, resolvedConfig.customContent);
+  const filePath = path30.join(dir, `${slug}.md`);
+  if (!fs28.existsSync(filePath)) return null;
   try {
-    const raw = fs29.readFileSync(filePath, "utf8");
+    const raw = fs28.readFileSync(filePath, "utf8");
     const parsed = parseFrontmatter(raw);
     if (parsed) {
       return {
@@ -18723,7 +18260,7 @@ function buildDocsManifest(rootDir, config) {
   const portal = loadPortal(rootDir);
   const customPages = loadCustomPages(rootDir, resolvedConfig.customContent);
   const uniIndex = loadUniversityIndex(rootDir);
-  const projectName = scanIndex?.$meta?.project || path31.basename(rootDir);
+  const projectName = scanIndex?.$meta?.project || path30.basename(rootDir);
   const title = resolvedConfig.title || `${projectName} Docs`;
   const groups = [];
   const symbolCounts = {};
@@ -19679,8 +19216,8 @@ async function handleStreamsTool(name, args, ctx) {
 init_nomination_engine();
 init_event_stream();
 init_agent_loader();
-import * as fs30 from "fs";
-import * as path32 from "path";
+import * as fs29 from "fs";
+import * as path31 from "path";
 init_journal_loader();
 function getAmbientToolsList() {
   return [
@@ -19832,10 +19369,10 @@ async function handleAmbientTool(name, args, ctx) {
       });
       const surfacingConfig = loadSurfacingConfig(ctx.rootDir);
       nominations = applySurfacingRules(nominations, surfacingConfig).slice(0, limit);
-      const nominationsPath = path32.join(ctx.rootDir, ".paradigm/events/nominations.jsonl");
-      if (fs30.existsSync(nominationsPath)) {
+      const nominationsPath = path31.join(ctx.rootDir, ".paradigm/events/nominations.jsonl");
+      if (fs29.existsSync(nominationsPath)) {
         try {
-          const content = fs30.readFileSync(nominationsPath, "utf8");
+          const content = fs29.readFileSync(nominationsPath, "utf8");
           const surfacedIds = new Set(nominations.map((n) => n.id));
           const lines = content.trim().split("\n").map((line) => {
             try {
@@ -19849,7 +19386,7 @@ async function handleAmbientTool(name, args, ctx) {
               return line;
             }
           });
-          fs30.writeFileSync(nominationsPath, lines.join("\n") + "\n", "utf8");
+          fs29.writeFileSync(nominationsPath, lines.join("\n") + "\n", "utf8");
         } catch {
         }
       }
@@ -20073,7 +19610,7 @@ async function handleAmbientTool(name, args, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/fallback-grep.ts
-import * as path33 from "path";
+import * as path32 from "path";
 import { execSync as execSync8 } from "child_process";
 function grepForReferences(rootDir, symbol, options = {}) {
   const { maxResults = 20 } = options;
@@ -20102,7 +19639,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
     const match = line.match(/^(.+?):(\d+):(.*)$/);
     if (match) {
       const [, filePath, lineNum, content] = match;
-      const relativePath = path33.relative(rootDir, filePath);
+      const relativePath = path32.relative(rootDir, filePath);
       let context2 = "unknown";
       if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
         context2 = "purpose";
@@ -21155,10 +20692,10 @@ Update command:
               trackToolCall(noWsText.length, name);
               return { content: [{ type: "text", text: noWsText }] };
             }
-            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-KFUPB3ES.js");
+            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-U2HEB6GW.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
-              const memberAbsPath = path34.resolve(path34.dirname(ctx.workspace.workspacePath), member.path);
+              const memberAbsPath = path33.resolve(path33.dirname(ctx.workspace.workspacePath), member.path);
               try {
                 const result = await rebuildStaticFiles2(memberAbsPath);
                 memberResults.push({