getprismo 0.1.28 → 0.1.30

package/lib/prismo-dev/receipt.js

@@ -0,0 +1,291 @@
+module.exports = function createReceipt(deps) {
+  const {
+    fs,
+    path,
+    GENERATED_ARTIFACT_PATTERNS,
+    NPX_COMMAND,
+    formatTokenCount,
+    getUsageSummary,
+    readIfText,
+  } = deps;
+
+  const {
+    getActionableRepeatedPaths,
+    summarizeGeneratedArtifacts,
+  } = require("./usage-log-utils")({
+    fs,
+    path,
+    GENERATED_ARTIFACT_PATTERNS,
+    readIfText,
+  });
+
+  function sumCounts(items) {
+    return (items || []).reduce((sum, item) => sum + Number(item.count || 0), 0);
+  }
+
+  function topItems(items, limit = 5) {
+    return (items || [])
+      .slice()
+      .sort((a, b) => Number(b.count || 0) - Number(a.count || 0))
+      .slice(0, limit)
+      .map((item) => ({
+        value: item.value,
+        count: Number(item.count || 0),
+      }));
+  }
+
+  function sessionScore(session) {
+    let score = 0;
+    if (session.contextRisk === "High") score += 45;
+    else if (session.contextRisk === "Medium") score += 25;
+    if ((session.estimatedToolTokens || 0) >= 75000) score += 30;
+    else if ((session.estimatedToolTokens || 0) >= 25000) score += 15;
+    score += Math.min(25, sumCounts(session.repeatedPathMentions) * 2);
+    score += Math.min(20, sumCounts(session.generatedArtifacts) * 2);
+    score += Math.min(20, sumCounts(session.repeatedCommands) * 3);
+    if (session.loopSuspicion) score += 20;
+    if ((session.turns || 0) >= 30) score += 10;
+    return score;
+  }
+
+  function chooseRootCause(session) {
+    if (!session) return { cause: "no-session", confidence: "low", summary: "No local coding-agent sessions were found for this repo." };
+    if ((session.estimatedToolTokens || 0) >= 75000) {
+      return {
+        cause: "tool-output-flood",
+        confidence: session.estimatedToolTokens >= 200000 ? "high" : "medium",
+        summary: `Tool/output tokens dominated the session (${formatTokenCount(session.estimatedToolTokens)} estimated tokens).`,
+      };
+    }
+    if (session.loopSuspicion && (session.repeatedCommands || []).length) {
+      return {
+        cause: "possible-command-loop",
+        confidence: session.loopConfidence || "medium",
+        summary: `${session.repeatedCommands[0].value} repeated ${session.repeatedCommands[0].count}x.`,
+      };
+    }
+    const artifactGroup = summarizeGeneratedArtifacts(session.generatedArtifacts || [], 1)[0];
+    if (artifactGroup) {
+      return {
+        cause: "artifact-leak",
+        confidence: artifactGroup.count >= 10 ? "high" : "medium",
+        summary: `${artifactGroup.type} artifacts appeared in context (${artifactGroup.count} mentions).`,
+      };
+    }
+    const repeatedPath = getActionableRepeatedPaths(session, 1)[0] || topItems(session.repeatedPathMentions, 1)[0];
+    if (repeatedPath) {
+      return {
+        cause: "repeated-file-read",
+        confidence: repeatedPath.count >= 20 ? "high" : "medium",
+        summary: `${repeatedPath.value} repeatedly entered context (${repeatedPath.count}x).`,
+      };
+    }
+    if (session.contextRisk === "High") {
+      return {
+        cause: "high-context-pressure",
+        confidence: "medium",
+        summary: `Session reached high context pressure (${formatTokenCount(session.displayTokens || session.contextTokens)} tokens).`,
+      };
+    }
+    return {
+      cause: "healthy-or-low-signal",
+      confidence: "low",
+      summary: "No major repeated reads, command loops, tool-output floods, or artifact leaks were detected.",
+    };
+  }
+
+  function buildReceiptSession(session) {
+    const repeatedReads = topItems(getActionableRepeatedPaths(session, 10).length ? getActionableRepeatedPaths(session, 10) : session.repeatedPathMentions, 10);
+    const artifactGroups = summarizeGeneratedArtifacts(session.generatedArtifacts || [], 10);
+    const repeatedCommands = topItems(session.repeatedCommands, 10);
+    const likelyInfluence = [];
+    for (const item of repeatedReads.slice(0, 5)) {
+      likelyInfluence.push({
+        type: "repeated-read",
+        value: item.value,
+        reason: `Read or mentioned ${item.count}x in the session.`,
+      });
+    }
+    for (const command of repeatedCommands.slice(0, 3)) {
+      likelyInfluence.push({
+        type: "repeated-command",
+        value: command.value,
+        reason: `Command appeared ${command.count}x${session.loopSuspicion ? "; possible loop signal." : "."}`,
+      });
+    }
+    if ((session.estimatedToolTokens || 0) > 0) {
+      likelyInfluence.push({
+        type: "tool-output",
+        value: `${formatTokenCount(session.estimatedToolTokens)} estimated tokens`,
+        reason: "Tool output likely shaped later turns because it remained in session context.",
+      });
+    }
+
+    const shouldIgnore = [];
+    for (const group of artifactGroups) {
+      shouldIgnore.push({
+        value: group.type,
+        reason: `${group.count} artifact mention${group.count === 1 ? "" : "s"} in context.`,
+      });
+    }
+    for (const item of topItems(session.generatedArtifacts, 5)) {
+      shouldIgnore.push({
+        value: item.value,
+        reason: `${item.count} mention${item.count === 1 ? "" : "s"} in context.`,
+      });
+    }
+
+    const nextRun = [];
+    if (session.contextRisk === "High") nextRun.push("Start a fresh scoped session before continuing.");
+    if ((session.estimatedToolTokens || 0) >= 25000) nextRun.push(`Run noisy commands through ${NPX_COMMAND} shield -- <command>.`);
+    if (artifactGroups.length || shouldIgnore.length) nextRun.push(`Run ${NPX_COMMAND} doctor --apply-suggestions --dry-run and review ignore candidates.`);
+    if (repeatedReads.length) nextRun.push(`Use ${NPX_COMMAND} firewall <task> so the agent starts with a smaller read boundary.`);
+    if (session.loopSuspicion) nextRun.push(`Run ${NPX_COMMAND} watch --rescue and ask the agent to summarize state before another command.`);
+    if (!nextRun.length) nextRun.push("Keep the next session scoped; no urgent corrective action was detected.");
+
+    return {
+      sessionId: session.sessionId,
+      tool: session.tool,
+      model: session.model || "",
+      startedAt: session.startedAt || null,
+      updatedAt: session.updatedAt || null,
+      contextRisk: session.contextRisk,
+      confidence: session.confidence,
+      turns: session.turns || 0,
+      toolCalls: session.toolCalls || 0,
+      toolResults: session.toolResults || 0,
+      tokens: {
+        display: session.displayTokens || 0,
+        context: session.contextTokens || 0,
+        exact: session.exactTotalTokens || 0,
+        toolOutput: session.estimatedToolTokens || 0,
+      },
+      rootCause: chooseRootCause(session),
+      readReceipt: {
+        repeatedReads,
+        repeatedReadMentions: sumCounts(repeatedReads),
+      },
+      outputReceipt: {
+        toolOutputTokens: session.estimatedToolTokens || 0,
+        repeatedCommands,
+        loopSuspicion: Boolean(session.loopSuspicion),
+        loopConfidence: session.loopConfidence || "low",
+      },
+      artifactReceipt: {
+        artifactGroups,
+        generatedArtifacts: topItems(session.generatedArtifacts, 10),
+      },
+      likelyInfluence: likelyInfluence.slice(0, 10),
+      nextRun,
+      score: sessionScore(session),
+    };
+  }
+
+  function buildReceipt(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const limit = options.limit || 5;
+    const tool = options.tool || "all";
+    const usage = getUsageSummary({ cwd, limit, tool });
+    const sessions = (usage.sessions || [])
+      .map(buildReceiptSession)
+      .sort((a, b) => b.score - a.score || new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0));
+    const primary = sessions[0] || null;
+    const aggregate = sessions.reduce((acc, session) => {
+      acc.sessions += 1;
+      acc.displayTokens += session.tokens.display || 0;
+      acc.contextTokens += session.tokens.context || 0;
+      acc.toolOutputTokens += session.tokens.toolOutput || 0;
+      acc.repeatedReadMentions += session.readReceipt.repeatedReadMentions || 0;
+      acc.repeatedCommands += session.outputReceipt.repeatedCommands.reduce((sum, item) => sum + Number(item.count || 0), 0);
+      acc.artifactMentions += session.artifactReceipt.generatedArtifacts.reduce((sum, item) => sum + Number(item.count || 0), 0);
+      return acc;
+    }, {
+      sessions: 0,
+      displayTokens: 0,
+      contextTokens: 0,
+      toolOutputTokens: 0,
+      repeatedReadMentions: 0,
+      repeatedCommands: 0,
+      artifactMentions: 0,
+    });
+
+    return {
+      schemaVersion: 1,
+      command: "receipt",
+      generatedAt: new Date().toISOString(),
+      scannedPath: cwd,
+      tool,
+      confidence: usage.confidence,
+      sources: usage.sources || [],
+      aggregate,
+      primary,
+      sessions,
+      next: primary ? primary.nextRun : [`Run ${NPX_COMMAND} watch --once after starting a coding-agent session in this repo.`],
+    };
+  }
+
+  function renderReceiptTerminal(receipt) {
+    const lines = [];
+    lines.push("");
+    lines.push("Prismo Run Receipt");
+    lines.push("");
+    if (!receipt.sessions.length) {
+      lines.push("No matching local coding-agent sessions found for this repo.");
+      lines.push("");
+      lines.push(`Next: ${receipt.next[0]}`);
+      return lines.join("\n");
+    }
+
+    const primary = receipt.primary;
+    lines.push(`Session: ${primary.sessionId || "unknown"} (${primary.tool})`);
+    lines.push(`Model: ${primary.model || "unknown"}`);
+    lines.push(`Updated: ${primary.updatedAt || "unknown"}`);
+    lines.push(`Context: ${formatTokenCount(primary.tokens.display || primary.tokens.context)} tokens (${primary.contextRisk || "Unknown"} risk, ${primary.confidence})`);
+    lines.push("");
+    lines.push("Root Cause");
+    lines.push(`- ${primary.rootCause.cause} (${primary.rootCause.confidence})`);
+    lines.push(`- ${primary.rootCause.summary}`);
+    lines.push("");
+    lines.push("Read Receipt");
+    if (primary.readReceipt.repeatedReads.length) {
+      primary.readReceipt.repeatedReads.slice(0, 5).forEach((item) => lines.push(`- ${item.value} (${item.count}x)`));
+    } else {
+      lines.push("- No repeated source/file reads detected.");
+    }
+    lines.push("");
+    lines.push("Output Receipt");
+    lines.push(`- Tool/output tokens: ${formatTokenCount(primary.outputReceipt.toolOutputTokens)}`);
+    if (primary.outputReceipt.repeatedCommands.length) {
+      primary.outputReceipt.repeatedCommands.slice(0, 5).forEach((item) => lines.push(`- Repeated command: ${item.value} (${item.count}x)`));
+    } else {
+      lines.push("- No repeated commands detected.");
+    }
+    lines.push("");
+    lines.push("Artifact Receipt");
+    if (primary.artifactReceipt.artifactGroups.length) {
+      primary.artifactReceipt.artifactGroups.slice(0, 5).forEach((item) => lines.push(`- ${item.type}: ${item.count} mentions`));
+    } else {
+      lines.push("- No generated artifact leaks detected.");
+    }
+    lines.push("");
+    lines.push("Likely Influence");
+    if (primary.likelyInfluence.length) {
+      primary.likelyInfluence.slice(0, 5).forEach((item) => lines.push(`- ${item.value}: ${item.reason}`));
+    } else {
+      lines.push("- No strong influence signals detected.");
+    }
+    lines.push("");
+    lines.push("Next Run");
+    primary.nextRun.forEach((item, index) => lines.push(`${index + 1}. ${item}`));
+    if (receipt.sessions.length > 1) {
+      lines.push("");
+      lines.push(`Receipt covered ${receipt.sessions.length} session(s): ${formatTokenCount(receipt.aggregate.displayTokens)} displayed tokens, ${formatTokenCount(receipt.aggregate.toolOutputTokens)} tool/output tokens.`);
+    }
+    return lines.join("\n");
+  }
+
+  return {
+    buildReceipt,
+    renderReceiptTerminal,
+  };
+};

package/lib/prismo-dev/replay.js

@@ -0,0 +1,191 @@
+module.exports = function createReplay(deps) {
+  const {
+    NPX_COMMAND,
+    buildMultiSessionTimeline,
+    buildReceipt,
+    formatTokenCount,
+  } = deps;
+
+  function classifyIncident(receipt, timeline) {
+    const primary = receipt.primary;
+    if (!primary) {
+      return {
+        type: "no-session",
+        severity: "low",
+        summary: "No local coding-agent sessions were found for this repo.",
+      };
+    }
+    if (primary.rootCause.cause === "tool-output-flood") {
+      return {
+        type: "tool-output-spiral",
+        severity: primary.tokens.toolOutput >= 200000 ? "high" : "medium",
+        summary: "Tool output dominated the session and likely crowded out useful working state.",
+      };
+    }
+    if (primary.outputReceipt.loopSuspicion) {
+      return {
+        type: "command-loop",
+        severity: primary.outputReceipt.loopConfidence === "high" ? "high" : "medium",
+        summary: "The same command or workflow repeated enough times to look like a loop.",
+      };
+    }
+    if (primary.rootCause.cause === "artifact-leak" || timeline.repeatedArtifacts.length) {
+      return {
+        type: "artifact-context-leak",
+        severity: timeline.repeatedArtifacts.some((item) => item.sessions >= 2) ? "high" : "medium",
+        summary: "Generated or low-signal artifacts repeatedly entered agent context.",
+      };
+    }
+    if (primary.rootCause.cause === "repeated-file-read" || timeline.repeatedFiles.length) {
+      return {
+        type: "repeated-exploration",
+        severity: timeline.repeatedFiles.some((item) => item.sessions >= 2) ? "medium" : "low",
+        summary: "The agent repeatedly revisited the same files instead of converging.",
+      };
+    }
+    if (primary.contextRisk === "High") {
+      return {
+        type: "stale-large-session",
+        severity: "medium",
+        summary: "The session reached high context pressure and should likely have split earlier.",
+      };
+    }
+    return {
+      type: "low-signal",
+      severity: "low",
+      summary: "No obvious incident pattern was detected.",
+    };
+  }
+
+  function buildRecoveryPrompt(replay) {
+    const primary = replay.receipt.primary;
+    if (!primary) return "Start a coding-agent session in this repo, then rerun Prismo replay.";
+    const blocked = [
+      ...primary.artifactReceipt.generatedArtifacts.map((item) => item.value),
+      ...replay.timeline.repeatedArtifacts.map((item) => item.value),
+    ].slice(0, 8);
+    const reads = primary.readReceipt.repeatedReads.slice(0, 5).map((item) => item.value);
+    const lines = [];
+    if (replay.incident.type === "low-signal") {
+      lines.push("No high-confidence waste incident was detected. Use this as a lightweight handoff before continuing.");
+    } else {
+      lines.push("We are recovering from a high-waste AI coding session. Stop broad exploration and rebuild working state before continuing.");
+    }
+    lines.push("");
+    lines.push(`Incident pattern: ${replay.incident.type} (${replay.incident.severity}).`);
+    lines.push(`Root cause: ${primary.rootCause.summary}`);
+    if (reads.length) lines.push(`Do not reread these unless they changed: ${reads.join(", ")}.`);
+    if (blocked.length) lines.push(`Do not read these generated/noisy artifacts unless explicitly required: ${Array.from(new Set(blocked)).join(", ")}.`);
+    lines.push("");
+    lines.push("Before editing anything else, summarize:");
+    lines.push("- files changed so far");
+    lines.push("- exact failing command or error");
+    lines.push("- current hypothesis");
+    lines.push("- next smallest file or test to inspect");
+    lines.push("");
+    lines.push(`Use ${NPX_COMMAND} shield -- <command> for noisy commands.`);
+    lines.push(`Use ${NPX_COMMAND} firewall <task> before the next scoped session.`);
+    return lines.join("\n");
+  }
+
+  function buildReplay(options = {}) {
+    const receipt = buildReceipt(options);
+    const timeline = buildMultiSessionTimeline(options);
+    const incident = classifyIncident(receipt, timeline);
+    const primary = receipt.primary;
+    const sequence = [];
+    if (primary) {
+      if (primary.tokens.toolOutput) {
+        sequence.push({
+          type: "tool-output",
+          detail: `${formatTokenCount(primary.tokens.toolOutput)} tool/output tokens entered the session.`,
+        });
+      }
+      primary.artifactReceipt.artifactGroups.forEach((group) => {
+        sequence.push({
+          type: "artifact-leak",
+          detail: `${group.type} artifacts appeared ${group.count} time(s).`,
+        });
+      });
+      primary.readReceipt.repeatedReads.forEach((item) => {
+        sequence.push({
+          type: "repeated-read",
+          detail: `${item.value} appeared ${item.count} time(s).`,
+        });
+      });
+      primary.outputReceipt.repeatedCommands.forEach((item) => {
+        sequence.push({
+          type: "repeated-command",
+          detail: `${item.value} repeated ${item.count} time(s).`,
+        });
+      });
+      if (primary.contextRisk === "High") {
+        sequence.push({
+          type: "split-needed",
+          detail: "Context pressure reached High; future work should split at a task boundary.",
+        });
+      }
+    }
+
+    const replay = {
+      schemaVersion: 1,
+      command: "replay",
+      generatedAt: new Date().toISOString(),
+      scannedPath: receipt.scannedPath,
+      tool: receipt.tool,
+      incident,
+      sequence,
+      receipt,
+      timeline,
+      recoveryPrompt: "",
+      next: primary
+        ? [
+            ...primary.nextRun,
+            `${NPX_COMMAND} timeline --last ${Math.max(timeline.sessionsAnalyzed || 5, 5)}`,
+          ]
+        : receipt.next,
+    };
+    replay.recoveryPrompt = buildRecoveryPrompt(replay);
+    return replay;
+  }
+
+  function renderReplayTerminal(replay) {
+    const lines = [];
+    lines.push("");
+    lines.push("Prismo Incident Replay");
+    lines.push("");
+    lines.push(`Incident: ${replay.incident.type} (${replay.incident.severity})`);
+    lines.push(replay.incident.summary);
+    lines.push("");
+    if (!replay.receipt.primary) {
+      lines.push("No session evidence available yet.");
+      lines.push(`Next: ${replay.next[0]}`);
+      return lines.join("\n");
+    }
+    lines.push("What Happened");
+    if (replay.sequence.length) replay.sequence.slice(0, 10).forEach((event) => lines.push(`- ${event.type}: ${event.detail}`));
+    else lines.push("- No high-signal sequence detected.");
+    lines.push("");
+    lines.push("Why It Matters");
+    lines.push(`- Root cause: ${replay.receipt.primary.rootCause.summary}`);
+    lines.push(`- Sessions analyzed: ${replay.timeline.sessionsAnalyzed}`);
+    if (replay.timeline.repeatedArtifacts.length) {
+      lines.push(`- Recurring artifacts: ${replay.timeline.repeatedArtifacts.slice(0, 3).map((item) => item.value).join(", ")}`);
+    }
+    if (replay.timeline.repeatedFiles.length) {
+      lines.push(`- Recurring repeated reads: ${replay.timeline.repeatedFiles.slice(0, 3).map((item) => item.value).join(", ")}`);
+    }
+    lines.push("");
+    lines.push("Recovery Prompt");
+    lines.push(replay.recoveryPrompt);
+    lines.push("");
+    lines.push("Next");
+    replay.next.slice(0, 5).forEach((item, index) => lines.push(`${index + 1}. ${item}`));
+    return lines.join("\n");
+  }
+
+  return {
+    buildReplay,
+    renderReplayTerminal,
+  };
+};

package/lib/prismo-dev/scan.js

@@ -20,6 +20,7 @@ module.exports = function createScan(deps) {
     getCodexSessionFiles,
     compactUsageSummary,
     formatTokenCount,
+    color,
   } = deps;
 
 const {

package/lib/prismo-dev/timeline.js

@@ -0,0 +1,185 @@
+module.exports = function createTimeline(deps) {
+  const {
+    fs,
+    path,
+    GENERATED_ARTIFACT_PATTERNS,
+    NPX_COMMAND,
+    formatTokenCount,
+    getUsageSummary,
+    readIfText,
+  } = deps;
+
+  const {
+    getActionableRepeatedPaths,
+    summarizeGeneratedArtifacts,
+  } = require("./usage-log-utils")({
+    fs,
+    path,
+    GENERATED_ARTIFACT_PATTERNS,
+    readIfText,
+  });
+
+  function bump(map, key, count = 1, sessionId = null) {
+    if (!key) return;
+    const item = map.get(key) || { value: key, count: 0, sessions: new Set() };
+    item.count += Number(count || 0);
+    if (sessionId) item.sessions.add(sessionId);
+    map.set(key, item);
+  }
+
+  function sortedMap(map, limit = 10) {
+    return Array.from(map.values())
+      .map((item) => ({
+        value: item.value,
+        count: item.count,
+        sessions: item.sessions.size,
+      }))
+      .sort((a, b) => b.sessions - a.sessions || b.count - a.count)
+      .slice(0, limit);
+  }
+
+  function buildMultiSessionTimeline(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const limit = options.limit || 20;
+    const tool = options.tool || "all";
+    const usage = getUsageSummary({ cwd, limit, tool });
+    const sessions = usage.sessions || [];
+    const artifactMap = new Map();
+    const fileMap = new Map();
+    const commandMap = new Map();
+    const events = [];
+    let highRiskSessions = 0;
+    let toolFloodSessions = 0;
+    let loopSessions = 0;
+    let totalToolOutputTokens = 0;
+
+    for (const session of sessions) {
+      const sessionId = session.sessionId || session.updatedAt || "unknown";
+      if (session.contextRisk === "High") highRiskSessions += 1;
+      if ((session.estimatedToolTokens || 0) >= 75000) toolFloodSessions += 1;
+      if (session.loopSuspicion) loopSessions += 1;
+      totalToolOutputTokens += Number(session.estimatedToolTokens || 0);
+
+      for (const group of summarizeGeneratedArtifacts(session.generatedArtifacts || [], 10)) {
+        bump(artifactMap, group.type, group.count, sessionId);
+      }
+      for (const item of getActionableRepeatedPaths(session, 10)) {
+        bump(fileMap, item.value, item.count, sessionId);
+      }
+      for (const item of session.repeatedCommands || []) {
+        bump(commandMap, item.value, item.count, sessionId);
+      }
+
+      if (session.contextRisk === "High") {
+        events.push({
+          timestamp: session.updatedAt || null,
+          sessionId,
+          tool: session.tool,
+          type: "high-context-pressure",
+          detail: `${formatTokenCount(session.displayTokens || session.contextTokens)} tokens`,
+        });
+      }
+      if ((session.estimatedToolTokens || 0) >= 75000) {
+        events.push({
+          timestamp: session.updatedAt || null,
+          sessionId,
+          tool: session.tool,
+          type: "tool-output-flood",
+          detail: `${formatTokenCount(session.estimatedToolTokens)} tool/output tokens`,
+        });
+      }
+      if (session.loopSuspicion) {
+        events.push({
+          timestamp: session.updatedAt || null,
+          sessionId,
+          tool: session.tool,
+          type: "possible-loop",
+          detail: `${session.repeatedCommands?.[0]?.value || "command"} repeated`,
+        });
+      }
+    }
+
+    const repeatedArtifacts = sortedMap(artifactMap, 10);
+    const repeatedFiles = sortedMap(fileMap, 10);
+    const repeatedCommands = sortedMap(commandMap, 10);
+    const recommendations = [];
+    if (repeatedArtifacts.length) recommendations.push(`Add/verify ignore coverage for ${repeatedArtifacts.slice(0, 3).map((item) => item.value).join(", ")}.`);
+    if (toolFloodSessions) recommendations.push(`Route noisy commands through ${NPX_COMMAND} shield -- <command>.`);
+    if (repeatedFiles.length) recommendations.push(`Use ${NPX_COMMAND} firewall <task> to start sessions with narrower read boundaries.`);
+    if (highRiskSessions >= 2) recommendations.push("Split future work earlier; multiple recent sessions reached high context pressure.");
+    if (loopSessions) recommendations.push(`Use ${NPX_COMMAND} watch --rescue when loops appear.`);
+    if (!recommendations.length) recommendations.push("No recurring multi-session waste pattern detected yet.");
+
+    return {
+      schemaVersion: 1,
+      command: "timeline",
+      generatedAt: new Date().toISOString(),
+      scannedPath: cwd,
+      tool,
+      sessionsAnalyzed: sessions.length,
+      confidence: usage.confidence,
+      sources: usage.sources || [],
+      summary: {
+        highRiskSessions,
+        toolFloodSessions,
+        loopSessions,
+        totalToolOutputTokens,
+      },
+      repeatedArtifacts,
+      repeatedFiles,
+      repeatedCommands,
+      events: events.sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0)).slice(-50),
+      recommendations,
+    };
+  }
+
+  function renderMultiSessionTimelineTerminal(timeline) {
+    const lines = [];
+    lines.push("");
+    lines.push("Prismo Multi-Session Timeline");
+    lines.push("");
+    lines.push(`Sessions analyzed: ${timeline.sessionsAnalyzed}`);
+    lines.push(`Sources: ${timeline.sources.join(", ") || "none"}`);
+    lines.push(`High-risk sessions: ${timeline.summary.highRiskSessions}`);
+    lines.push(`Tool-output flood sessions: ${timeline.summary.toolFloodSessions}`);
+    lines.push(`Possible loop sessions: ${timeline.summary.loopSessions}`);
+    lines.push(`Total tool/output tokens: ${formatTokenCount(timeline.summary.totalToolOutputTokens)}`);
+    lines.push("");
+    lines.push("Recurring Artifacts");
+    if (timeline.repeatedArtifacts.length) {
+      timeline.repeatedArtifacts.slice(0, 5).forEach((item) => lines.push(`- ${item.value}: ${item.count} mentions across ${item.sessions} session(s)`));
+    } else {
+      lines.push("- None detected.");
+    }
+    lines.push("");
+    lines.push("Recurring Repeated Files");
+    if (timeline.repeatedFiles.length) {
+      timeline.repeatedFiles.slice(0, 5).forEach((item) => lines.push(`- ${item.value}: ${item.count} mentions across ${item.sessions} session(s)`));
+    } else {
+      lines.push("- None detected.");
+    }
+    lines.push("");
+    lines.push("Recurring Commands");
+    if (timeline.repeatedCommands.length) {
+      timeline.repeatedCommands.slice(0, 5).forEach((item) => lines.push(`- ${item.value}: ${item.count} mentions across ${item.sessions} session(s)`));
+    } else {
+      lines.push("- None detected.");
+    }
+    lines.push("");
+    lines.push("Recent Events");
+    if (timeline.events.length) {
+      timeline.events.slice(-8).forEach((event) => lines.push(`- ${event.timestamp || "unknown"} ${event.type}: ${event.detail}`));
+    } else {
+      lines.push("- No high-signal events detected.");
+    }
+    lines.push("");
+    lines.push("Next");
+    timeline.recommendations.forEach((item, index) => lines.push(`${index + 1}. ${item}`));
+    return lines.join("\n");
+  }
+
+  return {
+    buildMultiSessionTimeline,
+    renderMultiSessionTimelineTerminal,
+  };
+};

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

@@ -571,6 +571,7 @@ async function watchUsage(options = {}) {
     analyzeCursorSessions,
     buildCursorDiagnosis,
     buildCursorSessionTimeline,
+    buildMultiAgentView,
     calculateClaudeCost,
     compactUsageSummary,
     formatMoney,