@tintinweb/pi-subagents 0.2.5 → 0.2.7

package/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.7] - 2026-03-08
+
+### Fixed
+- **Widget crash in narrow terminals** — agent widget lines were not truncated to terminal width, causing `doRender` to throw when the tmux pane was narrower than the rendered content. All widget lines are now truncated using `truncateToWidth()` with the actual terminal column count.
+
+## [0.2.6] - 2026-03-07
+
+### Added
+- **Background task join strategies** — smart grouping of background agent completion notifications
+  - `smart` (default): 2+ background agents spawned in the same turn are auto-grouped into a single consolidated notification instead of individual nudges
+  - `async`: each agent notifies individually on completion (previous behavior)
+  - `group`: force grouping even for solo agents
+  - 30s timeout after first completion delivers partial results; 15s straggler re-batch window for remaining agents
+- **`join_mode` parameter** on the `Agent` tool — override join strategy per agent (`"async"` or `"group"`)
+- **Join mode setting** in `/agents` → Settings — configure the default join mode at runtime
+- New `src/group-join.ts` — `GroupJoinManager` class for batched completion notifications
+
+### Changed
+- `AgentRecord` now includes optional `groupId`, `joinMode`, and `resultConsumed` fields
+- Background agent completion routing refactored: individual nudge logic extracted to `sendIndividualNudge()`, group delivery via `GroupJoinManager`
+
+### Fixed
+- **Debounce window race** — agents that complete during the 100ms batch debounce window are now deferred and retroactively fed into the group once it's registered, preventing split notifications (one individual + one partial group) and zombie groups
+- **Solo agent swallowed notification** — if only one agent was spawned (no group formed) but it completed during the debounce window, its deferred notification is now sent when the batch finalizes
+- **Duplicate notifications after polling** — calling `get_subagent_result` on a completed agent now marks its result as consumed, suppressing the subsequent completion notification (both individual and group)
+
 ## [0.2.5] - 2026-03-06
 
 ### Added
@@ -104,6 +130,8 @@ Initial release.
 - **Thinking level** — per-agent extended thinking control
 - **`/agent` and `/agents` commands**
 
+[0.2.7]: https://github.com/tintinweb/pi-subagents/compare/v0.2.6...v0.2.7
+[0.2.6]: https://github.com/tintinweb/pi-subagents/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/tintinweb/pi-subagents/compare/v0.2.4...v0.2.5
 [0.2.4]: https://github.com/tintinweb/pi-subagents/compare/v0.2.3...v0.2.4
 [0.2.3]: https://github.com/tintinweb/pi-subagents/compare/v0.2.2...v0.2.3

package/README.md

@@ -13,7 +13,7 @@ https://github.com/user-attachments/assets/5d1331e8-6d02-420b-b30a-dcbf838b1660
 ## Features
 
 - **Claude Code look & feel** — same tool names, calling conventions, and UI patterns (`Agent`, `get_subagent_result`, `steer_subagent`) — feels native
-- **Parallel background agents** — spawn multiple agents that run concurrently with automatic queuing (configurable concurrency limit, default 4)
+- **Parallel background agents** — spawn multiple agents that run concurrently with automatic queuing (configurable concurrency limit, default 4) and smart group join (consolidated notifications)
 - **Live widget UI** — persistent above-editor widget with animated spinners, live tool activity, token counts, and colored status icons
 - **Custom agent types** — define agents in `.pi/agents/<name>.md` with YAML frontmatter: custom system prompts, model selection, thinking levels, tool restrictions
 - **Mid-run steering** — inject messages into running agents to redirect their work without restarting
@@ -162,6 +162,7 @@ Launch a sub-agent.
 | `resume` | string | no | Agent ID to resume a previous session |
 | `isolated` | boolean | no | No extension/MCP tools |
 | `inherit_context` | boolean | no | Fork parent conversation into agent |
+| `join_mode` | `"async"` \| `"group"` | no | Override join strategy for background completion notifications (default: smart) |
 
 ### `get_subagent_result`
 
@@ -194,7 +195,7 @@ The `/agents` command opens an interactive menu:
 Running agents (2) — 1 running, 1 done     ← only shown when agents exist
 Custom agents (3)                           ← submenu: edit or delete agents
 Create new agent                            ← manual wizard or AI-generated
-Settings                                    ← max concurrency, max turns, grace turns
+Settings                                    ← max concurrency, max turns, grace turns, join mode
 
 Built-in (always available):
   general-purpose · inherit
@@ -205,7 +206,7 @@ Built-in (always available):
 
 - **Custom agents submenu** — select an agent to edit (opens editor) or delete
 - **Create new agent** — choose project/personal location, then manual wizard (step-by-step prompts for name, tools, model, thinking, system prompt) or AI-generated (describe what the agent should do and a sub-agent writes the `.md` file)
-- **Settings** — configure max concurrency, default max turns, and grace turns at runtime
+- **Settings** — configure max concurrency, default max turns, grace turns, and join mode at runtime
 
 ## Graceful Max Turns
 
@@ -228,6 +229,22 @@ Background agents are subject to a configurable concurrency limit (default: 4).
 
 Foreground agents bypass the queue — they block the parent anyway.
 
+## Join Strategies
+
+When background agents complete, they notify the main agent. The **join mode** controls how these notifications are delivered:
+
+| Mode | Behavior |
+|------|----------|
+| `smart` (default) | 2+ background agents spawned in the same turn are auto-grouped into a single consolidated notification. Solo agents notify individually. |
+| `async` | Each agent sends its own notification on completion (original behavior). Best when results need incremental processing. |
+| `group` | Force grouping even when spawning a single agent. Useful when you know more agents will follow. |
+
+**Timeout behavior:** When agents are grouped, a 30-second timeout starts after the first agent completes. If not all agents finish in time, a partial notification is sent with completed results and remaining agents continue with a shorter 15-second re-batch window for stragglers.
+
+**Configuration:**
+- Per-call: `Agent({ ..., join_mode: "async" })` overrides for that agent
+- Global default: `/agents` → Settings → Join mode
+
 ## Architecture
 
 ```
@@ -237,6 +254,7 @@ src/
   agent-types.ts      # Agent type registry (built-in + custom), tool factories
   agent-runner.ts     # Session creation, execution, graceful max_turns, steer/resume
   agent-manager.ts    # Agent lifecycle, concurrency queue, completion notifications
+  group-join.ts       # Group join manager: batched completion notifications with timeout
   custom-agents.ts    # Load custom agents from .pi/agents/*.md
   prompts.ts          # System prompts per agent type
   context.ts          # Parent conversation context for inherit_context

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tintinweb/pi-subagents",
-  "version": "0.2.5",
-  "description": "A pi extension providing autonomous sub-agents with Claude Code-style UI",
+  "version": "0.2.7",
+  "description": "A pi extension extension that brings smart Claude Code-style autonomous sub-agents to pi.",
   "author": "tintinweb",
   "license": "MIT",
   "repository": {

package/src/group-join.ts

@@ -0,0 +1,141 @@
+/**
+ * group-join.ts — Manages grouped background agent completion notifications.
+ *
+ * Instead of each agent individually nudging the main agent on completion,
+ * agents in a group are held until all complete (or a timeout fires),
+ * then a single consolidated notification is sent.
+ */
+
+import type { AgentRecord } from "./types.js";
+
+export type DeliveryCallback = (records: AgentRecord[], partial: boolean) => void;
+
+interface AgentGroup {
+  groupId: string;
+  agentIds: Set<string>;
+  completedRecords: Map<string, AgentRecord>;
+  timeoutHandle?: ReturnType<typeof setTimeout>;
+  delivered: boolean;
+  /** Shorter timeout for stragglers after a partial delivery. */
+  isStraggler: boolean;
+}
+
+/** Default timeout: 30s after first completion in a group. */
+const DEFAULT_TIMEOUT = 30_000;
+/** Straggler re-batch timeout: 15s. */
+const STRAGGLER_TIMEOUT = 15_000;
+
+export class GroupJoinManager {
+  private groups = new Map<string, AgentGroup>();
+  private agentToGroup = new Map<string, string>();
+
+  constructor(
+    private deliverCb: DeliveryCallback,
+    private groupTimeout = DEFAULT_TIMEOUT,
+  ) {}
+
+  /** Register a group of agent IDs that should be joined. */
+  registerGroup(groupId: string, agentIds: string[]): void {
+    const group: AgentGroup = {
+      groupId,
+      agentIds: new Set(agentIds),
+      completedRecords: new Map(),
+      delivered: false,
+      isStraggler: false,
+    };
+    this.groups.set(groupId, group);
+    for (const id of agentIds) {
+      this.agentToGroup.set(id, groupId);
+    }
+  }
+
+  /**
+   * Called when an agent completes.
+   * Returns:
+   * - 'pass'      — agent is not grouped, caller should send individual nudge
+   * - 'held'      — result held, waiting for group completion
+   * - 'delivered'  — this completion triggered the group notification
+   */
+  onAgentComplete(record: AgentRecord): 'delivered' | 'held' | 'pass' {
+    const groupId = this.agentToGroup.get(record.id);
+    if (!groupId) return 'pass';
+
+    const group = this.groups.get(groupId);
+    if (!group || group.delivered) return 'pass';
+
+    group.completedRecords.set(record.id, record);
+
+    // All done — deliver immediately
+    if (group.completedRecords.size >= group.agentIds.size) {
+      this.deliver(group, false);
+      return 'delivered';
+    }
+
+    // First completion in this batch — start timeout
+    if (!group.timeoutHandle) {
+      const timeout = group.isStraggler ? STRAGGLER_TIMEOUT : this.groupTimeout;
+      group.timeoutHandle = setTimeout(() => {
+        this.onTimeout(group);
+      }, timeout);
+    }
+
+    return 'held';
+  }
+
+  private onTimeout(group: AgentGroup): void {
+    if (group.delivered) return;
+    group.timeoutHandle = undefined;
+
+    // Partial delivery — some agents still running
+    const remaining = new Set<string>();
+    for (const id of group.agentIds) {
+      if (!group.completedRecords.has(id)) remaining.add(id);
+    }
+
+    // Clean up agentToGroup for delivered agents (they won't complete again)
+    for (const id of group.completedRecords.keys()) {
+      this.agentToGroup.delete(id);
+    }
+
+    // Deliver what we have
+    this.deliverCb([...group.completedRecords.values()], true);
+
+    // Set up straggler group for remaining agents
+    group.completedRecords.clear();
+    group.agentIds = remaining;
+    group.isStraggler = true;
+    // Timeout will be started when the next straggler completes
+  }
+
+  private deliver(group: AgentGroup, partial: boolean): void {
+    if (group.timeoutHandle) {
+      clearTimeout(group.timeoutHandle);
+      group.timeoutHandle = undefined;
+    }
+    group.delivered = true;
+    this.deliverCb([...group.completedRecords.values()], partial);
+    this.cleanupGroup(group.groupId);
+  }
+
+  private cleanupGroup(groupId: string): void {
+    const group = this.groups.get(groupId);
+    if (!group) return;
+    for (const id of group.agentIds) {
+      this.agentToGroup.delete(id);
+    }
+    this.groups.delete(groupId);
+  }
+
+  /** Check if an agent is in a group. */
+  isGrouped(agentId: string): boolean {
+    return this.agentToGroup.has(agentId);
+  }
+
+  dispose(): void {
+    for (const group of this.groups.values()) {
+      if (group.timeoutHandle) clearTimeout(group.timeoutHandle);
+    }
+    this.groups.clear();
+    this.agentToGroup.clear();
+  }
+}

package/src/index.ts

@@ -18,7 +18,8 @@ import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { AgentManager } from "./agent-manager.js";
 import { steerAgent, getAgentConversation, getDefaultMaxTurns, setDefaultMaxTurns, getGraceTurns, setGraceTurns } from "./agent-runner.js";
-import { SUBAGENT_TYPES, type SubagentType, type ThinkingLevel, type CustomAgentConfig } from "./types.js";
+import { SUBAGENT_TYPES, type SubagentType, type ThinkingLevel, type CustomAgentConfig, type JoinMode, type AgentRecord } from "./types.js";
+import { GroupJoinManager } from "./group-join.js";
 import { getAvailableTypes, getCustomAgentNames, getCustomAgentConfig, isValidType, registerCustomAgents, BUILTIN_TOOL_NAMES } from "./agent-types.js";
 import { loadCustomAgents } from "./custom-agents.js";
 import {
@@ -202,13 +203,11 @@ export default function (pi: ExtensionAPI) {
   // ---- Agent activity tracking + widget ----
   const agentActivity = new Map<string, AgentActivity>();
 
-  // Background completion: push notification into conversation
-  const manager = new AgentManager((record) => {
+  // ---- Individual nudge helper (async join mode) ----
+  function sendIndividualNudge(record: AgentRecord) {
     const displayName = getDisplayName(record.type);
     const duration = formatDuration(record.startedAt, record.completedAt);
-
     const status = getStatusLabel(record.status, record.error);
-
     const resultPreview = record.result
       ? record.result.length > 500
         ? record.result.slice(0, 500) + "\n...(truncated, use get_subagent_result for full output)"
@@ -218,7 +217,6 @@ export default function (pi: ExtensionAPI) {
     agentActivity.delete(record.id);
     widget.markFinished(record.id);
 
-    // Poke the main agent so it processes the result (queues as follow-up if busy)
     pi.sendUserMessage(
       `Background agent completed: ${displayName} (${record.description})\n` +
       `Agent ID: ${record.id} | Status: ${status} | Tool uses: ${record.toolUses} | Duration: ${duration}\n\n` +
@@ -226,11 +224,128 @@ export default function (pi: ExtensionAPI) {
       { deliverAs: "followUp" },
     );
     widget.update();
+  }
+
+  /** Format a single agent's summary for grouped notification. */
+  function formatAgentSummary(record: AgentRecord): string {
+    const displayName = getDisplayName(record.type);
+    const duration = formatDuration(record.startedAt, record.completedAt);
+    const status = getStatusLabel(record.status, record.error);
+    const resultPreview = record.result
+      ? record.result.length > 300
+        ? record.result.slice(0, 300) + "\n...(truncated)"
+        : record.result
+      : "No output.";
+    return `- ${displayName} (${record.description})\n  ID: ${record.id} | Status: ${status} | Tools: ${record.toolUses} | Duration: ${duration}\n  ${resultPreview}`;
+  }
+
+  // ---- Group join manager ----
+  const groupJoin = new GroupJoinManager(
+    (records, partial) => {
+      // Filter out agents whose results were already consumed via get_subagent_result
+      const unconsumed = records.filter(r => !r.resultConsumed);
+
+      for (const r of records) {
+        agentActivity.delete(r.id);
+        widget.markFinished(r.id);
+      }
+
+      // If all results were already consumed, skip the notification entirely
+      if (unconsumed.length === 0) {
+        widget.update();
+        return;
+      }
+
+      const total = unconsumed.length;
+      const label = partial ? `${total} agent(s) finished (partial — others still running)` : `${total} agent(s) finished`;
+      const summary = unconsumed.map(r => formatAgentSummary(r)).join("\n\n");
+
+      pi.sendUserMessage(
+        `Background agent group completed: ${label}\n\n${summary}\n\nUse get_subagent_result for full output.`,
+        { deliverAs: "followUp" },
+      );
+      widget.update();
+    },
+    30_000,
+  );
+
+  // Background completion: route through group join or send individual nudge
+  const manager = new AgentManager((record) => {
+    // Skip notification if result was already consumed via get_subagent_result
+    if (record.resultConsumed) {
+      agentActivity.delete(record.id);
+      widget.markFinished(record.id);
+      widget.update();
+      return;
+    }
+
+    // If this agent is pending batch finalization (debounce window still open),
+    // don't send an individual nudge — finalizeBatch will pick it up retroactively.
+    if (currentBatchAgents.some(a => a.id === record.id)) {
+      widget.update();
+      return;
+    }
+
+    const result = groupJoin.onAgentComplete(record);
+    if (result === 'pass') {
+      sendIndividualNudge(record);
+    }
+    // 'held' → do nothing, group will fire later
+    // 'delivered' → group callback already fired
+    widget.update();
   });
 
   // Live widget: show running agents above editor
   const widget = new AgentWidget(manager, agentActivity);
 
+  // ---- Join mode configuration ----
+  let defaultJoinMode: JoinMode = 'smart';
+  function getDefaultJoinMode(): JoinMode { return defaultJoinMode; }
+  function setDefaultJoinMode(mode: JoinMode) { defaultJoinMode = mode; }
+
+  // ---- Batch tracking for smart join mode ----
+  // Collects background agent IDs spawned in the current turn for smart grouping.
+  // Uses a debounced timer: each new agent resets the 100ms window so that all
+  // parallel tool calls (which may be dispatched across multiple microtasks by the
+  // framework) are captured in the same batch.
+  let currentBatchAgents: { id: string; joinMode: JoinMode }[] = [];
+  let batchFinalizeTimer: ReturnType<typeof setTimeout> | undefined;
+  let batchCounter = 0;
+
+  /** Finalize the current batch: if 2+ smart-mode agents, register as a group. */
+  function finalizeBatch() {
+    batchFinalizeTimer = undefined;
+    const batchAgents = [...currentBatchAgents];
+    currentBatchAgents = [];
+
+    const smartAgents = batchAgents.filter(a => a.joinMode === 'smart' || a.joinMode === 'group');
+    if (smartAgents.length >= 2) {
+      const groupId = `batch-${++batchCounter}`;
+      const ids = smartAgents.map(a => a.id);
+      groupJoin.registerGroup(groupId, ids);
+      // Retroactively process agents that already completed during the debounce window.
+      // Their onComplete fired but was deferred (agent was in currentBatchAgents),
+      // so we feed them into the group now.
+      for (const id of ids) {
+        const record = manager.getRecord(id);
+        if (!record) continue;
+        record.groupId = groupId;
+        if (record.completedAt != null && !record.resultConsumed) {
+          groupJoin.onAgentComplete(record);
+        }
+      }
+    } else {
+      // No group formed — send individual nudges for any agents that completed
+      // during the debounce window and had their notification deferred.
+      for (const { id } of batchAgents) {
+        const record = manager.getRecord(id);
+        if (record?.completedAt != null && !record.resultConsumed) {
+          sendIndividualNudge(record);
+        }
+      }
+    }
+  }
+
   // Grab UI context from first tool execution + clear lingering widget on new turn
   pi.on("tool_execution_start", async (_event, ctx) => {
     widget.setUICtx(ctx.ui as UICtx);
@@ -288,7 +403,8 @@ Guidelines:
 - Use steer_subagent to send mid-run messages to a running background agent.
 - Use model to specify a different model (as "provider/modelId", or fuzzy e.g. "haiku", "sonnet").
 - Use thinking to control extended thinking level.
-- Use inherit_context if the agent needs the parent conversation history.`,
+- Use inherit_context if the agent needs the parent conversation history.
+- Use join_mode to control how background completion notifications are delivered. By default (smart), 2+ background agents spawned in the same turn are grouped into a single notification. Use "async" for individual notifications or "group" to force grouping.`,
     parameters: Type.Object({
       prompt: Type.String({
         description: "The task for the agent to perform.",
@@ -336,6 +452,12 @@ Guidelines:
           description: "If true, fork parent conversation into the agent. Default: false (fresh context).",
         }),
       ),
+      join_mode: Type.Optional(
+        Type.Union([
+          Type.Literal("async"),
+          Type.Literal("group"),
+        ], { description: "Override join behavior for background agents. async: individual nudge on completion. group: hold and send one consolidated notification when all agents in the group complete. Default: smart (auto-groups 2+ background agents spawned in the same turn)." }),
+      ),
     }),
 
     // ---- Custom rendering: Claude Code style ----
@@ -520,10 +642,25 @@ Guidelines:
           ...bgCallbacks,
         });
 
+        // Determine join mode and track for batching
+        const joinMode: JoinMode = params.join_mode ?? defaultJoinMode;
+        const record = manager.getRecord(id);
+        if (record) record.joinMode = joinMode;
+
+        if (joinMode === 'async') {
+          // Explicit async — not part of any batch
+        } else {
+          // smart or group — add to current batch
+          currentBatchAgents.push({ id, joinMode });
+          // Debounce: reset timer on each new agent so parallel tool calls
+          // dispatched across multiple event loop ticks are captured together
+          if (batchFinalizeTimer) clearTimeout(batchFinalizeTimer);
+          batchFinalizeTimer = setTimeout(finalizeBatch, 100);
+        }
+
         agentActivity.set(id, bgState);
         widget.ensureTimer();
         widget.update();
-        const record = manager.getRecord(id);
         const isQueued = record?.status === "queued";
         return textResult(
           `Agent ${isQueued ? "queued" : "started"} in background.\n` +
@@ -670,6 +807,11 @@ Guidelines:
         output += record.result ?? "No output.";
       }
 
+      // Mark result as consumed — suppresses the completion notification
+      if (record.status !== "running" && record.status !== "queued") {
+        record.resultConsumed = true;
+      }
+
       // Verbose: include full conversation
       if (params.verbose && record.session) {
         const conversation = getAgentConversation(record.session);
@@ -1090,6 +1232,7 @@ ${systemPrompt}
       `Max concurrency (current: ${manager.getMaxConcurrent()})`,
       `Default max turns (current: ${getDefaultMaxTurns()})`,
       `Grace turns (current: ${getGraceTurns()})`,
+      `Join mode (current: ${getDefaultJoinMode()})`,
     ]);
     if (!choice) return;
 
@@ -1126,6 +1269,17 @@ ${systemPrompt}
           ctx.ui.notify("Must be a positive integer.", "warning");
         }
       }
+    } else if (choice.startsWith("Join mode")) {
+      const val = await ctx.ui.select("Default join mode for background agents", [
+        "smart — auto-group 2+ agents in same turn (default)",
+        "async — always notify individually",
+        "group — always group background agents",
+      ]);
+      if (val) {
+        const mode = val.split(" ")[0] as JoinMode;
+        setDefaultJoinMode(mode);
+        ctx.ui.notify(`Default join mode set to ${mode}`, "info");
+      }
     }
   }
 

package/src/types.ts

@@ -62,6 +62,8 @@ export interface CustomAgentConfig {
   isolated: boolean;
 }
 
+export type JoinMode = 'async' | 'group' | 'smart';
+
 export interface AgentRecord {
   id: string;
   type: SubagentType;
@@ -75,6 +77,10 @@ export interface AgentRecord {
   session?: AgentSession;
   abortController?: AbortController;
   promise?: Promise<string>;
+  groupId?: string;
+  joinMode?: JoinMode;
+  /** Set when result was already consumed via get_subagent_result — suppresses completion notification. */
+  resultConsumed?: boolean;
 }
 
 export interface EnvInfo {

package/src/ui/agent-widget.ts

@@ -5,6 +5,7 @@
  * Uses the callback form of setWidget for themed rendering.
  */
 
+import { truncateToWidth } from "@mariozechner/pi-tui";
 import type { AgentManager } from "../agent-manager.js";
 import type { SubagentType } from "../types.js";
 import { getConfig } from "../agent-types.js";
@@ -262,17 +263,19 @@ export class AgentWidget {
     this.widgetFrame++;
     const frame = SPINNER[this.widgetFrame % SPINNER.length];
 
-    this.uiCtx.setWidget("agents", (_tui, theme) => {
+    this.uiCtx.setWidget("agents", (tui, theme) => {
+      const w = tui.terminal.columns;
+      const truncate = (line: string) => truncateToWidth(line, w);
       const headingColor = hasActive ? "accent" : "dim";
       const headingIcon = hasActive ? "●" : "○";
-      const lines: string[] = [theme.fg(headingColor, headingIcon) + " " + theme.fg(headingColor, "Agents")];
+      const lines: string[] = [truncate(theme.fg(headingColor, headingIcon) + " " + theme.fg(headingColor, "Agents"))];
 
       // --- Finished agents (shown first, dimmed) ---
       for (let i = 0; i < finished.length; i++) {
         const a = finished[i];
         const isLast = !hasActive && i === finished.length - 1;
         const connector = isLast ? "└─" : "├─";
-        lines.push(theme.fg("dim", connector) + " " + this.renderFinishedLine(a, theme));
+        lines.push(truncate(theme.fg("dim", connector) + " " + this.renderFinishedLine(a, theme)));
       }
 
       // --- Running agents ---
@@ -299,14 +302,14 @@ export class AgentWidget {
 
         const activity = bg ? describeActivity(bg.activeTools, bg.responseText) : "thinking…";
 
-        lines.push(theme.fg("dim", connector) + ` ${theme.fg("accent", frame)} ${theme.bold(name)}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", statsText)}`);
+        lines.push(truncate(theme.fg("dim", connector) + ` ${theme.fg("accent", frame)} ${theme.bold(name)}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", statsText)}`));
         const indent = isLast ? "   " : "│  ";
-        lines.push(theme.fg("dim", indent) + theme.fg("dim", `  ⎿  ${activity}`));
+        lines.push(truncate(theme.fg("dim", indent) + theme.fg("dim", `  ⎿  ${activity}`)));
       }
 
       // --- Queued agents (collapsed) ---
       if (queued.length > 0) {
-        lines.push(theme.fg("dim", "└─") + ` ${theme.fg("muted", "◦")} ${theme.fg("dim", `${queued.length} queued`)}`);
+        lines.push(truncate(theme.fg("dim", "└─") + ` ${theme.fg("muted", "◦")} ${theme.fg("dim", `${queued.length} queued`)}`));
       }
 
       return { render: () => lines, invalidate: () => {} };