getprismo 0.1.25 → 0.1.27

package/README.md

@@ -492,6 +492,14 @@ Run npx getprismo optimize, then start from .prismo/architecture-summary.md.
 
 timeline shows exactly what leaked, what repeated, and what to do differently next time.
 
+to turn a postmortem into a safer next-session policy, run:
+
+```bash
+npx getprismo cc timeline --firewall --task auth-bug
+```
+
+this writes `.prismo/timeline-firewall-suggestions.md`, `.prismo/context-firewall.suggested.md`, `.prismo/allowed-context.suggested.txt`, and `.prismo/blocked-context.suggested.txt` from the latest session evidence. it does not overwrite your active firewall; it gives you a per-task allow/block recommendation for the next session.
+
 ---
 
 ## how doctor improves a repo
@@ -552,6 +560,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 +662,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 +701,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 +709,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:
 
@@ -723,6 +744,7 @@ For local development from this repo:
 ```bash
 npx getprismo cc                         # latest session cost
 npx getprismo cc timeline                # event timeline for latest session
+npx getprismo cc timeline --firewall --task auth-bug # suggest next-session firewall rules
 npx getprismo cc list                    # list recent sessions
 npx getprismo cc last 5                  # last 5 sessions
 npx getprismo cc all                     # everything

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/firewall.js

@@ -99,6 +99,58 @@ function buildBlockedContext(ctx) {
   return uniq(blocked).slice(0, 80);
 }
 
+function isGeneratedLike(value) {
+  const text = String(value || "").replace(/\\/g, "/").toLowerCase();
+  return /(^|\/)(node_modules|dist|build|coverage|\.next|__pycache__|logs?|events?|source-streams?|session-dumps?|playwright-report|test-results)(\/|$)/.test(text)
+    || /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb)$/.test(text)
+    || /\.(log|jsonl|ndjson|map|pyc)$/.test(text);
+}
+
+function firewallPatternForPath(value) {
+  const text = String(value || "").replace(/\\/g, "/").replace(/\s+\(\d+x\)$/, "");
+  if (!text) return null;
+  if (/(^|\/)__pycache__(\/|$)/.test(text)) return "**/__pycache__/**";
+  if (/(^|\/)(node_modules|dist|build|coverage|\.next|logs?|events?|source-streams?|session-dumps?|playwright-report|test-results)\//.test(text)) {
+    const match = text.match(/(^|\/)(node_modules|dist|build|coverage|\.next|logs?|events?|source-streams?|session-dumps?|playwright-report|test-results)\//);
+    const prefix = text.slice(0, match.index + match[0].length).replace(/\/$/, "");
+    return `${prefix}/**`;
+  }
+  return text;
+}
+
+function timelineEventPath(event) {
+  const detail = String(event?.detail || "");
+  const match = detail.match(/^(.+?)\s+\(\d+x\)$/);
+  return (match ? match[1] : detail).trim();
+}
+
+function buildTimelineFirewallSuggestions(ctx, session, taskScope) {
+  const baseAllowed = buildAllowedContext(ctx, taskScope);
+  const baseBlocked = buildBlockedContext(ctx);
+  const timeline = session?.timeline || [];
+  const repeated = session?.repeatedPathMentions || [];
+  const artifacts = session?.generatedArtifacts || [];
+
+  const sessionAllowed = repeated
+    .map((item) => item.value)
+    .filter((value) => value && !isGeneratedLike(value))
+    .map(globForFile)
+    .slice(0, 20);
+
+  const sessionBlocked = [
+    ...artifacts.map((item) => item.value),
+    ...timeline.filter((event) => event.type === "artifact-leak").map(timelineEventPath),
+    ...repeated.map((item) => item.value).filter(isGeneratedLike),
+  ].map(firewallPatternForPath).filter(Boolean);
+
+  return {
+    allowed: uniq([...sessionAllowed, ...baseAllowed]).slice(0, 80),
+    blocked: uniq([...sessionBlocked, ...baseBlocked]).slice(0, 100),
+    sessionAllowed: uniq(sessionAllowed),
+    sessionBlocked: uniq(sessionBlocked),
+  };
+}
+
 function renderLines(title, items) {
   return [`# ${title}`, "", ...items.map((item) => item)].join("\n") + "\n";
 }
@@ -187,6 +239,71 @@ function runFirewall(rootDir = process.cwd(), options = {}) {
   return result;
 }
 
+function renderTimelineFirewallSuggestions(result) {
+  const lines = [];
+  lines.push("# Prismo Timeline Firewall Suggestions");
+  lines.push("");
+  lines.push(`Generated: ${result.generatedAt}`);
+  lines.push(`Task: ${result.task}`);
+  lines.push(`Scope: ${result.scope}`);
+  if (result.sessionId) lines.push(`Session: ${result.sessionId}`);
+  lines.push("");
+  lines.push("These suggestions came from `cc timeline` session evidence. They are safe recommendation files; Prismo does not overwrite your active firewall unless you copy/apply them.");
+  lines.push("");
+  lines.push("## Session-Derived Allowed Context");
+  lines.push("");
+  if (result.sessionAllowed.length) result.sessionAllowed.forEach((item) => lines.push(`- ${item}`));
+  else lines.push("- No repeated source files were strong enough to promote.");
+  lines.push("");
+  lines.push("## Session-Derived Blocked Context");
+  lines.push("");
+  if (result.sessionBlocked.length) result.sessionBlocked.forEach((item) => lines.push(`- ${item}`));
+  else lines.push("- No generated/noisy paths were strong enough to add.");
+  lines.push("");
+  lines.push("## Next Session Prompt");
+  lines.push("");
+  lines.push("```text");
+  lines.push(`Use .prismo/context-firewall.suggested.md as the starting context policy for this ${result.task} task.`);
+  lines.push("Start from allowed context first. Do not read blocked paths unless you explain why they are required.");
+  lines.push("If you need wider context, name the exact file and reason before reading.");
+  lines.push("```");
+  lines.push("");
+  return lines.join("\n");
+}
+
+function runTimelineFirewallSuggestions(rootDir = process.cwd(), session = null, options = {}) {
+  const ctx = createOptimizeContext(rootDir, options.scope || null);
+  const task = options.task || options.scope || "timeline-followup";
+  const scope = inferTaskScope(task, ctx);
+  const suggestions = buildTimelineFirewallSuggestions(ctx, session, scope);
+  const result = {
+    root: ctx.root,
+    task,
+    scope,
+    sessionId: session?.sessionId || null,
+    allowed: suggestions.allowed,
+    blocked: suggestions.blocked,
+    sessionAllowed: suggestions.sessionAllowed,
+    sessionBlocked: suggestions.sessionBlocked,
+    generatedAt: new Date().toISOString(),
+    generatedFiles: [
+      ".prismo/timeline-firewall-suggestions.md",
+      ".prismo/context-firewall.suggested.md",
+      ".prismo/allowed-context.suggested.txt",
+      ".prismo/blocked-context.suggested.txt",
+    ],
+  };
+
+  if (!options.dryRun) {
+    writeGeneratedFile(ctx.root, ".prismo/timeline-firewall-suggestions.md", renderTimelineFirewallSuggestions(result));
+    writeGeneratedFile(ctx.root, ".prismo/context-firewall.suggested.md", renderFirewallPolicy(result));
+    writeGeneratedFile(ctx.root, ".prismo/allowed-context.suggested.txt", renderLines("Allowed Context Suggestions", result.allowed));
+    writeGeneratedFile(ctx.root, ".prismo/blocked-context.suggested.txt", renderLines("Blocked Context Suggestions", result.blocked));
+  }
+  result.dryRun = Boolean(options.dryRun);
+  return result;
+}
+
 function renderFirewallTerminal(result) {
   const lines = [];
   lines.push("");
@@ -218,6 +335,8 @@ function renderFirewallTerminal(result) {
     renderFirewallPolicy,
     renderFirewallPrompt,
     renderFirewallTerminal,
+    renderTimelineFirewallSuggestions,
     runFirewall,
+    runTimelineFirewallSuggestions,
   };
 };

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

@@ -202,6 +202,7 @@ const {
 const {
   renderFirewallTerminal,
   runFirewall,
+  runTimelineFirewallSuggestions,
 } = require("./prismo-dev/firewall")({
   fs,
   path,
@@ -263,9 +264,9 @@ Usage:
   prismo scan [--fix] [--ci] [--json] [--usage] [--optimizer-fit] [--report-card] [--simple] [--no-report] [path]
   prismo optimize [scope] [--json] [path]
   prismo context [scope] [--json] [path]
-  prismo cc [list|last N|all] [--json] [--limit N] [path]
+  prismo cc [list|last N|all|timeline] [--json] [--limit N] [--firewall] [--task TASK] [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:
@@ -295,12 +296,15 @@ Options:
   --simple    Print a plain-English scan summary for first-time or non-technical users.
   --no-report Do not write .prismo/prismo-dev-report.md.
   --limit N   Number of recent local sessions to show.
+  --firewall Generate cc timeline-derived firewall suggestion files.
+  --task TASK Name the task for timeline-derived firewall suggestions.
   --interval N Refresh interval in seconds for watch mode.
   --dry-run  Preview doctor/fix actions without writing files.
   --apply-ignores-only Only create/suggest AI ignore files in doctor mode.
   --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.
@@ -376,7 +380,7 @@ Output:
 
 Usage:
   prismo cc [--json] [path]
-  prismo cc timeline [--json] [path]
+  prismo cc timeline [--json] [--firewall] [--task TASK] [path]
   prismo cc list [--json] [--limit N] [path]
   prismo cc last N [--json] [path]
   prismo cc all [--json] [path]
@@ -384,6 +388,7 @@ Usage:
 Examples:
   prismo cc
   prismo cc timeline
+  prismo cc timeline --firewall --task auth-bug
   prismo cc list
   prismo cc last 5
   prismo cc all --json
@@ -392,6 +397,7 @@ Examples:
   Reads ~/.claude/projects session logs and estimates Claude API token cost from input, output, cache write, and cache read tokens.
   Adds Prismo diagnosis: cost drivers, estimated avoidable spend, and context-optimization next actions.
   timeline shows context spikes, repeated commands, artifact leaks, and tool-output pressure for the latest session.
+  --firewall writes .prismo/timeline-firewall-suggestions.md and suggested allow/block files from timeline evidence.
   Without a path, cc commands read all Claude Code projects. Passing a path filters to that project.`,
     usage: `Prismo Usage
 
@@ -405,11 +411,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 +428,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.
@@ -756,7 +764,17 @@ async function runCli(argv) {
   if (command === "cc") {
     const json = rest.includes("--json");
     const limitIndex = rest.indexOf("--limit");
-    const positional = getPositionals(rest, new Set(["--limit"]));
+    const firewall = rest.includes("--firewall");
+    const taskIndex = rest.indexOf("--task");
+    const firewallTask = taskIndex >= 0 && rest[taskIndex + 1] && !rest[taskIndex + 1].startsWith("-")
+      ? rest[taskIndex + 1]
+      : "timeline-followup";
+    const ccArgs = rest.filter((_, index) => {
+      if (index === rest.indexOf("--firewall")) return false;
+      if (taskIndex >= 0 && (index === taskIndex || index === taskIndex + 1)) return false;
+      return true;
+    });
+    const positional = getPositionals(ccArgs, new Set(["--limit"]));
     const subcommand = positional[0] && ["list", "last", "all", "timeline"].includes(positional[0].toLowerCase()) ? positional[0].toLowerCase() : "latest";
     const lastCount = subcommand === "last" ? parsePositiveInt(positional[1], 5) : null;
     const limit = subcommand === "list"
@@ -777,6 +795,9 @@ async function runCli(argv) {
     if (json) {
       if (subcommand === "timeline") {
         const latest = summary.sessions[0] || null;
+        const firewallSuggestions = firewall && latest
+          ? runTimelineFirewallSuggestions(path.resolve(target), latest, { task: firewallTask, dryRun: false })
+          : null;
         console.log(JSON.stringify({
           schemaVersion: 1,
           generatedAt: summary.generatedAt,
@@ -793,6 +814,7 @@ async function runCli(argv) {
               }
             : null,
           timeline: latest ? latest.timeline || [] : [],
+          firewallSuggestions,
           suggestedAction: latest?.prismo?.recommendations?.[0] || `${NPX_COMMAND} doctor`,
         }, null, 2));
         return;
@@ -800,7 +822,20 @@ async function runCli(argv) {
       console.log(JSON.stringify(summary, null, 2));
       return;
     }
-    console.log(renderClaudeCostTerminal(summary));
+    const output = [renderClaudeCostTerminal(summary)];
+    if (subcommand === "timeline" && firewall) {
+      const latest = summary.sessions[0] || null;
+      if (latest) {
+        const suggestions = runTimelineFirewallSuggestions(path.resolve(target), latest, { task: firewallTask, dryRun: false });
+        output.push("");
+        output.push("Timeline Firewall Suggestions");
+        output.push(`Wrote: ${suggestions.generatedFiles.join(", ")}`);
+        output.push(`Session-derived allowed: ${suggestions.sessionAllowed.length}`);
+        output.push(`Session-derived blocked: ${suggestions.sessionBlocked.length}`);
+        output.push("Tell your agent: Use .prismo/context-firewall.suggested.md for the next scoped session.");
+      }
+    }
+    console.log(output.join("\n"));
     return;
   }
 
@@ -825,6 +860,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.27",
   "description": "Local AI coding workflow scanner for Codex, Claude Code, Cursor, and token-waste diagnostics.",
   "license": "MIT",
   "homepage": "https://github.com/shanirsh/prismodev#readme",