@a-company/paradigm 5.3.3 → 5.5.0

package/dist/{agent-HYKC2LAK.js → agent-WERIO2XV.js}

@@ -318,6 +318,139 @@ async function agentSyncCommand(id, options = {}) {
   }
   tracker.success(`Synced ${symbolsUpdated.size} symbols from ${entriesProcessed} entries`);
 }
+async function agentRosterCommand(options = {}) {
+  const cwd = process.cwd();
+  const tracker = log.command("agent-roster").start("Agent roster", { cwd });
+  const profiles = [];
+  if (fs.existsSync(GLOBAL_AGENTS_DIR)) {
+    for (const file of fs.readdirSync(GLOBAL_AGENTS_DIR).filter((f) => f.endsWith(AGENT_EXT))) {
+      try {
+        const p = yaml.load(fs.readFileSync(path.join(GLOBAL_AGENTS_DIR, file), "utf-8"));
+        if (p?.id) profiles.push(p);
+      } catch {
+      }
+    }
+  }
+  const projectDir = path.join(cwd, PROJECT_AGENTS_DIR);
+  if (fs.existsSync(projectDir)) {
+    for (const file of fs.readdirSync(projectDir).filter((f) => f.endsWith(AGENT_EXT))) {
+      try {
+        const p = yaml.load(fs.readFileSync(path.join(projectDir, file), "utf-8"));
+        if (p?.id) {
+          const idx = profiles.findIndex((e) => e.id === p.id);
+          if (idx >= 0) profiles[idx] = p;
+          else profiles.push(p);
+        }
+      } catch {
+      }
+    }
+  }
+  const active = profiles.filter((p) => !p.benched);
+  const benched = profiles.filter((p) => p.benched);
+  if (options.json) {
+    console.log(JSON.stringify({
+      active: active.map(rosterSummarize),
+      benched: benched.map(rosterSummarize)
+    }, null, 2));
+    tracker.success(`${active.length} active, ${benched.length} benched`);
+    return;
+  }
+  console.log(chalk.blue("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(chalk.blue("\u2502") + chalk.white.bold("  Agent Roster                                    ") + chalk.blue("\u2502"));
+  console.log(chalk.blue("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n"));
+  if (active.length > 0) {
+    console.log(chalk.green.bold("  Active"));
+    for (const p of active) {
+      printRosterRow(p);
+    }
+  }
+  if (benched.length > 0) {
+    console.log(chalk.gray.bold("\n  Benched"));
+    for (const p of benched) {
+      printRosterRow(p, true);
+    }
+  }
+  if (profiles.length === 0) {
+    console.log(chalk.yellow("  No agents found.\n"));
+  } else {
+    console.log("");
+  }
+  tracker.success(`${active.length} active, ${benched.length} benched`);
+}
+function printRosterRow(p, dimmed = false) {
+  const expertise = (p.expertise || []).sort((a, b) => b.confidence - a.confidence);
+  const topSymbol = expertise[0] ? `${expertise[0].symbol} (${(expertise[0].confidence * 100).toFixed(0)}%)` : chalk.gray("\u2014");
+  const color = dimmed ? chalk.gray : chalk.white;
+  const nickname = p.nickname ? ` (${p.nickname})` : "";
+  const threshold = p.attention?.threshold;
+  const thresholdStr = threshold != null ? ` | thr: ${threshold.toFixed(2)}` : "";
+  console.log(`    ${color.bold(p.id)}${chalk.gray(nickname)} \u2014 ${chalk.gray(p.role)}`);
+  console.log(`      Top: ${topSymbol} | ${expertise.length} symbols${thresholdStr}`);
+}
+function rosterSummarize(p) {
+  const expertise = (p.expertise || []).sort((a, b) => b.confidence - a.confidence);
+  return {
+    id: p.id,
+    role: p.role,
+    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
+  };
+}
+async function agentBenchCommand(id) {
+  const cwd = process.cwd();
+  const tracker = log.command("agent-bench").start(`Benching agent ${id}`, { cwd });
+  const profile = loadProfile(cwd, id);
+  if (!profile) {
+    console.log(chalk.red(`
+  Agent "${id}" not found.
+`));
+    tracker.error("Not found");
+    return;
+  }
+  profile.benched = true;
+  profile.updated = (/* @__PURE__ */ new Date()).toISOString();
+  saveProfile(cwd, id, profile);
+  console.log(chalk.yellow(`
+  \u23F8 Agent "${id}" is now benched.`));
+  console.log(chalk.gray("  Maestro will skip this agent during orchestration.\n"));
+  tracker.success(`Benched ${id}`);
+}
+async function agentActivateCommand(id) {
+  const cwd = process.cwd();
+  const tracker = log.command("agent-activate").start(`Activating agent ${id}`, { cwd });
+  const profile = loadProfile(cwd, id);
+  if (!profile) {
+    console.log(chalk.red(`
+  Agent "${id}" not found.
+`));
+    tracker.error("Not found");
+    return;
+  }
+  profile.benched = false;
+  profile.updated = (/* @__PURE__ */ new Date()).toISOString();
+  saveProfile(cwd, id, profile);
+  console.log(chalk.green(`
+  \u25B6 Agent "${id}" is now active.`));
+  console.log(chalk.gray("  Maestro will include this agent in orchestration.\n"));
+  tracker.success(`Activated ${id}`);
+}
+function saveProfile(rootDir, id, profile) {
+  const projectPath = path.join(rootDir, PROJECT_AGENTS_DIR, `${id}${AGENT_EXT}`);
+  if (fs.existsSync(projectPath)) {
+    fs.writeFileSync(projectPath, yaml.dump(profile, { lineWidth: 120, noRefs: true, sortKeys: false }), "utf-8");
+    return;
+  }
+  const globalPath = path.join(GLOBAL_AGENTS_DIR, `${id}${AGENT_EXT}`);
+  const dir = GLOBAL_AGENTS_DIR;
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(globalPath, yaml.dump(profile, { lineWidth: 120, noRefs: true, sortKeys: false }), "utf-8");
+}
 function loadProfile(rootDir, id) {
   const projectPath = path.join(rootDir, PROJECT_AGENTS_DIR, `${id}${AGENT_EXT}`);
   if (fs.existsSync(projectPath)) {
@@ -380,8 +513,11 @@ function scanLoreDir(lorePath) {
   return entries;
 }
 export {
+  agentActivateCommand,
+  agentBenchCommand,
   agentCreateCommand,
   agentListCommand,
+  agentRosterCommand,
   agentShowCommand,
   agentSyncCommand
 };

package/dist/{agent-loader-SJPJJS33.js → agent-loader-DBF4OARL.js}

@@ -15,7 +15,7 @@ import {
   updateExpertiseFromAssessment,
   updateExpertiseFromLore,
   verifyIntegrity
-} from "./chunk-A2L4TSLZ.js";
+} from "./chunk-ITPJJIHG.js";
 import "./chunk-7N7GSU6K.js";
 init_agent_loader();
 export {

package/dist/{chunk-GGMI6C2L.js → chunk-B2RC3HEB.js}

@@ -4,7 +4,7 @@ import {
   loadAgentProfile,
   loadAllAgentProfiles,
   saveAgentProfile
-} from "./chunk-A2L4TSLZ.js";
+} from "./chunk-ITPJJIHG.js";
 import {
   init_journal_loader,
   journal_loader_exports
@@ -493,6 +493,7 @@ function processEvent(rootDir, event) {
   const scores = [];
   for (const profile of profiles) {
     if (!profile.attention) continue;
+    if (profile.benched) continue;
     if (event.path && !canObservePath(policy, event.path, profile.id)) {
       continue;
     }
@@ -685,7 +686,7 @@ function loadDebates(rootDir) {
     return [];
   }
 }
-function engageNomination(rootDir, nominationId, response) {
+function engageNomination(rootDir, nominationId, response, reason) {
   const filePath = getNominationsPath(rootDir);
   if (!fs4.existsSync(filePath)) return false;
   try {
@@ -698,6 +699,7 @@ function engageNomination(rootDir, nominationId, response) {
         if (nom.id === nominationId) {
           nom.engaged = true;
           nom.response = response;
+          if (reason) nom.reason = reason;
           found = true;
           return JSON.stringify(nom);
         }
@@ -846,8 +848,12 @@ function adjustAttentionFromFeedback(rootDir, agentId) {
     return { adjusted: false, oldThreshold: 0.6, newThreshold: 0.6, reason: "No attention config" };
   }
   const oldThreshold = profile.attention.threshold ?? 0.6;
-  const nominations = loadNominations(rootDir, { agent: agentId });
-  const engaged = nominations.filter((n) => n.engaged);
+  const STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
+  const allNominations = loadNominations(rootDir, { agent: agentId });
+  const active = allNominations.filter(
+    (n) => n.engaged || Date.now() - new Date(n.timestamp).getTime() < STALE_THRESHOLD_MS
+  );
+  const engaged = active.filter((n) => n.engaged);
   if (engaged.length < 5) {
     return { adjusted: false, oldThreshold, newThreshold: oldThreshold, reason: `Insufficient data (${engaged.length}/5 engaged nominations)` };
   }
@@ -881,7 +887,11 @@ function adjustAttentionFromFeedback(rootDir, agentId) {
   return { adjusted: true, oldThreshold, newThreshold, reason };
 }
 function getNominationStats(rootDir, agentId) {
-  const nominations = loadNominations(rootDir, { agent: agentId });
+  const STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
+  const allNominations = loadNominations(rootDir, { agent: agentId });
+  const nominations = allNominations.filter(
+    (n) => n.engaged || Date.now() - new Date(n.timestamp).getTime() < STALE_THRESHOLD_MS
+  );
   const accepted = nominations.filter((n) => n.response === "accepted").length;
   const dismissed = nominations.filter((n) => n.response === "dismissed").length;
   const deferred = nominations.filter((n) => n.response === "deferred").length;
@@ -896,6 +906,57 @@ function getNominationStats(rootDir, agentId) {
     acceptRate: engaged > 0 ? accepted / engaged : 0
   };
 }
+function getNeverlandMetrics(rootDir) {
+  const profiles = loadAllAgentProfiles(rootDir);
+  const agentMetrics = profiles.filter((p) => !p.benched).map((p) => {
+    const stats = getNominationStats(rootDir, p.id);
+    let notebookCount = 0;
+    try {
+      const nbDir = path4.join(os2.homedir(), ".paradigm", "notebooks", p.id);
+      if (fs4.existsSync(nbDir)) {
+        notebookCount = fs4.readdirSync(nbDir).filter((f) => f.endsWith(".yaml")).length;
+      }
+    } catch {
+    }
+    return {
+      id: p.id,
+      acceptRate: stats.acceptRate,
+      threshold: p.attention?.threshold ?? 0.5,
+      expertiseCount: (p.expertise || []).length,
+      notebookCount,
+      transferableCount: (p.transferable || []).length,
+      totalNominations: stats.total
+    };
+  });
+  const count = agentMetrics.length || 1;
+  const avgAcceptRate = agentMetrics.reduce((s, a) => s + a.acceptRate, 0) / count;
+  const avgThreshold = agentMetrics.reduce((s, a) => s + a.threshold, 0) / count;
+  const totalExpertise = agentMetrics.reduce((s, a) => s + a.expertiseCount, 0);
+  const totalNotebooks = agentMetrics.reduce((s, a) => s + a.notebookCount, 0);
+  const totalTransferable = agentMetrics.reduce((s, a) => s + a.transferableCount, 0);
+  const totalNominations = agentMetrics.reduce((s, a) => s + a.totalNominations, 0);
+  let healthStatus;
+  if (totalNominations < 10) {
+    healthStatus = "cold-start";
+  } else if (avgAcceptRate < 0.5) {
+    healthStatus = "accumulating";
+  } else if (avgAcceptRate < 0.7) {
+    healthStatus = "calibrating";
+  } else {
+    healthStatus = "mature";
+  }
+  return {
+    agents: agentMetrics,
+    aggregate: {
+      avgAcceptRate,
+      avgThreshold,
+      totalExpertise,
+      totalNotebooks,
+      totalTransferable
+    },
+    healthStatus
+  };
+}
 function forwardNominationsToRelay(rootDir, nominations) {
   if (nominations.length === 0) return;
   const outboxDir = path4.join(os2.homedir(), ".paradigm", "score", "outbox");
@@ -935,10 +996,9 @@ function autoPromoteJournalEntries(rootDir, agentId) {
   } catch {
     return { promoted: 0, entries: [] };
   }
-  const journal = loadJournalEntries(agentId, {
-    trigger: "pattern_discovered",
-    limit: 100
-  });
+  const patternEntries = loadJournalEntries(agentId, { trigger: "pattern_discovered", limit: 100 });
+  const feedbackEntries = loadJournalEntries(agentId, { trigger: "human_feedback", limit: 100 });
+  const journal = [...patternEntries, ...feedbackEntries];
   const promoted = [];
   for (const entry of journal) {
     if (entry.promoted_to_notebook) continue;
@@ -1067,6 +1127,7 @@ export {
   emitAndProcess,
   adjustAttentionFromFeedback,
   getNominationStats,
+  getNeverlandMetrics,
   forwardNominationsToRelay,
   autoPromoteJournalEntries,
   loadSurfacingConfig,

package/dist/{chunk-A2L4TSLZ.js → chunk-ITPJJIHG.js}

@@ -13,21 +13,24 @@ var init_agents = __esm({
       builder: { style: "rapid", risk: "balanced", verbosity: "concise" },
       tester: { style: "methodical", risk: "conservative", verbosity: "concise" },
       reviewer: { style: "deliberate", risk: "conservative", verbosity: "detailed" },
-      security: { style: "methodical", risk: "conservative", verbosity: "detailed" }
+      security: { style: "methodical", risk: "conservative", verbosity: "detailed" },
+      documentor: { style: "methodical", risk: "conservative", verbosity: "concise" }
     };
     DEFAULT_ATTENTION = {
       architect: { symbols: ["$*", "#*"], concepts: ["architecture", "design", "pattern", "refactor"], signals: [{ type: "flow-modified" }, { type: "compliance-violation" }], threshold: 0.5 },
       builder: { paths: ["src/**", "lib/**", "packages/**"], signals: [{ type: "file-modified" }, { type: "error-encountered" }], threshold: 0.7 },
       reviewer: { concepts: ["code quality", "bug", "smell", "convention"], signals: [{ type: "compliance-violation" }], threshold: 0.6 },
       tester: { paths: ["**/*.test.*", "**/*.spec.*"], concepts: ["test", "coverage", "assertion"], signals: [{ type: "error-encountered" }, { type: "test-result" }], threshold: 0.5 },
-      security: { symbols: ["^*", "#*-auth", "#*-middleware"], paths: ["auth/**", "middleware/**", "guards/**"], concepts: ["permission", "JWT", "session", "RBAC", "XSS", "injection"], signals: [{ type: "gate-added" }, { type: "route-created" }, { type: "gate-checked" }, { type: "compliance-violation" }], threshold: 0.4 }
+      security: { symbols: ["^*", "#*-auth", "#*-middleware"], paths: ["auth/**", "middleware/**", "guards/**"], concepts: ["permission", "JWT", "session", "RBAC", "XSS", "injection"], signals: [{ type: "gate-added" }, { type: "route-created" }, { type: "gate-checked" }, { type: "compliance-violation" }], threshold: 0.4 },
+      documentor: { paths: ["**/.purpose", "**/portal.yaml", ".paradigm/**"], concepts: ["purpose", "portal", "symbol", "documentation", "component", "gate", "flow"], signals: [{ type: "file-modified" }, { type: "compliance-violation" }, { type: "work-completed" }], threshold: 0.3 }
     };
     DEFAULT_COLLABORATION = {
       architect: { stance: "lead", debate: { will_challenge: true, evidence_required: true, escalate_to_human: true } },
       builder: { stance: "supportive", with: { architect: { stance: "supportive", can_contradict: false } } },
       reviewer: { stance: "advisory", debate: { will_challenge: true, evidence_required: true, escalate_to_human: true } },
       tester: { stance: "supportive", debate: { will_challenge: false, evidence_required: true, escalate_to_human: false } },
-      security: { stance: "advisory", with: { architect: { stance: "peer", can_contradict: true }, builder: { stance: "advisory", review_output: true } }, debate: { will_challenge: true, evidence_required: true, escalate_to_human: true } }
+      security: { stance: "advisory", with: { architect: { stance: "peer", can_contradict: true }, builder: { stance: "advisory", review_output: true } }, debate: { will_challenge: true, evidence_required: true, escalate_to_human: true } },
+      documentor: { stance: "supportive", with: { architect: { stance: "supportive" }, builder: { stance: "supportive" }, reviewer: { stance: "supportive" }, security: { stance: "supportive" } }, debate: { will_challenge: false, evidence_required: false, escalate_to_human: false } }
     };
   }
 });

package/dist/chunk-SDDCVUCV.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import {
+  __esm,
+  __export
+} from "./chunk-7N7GSU6K.js";
+
+// ../paradigm-mcp/src/utils/session-work-log.ts
+var session_work_log_exports = {};
+__export(session_work_log_exports, {
+  appendSessionWorkEntry: () => appendSessionWorkEntry,
+  clearSessionWorkLog: () => clearSessionWorkLog,
+  getAgentEntries: () => getAgentEntries,
+  getAgentVerdicts: () => getAgentVerdicts,
+  getContributingAgents: () => getContributingAgents,
+  readSessionWorkLog: () => readSessionWorkLog
+});
+import * as fs from "fs";
+import * as path from "path";
+function appendSessionWorkEntry(rootDir, entry) {
+  try {
+    const filePath = path.join(rootDir, SESSION_LOG_FILE);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, "utf8");
+      const lineCount = content.trim().split("\n").filter((l) => l.trim()).length;
+      if (lineCount >= MAX_ENTRIES) return;
+    }
+    const line = JSON.stringify(entry) + "\n";
+    fs.appendFileSync(filePath, line, "utf8");
+  } catch {
+  }
+}
+function readSessionWorkLog(rootDir) {
+  try {
+    const filePath = path.join(rootDir, SESSION_LOG_FILE);
+    if (!fs.existsSync(filePath)) return [];
+    return fs.readFileSync(filePath, "utf8").trim().split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+  } catch {
+    return [];
+  }
+}
+function clearSessionWorkLog(rootDir) {
+  try {
+    const filePath = path.join(rootDir, SESSION_LOG_FILE);
+    if (fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, "", "utf8");
+    }
+  } catch {
+  }
+}
+function getContributingAgents(rootDir) {
+  const entries = readSessionWorkLog(rootDir);
+  const agents = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.agent) agents.add(entry.agent);
+  }
+  return Array.from(agents);
+}
+function getAgentEntries(rootDir, agentId) {
+  return readSessionWorkLog(rootDir).filter((e) => e.agent === agentId);
+}
+function getAgentVerdicts(rootDir, agentId) {
+  const entries = getAgentEntries(rootDir, agentId);
+  const contributions = entries.filter((e) => e.type === "agent-contribution");
+  const verdicts = entries.filter((e) => e.type === "user-verdict");
+  const pairs = [];
+  for (const contrib of contributions) {
+    pairs.push({ contribution: contrib });
+  }
+  for (const verdict of verdicts) {
+    const unpaired = pairs.find((p) => !p.verdict && p.contribution);
+    if (unpaired) {
+      unpaired.verdict = verdict;
+    } else {
+      pairs.push({ verdict });
+    }
+  }
+  return pairs;
+}
+var SESSION_LOG_FILE, MAX_ENTRIES;
+var init_session_work_log = __esm({
+  "../paradigm-mcp/src/utils/session-work-log.ts"() {
+    SESSION_LOG_FILE = ".paradigm/events/session-log.jsonl";
+    MAX_ENTRIES = 200;
+  }
+});
+
+export {
+  appendSessionWorkEntry,
+  readSessionWorkLog,
+  clearSessionWorkLog,
+  getContributingAgents,
+  getAgentEntries,
+  getAgentVerdicts,
+  session_work_log_exports,
+  init_session_work_log
+};

package/dist/{chunk-S6MZ2IEX.js → chunk-SU3WDCRR.js}

@@ -1,14 +1,18 @@
 #!/usr/bin/env node
-import {
-  init_lore_loader,
-  loadLoreEntries,
-  loadLoreEntry
-} from "./chunk-5VKJBNJL.js";
 import {
   checkComponentAnchors,
   checkIntegrity,
   checkPurposeHealth
 } from "./chunk-L27I3CPZ.js";
+import {
+  init_session_work_log,
+  session_work_log_exports
+} from "./chunk-SDDCVUCV.js";
+import {
+  init_lore_loader,
+  loadLoreEntries,
+  loadLoreEntry
+} from "./chunk-5VKJBNJL.js";
 import {
   __esm,
   __export,
@@ -2113,6 +2117,11 @@ var SessionTracker = class {
    */
   setRootDir(rootDir) {
     this.rootDir = rootDir;
+    try {
+      const { clearSessionWorkLog } = (init_session_work_log(), __toCommonJS(session_work_log_exports));
+      clearSessionWorkLog(rootDir);
+    } catch {
+    }
   }
   createNewSession() {
     return {
@@ -3223,7 +3232,7 @@ async function buildRecoveryPreamble(rootDir) {
   } catch {
   }
   try {
-    const { loadNominations } = await import("./nomination-engine-Q4XSXFKT.js");
+    const { loadNominations } = await import("./nomination-engine-LPLCCDW2.js");
     const urgent = loadNominations(rootDir, { pending_only: true }).filter((n) => n.urgency === "critical" || n.urgency === "high");
     if (urgent.length > 0) {
       lines.push("");

package/dist/{docs-LVLRPBAW.js → docs-J2BTKRVU.js}

@@ -17,7 +17,7 @@ async function docsServeCommand(options) {
   const shouldOpen = options.open !== false;
   console.log(chalk.cyan("\n  Starting Paradigm Docs...\n"));
   try {
-    const { startPlatformServer } = await import("./platform-server-PMD57BEG.js");
+    const { startPlatformServer } = await import("./platform-server-2D6S6YTK.js");
     await startPlatformServer({
       projectDir,
       port,

package/dist/index.js

@@ -719,7 +719,7 @@ loreCmd.option("-p, --port <port>", "Port to run on", "3840").option("--no-open"
   await loreServeCommand(void 0, options);
 });
 program.command("serve").description("Launch Paradigm Platform \u2014 unified development management UI").option("-p, --port <port>", "Port to run on", "3850").option("--no-open", "Don't open browser automatically").option("--sections <list>", "Comma-separated sections to enable (e.g., lore,graph,git)").action(async (options) => {
-  const { serveCommand } = await import("./serve-FLTFTM3P.js");
+  const { serveCommand } = await import("./serve-EFVRS4GA.js");
   await serveCommand(options);
 });
 var graphCmd = program.command("graph").description("Interactive symbol relationship graph").argument("[path]", "Project directory", void 0).option("-p, --port <port>", "Port to run on", "3841").option("--no-open", "Don't open browser automatically").action(async (path2, options) => {
@@ -857,15 +857,15 @@ universityCmd.option("-p, --port <port>", "Port to run on", "3839").option("--no
 });
 var docsCmd = program.command("docs").description("Auto-generated documentation from the symbol graph");
 docsCmd.command("serve").description("Launch interactive docs viewer in browser").option("-p, --port <port>", "Port number (default: 3850)").option("--no-open", "Do not open browser automatically").action(async (options) => {
-  const { docsServeCommand } = await import("./docs-LVLRPBAW.js");
+  const { docsServeCommand } = await import("./docs-J2BTKRVU.js");
   await docsServeCommand(options);
 });
 docsCmd.command("build").description("Build static documentation site").option("-o, --output <dir>", "Output directory (default: from config or .paradigm/docs-site)").action(async (options) => {
-  const { docsBuildCommand } = await import("./docs-LVLRPBAW.js");
+  const { docsBuildCommand } = await import("./docs-J2BTKRVU.js");
   await docsBuildCommand(options);
 });
 docsCmd.action(async () => {
-  const { docsServeCommand } = await import("./docs-LVLRPBAW.js");
+  const { docsServeCommand } = await import("./docs-J2BTKRVU.js");
   await docsServeCommand({});
 });
 var pipelineCmd = program.command("pipeline").description("Spec pipeline \u2014 structured feature workflow with configurable gates");
@@ -1006,23 +1006,35 @@ notebookCmd.action(async () => {
 });
 var agentCmd = program.command("agent").description("Agent identity management \u2014 persistent profiles with expertise tracking");
 agentCmd.command("list").alias("ls").description("List all agent identity profiles").option("--json", "Output as JSON").option("--global", "Show only global profiles").option("--project", "Show only project-level profiles").action(async (options) => {
-  const { agentListCommand } = await import("./agent-HYKC2LAK.js");
+  const { agentListCommand } = await import("./agent-WERIO2XV.js");
   await agentListCommand(options);
 });
 agentCmd.command("show <id>").description("Show full agent profile with expertise table").option("--json", "Output as JSON").action(async (id, options) => {
-  const { agentShowCommand } = await import("./agent-HYKC2LAK.js");
+  const { agentShowCommand } = await import("./agent-WERIO2XV.js");
   await agentShowCommand(id, options);
 });
 agentCmd.command("create <id>").description("Create a new .agent identity file").option("-r, --role <role>", "Agent role description").option("-d, --description <desc>", "Extended description").option("-g, --global", "Create in global ~/.paradigm/agents/ (default)").option("--deny-paths <patterns>", 'Comma-separated glob patterns to deny (e.g., ".env*,*.key")').action(async (id, options) => {
-  const { agentCreateCommand } = await import("./agent-HYKC2LAK.js");
+  const { agentCreateCommand } = await import("./agent-WERIO2XV.js");
   await agentCreateCommand(id, { ...options, global: options.global !== false });
 });
 agentCmd.command("sync <id>").description("Bootstrap expertise from existing project lore").option("-n, --dry-run", "Show what would change without writing").option("--json", "Output as JSON").action(async (id, options) => {
-  const { agentSyncCommand } = await import("./agent-HYKC2LAK.js");
+  const { agentSyncCommand } = await import("./agent-WERIO2XV.js");
   await agentSyncCommand(id, options);
 });
+agentCmd.command("roster").description("Show agent roster with active/benched status").option("--json", "Output as JSON").action(async (options) => {
+  const { agentRosterCommand } = await import("./agent-WERIO2XV.js");
+  await agentRosterCommand(options);
+});
+agentCmd.command("bench <id>").description("Bench an agent \u2014 Maestro will skip it during orchestration").action(async (id) => {
+  const { agentBenchCommand } = await import("./agent-WERIO2XV.js");
+  await agentBenchCommand(id);
+});
+agentCmd.command("activate <id>").description("Activate a benched agent \u2014 restore to Maestro orchestration").action(async (id) => {
+  const { agentActivateCommand } = await import("./agent-WERIO2XV.js");
+  await agentActivateCommand(id);
+});
 agentCmd.action(async () => {
-  const { agentListCommand } = await import("./agent-HYKC2LAK.js");
+  const { agentListCommand } = await import("./agent-WERIO2XV.js");
   await agentListCommand({});
 });
 program.parse();