@pi-unipi/subagents 0.1.13 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/subagents",
-  "version": "0.1.13",
+  "version": "0.2.3",
   "description": "Subagents for UniPi — parallel execution, file locking, workflow integration",
   "type": "module",
   "main": "dist/index.js",

package/src/__tests__/badge-generation.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Test: Badge Generation Flow
+ *
+ * Tests the full badge name generation flow to identify and verify
+ * fixes for "Generating session name..." getting stuck.
+ *
+ * BUG 1 — Tool mismatch:
+ * Background agent was told to "Call the set_session_name tool" but the tool
+ * doesn't exist in the agent's session (only builtin tools available).
+ * FIX: Changed prompt to output title directly, parse in onComplete callback.
+ *
+ * BUG 2 — Wrong event bus:
+ * Cross-module events emitted via pi.events.emit() but listeners used pi.on()
+ * (extension lifecycle events) — completely different event bus.
+ * FIX: Changed all cross-module listeners to pi.events.on().
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const ROOT = join(import.meta.dirname, "../../../..");
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function readSource(relativePath: string): string {
+  const fullPath = join(ROOT, relativePath);
+  if (!existsSync(fullPath)) throw new Error(`File not found: ${fullPath}`);
+  return readFileSync(fullPath, "utf-8");
+}
+
+// ─── Test: Tool availability in spawned agent ──────────────────────
+
+describe("Badge generation — tool availability", () => {
+  it("agent-runner uses only builtin tools, NOT extension-registered tools", () => {
+    const src = readSource("packages/subagents/src/agent-runner.ts");
+
+    const builtinMatch = src.match(
+      /const BUILTIN_TOOL_NAMES\s*=\s*(\[.*?\])/s,
+    );
+    assert.ok(builtinMatch, "BUILTIN_TOOL_NAMES should be defined");
+
+    const builtinTools: string[] = eval(builtinMatch[1]);
+    assert.deepStrictEqual(builtinTools, [
+      "read", "bash", "edit", "write", "grep", "find", "ls",
+    ]);
+  });
+
+  it("set_session_name is NOT in the agent's tool list", () => {
+    const src = readSource("packages/subagents/src/agent-runner.ts");
+    const builtinMatch = src.match(
+      /const BUILTIN_TOOL_NAMES\s*=\s*(\[.*?\])/s,
+    );
+    const tools: string[] = eval(builtinMatch![1]);
+    assert.ok(!tools.includes("set_session_name"));
+  });
+});
+
+// ─── Test: Prompt no longer references non-existent tool ───────────
+
+describe("Badge generation — prompt fix", () => {
+  it("prompt asks agent to OUTPUT the title directly (not call a tool)", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(
+      src.includes("Reply with ONLY the title"),
+      "Prompt should ask agent to reply with only the title",
+    );
+
+    assert.ok(
+      !src.includes("Call the set_session_name tool"),
+      "Prompt should NOT tell agent to call set_session_name",
+    );
+  });
+});
+
+// ─── Test: onComplete extracts name from result ────────────────────
+
+describe("Badge generation — onComplete callback", () => {
+  it("onComplete extracts name from agent result and calls pi.setSessionName", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(
+      src.includes('record.description === "Generate session name"'),
+      "Should detect badge generation agents by description",
+    );
+
+    assert.ok(
+      src.includes("pi.setSessionName(name)"),
+      "Should call pi.setSessionName with extracted name",
+    );
+  });
+});
+
+// ─── Test: Cross-module event bus — the critical fix ───────────────
+
+describe("Badge generation — event bus (CRITICAL FIX)", () => {
+  it("emitEvent uses pi.events.emit (not pi.on)", () => {
+    const src = readSource("packages/core/utils.ts");
+
+    assert.ok(
+      src.includes("pi.events.emit(eventName, payload)"),
+      "emitEvent should use pi.events.emit()",
+    );
+  });
+
+  it("subagents listens via pi.events.on (NOT pi.on)", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    // Must use pi.events.on for cross-module events
+    assert.ok(
+      src.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
+      "Subagents should listen via pi.events.on",
+    );
+
+    // Should NOT use pi.on for custom events
+    const piOnMatch = src.match(/pi\.on\(UNIPI_EVENTS\.BADGE_GENERATE_REQUEST/g);
+    assert.ok(!piOnMatch, "Should NOT use pi.on() for cross-module events");
+  });
+
+  it("utility BADGE_GENERATE_REQUEST listener is removed (input handler already shows overlay)", () => {
+    const src = readSource("packages/utility/src/index.ts");
+
+    // Should NOT have a separate BADGE_GENERATE_REQUEST listener
+    // The input handler already shows the overlay and emits the event
+    assert.ok(
+      !src.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
+      "Utility should NOT have a separate BADGE_GENERATE_REQUEST listener",
+    );
+  });
+
+  it("workflow listens for MODULE_READY via pi.events.on (NOT pi.on)", () => {
+    const src = readSource("packages/workflow/index.ts");
+
+    assert.ok(
+      src.includes("pi.events.on(UNIPI_EVENTS.MODULE_READY"),
+      "Workflow should listen via pi.events.on",
+    );
+
+    const piOnMatch = src.match(/pi\.on\(UNIPI_EVENTS\.MODULE_READY/g);
+    assert.ok(!piOnMatch, "Should NOT use pi.on() for cross-module events");
+  });
+
+  it("pi.on() is ONLY used for known lifecycle events", () => {
+    const subagentsSrc = readSource("packages/subagents/src/index.ts");
+    const utilitySrc = readSource("packages/utility/src/index.ts");
+
+    // These are valid lifecycle events that should use pi.on()
+    const validLifecycleEvents = [
+      "session_start", "session_shutdown", "input",
+      "tool_call", "tool_execution_start",
+    ];
+
+    // Check that pi.on() is only used with lifecycle events
+    const piOnPattern = /pi\.on\("([^"]+)"/g;
+    let match;
+    while ((match = piOnPattern.exec(subagentsSrc)) !== null) {
+      assert.ok(
+        validLifecycleEvents.includes(match[1]),
+        `subagents: pi.on("${match[1]}") should be a lifecycle event, use pi.events.on() for custom events`,
+      );
+    }
+    while ((match = piOnPattern.exec(utilitySrc)) !== null) {
+      assert.ok(
+        validLifecycleEvents.includes(match[1]),
+        `utility: pi.on("${match[1]}") should be a lifecycle event`,
+      );
+    }
+  });
+});
+
+// ─── Test: Event flow ──────────────────────────────────────────────
+
+describe("Badge generation — event flow", () => {
+  it("utility emits BADGE_GENERATE_REQUEST on first input", () => {
+    const src = readSource("packages/utility/src/index.ts");
+
+    assert.ok(src.includes("BADGE_GENERATE_REQUEST"));
+    assert.ok(src.includes('source: "input-hook"'));
+  });
+
+  it("BADGE_GENERATE_REQUEST event is defined in core", () => {
+    const src = readSource("packages/core/events.ts");
+    assert.ok(src.includes("BADGE_GENERATE_REQUEST"));
+  });
+});
+
+// ─── Test: Model resolution ────────────────────────────────────────
+
+describe("Badge generation — model resolution", () => {
+  it("reads generationModel from badge.json instead of hardcoding", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(!src.includes('"openai/gpt-oss-20b"'));
+    assert.ok(src.includes(".unipi/config/badge.json"));
+    assert.ok(src.includes("parsed.generationModel"));
+  });
+});
+
+// ─── Summary ───────────────────────────────────────────────────────
+
+describe("Badge generation — ROOT CAUSE SUMMARY", () => {
+  it("BUG 1 FIXED: prompt no longer references non-existent tool", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(!src.includes("Call the set_session_name tool"),
+      "FIXED: prompt no longer tells agent to call set_session_name");
+    assert.ok(src.includes("Reply with ONLY the title"),
+      "FIXED: prompt asks agent to reply with only the title");
+  });
+
+  it("BUG 1 FIXED: onComplete extracts name and sets it directly", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(src.includes('record.description === "Generate session name"'),
+      "FIXED: onComplete detects badge generation agents");
+    assert.ok(src.includes("pi.setSessionName(name)"),
+      "FIXED: onComplete calls pi.setSessionName directly");
+  });
+
+  it("BUG 2 FIXED: cross-module events use pi.events.on, not pi.on", () => {
+    const subagentsSrc = readSource("packages/subagents/src/index.ts");
+    const utilitySrc = readSource("packages/utility/src/index.ts");
+    const workflowSrc = readSource("packages/workflow/index.ts");
+
+    // Subagents: correct event bus
+    assert.ok(
+      subagentsSrc.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
+      "subagents: must use pi.events.on for BADGE_GENERATE_REQUEST",
+    );
+
+    // Utility: no duplicate listener (input handler already handles it)
+    assert.ok(
+      !utilitySrc.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
+      "utility: no duplicate BADGE_GENERATE_REQUEST listener",    );
+
+    // Workflow: correct event bus
+    assert.ok(
+      workflowSrc.includes("pi.events.on(UNIPI_EVENTS.MODULE_READY"),
+      "workflow: must use pi.events.on for MODULE_READY",
+    );
+  });
+});

package/src/agent-manager.ts

@@ -10,7 +10,9 @@ import type { Model } from "@mariozechner/pi-ai";
 import type { AgentSession, ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { runAgent, type ToolActivity } from "./agent-runner.js";
 import { resolveModel, type ModelRegistry } from "./model-resolver.js";
-import type { AgentRecord, AgentType, ThinkingLevel } from "./types.js";
+import type { AgentRecord, AgentConfig, AgentType, ThinkingLevel } from "./types.js";
+import { BUILTIN_CONFIGS } from "./types.js";
+import { loadCustomAgents } from "./custom-agents.js";
 import { FileLock } from "./file-lock.js";
 
 export type OnAgentComplete = (record: AgentRecord) => void;
@@ -49,6 +51,7 @@ export class AgentManager {
   private onComplete?: OnAgentComplete;
   private onStart?: OnAgentStart;
   private maxConcurrent: number;
+  private customAgents: Map<string, AgentConfig>;
 
   /** Per-file transparent locking for write agents. */
   readonly fileLock = new FileLock();
@@ -62,9 +65,15 @@ export class AgentManager {
     this.onComplete = onComplete;
     this.onStart = onStart;
     this.maxConcurrent = maxConcurrent;
+    this.customAgents = loadCustomAgents(process.cwd());
     this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
   }
 
+  /** Get resolved agent config for a type. */
+  getAgentConfig(type: AgentType): AgentConfig | undefined {
+    return this.customAgents.get(type) ?? BUILTIN_CONFIGS[type];
+  }
+
   setMaxConcurrent(n: number) {
     this.maxConcurrent = Math.max(1, n);
     this.drainQueue();
@@ -134,9 +143,11 @@ export class AgentManager {
       model = resolved;
     }
 
+    const agentConfig = this.getAgentConfig(type);
     const promise = runAgent(ctx, type, prompt, {
       pi,
       model,
+      agentConfig,
       maxTurns: options.maxTurns,
       isolated: options.isolated,
       inheritContext: options.inheritContext,

package/src/agent-runner.ts

@@ -17,7 +17,7 @@ import {
   SessionManager,
   SettingsManager,
 } from "@mariozechner/pi-coding-agent";
-import type { AgentConfig, AgentType, ThinkingLevel } from "./types.js";
+import { BUILTIN_CONFIGS, type AgentConfig, type AgentType, type ThinkingLevel } from "./types.js";
 
 /** Tools excluded from subagents to prevent nesting. */
 const EXCLUDED_TOOL_NAMES = ["Agent", "get_result"];
@@ -57,6 +57,7 @@ export interface ToolActivity {
 export interface RunOptions {
   pi: ExtensionAPI;
   model?: Model<any>;
+  agentConfig?: AgentConfig;
   maxTurns?: number;
   signal?: AbortSignal;
   isolated?: boolean;
@@ -122,6 +123,15 @@ function getToolNamesForType(type: AgentType, config?: AgentConfig): string[] {
   return [...BUILTIN_TOOL_NAMES];
 }
 
+/**
+ * Resolve agent config for a type.
+ * Priority: explicit config > builtin config > default
+ */
+function resolveAgentConfig(type: AgentType, explicitConfig?: AgentConfig): AgentConfig | undefined {
+  if (explicitConfig) return explicitConfig;
+  return BUILTIN_CONFIGS[type];
+}
+
 /** Resolve model from config. */
 function resolveDefaultModel(
   parentModel: Model<any> | undefined,
@@ -142,19 +152,24 @@ export async function runAgent(
 ): Promise<RunResult> {
   const effectiveCwd = options.cwd ?? ctx.cwd;
 
-  // Build system prompt
-  const agentConfig = options as any; // Will be properly typed later
+  // Resolve agent config
+  const agentConfig = resolveAgentConfig(type, options.agentConfig);
   const parentSystemPrompt = ctx.getSystemPrompt();
 
+  // Build system prompt using config or defaults
   let systemPrompt: string;
-  if (options.isolated) {
-    systemPrompt = `You are a ${type} agent. Follow the task instructions precisely. Do not ask questions.`;
+  if (agentConfig?.systemPrompt && agentConfig.promptMode === "replace") {
+    systemPrompt = agentConfig.systemPrompt;
+  } else if (options.isolated) {
+    const base = agentConfig?.systemPrompt ?? `You are a ${type} agent.`;
+    systemPrompt = `${base} Follow the task instructions precisely. Do not ask questions.`;
   } else {
-    systemPrompt = parentSystemPrompt + `\n\nYou are a ${type} agent. Follow the task instructions precisely.`;
+    const agentPrompt = agentConfig?.systemPrompt ?? `You are a ${type} agent.`;
+    systemPrompt = parentSystemPrompt + `\n\n${agentPrompt}`;
   }
 
-  // Get tool names
-  let toolNames = getToolNamesForType(type);
+  // Get tool names from config
+  let toolNames = getToolNamesForType(type, agentConfig);
 
   // Create resource loader
   const agentDir = getAgentDir();

package/src/conversation-viewer.ts

@@ -0,0 +1,299 @@
+/**
+ * @pi-unipi/subagents — Conversation Viewer
+ *
+ * Live-scrolling overlay for viewing agent conversations.
+ * Subscribes to session events for real-time streaming updates.
+ * Supports keyboard navigation: ↑↓, PgUp/PgDn, Home/End, Esc/q to close.
+ */
+
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import {
+  type Component,
+  matchesKey,
+  type TUI,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@mariozechner/pi-tui";
+import type { AgentActivity } from "./types.js";
+
+/** Lines consumed by chrome: top border + header + header sep + footer sep + footer + bottom border. */
+const CHROME_LINES = 6;
+const MIN_VIEWPORT = 3;
+
+/** Extract text from content array. */
+function extractText(content: string | Array<{ type: string; text?: string }>): string {
+  if (typeof content === "string") return content;
+  return content
+    .filter((p): p is { type: "text"; text: string } => p.type === "text" && typeof p.text === "string")
+    .map((p) => p.text)
+    .join("");
+}
+
+/** Format duration. */
+function formatMs(ms: number): string {
+  if (ms >= 60_000) return `${(ms / 60_000).toFixed(1)}m`;
+  if (ms >= 1_000) return `${(ms / 1_000).toFixed(1)}s`;
+  return `${ms}ms`;
+}
+
+/** Format tokens compactly. */
+function formatTokens(count: number): string {
+  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M token`;
+  if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k token`;
+  return `${count} token`;
+}
+
+/** Describe current activity from active tools. */
+function describeActivity(activeTools: Map<string, string>, responseText?: string): string {
+  if (activeTools.size > 0) {
+    const names = [...new Set(activeTools.values())];
+    return names.join(", ") + "…";
+  }
+  if (responseText && responseText.trim().length > 0) {
+    const lastLine = responseText.split("\n").find((l) => l.trim())?.trim() ?? "";
+    if (lastLine.length > 60) return lastLine.slice(0, 60) + "…";
+    if (lastLine.length > 0) return lastLine;
+  }
+  return "thinking…";
+}
+
+interface ViewerRecord {
+  type: string;
+  description: string;
+  status: string;
+  toolUses: number;
+  startedAt: number;
+  completedAt?: number;
+}
+
+export class ConversationViewer implements Component {
+  private scrollOffset = 0;
+  private autoScroll = true;
+  private unsubscribe: (() => void) | undefined;
+  private lastInnerW = 0;
+  private closed = false;
+
+  constructor(
+    private tui: TUI,
+    private session: AgentSession,
+    private record: ViewerRecord,
+    private activity: AgentActivity | undefined,
+    private theme: any,
+    private done: (result: undefined) => void,
+  ) {
+    this.unsubscribe = session.subscribe(() => {
+      if (this.closed) return;
+      this.tui.requestRender();
+    });
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, "escape") || matchesKey(data, "q")) {
+      this.closed = true;
+      this.done(undefined);
+      return;
+    }
+
+    const totalLines = this.buildContentLines(this.lastInnerW).length;
+    const viewportHeight = this.viewportHeight();
+    const maxScroll = Math.max(0, totalLines - viewportHeight);
+
+    if (matchesKey(data, "up") || matchesKey(data, "k")) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+      this.autoScroll = this.scrollOffset >= maxScroll;
+    } else if (matchesKey(data, "down") || matchesKey(data, "j")) {
+      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
+      this.autoScroll = this.scrollOffset >= maxScroll;
+    } else if (matchesKey(data, "pageUp")) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - viewportHeight);
+      this.autoScroll = false;
+    } else if (matchesKey(data, "pageDown")) {
+      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + viewportHeight);
+      this.autoScroll = this.scrollOffset >= maxScroll;
+    } else if (matchesKey(data, "home")) {
+      this.scrollOffset = 0;
+      this.autoScroll = false;
+    } else if (matchesKey(data, "end")) {
+      this.scrollOffset = maxScroll;
+      this.autoScroll = true;
+    }
+  }
+
+  render(width: number): string[] {
+    if (width < 6) return [];
+    const th = this.theme;
+    const innerW = width - 4; // border + padding
+    this.lastInnerW = innerW;
+    const lines: string[] = [];
+
+    const pad = (s: string, len: number) => {
+      const vis = visibleWidth(s);
+      return s + " ".repeat(Math.max(0, len - vis));
+    };
+    const row = (content: string) =>
+      th.fg("border", "│") + " " + truncateToWidth(pad(content, innerW), innerW) + " " + th.fg("border", "│");
+    const hrTop = th.fg("border", `╭${"─".repeat(width - 2)}╮`);
+    const hrBot = th.fg("border", `╰${"─".repeat(width - 2)}╯`);
+    const hrMid = row(th.fg("dim", "─".repeat(innerW)));
+
+    // Header
+    lines.push(hrTop);
+    const name = this.record.type;
+    const statusIcon =
+      this.record.status === "running"
+        ? th.fg("accent", "●")
+        : this.record.status === "completed"
+          ? th.fg("success", "✓")
+          : this.record.status === "error"
+            ? th.fg("error", "✗")
+            : th.fg("dim", "○");
+
+    const duration = this.record.completedAt
+      ? formatMs(this.record.completedAt - this.record.startedAt)
+      : `${formatMs(Date.now() - this.record.startedAt)} (running)`;
+
+    const headerParts: string[] = [duration];
+    const toolUses = this.activity?.toolUses ?? this.record.toolUses;
+    if (toolUses > 0) headerParts.unshift(`${toolUses} tool${toolUses === 1 ? "" : "s"}`);
+    if (this.activity?.session) {
+      try {
+        const tokens = (this.activity.session as any).getSessionStats().tokens.total;
+        if (tokens > 0) headerParts.push(formatTokens(tokens));
+      } catch {
+        /* */
+      }
+    }
+
+    lines.push(
+      row(
+        `${statusIcon} ${th.bold(name)}  ${th.fg("muted", this.record.description)} ${th.fg("dim", "·")} ${th.fg("dim", headerParts.join(" · "))}`,
+      ),
+    );
+    lines.push(hrMid);
+
+    // Content area
+    const contentLines = this.buildContentLines(innerW);
+    const viewportHeight = this.viewportHeight();
+    const maxScroll = Math.max(0, contentLines.length - viewportHeight);
+
+    if (this.autoScroll) {
+      this.scrollOffset = maxScroll;
+    }
+
+    const visibleStart = Math.min(this.scrollOffset, maxScroll);
+    const visible = contentLines.slice(visibleStart, visibleStart + viewportHeight);
+
+    for (let i = 0; i < viewportHeight; i++) {
+      lines.push(row(visible[i] ?? ""));
+    }
+
+    // Footer
+    lines.push(hrMid);
+    const scrollPct =
+      contentLines.length <= viewportHeight
+        ? "100%"
+        : `${Math.round(((visibleStart + viewportHeight) / contentLines.length) * 100)}%`;
+    const footerLeft = th.fg("dim", `${contentLines.length} lines · ${scrollPct}`);
+    const footerRight = th.fg("dim", "↑↓ scroll · PgUp/PgDn · Esc close");
+    const footerGap = Math.max(1, innerW - visibleWidth(footerLeft) - visibleWidth(footerRight));
+    lines.push(row(footerLeft + " ".repeat(footerGap) + footerRight));
+    lines.push(hrBot);
+
+    return lines;
+  }
+
+  invalidate(): void {
+    /* no cached state to clear */
+  }
+
+  dispose(): void {
+    this.closed = true;
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = undefined;
+    }
+  }
+
+  // ---- Private ----
+
+  private viewportHeight(): number {
+    return Math.max(MIN_VIEWPORT, this.tui.terminal.rows - CHROME_LINES);
+  }
+
+  private buildContentLines(width: number): string[] {
+    if (width <= 0) return [];
+
+    const th = this.theme;
+    const messages = (this.session as any).messages;
+    const lines: string[] = [];
+
+    if (!messages || messages.length === 0) {
+      lines.push(th.fg("dim", "(waiting for first message...)"));
+      return lines;
+    }
+
+    let needsSeparator = false;
+    for (const msg of messages) {
+      if (msg.role === "user") {
+        const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
+        if (!text.trim()) continue;
+        if (needsSeparator) lines.push(th.fg("dim", "───"));
+        lines.push(th.fg("accent", "[User]"));
+        for (const line of wrapTextWithAnsi(text.trim(), width)) {
+          lines.push(line);
+        }
+      } else if (msg.role === "assistant") {
+        const textParts: string[] = [];
+        const toolCalls: string[] = [];
+        for (const c of msg.content) {
+          if (c.type === "text" && c.text) textParts.push(c.text);
+          else if (c.type === "tool_use" || c.type === "toolCall") {
+            toolCalls.push((c as any).name ?? (c as any).toolName ?? "unknown");
+          }
+        }
+        if (needsSeparator) lines.push(th.fg("dim", "───"));
+        lines.push(th.bold("[Assistant]"));
+        if (textParts.length > 0) {
+          for (const line of wrapTextWithAnsi(textParts.join("\n").trim(), width)) {
+            lines.push(line);
+          }
+        }
+        for (const name of toolCalls) {
+          lines.push(truncateToWidth(th.fg("muted", `  [Tool: ${name}]`), width));
+        }
+      } else if (msg.role === "toolResult") {
+        const text = extractText(msg.content);
+        const truncated = text.length > 500 ? text.slice(0, 500) + "... (truncated)" : text;
+        if (!truncated.trim()) continue;
+        if (needsSeparator) lines.push(th.fg("dim", "───"));
+        lines.push(th.fg("dim", "[Result]"));
+        for (const line of wrapTextWithAnsi(truncated.trim(), width)) {
+          lines.push(th.fg("dim", line));
+        }
+      } else if ((msg as any).role === "bashExecution") {
+        const bash = msg as any;
+        if (needsSeparator) lines.push(th.fg("dim", "───"));
+        lines.push(truncateToWidth(th.fg("muted", `  $ ${bash.command}`), width));
+        if (bash.output?.trim()) {
+          const out = bash.output.length > 500 ? bash.output.slice(0, 500) + "... (truncated)" : bash.output;
+          for (const line of wrapTextWithAnsi(out.trim(), width)) {
+            lines.push(th.fg("dim", line));
+          }
+        }
+      } else {
+        continue;
+      }
+      needsSeparator = true;
+    }
+
+    // Streaming indicator for running agents
+    if (this.record.status === "running" && this.activity) {
+      const act = describeActivity(this.activity.activeTools, this.activity.responseText);
+      lines.push("");
+      lines.push(truncateToWidth(th.fg("accent", "▍ ") + th.fg("dim", act), width));
+    }
+
+    return lines.map((l) => truncateToWidth(l, width));
+  }
+}