@bubblebrain-ai/bubble 0.0.28 → 0.0.29

package/dist/tui-ink/message-list.js

@@ -4,10 +4,11 @@ import { Box, Static, Text, measureElement } from "ink";
 import { useTheme } from "./theme.js";
 import { highlightCode, inferLang } from "./code-highlight.js";
 import { MarkdownContent, StreamingMarkdown } from "./markdown.js";
+import { visualWidth, graphemeWidth, ambiguousIsWide } from "./width.js";
 import { userInputStatusBadgeLabel, } from "./display-history.js";
 import { buildTraceGroups, executeCommandBlock, formatTracePath, shouldInlineExecuteCommand, traceGroupLabel, } from "./trace-groups.js";
 import { EDIT_COLLAPSED_DIFF_LINES, formatEditSuccessSummary, getEditDiffDetails } from "./edit-diff.js";
-import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+import { latestSubagentNote, sortSubagents, subagentDescriptor, subagentLabel, subagentStatusColor, subagentSummary, } from "./subagent-view.js";
 import { sanitizeInternalReminderBlocks } from "../agent/internal-reminder-sanitizer.js";
 import { splitImageDisplayContent } from "../tui/image-display.js";
 const EXECUTE_COMMAND_BLOCK_MAX_LINES = 4;
@@ -116,10 +117,26 @@ const MessageItem = React.memo(function MessageItem({ message, terminalColumns,
     // Same defense as reasoning: strip any internal reminder markup the model
     // echoed back into its visible answer so it never reaches the transcript.
     const visibleContent = sanitizeInternalReminderBlocks(message.content ?? "");
-    const hasVisibleAssistantContent = !!visibleContent.trim() ||
-        (message.toolCalls?.length ?? 0) > 0 ||
-        (message.parts?.length ?? 0) > 0 ||
-        (!!visibleReasoning && (showThinking || verboseTrace));
+    // Decide visibility by what will ACTUALLY render below, not by raw array
+    // lengths. A turn whose only text part is an echoed <bubble_internal_*>
+    // reminder sanitizes to empty (TimelineText returns null), but the wrapper's
+    // marginTop/marginBottom would still emit a blank band — and long sessions
+    // inject more reminders, so consecutive empty turns stack into a large gap
+    // after the tool rows. Mirror the render: parts path → MessageParts; non-parts
+    // path → toolCalls/visibleContent; verbose adds a TurnDigest from toolCalls.
+    const hasParts = (message.parts?.length ?? 0) > 0;
+    const hasVisibleParts = hasParts &&
+        (message.parts ?? []).some((part) => part.type === "tools"
+            ? part.toolCalls.length > 0
+            : sanitizeInternalReminderBlocks(part.content).trim() !== "");
+    const toolCallCount = message.toolCalls?.length ?? 0;
+    const hasVisibleAssistantContent = (hasParts ? hasVisibleParts : (!!visibleContent.trim() || toolCallCount > 0)) ||
+        (!!visibleReasoning && (showThinking || verboseTrace)) ||
+        // A finalized turn carries taskElapsedMs and renders a TaskDurationLine even
+        // when its text/parts are empty — mirror that so the duration isn't dropped.
+        // (The verbose TurnDigest needs no term: whenever it renders, the same
+        // toolCalls already make the turn visible via the parts/non-parts branch.)
+        message.taskElapsedMs !== undefined;
     if (!hasVisibleAssistantContent)
         return null;
     return (_jsxs(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column", children: [visibleReasoning && (showThinking || verboseTrace) && _jsx(ReasoningTraceBlock, { reasoning: visibleReasoning }), message.parts && message.parts.length > 0 ? (_jsx(MessageParts, { parts: message.parts, terminalColumns: terminalColumns, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })) : (_jsxs(_Fragment, { children: [message.toolCalls && (_jsx(ToolsPart, { toolCalls: message.toolCalls, terminalColumns: terminalColumns, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })), visibleContent.trim() && _jsx(MarkdownContent, { content: visibleContent })] })), verboseTrace && message.toolCalls && message.toolCalls.length > 0 && (_jsx(TurnDigest, { toolCalls: message.toolCalls })), message.taskElapsedMs !== undefined && (_jsx(TaskDurationLine, { elapsedMs: message.taskElapsedMs }))] }));
@@ -167,10 +184,14 @@ function TimelineText({ content, compactTop, terminalColumns, streaming = false,
     const visible = sanitizeInternalReminderBlocks(content);
     if (!visible.trim())
         return null;
-    // marginLeft (2) + "●  " marker (3 visual cells) = 5 cells consumed by the
-    // timeline gutter; pass the remaining width so wide blocks like tables size
-    // themselves against the actual content area instead of the raw terminal.
-    const available = terminalColumns ? Math.max(20, terminalColumns - 5) : undefined;
+    // Timeline gutter = marginLeft (2) + "●  " marker. The ● (U+25CF) is itself
+    // an ambiguous-width glyph, so the marker is 3 cells on a narrow terminal but
+    // 4 on an ambiguous-wide one — Ink lays it out as 3 either way (it measures
+    // ●=1), so on a wide terminal the first line of every message gets shoved 1
+    // cell right and would overflow. Reserve that extra cell up front so the
+    // pre-wrap never packs a line the terminal then hard-wraps.
+    const gutter = ambiguousIsWide() ? 6 : 5;
+    const available = terminalColumns ? Math.max(20, terminalColumns - gutter) : undefined;
     const trimmed = visible.trim();
     return (_jsxs(Box, { marginLeft: 2, marginTop: compactTop ? 0 : 1, children: [_jsx(Text, { color: theme.agent, children: "\u25CF  " }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: streaming ? (_jsx(StreamingMarkdown, { content: trimmed, maxWidth: available })) : (_jsx(MarkdownContent, { content: trimmed, maxWidth: available })) })] }));
 }
@@ -300,7 +321,11 @@ function CompactionSummaryBlock({ message }) {
     const theme = useTheme();
     const rawStatus = message.content.replace(/^✓\s*/, "").trim();
     const status = rawStatus.replace(/^Compaction complete\s*(?:·\s*)?/i, "").trim() || "Session compacted";
-    const summary = message.compactionSummary?.trim();
+    // Same defense as every other visible-text path: strip any internal reminder
+    // markup before rendering, so a summary that echoed it never reaches the
+    // transcript. Belt-and-suspenders — the summarizer is fed sanitized history,
+    // but the summary is model-generated and also re-injected as context.
+    const summary = sanitizeInternalReminderBlocks(message.compactionSummary ?? "").trim() || undefined;
     return (_jsxs(Box, { marginTop: 1, marginBottom: 1, paddingX: 1, flexDirection: "column", borderStyle: "round", borderColor: theme.borderActive, children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.success, bold: true, children: "\u2713 " }), _jsx(Text, { color: theme.accent, bold: true, children: "Compaction checkpoint" }), _jsxs(Text, { color: theme.muted, children: [" \u00B7 ", status] })] }), summary && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.muted, dimColor: true, children: "Preserved context summary" }), _jsx(Box, { paddingLeft: 2, flexDirection: "column", children: _jsx(MarkdownContent, { content: summary }) })] }))] }));
 }
 function UserMessageBlock({ content, terminalColumns, inputStatus, separateFromPrevious = false, }) {
@@ -427,59 +452,6 @@ function subagentsFrom(toolCall) {
         return [];
     return raw.filter((item) => typeof item === "object" && item !== null);
 }
-function latestSubagentNote(subagent) {
-    const note = subagent.error
-        || subagent.toolNotes?.filter(Boolean).at(-1)
-        || subagent.summary
-        || subagent.task
-        || "";
-    return note.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).find(Boolean) ?? "";
-}
-function subagentLabel(subagent) {
-    return subagent.nickname ?? subagent.agentName ?? "subagent";
-}
-function subagentRole(subagent) {
-    return [subagent.agentName, subagent.category ? `/${subagent.category}` : ""].join("") || "default";
-}
-function subagentDescriptor(subagent, includeThinking = false) {
-    const route = formatSubagentRoute(subagent.route, { includeThinking });
-    const role = subagentRole(subagent);
-    return route ? `${role} @ ${route}` : role;
-}
-function subagentStatusColor(status, theme) {
-    if (status === "completed")
-        return theme.success;
-    if (status === "failed" || status === "blocked" || status === "cancelled")
-        return theme.error;
-    if (status === "queued")
-        return theme.muted;
-    return theme.toolPending;
-}
-function subagentSummary(subagents) {
-    if (subagents.length === 0)
-        return "no subagents";
-    const counts = new Map();
-    for (const subagent of subagents) {
-        const status = subagent.status ?? "running";
-        counts.set(status, (counts.get(status) ?? 0) + 1);
-    }
-    const order = ["running", "queued", "completed", "blocked", "failed", "cancelled"];
-    return order
-        .filter((status) => counts.has(status))
-        .map((status) => `${counts.get(status)} ${status}`)
-        .join("  ");
-}
-function sortSubagents(subagents) {
-    const rank = {
-        running: 0,
-        blocked: 1,
-        failed: 2,
-        queued: 3,
-        cancelled: 4,
-        completed: 5,
-    };
-    return [...subagents].sort((a, b) => (rank[a.status ?? "running"] ?? 9) - (rank[b.status ?? "running"] ?? 9));
-}
 const COLLAPSED_PREVIEW_LINES = 10;
 const EXPANDED_PREVIEW_LINES = 50;
 function ToolCallDisplay({ toolCall, isStreaming, verbose, terminalColumns, showExpandHint = false, waitingApproval = false, compactTop = false, nowTick, }) {
@@ -581,7 +553,7 @@ function SubagentToolDisplay({ toolCall, verbose, terminalColumns, compactTop, }
                         const descriptor = padVisual(truncateVisual(subagentDescriptor(subagent), descriptorWidth), descriptorWidth);
                         const note = truncateVisual(latestSubagentNote(subagent), Math.max(12, detailWidth - 16 - descriptorWidth - 10));
                         return (_jsxs(Box, { children: [_jsx(Text, { color: subagentStatusColor(status, theme), children: label }), _jsxs(Text, { color: theme.traceAction, children: [" ", descriptor] }), _jsxs(Text, { color: subagentStatusColor(status, theme), children: [" ", padVisual(status, 9)] }), note && _jsxs(Text, { color: subagent.error ? theme.error : theme.traceDetail, children: [" ", note] })] }, subagent.subAgentId ?? `${subagentLabel(subagent)}-${index}`));
-                    }), omitted > 0 && (_jsxs(Text, { color: theme.muted, children: ["... ", omitted, " more, Ctrl+O to view"] }))] })), subagents.length === 0 && toolCall.result && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: hasError ? theme.error : theme.muted, children: summarizeToolResult(toolCall) }) }))] }));
+                    }), omitted > 0 && (_jsxs(Text, { color: theme.muted, children: ["... ", omitted, " more \u00B7 Ctrl+O to expand \u00B7 Ctrl+G to inspect traces"] }))] })), subagents.length === 0 && toolCall.result && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: hasError ? theme.error : theme.muted, children: summarizeToolResult(toolCall) }) }))] }));
 }
 function TruncationHint({ remaining, verbose, showExpandHint, }) {
     const theme = useTheme();
@@ -766,7 +738,7 @@ function truncateVisual(str, maxWidth) {
     let out = "";
     let width = 0;
     for (const char of str) {
-        const w = charVisualWidth(char);
+        const w = graphemeWidth(char);
         if (width + w > maxWidth)
             break;
         out += char;
@@ -774,38 +746,10 @@ function truncateVisual(str, maxWidth) {
     }
     return out;
 }
-function visualWidth(str) {
-    let width = 0;
-    for (const char of str) {
-        const code = char.codePointAt(0) || 0;
-        if ((code >= 0x4e00 && code <= 0x9fff) ||
-            (code >= 0x3000 && code <= 0x303f) ||
-            (code >= 0xff00 && code <= 0xffef) ||
-            (code >= 0x3040 && code <= 0x309f) ||
-            (code >= 0x30a0 && code <= 0x30ff)) {
-            width += 2;
-        }
-        else {
-            width += 1;
-        }
-    }
-    return width;
-}
 function padVisual(str, width) {
     const currentWidth = visualWidth(str);
     return str + " ".repeat(Math.max(0, width - currentWidth));
 }
-function charVisualWidth(char) {
-    const code = char.codePointAt(0) || 0;
-    if ((code >= 0x4e00 && code <= 0x9fff) ||
-        (code >= 0x3000 && code <= 0x303f) ||
-        (code >= 0xff00 && code <= 0xffef) ||
-        (code >= 0x3040 && code <= 0x309f) ||
-        (code >= 0x30a0 && code <= 0x30ff)) {
-        return 2;
-    }
-    return 1;
-}
 function wrapByVisualWidth(line, maxWidth) {
     if (maxWidth <= 0)
         return [line];
@@ -815,7 +759,7 @@ function wrapByVisualWidth(line, maxWidth) {
     let current = "";
     let currentWidth = 0;
     for (const char of line) {
-        const w = charVisualWidth(char);
+        const w = graphemeWidth(char);
         if (currentWidth + w > maxWidth) {
             result.push(current);
             current = char;

package/dist/tui-ink/run.js

@@ -28,6 +28,11 @@ export async function runTui(agent, args, options = {}) {
     // forget — CodeBlock's lazy init falls back to raw lines if this isn't ready
     // yet, so callers don't need to await it.
     warmHighlighter();
+    // NOTE: the CSI 6n ambiguous-width probe is intentionally NOT run here. Doing
+    // raw-mode stdin I/O before Ink mounts left stdin in a state Bun's TTY compat
+    // didn't hand cleanly back to Ink, swallowing all composer keystrokes. The
+    // verdict now comes from `BUBBLE_AMBIGUOUS_WIDTH` / locale only (see width.ts);
+    // a safe Ink-mounted probe can be reintroduced later behind a flag.
     let exitSummary;
     const onFatalError = (err) => {
         restoreTerminal();

package/dist/tui-ink/subagent-inspector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Full-screen subagent inspector (Ctrl+G / /agents).
+ *
+ * Two-level drill-in modeled on Claude Code's workflow view: a grouped list of
+ * subagents (each spawn_agent is one member; each agent_team/agent_batch is a
+ * group of members) → a per-member working-trace detail (its task, every tool
+ * step it ran, and its final summary/error). Data is live: app.tsx derives the
+ * groups from the message state each render, so the inspector reflects running
+ * members as their events stream in.
+ */
+import { type SubagentGroup } from "./subagent-view.js";
+export type { SubagentGroup };
+export interface SubagentInspectorProps {
+    groups: SubagentGroup[];
+    onCancel: () => void;
+}
+export declare function SubagentInspector({ groups, onCancel }: SubagentInspectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/tui-ink/subagent-inspector.js

@@ -0,0 +1,189 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Full-screen subagent inspector (Ctrl+G / /agents).
+ *
+ * Two-level drill-in modeled on Claude Code's workflow view: a grouped list of
+ * subagents (each spawn_agent is one member; each agent_team/agent_batch is a
+ * group of members) → a per-member working-trace detail (its task, every tool
+ * step it ran, and its final summary/error). Data is live: app.tsx derives the
+ * groups from the message state each render, so the inspector reflects running
+ * members as their events stream in.
+ */
+import { useMemo, useState } from "react";
+import { Box, Text, useInput, useStdout } from "ink";
+import { isKeyReleaseEvent } from "./key-events.js";
+import { useTheme } from "./theme.js";
+import { padVisual, truncateVisual } from "../text-display.js";
+import { latestSubagentNote, subagentDescriptor, subagentLabel, subagentStatusColor, subagentSummary, } from "./subagent-view.js";
+const STATUS_FILTERS = [null, "running", "queued", "completed", "failed"];
+export function SubagentInspector({ groups, onCancel }) {
+    const theme = useTheme();
+    const { stdout } = useStdout();
+    const termHeight = stdout?.rows || 24;
+    const termWidth = stdout?.columns || 80;
+    const maxVisible = Math.max(6, termHeight - 12);
+    const [view, setView] = useState("list");
+    const [selectedIdx, setSelectedIdx] = useState(0);
+    const [detailScroll, setDetailScroll] = useState(0);
+    const [filterIdx, setFilterIdx] = useState(0);
+    const statusFilter = STATUS_FILTERS[filterIdx];
+    const allMembers = useMemo(() => groups.flatMap((g) => g.members), [groups]);
+    // Flat row list: a header per multi-member group, then its (filtered) members.
+    const rows = useMemo(() => {
+        const out = [];
+        for (const group of groups) {
+            const members = statusFilter
+                ? group.members.filter((m) => (m.status ?? "running") === statusFilter)
+                : group.members;
+            if (members.length === 0)
+                continue;
+            if (group.kind !== "single")
+                out.push({ type: "header", group });
+            members.forEach((member, i) => {
+                out.push({ type: "member", group, member, key: member.subAgentId ?? `${group.id}:${i}` });
+            });
+        }
+        return out;
+    }, [groups, statusFilter]);
+    const memberRowIndices = useMemo(() => rows.map((row, i) => (row.type === "member" ? i : -1)).filter((i) => i >= 0), [rows]);
+    const clampedIdx = memberRowIndices.length === 0 ? 0 : Math.min(selectedIdx, memberRowIndices.length - 1);
+    const selectedRowIndex = memberRowIndices[clampedIdx] ?? -1;
+    const selectedRow = rows[selectedRowIndex];
+    const selectedMember = selectedRow?.type === "member" ? selectedRow.member : undefined;
+    useInput((input, key) => {
+        if (isKeyReleaseEvent(key))
+            return;
+        if (view === "detail") {
+            if (key.escape || key.leftArrow) {
+                setView("list");
+                return;
+            }
+            if (key.upArrow || input === "k") {
+                setDetailScroll((s) => Math.max(0, s - 1));
+                return;
+            }
+            if (key.downArrow || input === "j") {
+                setDetailScroll((s) => s + 1);
+                return;
+            }
+            return;
+        }
+        // list view
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (input === "f") {
+            setFilterIdx((i) => (i + 1) % STATUS_FILTERS.length);
+            setSelectedIdx(0);
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIdx((i) => Math.max(0, i - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIdx((i) => Math.min(Math.max(0, memberRowIndices.length - 1), i + 1));
+            return;
+        }
+        if ((key.return || key.rightArrow) && selectedMember) {
+            setDetailScroll(0);
+            setView("detail");
+            return;
+        }
+    });
+    if (groups.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", marginY: 1, paddingX: 1, borderStyle: "round", borderColor: theme.borderActive, children: [_jsx(Text, { bold: true, color: theme.accent, children: "Subagents" }), _jsx(Text, { color: theme.muted, children: "No subagents have been spawned yet. Esc to close." })] }));
+    }
+    if (view === "detail" && selectedMember) {
+        return (_jsx(SubagentDetail, { member: selectedMember, group: selectedRow?.type === "member" ? selectedRow.group : undefined, scroll: detailScroll, maxVisible: maxVisible, termWidth: termWidth }));
+    }
+    // ---- list view ----
+    const start = clampWindowStart(rows, selectedRowIndex, maxVisible);
+    const visible = rows.slice(start, start + maxVisible);
+    const labelWidth = 12;
+    const descriptorWidth = Math.max(20, Math.min(46, termWidth - 48));
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, paddingX: 1, borderStyle: "round", borderColor: theme.borderActive, children: [_jsx(Text, { bold: true, color: theme.accent, children: "Subagents \u00B7 working traces" }), _jsxs(Text, { color: theme.muted, children: [allMembers.length, " member", allMembers.length === 1 ? "" : "s", " \u00B7 ", subagentSummary(allMembers), statusFilter ? `  ·  filter: ${statusFilter}` : ""] }), _jsx(Text, { color: theme.muted, children: "\u2191/\u2193 select \u00B7 Enter/\u2192 open trace \u00B7 f filter status \u00B7 Esc close" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [rows.length === 0 && (_jsx(Text, { color: theme.muted, children: "No members match the current filter." })), visible.map((row, i) => {
+                        const actualIndex = start + i;
+                        if (row.type === "header") {
+                            return (_jsx(Box, { marginTop: i === 0 ? 0 : 1, children: _jsxs(Text, { bold: true, color: theme.muted, children: ["\u25A6 ", row.group.kind, " \u00B7 ", truncateVisual(row.group.label, termWidth - 18), " (", row.group.members.length, ")"] }) }, `h-${actualIndex}`));
+                        }
+                        const member = row.member;
+                        const status = member.status ?? "running";
+                        const isSelected = actualIndex === selectedRowIndex;
+                        const note = truncateVisual(latestSubagentNote(member), Math.max(12, termWidth - labelWidth - descriptorWidth - 18));
+                        return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? theme.accent : undefined, children: isSelected ? "> " : "  " }), _jsx(Text, { color: subagentStatusColor(status, theme), children: padVisual(truncateVisual(subagentLabel(member), labelWidth), labelWidth) }), _jsxs(Text, { color: theme.traceAction, children: [" ", padVisual(truncateVisual(subagentDescriptor(member), descriptorWidth), descriptorWidth)] }), _jsxs(Text, { color: subagentStatusColor(status, theme), children: [" ", padVisual(status, 9)] }), note && _jsxs(Text, { color: member.error ? theme.error : theme.traceDetail, children: [" ", note] })] }, row.key));
+                    })] })] }));
+}
+function SubagentDetail({ member, group, scroll, maxVisible, termWidth, }) {
+    const theme = useTheme();
+    const status = member.status ?? "running";
+    const wrapWidth = Math.max(20, termWidth - 6);
+    // Build the scrollable body: task → working trace (every tool step) → summary/error.
+    const body = [];
+    if (member.task) {
+        body.push({ text: "Task", color: theme.muted });
+        for (const line of wrapText(member.task, wrapWidth))
+            body.push({ text: `  ${line}` });
+        body.push({ text: "" });
+    }
+    body.push({ text: `Working trace (${member.toolNotes?.length ?? 0} steps)`, color: theme.muted });
+    const notes = member.toolNotes?.filter(Boolean) ?? [];
+    if (notes.length === 0) {
+        body.push({ text: "  (no tool steps recorded yet)", dim: true });
+    }
+    else {
+        notes.forEach((noteRaw, i) => {
+            const note = noteRaw.replace(/\r\n/g, "\n").split("\n").map((l) => l.trim()).filter(Boolean).join(" ");
+            const wrapped = wrapText(`${String(i + 1).padStart(2, " ")}. ${note}`, wrapWidth);
+            wrapped.forEach((line, j) => body.push({ text: `  ${j === 0 ? line : `    ${line}`}`, color: theme.traceDetail }));
+        });
+    }
+    if (member.error) {
+        body.push({ text: "" });
+        body.push({ text: "Error", color: theme.error });
+        for (const line of wrapText(member.error, wrapWidth))
+            body.push({ text: `  ${line}`, color: theme.error });
+    }
+    else if (member.summary) {
+        body.push({ text: "" });
+        body.push({ text: "Summary", color: theme.muted });
+        for (const line of wrapText(member.summary, wrapWidth))
+            body.push({ text: `  ${line}` });
+    }
+    const maxScroll = Math.max(0, body.length - maxVisible);
+    const clampedScroll = Math.min(scroll, maxScroll);
+    const visible = body.slice(clampedScroll, clampedScroll + maxVisible);
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, paddingX: 1, borderStyle: "round", borderColor: theme.borderActive, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: theme.accent, children: subagentLabel(member) }), _jsxs(Text, { color: theme.traceAction, children: [" ", subagentDescriptor(member, true)] }), _jsxs(Text, { color: subagentStatusColor(status, theme), children: ["  ", status] }), group && group.kind !== "single" && _jsxs(Text, { color: theme.muted, children: ["  \u00B7 ", group.kind, " \u201C", truncateVisual(group.label, 28), "\u201D"] })] }), _jsxs(Text, { color: theme.muted, children: ["\u2191/\u2193 or j/k scroll \u00B7 \u2190/Esc back", maxScroll > 0 ? `  ·  ${clampedScroll + 1}-${Math.min(clampedScroll + maxVisible, body.length)}/${body.length}` : ""] }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: visible.map((line, i) => (_jsx(Text, { color: line.color, dimColor: line.dim, children: line.text || " " }, i))) })] }));
+}
+function wrapText(text, width) {
+    const out = [];
+    for (const rawLine of text.replace(/\r\n/g, "\n").split("\n")) {
+        let line = rawLine;
+        if (line.length === 0) {
+            out.push("");
+            continue;
+        }
+        while (line.length > width) {
+            // Prefer breaking at the last space within the width window.
+            let cut = line.lastIndexOf(" ", width);
+            if (cut <= 0)
+                cut = width;
+            out.push(line.slice(0, cut).trimEnd());
+            line = line.slice(cut).trimStart();
+        }
+        out.push(line);
+    }
+    return out;
+}
+function clampWindowStart(rows, selectedRowIndex, maxVisible) {
+    if (rows.length <= maxVisible)
+        return 0;
+    if (selectedRowIndex < 0)
+        return 0;
+    const half = Math.floor(maxVisible / 2);
+    let start = Math.max(0, selectedRowIndex - half);
+    if (start + maxVisible > rows.length)
+        start = rows.length - maxVisible;
+    return Math.max(0, start);
+}

package/dist/tui-ink/subagent-view.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared subagent view-model + presentation helpers, used by both the inline
+ * Subagents block (message-list.tsx) and the full-screen inspector
+ * (subagent-inspector.tsx). Pure functions only — no React.
+ */
+import { type SubagentRouteLike } from "../agent/subagent-route-format.js";
+import type { Theme } from "./theme.js";
+import type { DisplayMessage, DisplayToolCall } from "./display-history.js";
+export interface SubagentDisplay {
+    subAgentId?: string;
+    agentName?: string;
+    nickname?: string;
+    status?: string;
+    category?: string;
+    route?: SubagentRouteLike;
+    profileSource?: string;
+    task?: string;
+    summary?: string;
+    toolNotes?: string[];
+    error?: string;
+}
+export declare function latestSubagentNote(subagent: SubagentDisplay): string;
+export declare function subagentLabel(subagent: SubagentDisplay): string;
+export declare function subagentRole(subagent: SubagentDisplay): string;
+export declare function subagentDescriptor(subagent: SubagentDisplay, includeThinking?: boolean): string;
+export declare function subagentStatusColor(status: string | undefined, theme: Theme): string;
+export declare function subagentSummary(subagents: SubagentDisplay[]): string;
+export declare function sortSubagents(subagents: SubagentDisplay[]): SubagentDisplay[];
+/** A spawn_agent (one member), an agent_team/agent_batch, or a run_workflow (a group of members). */
+export interface SubagentGroup {
+    id: string;
+    kind: "single" | "team" | "batch" | "workflow";
+    label: string;
+    members: SubagentDisplay[];
+}
+/**
+ * Collects every spawned subagent from the live transcript + streaming tools,
+ * grouped by their originating tool call, for the inspector. Pure.
+ *
+ * The same subagent is echoed by MULTIPLE lifecycle tool calls — its spawn_agent
+ * (a stale snapshot) plus every wait_agent/list_agents that observed it (later
+ * snapshots), all carrying metadata.subagents (agent-lifecycle formatLifecycleResult).
+ * So we dedupe by subAgentId, keep the freshest snapshot, group team/batch members
+ * by their originating tool call, and collapse a single agent's many lifecycle
+ * echoes into one "single" group keyed by the agent itself.
+ */
+export declare function collectSubagentGroups(messages: DisplayMessage[], streamingTools: DisplayToolCall[]): SubagentGroup[];

package/dist/tui-ink/subagent-view.js

@@ -0,0 +1,163 @@
+/**
+ * Shared subagent view-model + presentation helpers, used by both the inline
+ * Subagents block (message-list.tsx) and the full-screen inspector
+ * (subagent-inspector.tsx). Pure functions only — no React.
+ */
+import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+export function latestSubagentNote(subagent) {
+    const note = subagent.error
+        || subagent.toolNotes?.filter(Boolean).at(-1)
+        || subagent.summary
+        || subagent.task
+        || "";
+    return note.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).find(Boolean) ?? "";
+}
+export function subagentLabel(subagent) {
+    return subagent.nickname ?? subagent.agentName ?? "subagent";
+}
+export function subagentRole(subagent) {
+    return [subagent.agentName, subagent.category ? `/${subagent.category}` : ""].join("") || "default";
+}
+export function subagentDescriptor(subagent, includeThinking = false) {
+    const route = formatSubagentRoute(subagent.route, { includeThinking });
+    const role = subagentRole(subagent);
+    return route ? `${role} @ ${route}` : role;
+}
+export function subagentStatusColor(status, theme) {
+    if (status === "completed")
+        return theme.success;
+    if (status === "failed" || status === "blocked" || status === "cancelled")
+        return theme.error;
+    if (status === "queued")
+        return theme.muted;
+    return theme.toolPending;
+}
+export function subagentSummary(subagents) {
+    if (subagents.length === 0)
+        return "no subagents";
+    const counts = new Map();
+    for (const subagent of subagents) {
+        const status = subagent.status ?? "running";
+        counts.set(status, (counts.get(status) ?? 0) + 1);
+    }
+    const order = ["running", "queued", "completed", "blocked", "failed", "cancelled"];
+    return order
+        .filter((status) => counts.has(status))
+        .map((status) => `${counts.get(status)} ${status}`)
+        .join("  ");
+}
+export function sortSubagents(subagents) {
+    const rank = {
+        running: 0,
+        blocked: 1,
+        failed: 2,
+        queued: 3,
+        cancelled: 4,
+        completed: 5,
+    };
+    return [...subagents].sort((a, b) => (rank[a.status ?? "running"] ?? 9) - (rank[b.status ?? "running"] ?? 9));
+}
+function subagentStatusRank(status) {
+    if (status === "completed" || status === "failed" || status === "blocked" || status === "cancelled" || status === "closed")
+        return 3;
+    if (status === "running")
+        return 2;
+    if (status === "queued")
+        return 1;
+    return 0;
+}
+/** Higher = more "complete"/recent snapshot of the same subagent. */
+function subagentFreshness(member) {
+    return subagentStatusRank(member.status) * 100_000
+        + (member.toolNotes?.length ?? 0) * 10
+        + (member.summary ? 1 : 0);
+}
+function memberKey(member) {
+    return member.subAgentId || `${member.nickname ?? ""}|${member.task ?? ""}`;
+}
+/**
+ * Collects every spawned subagent from the live transcript + streaming tools,
+ * grouped by their originating tool call, for the inspector. Pure.
+ *
+ * The same subagent is echoed by MULTIPLE lifecycle tool calls — its spawn_agent
+ * (a stale snapshot) plus every wait_agent/list_agents that observed it (later
+ * snapshots), all carrying metadata.subagents (agent-lifecycle formatLifecycleResult).
+ * So we dedupe by subAgentId, keep the freshest snapshot, group team/batch members
+ * by their originating tool call, and collapse a single agent's many lifecycle
+ * echoes into one "single" group keyed by the agent itself.
+ */
+export function collectSubagentGroups(messages, streamingTools) {
+    const toolCalls = [];
+    const ingest = (tcs) => {
+        if (!tcs)
+            return;
+        for (const tc of tcs)
+            if (tc.metadata?.kind === "subagent")
+                toolCalls.push(tc);
+    };
+    for (const message of messages) {
+        ingest(message.toolCalls);
+        if (message.parts) {
+            for (const part of message.parts) {
+                if (part.type === "tools")
+                    ingest(part.toolCalls);
+            }
+        }
+    }
+    ingest(streamingTools);
+    const freshest = new Map();
+    const memberToGroup = new Map();
+    const groups = new Map();
+    let order = 0;
+    for (const tc of toolCalls) {
+        const rawMembers = Array.isArray(tc.metadata?.subagents) ? tc.metadata.subagents : [];
+        const members = rawMembers.filter((m) => typeof m === "object" && m !== null);
+        if (members.length === 0)
+            continue;
+        // Track the freshest snapshot seen for each subagent.
+        for (const m of members) {
+            const key = memberKey(m);
+            const prev = freshest.get(key);
+            if (!prev || subagentFreshness(m) >= subagentFreshness(prev))
+                freshest.set(key, m);
+        }
+        const mode = tc.metadata.mode;
+        if (mode === "team" || mode === "batch" || mode === "workflow") {
+            // A team/batch/workflow tool call is the canonical group for its members.
+            const groupKey = tc.id;
+            if (!groups.has(groupKey)) {
+                const description = typeof tc.args?.description === "string" ? tc.args.description.trim()
+                    : typeof tc.args?.title === "string" ? tc.args.title.trim() : "";
+                groups.set(groupKey, { kind: mode, label: description || mode, memberKeys: [], order: order++ });
+            }
+            const group = groups.get(groupKey);
+            for (const m of members) {
+                const key = memberKey(m);
+                if (!memberToGroup.has(key)) {
+                    memberToGroup.set(key, groupKey);
+                    group.memberKeys.push(key);
+                }
+            }
+        }
+        else {
+            // Lifecycle echo (spawn/wait/list/...): one "single" group per agent,
+            // collapsing all its echoes; skip any already claimed by a team/batch.
+            for (const m of members) {
+                const key = memberKey(m);
+                if (memberToGroup.has(key))
+                    continue;
+                const groupKey = `single:${key}`;
+                memberToGroup.set(key, groupKey);
+                groups.set(groupKey, { kind: "single", label: m.nickname ?? m.task ?? "subagent", memberKeys: [key], order: order++ });
+            }
+        }
+    }
+    return [...groups.entries()]
+        .sort((a, b) => a[1].order - b[1].order)
+        .map(([id, g]) => ({
+        id,
+        kind: g.kind,
+        label: g.label,
+        members: g.memberKeys.map((k) => freshest.get(k)).filter((m) => !!m),
+    }));
+}

package/dist/tui-ink/terminal-env.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Whether we're running inside a terminal multiplexer (tmux or GNU screen).
+ *
+ * Ink commits settled transcript rows to native scrollback via <Static> and
+ * repaints only the short live region in place. When that live region SHRINKS
+ * (a turn settles, a steer commits, a run is interrupted), Ink erases the prior
+ * frame with a cursor-up + clear. Under a multiplexer that erase cannot reach
+ * rows that have already scrolled out of the pane, leaving a blank gap — so
+ * those transitions fall back to a full screen+scrollback reprint to stay clean.
+ *
+ * On a normal terminal that reprint is unnecessary (Ink's in-place erase works)
+ * and visible as a one-frame full-screen flash, so we skip it. This predicate is
+ * the gate. Pure + injectable for tests.
+ */
+export declare function isMultiplexedTerminal(env?: NodeJS.ProcessEnv): boolean;