getprismo 0.1.25 → 0.1.26

package/README.md

@@ -552,6 +552,16 @@ watch reads local session logs from codex and claude code. it detects:
 
 watch tells you the single most useful action to take right now. usually: start a fresh session, or switch to a scoped context pack.
 
+if you run multiple agents in the same repo, use:
+
+```bash
+npx getprismo watch --agents
+```
+
+multi-agent watch shows every visible local Codex/Claude Code session for the repo, ranks each agent by context pressure, and flags coordination risks like two agents repeatedly loading the same file, shared artifact leaks, multiple high-pressure sessions, or agents that should move noisy commands into `shield`.
+
+the same multi-agent coordination signal is included in `usage --json`, `scan --usage --json`, doctor output, and the generated markdown report whenever multiple local sessions are visible for the repo.
+
 `watch --rescue` prints a paste-ready prompt for the active coding session. use it when the agent is looping, reading too many files, or flooding context with logs:
 
 ```bash
@@ -644,6 +654,8 @@ npx getprismo doctor --json              # machine-readable output
 ```bash
 npx getprismo watch                      # live refresh
 npx getprismo watch --once               # single snapshot
+npx getprismo watch --agents             # multi-agent coordination view
+npx getprismo watch --agents --json      # machine-readable multi-agent state
 npx getprismo watch --once --report      # write .prismo/watch-report.md
 npx getprismo watch --once --json        # machine-readable
 npx getprismo watch --auto               # guardrails + throttle + 600k budget
@@ -681,6 +693,7 @@ npx getprismo mcp /path/to/repo
 - `prismo_scan`
 - `prismo_doctor_dry_run`
 - `prismo_watch_snapshot`
+- `prismo_multi_agent_watch`
 - `prismo_shield_run`
 - `prismo_shield_search`
 - `prismo_shield_last`
@@ -688,7 +701,7 @@ npx getprismo mcp /path/to/repo
 - `prismo_firewall`
 - `prismo_cc_timeline`
 
-This lets an MCP-compatible agent search prior shielded test/build output, request scoped context packs, or inspect token-waste signals without pasting giant logs into the conversation.
+This lets an MCP-compatible agent search prior shielded test/build output, request scoped context packs, inspect token-waste signals, or coordinate multiple local agents without pasting giant logs into the conversation.
 
 Generic MCP client config:
 

package/docs/mcp.md

@@ -49,6 +49,7 @@ For local development from this repo:
 - `prismo_scan`: scan repo context/token waste
 - `prismo_doctor_dry_run`: preview doctor payoff without writing files
 - `prismo_watch_snapshot`: inspect live context pressure
+- `prismo_multi_agent_watch`: inspect coordination risks across parallel local agents
 - `prismo_shield_run`: run a noisy command and store full output locally
 - `prismo_shield_search`: search stored shield output
 - `prismo_shield_last`: list recent shielded command runs

package/lib/prismo-dev/doctor.js

@@ -324,6 +324,7 @@ function toDoctorJsonPayload(result) {
         confidence: usage.confidence,
         totals: usage.totals,
         sources: usage.sources,
+        multiAgent: usage.multiAgent || null,
       }
     : null;
   return {
@@ -381,6 +382,13 @@ function renderDoctorTerminal(result) {
   if (result.before.realUsage && result.before.realUsage.sessions.length) {
     lines.push(`Local usage: ${formatTokenCount(result.before.realUsage.totals.displayTokens)} tokens across ${result.before.realUsage.sessions.length} recent session(s)`);
   }
+  const multiAgent = result.before.realUsage && result.before.realUsage.multiAgent;
+  if (multiAgent && multiAgent.agentCount > 1) {
+    lines.push(`Multi-agent: ${multiAgent.agentCount} agents visible; highest pressure ${multiAgent.highestPressure}`);
+    if (multiAgent.coordinationWarnings && multiAgent.coordinationWarnings[0]) {
+      lines.push(`Coordination warning: ${multiAgent.coordinationWarnings[0]}`);
+    }
+  }
   if (!(result.dryRun && result.applySuggestions)) lines.push(`Estimated exposed context reduction: ${result.exposedTokenReductionPercent}%`);
   if (!result.dryRun) {
     lines.push(`Payoff: ${scoreDelta > 0 ? `repo is ${scoreDelta} points cleaner for AI coding sessions` : "safe fixes applied; remaining risk needs manual cleanup"}`);
@@ -457,6 +465,10 @@ function renderDevTerminal(result) {
   } else if (result.scan.realUsage) {
     lines.push("Real local usage: no matching local sessions found for this repo");
   }
+  const multiAgent = result.scan.realUsage && result.scan.realUsage.multiAgent;
+  if (multiAgent && multiAgent.agentCount > 1) {
+    lines.push(`Multi-agent: ${multiAgent.agentCount} agents visible; highest pressure ${multiAgent.highestPressure}`);
+  }
   lines.push("");
   lines.push("Generated:");
   result.optimize.generatedFiles.slice(0, 8).forEach((file) => lines.push(`- ${file}`));

package/lib/prismo-dev/mcp.js

@@ -69,6 +69,11 @@ function createMcpTools(deps) {
       tool: { type: "string", enum: ["all", "codex", "claude"], description: "Which local session logs to inspect." },
       limit: limitProperty,
     }),
+    makeTool("prismo_multi_agent_watch", "Return multi-agent coordination risks across visible local Codex/Claude sessions.", {
+      path: pathProperty,
+      tool: { type: "string", enum: ["all", "codex", "claude"], description: "Which local session logs to inspect." },
+      limit: limitProperty,
+    }),
     makeTool("prismo_shield_run", "Run a noisy command through Prismo shield and store full output locally.", {
       path: pathProperty,
       command: {
@@ -131,11 +136,27 @@ function createMcpTools(deps) {
       const summary = getUsageSummary({
         cwd: target,
         limit: Number(args.limit) || 3,
-        usageTool: args.tool || "all",
+        tool: args.tool || "all",
       });
       return createTextResult(summary);
     }
 
+    if (name === "prismo_multi_agent_watch") {
+      const summary = getUsageSummary({
+        cwd: target,
+        limit: Number(args.limit) || 8,
+        tool: args.tool || "all",
+      });
+      return createTextResult({
+        schemaVersion: 1,
+        generatedAt: summary.generatedAt,
+        scannedPath: summary.scannedPath,
+        tool: summary.tool,
+        totals: summary.totals,
+        multiAgent: summary.multiAgent,
+      });
+    }
+
     if (name === "prismo_shield_run") {
       return createTextResult(runShield(target, args.command));
     }
@@ -265,6 +286,7 @@ async function runMcpDoctor(deps) {
     "prismo_scan",
     "prismo_doctor_dry_run",
     "prismo_watch_snapshot",
+    "prismo_multi_agent_watch",
     "prismo_shield_run",
     "prismo_shield_search",
     "prismo_shield_last",
@@ -315,7 +337,7 @@ async function runMcpDoctor(deps) {
     next: [
       "Add the config snippet to your MCP-compatible client.",
       "Restart the client and confirm prismodev appears in the MCP tool list.",
-      "Ask the agent to call prismo_scan or prismo_shield_run.",
+      "Ask the agent to call prismo_scan, prismo_multi_agent_watch, or prismo_shield_run.",
     ],
   };
 }

package/lib/prismo-dev/report.js

@@ -45,6 +45,10 @@ function renderTerminalReport(result, options = {}) {
   if (result.realUsage && result.realUsage.sessions.length) {
     lines.push(`- Real local usage: ${formatTokenCount(result.realUsage.totals.displayTokens)} tokens across ${result.realUsage.sessions.length} session(s)`);
     lines.push(`- Usage confidence: ${result.realUsage.confidence}`);
+    if (result.realUsage.multiAgent && result.realUsage.multiAgent.agentCount > 1) {
+      lines.push(`- Multi-agent: ${result.realUsage.multiAgent.agentCount} agents visible; highest pressure ${result.realUsage.multiAgent.highestPressure}`);
+      if (result.realUsage.multiAgent.coordinationWarnings[0]) lines.push(`- Coordination warning: ${result.realUsage.multiAgent.coordinationWarnings[0]}`);
+    }
   } else if (result.realUsage) {
     lines.push("- Real local usage: no matching local Codex/Claude Code sessions found for this repo");
   }
@@ -116,6 +120,9 @@ function renderOptimizerFitTerminal(result, options = {}) {
   lines.push(`Primary bottleneck: ${color(fit.summary, tone, useColor)}`);
   if (result.realUsage && result.realUsage.sessions.length) {
     lines.push(`Local usage: ${formatTokenCount(result.realUsage.totals.displayTokens)} tokens across ${result.realUsage.sessions.length} session(s)`);
+    if (result.realUsage.multiAgent && result.realUsage.multiAgent.agentCount > 1) {
+      lines.push(`Multi-agent: ${result.realUsage.multiAgent.agentCount} agents visible; highest pressure ${result.realUsage.multiAgent.highestPressure}`);
+    }
   } else if (result.realUsage) {
     lines.push("Local usage: no matching local Claude/Codex sessions found");
   }
@@ -261,6 +268,9 @@ function renderMarkdownReport(result) {
   if (result.realUsage) {
     lines.push(`- **Real Local Usage:** ${result.realUsage.totals.displayTokens.toLocaleString()} tokens across ${result.realUsage.sessions.length} session(s)`);
     lines.push(`- **Usage Confidence:** ${result.realUsage.confidence}`);
+    if (result.realUsage.multiAgent && result.realUsage.multiAgent.agentCount > 1) {
+      lines.push(`- **Multi-Agent:** ${result.realUsage.multiAgent.agentCount} agents visible; highest pressure ${result.realUsage.multiAgent.highestPressure}`);
+    }
   }
   lines.push("");
   lines.push("Estimates are based on local file-size and configuration heuristics. They are not provider billing data and are not guaranteed savings.");
@@ -346,6 +356,20 @@ function renderMarkdownReport(result) {
     lines.push(`- Estimated tool/output tokens: ${result.realUsage.totals.toolTokens.toLocaleString()}`);
     lines.push(`- Confidence: ${result.realUsage.confidence}`);
     lines.push("");
+    if (result.realUsage.multiAgent && result.realUsage.multiAgent.agentCount > 1) {
+      lines.push("### Multi-Agent Coordination");
+      lines.push("");
+      lines.push(`- Agents visible: ${result.realUsage.multiAgent.agentCount}`);
+      lines.push(`- Highest pressure: ${result.realUsage.multiAgent.highestPressure}`);
+      result.realUsage.multiAgent.coordinationWarnings.slice(0, 5).forEach((warning) => lines.push(`- ${warning}`));
+      if (result.realUsage.multiAgent.sharedFiles.length) {
+        lines.push(`- Shared repeated files: ${result.realUsage.multiAgent.sharedFiles.slice(0, 5).map((item) => `\`${item.path}\` (${item.agents} agents)`).join(", ")}`);
+      }
+      if (result.realUsage.multiAgent.sharedArtifacts.length) {
+        lines.push(`- Shared artifact leaks: ${result.realUsage.multiAgent.sharedArtifacts.slice(0, 5).map((item) => `${item.type} (${item.agents} agents)`).join(", ")}`);
+      }
+      lines.push("");
+    }
     result.realUsage.sessions.slice(0, 5).forEach((session, index) => {
       lines.push(`${index + 1}. ${session.tool} - ${session.title || session.sessionId}`);
       lines.push(`   - Tokens: ${session.displayTokens.toLocaleString()} (${session.confidence})`);

package/lib/prismo-dev/usage-watch.js

@@ -53,6 +53,7 @@ const {
 
 const {
   buildLiveSessionView,
+  buildMultiAgentView,
 } = require("./watch-live")({
   NPX_COMMAND,
   formatTokenCount,
@@ -65,7 +66,7 @@ const {
   getAllClaudeSessionFiles,
   getClaudeSessionFiles,
   getCodexSessionFiles,
-  getUsageSummary,
+  getUsageSummary: getBaseUsageSummary,
 } = require("./usage-sessions")({
   fs,
   os,
@@ -76,15 +77,25 @@ const {
   readIfText,
 });
 
+function getUsageSummary(options = {}) {
+  const summary = getBaseUsageSummary(options);
+  if ((summary.sessions || []).length > 1) {
+    summary.multiAgent = buildMultiAgentView(summary);
+  }
+  return summary;
+}
+
 const {
   renderContextThrottle,
   renderLiveGuardrails,
+  renderMultiAgentWatchTerminal,
   renderRescuePrompt,
   renderUsageTerminal,
   renderWatchTerminal,
 } = require("./watch-render")({
   NPX_COMMAND,
   buildLiveSessionView,
+  buildMultiAgentView,
   color,
   formatTokenCount,
   getActionableRepeatedPaths,
@@ -199,24 +210,6 @@ function parseScopeAndTarget(args, valueFlags = new Set()) {
   return { scope: null, target: positional[0] || process.cwd() };
 }
 
-function formatTokenCount(value) {
-  const n = Number(value || 0);
-  if (n >= 1000000) return `${(n / 1000000).toFixed(2)}M`;
-  if (n >= 1000) return `${Math.round(n / 1000)}k`;
-  return String(Math.round(n));
-}
-
-function formatMoney(value) {
-  const n = Number(value || 0);
-  if (n >= 1) return `$${n.toFixed(2)}`;
-  return `$${n.toFixed(4)}`;
-}
-
-
-
-
-
-
 function writeLiveFile(root, relPath, contents) {
   const fullPath = path.join(root || process.cwd(), relPath);
   fs.mkdirSync(path.dirname(fullPath), { recursive: true });
@@ -432,6 +425,7 @@ function compactUsageSummary(summary) {
     totals: summary.totals,
     sources: summary.sources,
     sessions: (summary.sessions || []).map(compactWatchSession),
+    multiAgent: summary.multiAgent || ((summary.sessions || []).length > 1 ? buildMultiAgentView(summary) : null),
   };
 }
 
@@ -484,6 +478,7 @@ function toWatchJsonPayload(summary) {
     sources: summary.sources,
     sessions: summary.sessions.map(compactWatchSession),
     live: summary.live || buildLiveSessionView(summary),
+    multiAgent: summary.multiAgent || (summary.agents ? buildMultiAgentView(summary) : null),
     auto: Boolean(summary.auto),
     rescuePrompt: summary.includeRescuePrompt ? renderRescuePrompt(summary) : null,
     guardrailsPath: summary.guardrailsPath || null,
@@ -502,7 +497,11 @@ async function watchUsage(options = {}) {
   for (let i = 0; i < iterations; i += 1) {
     const summary = getUsageSummary(options);
     summary.auto = Boolean(options.auto);
+    summary.agents = Boolean(options.agents);
     summary.live = buildLiveSessionView(summary);
+    if (options.agents) {
+      summary.multiAgent = buildMultiAgentView(summary);
+    }
     if (options.guardrails) {
       const written = writeLiveGuardrails(summary);
       summary.guardrailsPath = written.guardrailsPath;
@@ -524,7 +523,11 @@ async function watchUsage(options = {}) {
     }
     summary.redactPaths = Boolean(options.redactPaths);
     summary.includeRescuePrompt = Boolean(options.rescue);
-    if (options.rescue && !options.json) {
+    if (options.agents && !options.json) {
+      console.clear();
+      console.log(renderMultiAgentWatchTerminal(summary));
+      if (!options.once) console.log(`\nRefreshing every ${Math.round(intervalMs / 1000)}s. Press Ctrl+C to stop.`);
+    } else if (options.rescue && !options.json) {
       console.log(renderRescuePrompt(summary));
     } else if (options.json) {
       console.log(JSON.stringify(toWatchJsonPayload(summary), null, 2));

package/lib/prismo-dev/watch-live.js

@@ -345,8 +345,111 @@ module.exports = function createWatchLive(deps) {
     };
   }
 
+  function agentLabel(session, index) {
+    const tool = session.tool === "claude-code" ? "claude" : session.tool || "agent";
+    const id = String(session.sessionId || index + 1).slice(0, 8);
+    return `${tool}-${id}`;
+  }
+
+  function buildMultiAgentView(summary) {
+    const agents = (summary.sessions || []).map((session, index) => {
+      const singleSummary = {
+        ...summary,
+        sessions: [session],
+        totals: {
+          sessions: 1,
+          displayTokens: session.displayTokens || 0,
+          contextTokens: session.contextTokens || 0,
+          estimatedTokens: session.estimatedTotalTokens || 0,
+          exactTokens: session.exactAvailable ? session.exactTotalTokens || 0 : 0,
+          toolTokens: session.estimatedToolTokens || 0,
+        },
+      };
+      const live = buildLiveSessionView(singleSummary);
+      return {
+        label: agentLabel(session, index),
+        tool: session.tool,
+        sessionId: session.sessionId,
+        title: session.title,
+        model: session.model,
+        updatedAt: session.updatedAt,
+        contextPressure: live.contextPressure,
+        tokens: session.displayTokens || 0,
+        contextTokens: session.contextTokens || 0,
+        toolOutputTokens: session.estimatedToolTokens || 0,
+        turns: session.turns || 0,
+        toolCalls: session.toolCalls || 0,
+        liveAction: live.liveAction,
+        warnings: live.warnings,
+        repeatedFiles: live.activeSession?.actionableRepeatedPaths || [],
+        artifactGroups: live.activeSession?.generatedArtifactGroups || [],
+        repeatedCommands: session.repeatedCommands || [],
+      };
+    });
+
+    const warnings = [];
+    const highPressureAgents = agents.filter((agent) => agent.contextPressure === "High");
+    if (highPressureAgents.length >= 2) {
+      warnings.push(`${highPressureAgents.length} agents are under high context pressure; pause broad exploration and split work by task boundary.`);
+    }
+    const noisyAgents = agents.filter((agent) => ["tool-output-flood", "possible-loop"].includes(agent.liveAction?.cause));
+    if (noisyAgents.length) {
+      warnings.push(`${noisyAgents.length} agent${noisyAgents.length === 1 ? "" : "s"} should route noisy commands through shield before rerunning.`);
+    }
+
+    const fileOwners = new Map();
+    for (const agent of agents) {
+      for (const item of agent.repeatedFiles || []) {
+        const owners = fileOwners.get(item.value) || [];
+        owners.push({ agent: agent.label, count: item.count });
+        fileOwners.set(item.value, owners);
+      }
+    }
+    const sharedFiles = Array.from(fileOwners.entries())
+      .filter(([, owners]) => owners.length >= 2)
+      .map(([path, owners]) => ({ path, owners }))
+      .slice(0, 5);
+    for (const item of sharedFiles.slice(0, 3)) {
+      warnings.push(`${item.path} is repeatedly entering context across ${item.owners.length} agents.`);
+    }
+
+    const artifactOwners = new Map();
+    for (const agent of agents) {
+      for (const group of agent.artifactGroups || []) {
+        const owners = artifactOwners.get(group.type) || [];
+        owners.push({ agent: agent.label, count: group.count, example: group.examples?.[0] || null });
+        artifactOwners.set(group.type, owners);
+      }
+    }
+    const sharedArtifacts = Array.from(artifactOwners.entries())
+      .filter(([, owners]) => owners.length >= 2)
+      .map(([type, owners]) => ({ type, owners }))
+      .slice(0, 5);
+    for (const item of sharedArtifacts.slice(0, 2)) {
+      warnings.push(`${item.type} artifacts appear across ${item.owners.length} agents; add/verify ignore coverage before continuing.`);
+    }
+
+    const recommendedActions = [];
+    if (noisyAgents.length) recommendedActions.push(`${NPX_COMMAND} shield -- <noisy command>`);
+    if (sharedFiles.length || sharedArtifacts.length) recommendedActions.push(`${NPX_COMMAND} doctor --apply-suggestions --dry-run`);
+    if (highPressureAgents.length) recommendedActions.push("Ask each high-pressure agent for a compact handoff summary, then restart scoped sessions.");
+    if (!recommendedActions.length) recommendedActions.push("Keep agents scoped to separate files/tasks and continue watching.");
+
+    return {
+      enabled: true,
+      agentCount: agents.length,
+      agents,
+      highestPressure: agents.reduce((pressure, agent) => (getRiskRank(agent.contextPressure) > getRiskRank(pressure) ? agent.contextPressure : pressure), "Low"),
+      coordinationWarnings: Array.from(new Set(warnings)).slice(0, 8),
+      sharedFiles,
+      sharedArtifacts,
+      recommendedActions: Array.from(new Set(recommendedActions)).slice(0, 5),
+    };
+  }
+
   return {
     buildLiveSessionView,
+    buildMultiAgentView,
     getRiskRank,
     getTokenBudgetStatus,
   };

package/lib/prismo-dev/watch-render.js

@@ -2,6 +2,7 @@ module.exports = function createWatchRender(deps) {
   const {
     NPX_COMMAND,
     buildLiveSessionView,
+    buildMultiAgentView,
     color,
     formatTokenCount,
     getActionableRepeatedPaths,
@@ -33,6 +34,15 @@ function renderUsageTerminal(summary, title = "Prismo Usage") {
   }
   lines.push("");
   lines.push("Notes: exact means the local tool log exposed token fields. Estimated means Prismo used local text size heuristics only.");
+  const multi = summary.multiAgent || ((summary.sessions || []).length > 1 && buildMultiAgentView ? buildMultiAgentView(summary) : null);
+  if (multi && multi.agentCount > 1) {
+    lines.push("");
+    lines.push("Multi-Agent Coordination:");
+    lines.push(`- Agents visible: ${multi.agentCount}`);
+    lines.push(`- Highest pressure: ${multi.highestPressure}`);
+    if (multi.coordinationWarnings.length) lines.push(`- Top warning: ${multi.coordinationWarnings[0]}`);
+    lines.push(`- Live view: ${NPX_COMMAND} watch --agents`);
+  }
   return lines.join("\n");
 }
 function renderWatchTerminal(summary) {
@@ -107,6 +117,60 @@ function renderWatchTerminal(summary) {
   lines.push("Expected project instruction files are muted unless they combine with stronger context-pressure signals.");
   return lines.join("\n");
 }
+function renderMultiAgentWatchTerminal(summary) {
+  const multi = summary.multiAgent;
+  const lines = [];
+  lines.push("");
+  lines.push(color("Prismo Multi-Agent Watch", "bold"));
+  lines.push("");
+  if (!multi || !multi.agentCount) {
+    lines.push("Agents: 0");
+    lines.push("- No local Codex/Claude Code sessions detected for this repo yet.");
+    lines.push("");
+    lines.push("Suggested Action");
+    lines.push(`Run: ${NPX_COMMAND} setup`);
+    return lines.join("\n");
+  }
+
+  const pressureTone = multi.highestPressure === "High" ? "red" : multi.highestPressure === "Medium" ? "yellow" : "green";
+  lines.push(`Agents: ${multi.agentCount}`);
+  lines.push(`Highest Pressure: ${color(String(multi.highestPressure).toUpperCase(), pressureTone)}`);
+  lines.push("");
+  lines.push("Active Agents");
+  multi.agents.slice(0, 8).forEach((agent) => {
+    const tone = agent.contextPressure === "High" ? "red" : agent.contextPressure === "Medium" ? "yellow" : "green";
+    lines.push(`- ${agent.label}  ${agent.tool}  ${color(agent.contextPressure.toUpperCase(), tone)}  ${formatTokenCount(agent.tokens)} tokens  ${agent.liveAction.cause}`);
+    if (agent.updatedAt) lines.push(`  updated: ${agent.updatedAt}`);
+  });
+
+  lines.push("");
+  lines.push("Coordination Warnings");
+  if (multi.coordinationWarnings.length) multi.coordinationWarnings.forEach((warning) => lines.push(`- ${warning}`));
+  else lines.push("- No cross-agent coordination risks detected.");
+
+  if (multi.sharedFiles.length) {
+    lines.push("");
+    lines.push("Shared Repeated Files");
+    multi.sharedFiles.slice(0, 5).forEach((item) => {
+      lines.push(`- ${item.path} (${item.owners.map((owner) => `${owner.agent}:${owner.count}x`).join(", ")})`);
+    });
+  }
+
+  if (multi.sharedArtifacts.length) {
+    lines.push("");
+    lines.push("Shared Artifact Leaks");
+    multi.sharedArtifacts.slice(0, 5).forEach((item) => {
+      lines.push(`- ${item.type} (${item.owners.map((owner) => `${owner.agent}:${owner.count}x`).join(", ")})`);
+    });
+  }
+
+  lines.push("");
+  lines.push("Do This Now");
+  multi.recommendedActions.forEach((action, index) => lines.push(`${index + 1}. ${action}`));
+  lines.push("");
+  lines.push("Signals are local estimates from available coding-agent logs. Use this view to coordinate parallel agents before they duplicate work or flood context.");
+  return lines.join("\n");
+}
 function renderRescuePrompt(summary) {
   const live = summary.live || buildLiveSessionView(summary);
   const active = live.activeSession;
@@ -283,6 +347,7 @@ function renderContextThrottle(summary) {
   return {
     renderContextThrottle,
     renderLiveGuardrails,
+    renderMultiAgentWatchTerminal,
     renderRescuePrompt,
     renderUsageTerminal,
     renderWatchTerminal,

package/lib/prismo-dev-scan.js

@@ -265,7 +265,7 @@ Usage:
   prismo context [scope] [--json] [path]
   prismo cc [list|last N|all] [--json] [--limit N] [path]
   prismo usage [codex|claude|all] [--json] [--limit N] [path]
-  prismo watch [codex|claude|all] [--json] [--once] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
+  prismo watch [codex|claude|all] [--json] [--once] [--agents] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
   prismo demo
 
 Commands:
@@ -301,6 +301,7 @@ Options:
   --apply-suggestions Append missing recommended ignore rules with backups.
   --no-context-packs Skip .prismo context-pack generation in doctor mode.
   --report   Write .prismo/watch-report.md in watch mode.
+  --agents   Show multi-agent coordination view for parallel local sessions.
   --rescue   Print a paste-ready live-session rescue prompt in watch mode.
   --guardrails Write/update .prismo/live-guardrails.md and .prismo/live-rescue-prompt.md.
   --throttle Write/update .prismo/live-context-throttle.md in watch mode.
@@ -405,11 +406,12 @@ Examples:
     watch: `Prismo Watch
 
 Usage:
-  prismo watch [codex|claude|all] [--json] [--once] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
+  prismo watch [codex|claude|all] [--json] [--once] [--agents] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
 
 Examples:
   prismo watch codex
   prismo watch claude --once --json
+  prismo watch --agents --once
   prismo watch --once --report
   prismo watch --once --redact-paths
   prismo watch --rescue
@@ -421,6 +423,7 @@ Examples:
 
 Output:
   Shows context pressure, recent growth, likely context leaks, repeated reads/commands, loop suspicion, one suggested action, and live intervention steps.
+  --agents shows all visible local sessions for this repo and coordination warnings.
   --rescue prints a paste-ready prompt to recover a noisy or looping active session.
   --guardrails continuously updates .prismo/live-guardrails.md and .prismo/live-rescue-prompt.md for the active session.
   --throttle writes a stricter live context budget file for the current agent session.
@@ -825,6 +828,7 @@ async function runCli(argv) {
       limit,
       tokenBudget,
       auto,
+      agents: rest.includes("--agents"),
       json,
       once: rest.includes("--once"),
       report: rest.includes("--report"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getprismo",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Local AI coding workflow scanner for Codex, Claude Code, Cursor, and token-waste diagnostics.",
   "license": "MIT",
   "homepage": "https://github.com/shanirsh/prismodev#readme",