oira666_pi-subagent 0.3.11 → 0.3.13

package/README.md

@@ -130,7 +130,9 @@ The Markdown body becomes the agent's system prompt (appended to Pi's default, n
 
 ## Delegation Guards
 
-Depth and cycle guards prevent runaway recursive delegation. Layer availability is evaluated for the child being launched: depth 1 is the first layer, and `PI_SUBAGENT_MAX_DEPTH` is the last layer. The bundled `team-lead` agent sets `last-layer: disabled` so it cannot consume the final delegation layer. Cycle checks are applied per task: in a mixed parallel call, cyclic tasks fail while legal siblings still run.
+Depth and cycle guards prevent runaway recursive delegation. Layer availability is evaluated for the child being launched: depth 1 is the first layer, and `PI_SUBAGENT_MAX_DEPTH` is the last layer. The bundled `team-lead` agent sets `last-layer: disabled` so it cannot consume the final delegation layer. When cycle prevention is enabled, agents already in the current delegation stack are omitted from the child model's available-agent list. The runner still checks every task as a safety boundary: in a mixed parallel call, cyclic tasks fail while legal siblings still run.
+
+A nested delegation failure is returned to its calling agent as a recoverable tool error. If that agent subsequently retries, completes the work itself, and produces a successful final answer, the earlier tool error does not incorrectly turn the completed agent—and all of its ancestors—into failures.
 
 | Config                         | Default | Description                                      |
 | ------------------------------ | ------- | ------------------------------------------------ |
@@ -175,7 +177,10 @@ reported immediately as failures.
 ## Timestamps & Status Footer
 
 Subagent tool calls and live activity lines render a dim `hh:mm:ss` timestamp
-(call start, per-subagent run start, and each live log entry).
+(call start, per-subagent run start, and each live log entry). The collapsed tool
+row keeps the normal compact progress text. Press `Ctrl+O` to expand it into the
+subagent tree immediately; every running node shows its latest six activity
+lines (thinking, tool starts/completions, and completed turns).
 
 In the interactive TUI the extension publishes the combined `total` usage line
 (parent + all subagents, recursively) via Pi's normal `ctx.ui.setStatus()`

package/agents.ts

@@ -200,6 +200,27 @@ export function isAgentEnabledAtLayer(
 	return true;
 }
 
+/**
+ * Return only agents that may be advertised for the next delegation.
+ *
+ * The runner still enforces cycle prevention as a final safety boundary, but
+ * forbidden agents must not be presented to the model as available choices.
+ */
+export function filterAdvertisedAgents(
+	agents: AgentConfig[],
+	targetDepth: number,
+	maxDepth: number,
+	delegationStack: string[],
+	preventCycles: boolean,
+): AgentConfig[] {
+	const blocked = preventCycles ? new Set(delegationStack) : null;
+	return agents.filter(
+		(agent) =>
+			isAgentEnabledAtLayer(agent, targetDepth, maxDepth) &&
+			!blocked?.has(agent.name),
+	);
+}
+
 /**
  * Discover all available agents according to the requested scope.
  *

package/index.ts

@@ -18,7 +18,12 @@ import {
   lazyStream,
 } from "@mariozechner/pi-ai";
 import { Type } from "@sinclair/typebox";
-import { type AgentConfig, discoverAgents, isAgentEnabledAtLayer } from "./agents.js";
+import {
+  type AgentConfig,
+  discoverAgents,
+  filterAdvertisedAgents,
+  isAgentEnabledAtLayer,
+} from "./agents.js";
 import { loadPiSubagentsConfig } from "./config.js";
 import {
   allocateSubagentNames,
@@ -430,6 +435,22 @@ function filterAgentsForCurrentLayer(
   return agents.filter((agent) => isAgentEnabledAtLayer(agent, targetDepth, maxDepth));
 }
 
+function filterAgentsForPrompt(
+  agents: AgentConfig[],
+  currentDepth: number,
+  maxDepth: number,
+  delegationStack: string[],
+  preventCycles: boolean,
+): AgentConfig[] {
+  return filterAdvertisedAgents(
+    agents,
+    currentDepth + 1,
+    maxDepth,
+    delegationStack,
+    preventCycles,
+  );
+}
+
 function formatAgentNames(agents: AgentConfig[]): string {
   return agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
 }
@@ -1424,7 +1445,13 @@ export default function (pi: ExtensionAPI) {
       if (!canDelegate) return;
 
       const discovery = discoverAgents(ctx.cwd, "both");
-      discoveredAgents = filterAgentsForCurrentLayer(discovery.agents, currentDepth, maxDepth);
+      discoveredAgents = filterAgentsForPrompt(
+        discovery.agents,
+        currentDepth,
+        maxDepth,
+        ancestorAgentStack,
+        preventCycles,
+      );
       currentSessionId = ctx.sessionManager.getSessionId?.() ?? "ephemeral";
       currentSubagentSessionRoot = getDefaultSubagentSessionRoot(ctx);
       if (resumableSubagentsDisabled()) {
@@ -1720,11 +1747,12 @@ export default function (pi: ExtensionAPI) {
   pi.on("before_agent_start", async (event) => {
     try {
       if (!canDelegate) return;
-      if (discoveredAgents.length === 0) return;
 
-      const agentList = discoveredAgents
-        .map((a) => `- **${a.name}**: ${a.description}`)
-        .join("\n");
+      const agentList = discoveredAgents.length > 0
+        ? discoveredAgents
+            .map((a) => `- **${a.name}**: ${a.description}`)
+            .join("\n")
+        : "_No agents are available for the next delegation layer. Do not call the subagents tool._";
       const subagentsGuidance = configuredToolPrompts[SUBAGENT_TOOL_NAME] ?? `### How to call the subagents tool
 
 Each subagent runs in an **isolated process**.
@@ -1746,8 +1774,18 @@ calls one after another. Do NOT put dependent tasks in the same array.
 { "tasks": [{ "agent": "agent-a", "task": "..." }, { "agent": "agent-b", "task": "..." }] }
 \`\`\`
 
-- Max depth: current depth ${currentDepth}, max depth ${maxDepth}
 - Max subagents per tool call: ${maxParallelTasks}`;
+      const delegationStackText = ancestorAgentStack.length > 0
+        ? ancestorAgentStack.join(" -> ")
+        : "(root)";
+      const delegationGuardGuidance = `### Delegation guards
+
+- Current depth: ${currentDepth}; max depth: ${maxDepth}
+- Cycle prevention: ${preventCycles ? "enabled" : "disabled"}
+- Current delegation stack: ${delegationStackText}
+${preventCycles
+  ? "- Agents already in this stack are intentionally omitted from the available list. Do not request omitted agent names."
+  : "- Cyclic delegation is allowed by configuration."}`;
       const resumeGuidance = resumableSubagentsDisabled()
         ? ""
         : configuredToolPrompts[RESUME_SUBAGENTS_TOOL_NAME] ?? `### Resumable subagents
@@ -1772,7 +1810,7 @@ keeping their full previous context:
 
 The following subagents are available via the \`subagents\` tool:
 
-${agentList}\n\n${subagentsGuidance}${resumeGuidance ? `\n\n${resumeGuidance}` : ""}`,
+${agentList}\n\n${subagentsGuidance}\n\n${delegationGuardGuidance}${resumeGuidance ? `\n\n${resumeGuidance}` : ""}`,
       };
     } catch (err) {
       console.error("[pi-subagent] Error in before_agent_start:", err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",

package/render.ts

@@ -7,12 +7,19 @@
  */
 
 import { Container, Spacer, Text } from "@mariozechner/pi-tui";
-import type { SubagentDetails } from "./types.js";
+import {
+	MAX_LIVE_LOG_ENTRIES,
+	isResultError,
+	isSubagentDetails,
+	type SingleResult,
+	type SubagentDetails,
+} from "./types.js";
 import {
 	type ThemeFg,
 	buildTopLevelNodes,
 	countNodes,
 	formatClockTime,
+	formatLiveLogEntry,
 	hasNestedChildren,
 	renderTreeLines,
 	setBroadcastNumberingActive,
@@ -122,37 +129,119 @@ export function renderResumeCall(
 // renderResult — shown after the tool completes / streams updates
 // ---------------------------------------------------------------------------
 
+function getResultText(
+	result: { content?: Array<{ type: string; text?: string }> },
+): string {
+	const first = Array.isArray(result.content) ? result.content[0] : undefined;
+	return first?.type === "text" && typeof first.text === "string" && first.text
+		? first.text
+		: "(no output)";
+}
+
+function compactText(text: string, maxLength = 240): string {
+	const firstLine = text.replace(/\r\n?/g, "\n").split("\n").find((line) => line.trim()) ?? "(no output)";
+	return truncate(firstLine, maxLength);
+}
+
+function isRenderableResult(value: unknown): value is SingleResult {
+	return value !== null &&
+		typeof value === "object" &&
+		!Array.isArray(value) &&
+		typeof (value as Partial<SingleResult>).agent === "string" &&
+		typeof (value as Partial<SingleResult>).exitCode === "number";
+}
+
+function getCollapsedResultText(details: SubagentDetails, fallbackText: string): string {
+	const results = details.results.filter(isRenderableResult);
+	if (results.length === 0) return compactText(fallbackText);
+
+	const running = results.filter((item) => item.exitCode === -1).length;
+	const finished = results.length - running;
+	const succeeded = results.filter((item) => item.exitCode === 0 && !isResultError(item)).length;
+	const failed = finished - succeeded;
+
+	if (details.mode === "parallel") {
+		return running > 0
+			? `Parallel: ${finished}/${results.length} done, ${running} running...`
+			: `Parallel: ${succeeded}/${results.length} succeeded${failed > 0 ? `, ${failed} failed` : ""}`;
+	}
+
+	const item = results[0];
+	if (item.exitCode === -1) return `Agent ${item.agent}: running...`;
+	if (isResultError(item)) {
+		const reason = [item.errorMessage, item.stderr, item.stopReason]
+			.find((value): value is string => typeof value === "string" && value.length > 0);
+		return `Agent ${item.agent}: failed${reason ? ` — ${compactText(reason, 180)}` : ""}`;
+	}
+	return `Agent ${item.agent}: completed`;
+}
+
 export function renderResult(
 	result: { content: Array<{ type: string; text?: string }>; details?: unknown },
-	_expanded: boolean,
+	expanded: boolean,
 	theme: { fg: ThemeFg; bold: (s: string) => string },
 ): Container | Text {
-	const details = result.details as SubagentDetails | undefined;
-	if (!details || details.results.length === 0) {
-		const first = result.content[0];
-		return new Text(first?.type === "text" && first.text ? first.text : "(no output)", 0, 0);
+	const fallbackText = getResultText(result);
+
+	// Keep the normal row compact. Ctrl+O switches to the live tree below.
+	if (!expanded) {
+		const text = isSubagentDetails(result.details)
+			? getCollapsedResultText(result.details, fallbackText)
+			: compactText(fallbackText);
+		return new Text(text, 0, 0);
 	}
 
-	const nodes = buildTopLevelNodes(details);
-	const counts = countNodes(nodes);
-	const showOutputPreview = !hasNestedChildren(nodes);
-	const icon = counts.running > 0
-		? theme.fg("warning", "⏳")
-		: counts.error > 0
-			? theme.fg("error", "❌")
-			: theme.fg("success", "✅");
+	if (!isSubagentDetails(result.details) || result.details.results.length === 0) {
+		return new Text(fallbackText, 0, 0);
+	}
+	const details: SubagentDetails = result.details;
 
-	const container = new Container();
-	container.addChild(
-		new Text(
-			`${icon} ${theme.fg("toolTitle", theme.bold("subagent tree "))}${theme.fg("dim", topLevelSummary(details, counts))}`,
-			0,
-			0,
-		),
-	);
+	try {
+		const nodes = buildTopLevelNodes(details);
+		const counts = countNodes(nodes);
+		const showOutputPreview = !hasNestedChildren(nodes);
+		const icon = counts.running > 0
+			? theme.fg("warning", "⏳")
+			: counts.error > 0
+				? theme.fg("error", "❌")
+				: theme.fg("success", "✅");
 
-	container.addChild(new Spacer(1));
-	container.addChild(new Text(renderTreeLines(nodes, theme, showOutputPreview).join("\n"), 0, 0));
+		const container = new Container();
+		container.addChild(
+			new Text(
+				`${icon} ${theme.fg("toolTitle", theme.bold("subagent tree "))}${theme.fg("dim", topLevelSummary(details, counts))}`,
+				0,
+				0,
+			),
+		);
 
-	return container;
+		container.addChild(new Spacer(1));
+		container.addChild(new Text(renderTreeLines(nodes, theme, showOutputPreview).join("\n"), 0, 0));
+		return container;
+	} catch {
+		// Pi falls back to raw result.content when a custom renderer throws, which
+		// made Ctrl+O appear broken until the offending rolling log entry expired.
+		// Keep an expanded tree visible even for malformed third-party/RPC data.
+		const lines: string[] = [];
+		for (const item of details.results) {
+			const agent = typeof item?.agent === "string" ? item.agent : "unknown agent";
+			const icon = item?.exitCode === -1
+				? theme.fg("warning", "⏳")
+				: item?.exitCode === 0
+					? theme.fg("success", "✅")
+					: theme.fg("error", "❌");
+			lines.push(`${icon} ${theme.fg("accent", agent)}`);
+			const liveLog = Array.isArray(item?.liveLog)
+				? item.liveLog.slice(-MAX_LIVE_LOG_ENTRIES)
+				: [];
+			for (const entry of liveLog) {
+				lines.push(`  ${formatLiveLogEntry(entry, theme)}`);
+			}
+		}
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("subagent tree"))}\n${lines.join("\n") || fallbackText}`,
+			0,
+			0,
+		);
+	}
 }

package/runner.ts

@@ -21,7 +21,6 @@ import {
   emptyUsage,
   extractToolCalls,
   getFinalOutput,
-  getNestedSubagentErrorSummary,
   isResultError,
   isResultSuccess,
   isSubagentDetails,
@@ -1239,16 +1238,11 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       if (!result.stderr.trim()) result.stderr = result.errorMessage;
     }
 
-    if (result.exitCode === 0) {
-      const nestedErrorSummary = getNestedSubagentErrorSummary(result.messages);
-      if (nestedErrorSummary) {
-        result.exitCode = 1;
-        result.stopReason = "error";
-        result.errorMessage = nestedErrorSummary;
-        if (!result.stderr.trim()) result.stderr = nestedErrorSummary;
-      }
-    }
-
+    // A failed nested delegation is a recoverable tool error, just like a
+    // failed bash/read call. Pi returns that error to the calling model, which
+    // may retry, choose another approach, or finish the task itself. Do not
+    // overwrite a later successful terminal answer with an earlier nested
+    // tool failure.
     return result;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);

package/tree.ts

@@ -13,6 +13,7 @@ import {
 	type LiveLogEntry,
 	type NestedSubagentResult,
 	type SingleResult,
+	MAX_LIVE_LOG_ENTRIES,
 	type SubagentDetails,
 	type UsageStats,
 	aggregateUsage,
@@ -65,17 +66,32 @@ interface PendingSubagentCall {
 // Formatting helpers
 // ---------------------------------------------------------------------------
 
+function asRecord(value: unknown): Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? value as Record<string, unknown>
+		: {};
+}
+
+function finiteNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function stringValue(value: unknown, fallback = ""): string {
+	return typeof value === "string" ? value : fallback;
+}
+
 export function formatClockTime(epochMs: number): string {
-	const d = new Date(epochMs);
+	const d = new Date(Number.isFinite(epochMs) ? epochMs : 0);
 	const pad = (n: number) => String(n).padStart(2, "0");
 	return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
 }
 
 export function formatTokens(count: number): string {
-	if (count < 1000) return count.toString();
-	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
-	if (count < 1000000) return `${Math.round(count / 1000)}k`;
-	return `${(count / 1000000).toFixed(1)}M`;
+	const safeCount = finiteNumber(count);
+	if (safeCount < 1000) return safeCount.toString();
+	if (safeCount < 10000) return `${(safeCount / 1000).toFixed(1)}k`;
+	if (safeCount < 1000000) return `${Math.round(safeCount / 1000)}k`;
+	return `${(safeCount / 1000000).toFixed(1)}M`;
 }
 
 export function formatCombinedUsageStatusLine(
@@ -95,36 +111,41 @@ export function formatCombinedUsageStatusLine(
 	return `WITH SUBS: (${subagentCount}) Σ $${cost.toFixed(4)} • ↑${formatTokens(input)} ↓${formatTokens(output)}${cache} T${formatTokens(total)} • ${turns} turn${turns === 1 ? "" : "s"}`;
 }
 
-export function formatUsage(usage: Partial<UsageStats>, model?: string): string {
+export function formatUsage(usage: Partial<UsageStats> | unknown, model?: unknown): string {
+	const safeUsage = asRecord(usage);
+	const input = finiteNumber(safeUsage.input);
+	const output = finiteNumber(safeUsage.output);
+	const cacheRead = finiteNumber(safeUsage.cacheRead);
+	const cacheWrite = finiteNumber(safeUsage.cacheWrite);
+	const cost = finiteNumber(safeUsage.cost);
+	const contextTokens = finiteNumber(safeUsage.contextTokens);
+	const turns = finiteNumber(safeUsage.turns);
 	const parts: string[] = [];
-	const totalTokens =
-		(usage.input || 0) +
-		(usage.output || 0) +
-		(usage.cacheRead || 0) +
-		(usage.cacheWrite || 0);
-	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
+	const totalTokens = input + output + cacheRead + cacheWrite;
+	if (turns) parts.push(`${turns} turn${turns > 1 ? "s" : ""}`);
 	if (totalTokens > 0) parts.push(`tok:${formatTokens(totalTokens)}`);
-	if (usage.input) parts.push(`in:${formatTokens(usage.input)}`);
-	if (usage.output) parts.push(`out:${formatTokens(usage.output)}`);
-	if (usage.cacheRead) parts.push(`cacheR:${formatTokens(usage.cacheRead)}`);
-	if (usage.cacheWrite) parts.push(`cacheW:${formatTokens(usage.cacheWrite)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	if (usage.contextTokens && usage.contextTokens > 0) parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
-	if (model) parts.push(model);
+	if (input) parts.push(`in:${formatTokens(input)}`);
+	if (output) parts.push(`out:${formatTokens(output)}`);
+	if (cacheRead) parts.push(`cacheR:${formatTokens(cacheRead)}`);
+	if (cacheWrite) parts.push(`cacheW:${formatTokens(cacheWrite)}`);
+	if (cost) parts.push(`$${cost.toFixed(4)}`);
+	if (contextTokens > 0) parts.push(`ctx:${formatTokens(contextTokens)}`);
+	if (typeof model === "string" && model) parts.push(model);
 	return parts.join(" • ");
 }
 
-export function truncate(text: string, maxLen: number): string {
-	return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
+export function truncate(text: unknown, maxLen: number): string {
+	const safeText = stringValue(text);
+	return safeText.length > maxLen ? `${safeText.slice(0, maxLen)}...` : safeText;
 }
 
-function splitOutputLines(text: string): string[] {
-	const lines = text.replace(/\r\n?/g, "\n").split("\n");
+function splitOutputLines(text: unknown): string[] {
+	const lines = stringValue(text).replace(/\r\n?/g, "\n").split("\n");
 	if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
 	return lines;
 }
 
-function lastNonEmptyLines(text: string, limit: number): string[] {
+function lastNonEmptyLines(text: unknown, limit: number): string[] {
 	return splitOutputLines(text)
 		.map((line) => line.trimEnd())
 		.filter((line) => line.trim().length > 0)
@@ -173,11 +194,12 @@ export function hasNestedChildren(nodes: TreeNode[]): boolean {
 	return nodes.some((node) => node.children.length > 0 || hasNestedChildren(node.children));
 }
 
-function extractPendingSubagentCalls(messages: SingleResult["messages"]): PendingSubagentCall[] {
+function extractPendingSubagentCalls(messages: SingleResult["messages"] | unknown): PendingSubagentCall[] {
+	const history = Array.isArray(messages) ? messages : [];
 	const calls: PendingSubagentCall[] = [];
-	for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
-		const message = messages[messageIndex] as any;
-		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+	for (let messageIndex = 0; messageIndex < history.length; messageIndex++) {
+		const message = history[messageIndex] as any;
+		if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
 		for (let partIndex = 0; partIndex < message.content.length; partIndex++) {
 			const part = message.content[partIndex] as any;
 			if (part?.type !== "toolCall" || !isSubagentToolName(part?.name)) continue;
@@ -235,11 +257,16 @@ function subagentCallSignature(call: PendingSubagentCall): string {
 
 function nestedResultIsHealthy(nested: NestedSubagentResult | undefined): boolean {
 	if (!nested || nested.isError) return false;
-	return nested.details.results.every((result) => !isResultError(result));
+	return nested.details.results.every(
+		(result) => result !== null && typeof result === "object" && !Array.isArray(result) && !isResultError(result),
+	);
 }
 
 function buildLiveDetailsSignature(details: SubagentDetails): string {
-	return JSON.stringify(details.results.map((result) => ({ agent: result.agent, task: result.task ?? "" })));
+	return JSON.stringify(details.results.map((result) => {
+		const value = asRecord(result);
+		return { agent: stringValue(value.agent), task: stringValue(value.task) };
+	}));
 }
 
 function findLiveNestedDetailsForCall(
@@ -276,7 +303,9 @@ function findLiveNestedDetailsForCall(
 	const agentSignature = JSON.stringify(call.tasks.map((task) => task.agent));
 	for (const [key, details] of Object.entries(live)) {
 		if (usedLiveKeys.has(key) || !isSubagentDetails(details)) continue;
-		const liveAgentSignature = JSON.stringify(details.results.map((nestedResult) => nestedResult.agent));
+		const liveAgentSignature = JSON.stringify(
+			details.results.map((nestedResult) => stringValue(asRecord(nestedResult).agent)),
+		);
 		if (liveAgentSignature !== agentSignature) continue;
 		usedLiveKeys.add(key);
 		return details;
@@ -339,38 +368,53 @@ function buildNestedChildren(result: SingleResult): TreeNode[] {
 	return nodes;
 }
 
-function formatToolArgPreview(toolName: string, args: Record<string, unknown>): string {
-	const shorten = (p: string) => {
+function formatToolArgPreview(toolName: unknown, rawArgs: unknown): string {
+	const args = asRecord(rawArgs);
+	const shorten = (value: unknown) => {
+		const p = stringValue(value);
 		const home = os.homedir();
 		return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
 	};
-	const truncateTo = (s: string, n: number) =>
-		s.length > n ? s.slice(0, n) + "\u2026" : s;
+	const truncateTo = (value: unknown, n: number) => {
+		const text = stringValue(value);
+		return text.length > n ? text.slice(0, n) + "\u2026" : text;
+	};
 
 	switch (toolName) {
-		case "bash": {
-			const cmd = (args.command as string) || "";
-			return truncateTo(cmd.replace(/\s+/g, " "), 52);
-		}
+		case "bash":
+			return truncateTo(stringValue(args.command).replace(/\s+/g, " "), 52);
 		case "read":
 		case "write":
 		case "edit":
-			return shorten(truncateTo((args.path ?? args.file_path ?? "") as string, 52));
-		case "grep":
-			return truncateTo(`/${args.pattern}/`, 30) +
-				   (args.path ? ` in ${shorten(args.path as string)}` : "");
-		case "find":
-			return truncateTo((args.pattern ?? "*") as string, 30) +
-				   (args.path ? ` in ${shorten(args.path as string)}` : "");
+			return shorten(truncateTo(args.path ?? args.file_path, 52));
+		case "grep": {
+			const pattern = stringValue(args.pattern);
+			const target = stringValue(args.path);
+			return truncateTo(`/${pattern}/`, 30) + (target ? ` in ${shorten(target)}` : "");
+		}
+		case "find": {
+			const pattern = stringValue(args.pattern, "*");
+			const target = stringValue(args.path);
+			return truncateTo(pattern, 30) + (target ? ` in ${shorten(target)}` : "");
+		}
 		case "subagent":
 		case "subagents": {
-			const tasks = (args.tasks as any[]) ?? [];
-			return tasks.map((t: any) => t.agent).join(", ");
+			const tasks = Array.isArray(args.tasks) ? args.tasks : [];
+			return tasks
+				.map((task) => stringValue(asRecord(task).agent))
+				.filter(Boolean)
+				.join(", ");
 		}
 		case "resume_subagents": {
-			const raw = (args as any).resumes;
-			const resumes = Array.isArray(raw) ? raw : raw ? [raw] : [];
-			return resumes.map((r: any) => r?.subagent ?? r?.name).filter(Boolean).join(", ");
+			const raw = args.resumes;
+			const resumes = Array.isArray(raw) ? raw : raw && typeof raw === "object" ? [raw] : [];
+			return resumes
+				.map((resume) => {
+					const item = asRecord(resume);
+					return stringValue(item.subagent) || stringValue(item.name);
+				})
+				.filter(Boolean)
+				.join(", ");
 		}
 		default:
 			return "";
@@ -381,12 +425,14 @@ export function formatLiveLogEntry(
 	entry: LiveLogEntry,
 	theme: { fg: ThemeFg },
 ): string {
-	const stamp = entry.at !== undefined ? theme.fg("dim", formatClockTime(entry.at)) + " " : "";
-	return stamp + formatLiveLogEntryBody(entry, theme);
+	const value = asRecord(entry);
+	const at = typeof value.at === "number" && Number.isFinite(value.at) ? value.at : undefined;
+	const stamp = at !== undefined ? theme.fg("dim", formatClockTime(at)) + " " : "";
+	return stamp + formatLiveLogEntryBody(value, theme);
 }
 
 function formatLiveLogEntryBody(
-	entry: LiveLogEntry,
+	entry: Record<string, unknown>,
 	theme: { fg: ThemeFg },
 ): string {
 	switch (entry.kind) {
@@ -394,24 +440,28 @@ function formatLiveLogEntryBody(
 			return theme.fg("muted", "\u27f3") + " " + theme.fg("dim", "thinking\u2026");
 
 		case "turn_end": {
-			const tokens = entry.inputTokens || entry.outputTokens
+			const inputTokens = finiteNumber(entry.inputTokens);
+			const outputTokens = finiteNumber(entry.outputTokens);
+			const tokens = inputTokens || outputTokens
 				? " " + theme.fg("dim",
-					`\u2191${formatTokens(entry.inputTokens)} \u2193${formatTokens(entry.outputTokens)}`)
+					`\u2191${formatTokens(inputTokens)} \u2193${formatTokens(outputTokens)}`)
 				: "";
+			const turn = finiteNumber(entry.turn);
 			return (
 				theme.fg("success", "\u2713") +
 				" " +
-				theme.fg("muted", `turn ${entry.turn}`) +
+				theme.fg("muted", `turn ${turn}`) +
 				tokens
 			);
 		}
 
 		case "tool_start": {
-			const argPreview = formatToolArgPreview(entry.toolName, entry.args);
+			const toolName = stringValue(entry.toolName, "unknown tool");
+			const argPreview = formatToolArgPreview(toolName, entry.args);
 			return (
 				theme.fg("muted", "\u2192") +
 				" " +
-				theme.fg("accent", entry.toolName) +
+				theme.fg("accent", toolName) +
 				(argPreview ? "  " + theme.fg("dim", argPreview) : "")
 			);
 		}
@@ -420,8 +470,11 @@ function formatLiveLogEntryBody(
 			return (
 				theme.fg("success", "\u2713") +
 				" " +
-				theme.fg("accent", entry.toolName)
+				theme.fg("accent", stringValue(entry.toolName, "unknown tool"))
 			);
+
+		default:
+			return theme.fg("muted", "activity");
 	}
 }
 
@@ -482,33 +535,64 @@ function loadMessagesFromSession(sessionDir: string | undefined): SingleResult["
 }
 
 function hydrateResultFromSession(result: SingleResult): SingleResult {
-	if (result.messages?.length > 0) return result;
-	const messages = loadMessagesFromSession(result.sessionDir);
-	return messages.length > 0 ? { ...result, messages } : result;
-}
-
-function buildResultNode(result: SingleResult): TreeNode {
-	result = hydrateResultFromSession(result);
+	if (Array.isArray(result.messages) && result.messages.length > 0) return result;
+	const messages = loadMessagesFromSession(
+		typeof result.sessionDir === "string" ? result.sessionDir : undefined,
+	);
+	if (messages.length > 0) return { ...result, messages };
+	return Array.isArray(result.messages) ? result : { ...result, messages: [] };
+}
+
+function buildResultNode(rawResult: SingleResult): TreeNode {
+	let result: SingleResult;
+	if (
+		rawResult !== null &&
+		typeof rawResult === "object" &&
+		!Array.isArray(rawResult) &&
+		typeof rawResult.agent === "string" &&
+		typeof rawResult.exitCode === "number"
+	) {
+		result = hydrateResultFromSession(rawResult);
+	} else {
+		result = {
+			agent: "unknown agent",
+			agentSource: "unknown",
+			task: "",
+			exitCode: 1,
+			messages: [],
+			stderr: "Malformed subagent result.",
+			usage: {} as UsageStats,
+			toolCalls: {},
+			completedTurns: 0,
+			turnInProgress: false,
+			liveLog: [],
+		};
+	}
 	const status = statusFromResult(result);
-	const usage = formatUsage(result.usage ?? {}, result.model);
+	const usage = formatUsage(result.usage, result.model);
 	const metaParts: string[] = [];
-	if (result.name) metaParts.push(result.name);
-	metaParts.push(result.agentSource);
+	if (typeof result.name === "string" && result.name) metaParts.push(result.name);
+	if (typeof result.agentSource === "string" && result.agentSource) metaParts.push(result.agentSource);
 	if (usage) metaParts.push(usage);
 	if (status === "error") {
 		const errorText = result.errorMessage || result.stderr || result.stopReason;
-		if (errorText) metaParts.push(truncate(errorText.replace(/\s+/g, " "), 120));
+		if (typeof errorText === "string" && errorText) {
+			metaParts.push(truncate(errorText.replace(/\s+/g, " "), 120));
+		}
 	}
 
 	const children = buildNestedChildren(result);
 	const isRunning = status === "running";
+	const liveLog = Array.isArray(result.liveLog) ? result.liveLog : [];
 	return {
-		label: result.agent,
+		label: stringValue(result.agent, "unknown agent"),
 		status,
 		meta: metaParts.join(" • "),
-		task: result.task,
-		startedAt: result.startedAt,
-		liveActivity: isRunning && (result.liveLog?.length ?? 0) > 0 ? result.liveLog : undefined,
+		task: typeof result.task === "string" ? result.task : undefined,
+		startedAt: typeof result.startedAt === "number" && Number.isFinite(result.startedAt)
+			? result.startedAt
+			: undefined,
+		liveActivity: isRunning && liveLog.length > 0 ? liveLog.slice(-MAX_LIVE_LOG_ENTRIES) : undefined,
 		outputPreview: !isRunning && children.length === 0 ? buildLeafPreview(result) : undefined,
 		children,
 	};
@@ -567,8 +651,11 @@ export function renderTreeLines(
 export function topLevelSummary(details: SubagentDetails, counts: TreeCounts): string {
 	// aggregatedUsage includes own agents + all their nested descendants;
 	// fall back to summing only direct results for old serialised data lacking the field.
+	const safeResults = details.results.filter(
+		(result): result is SingleResult => result !== null && typeof result === "object" && !Array.isArray(result),
+	);
 	const totalUsage = formatUsage(
-		usageSummaryToUsageStats(details.usageSummary) ?? details.aggregatedUsage ?? aggregateUsage(details.results),
+		usageSummaryToUsageStats(details.usageSummary) ?? details.aggregatedUsage ?? aggregateUsage(safeResults),
 	);
 	const parts = [
 		`${counts.running} running`,

package/types.ts

@@ -204,7 +204,7 @@ function asMessageArray(messages: unknown): Message[] {
 export function extractToolCalls(messages: unknown): ToolCallCounts {
   const counts: ToolCallCounts = {};
   for (const msg of asMessageArray(messages)) {
-    if (msg.role !== "assistant") continue;
+    if ((msg as any)?.role !== "assistant") continue;
     for (const part of (Array.isArray((msg as any).content) ? (msg as any).content : [])) {
       if ((part as any)?.type !== "toolCall") continue;
       const name: string = typeof (part as any).name === "string" ? (part as any).name : "unknown";
@@ -479,10 +479,10 @@ export function getFinalOutput(messages: unknown, fallback?: string): string {
 	const history = asMessageArray(messages);
 	for (let i = history.length - 1; i >= 0; i--) {
 		const msg = history[i];
-		if (msg.role === "assistant" && Array.isArray((msg as any).content)) {
+		if ((msg as any)?.role === "assistant" && Array.isArray((msg as any).content)) {
 			for (let j = (msg as any).content.length - 1; j >= 0; j--) {
 				const part = (msg as any).content[j];
-				if (part?.type === "text") return part.text;
+				if (part?.type === "text" && typeof part.text === "string") return part.text;
 			}
 		}
 	}
@@ -493,12 +493,16 @@ export function getFinalOutput(messages: unknown, fallback?: string): string {
 export function getDisplayItems(messages: unknown): DisplayItem[] {
 	const items: DisplayItem[] = [];
 	for (const msg of asMessageArray(messages)) {
-		if (msg.role === "assistant" && Array.isArray((msg as any).content)) {
+		if ((msg as any)?.role === "assistant" && Array.isArray((msg as any).content)) {
 			for (const part of (msg as any).content) {
-				if (part?.type === "text") {
+				if (part?.type === "text" && typeof part.text === "string") {
 					items.push({ type: "text", text: part.text });
-				} else if (part?.type === "toolCall") {
-					items.push({ type: "toolCall", name: part.name, args: part.arguments });
+				} else if (part?.type === "toolCall" && typeof part.name === "string") {
+					items.push({
+						type: "toolCall",
+						name: part.name,
+						args: part.arguments && typeof part.arguments === "object" ? part.arguments : {},
+					});
 				}
 			}
 		}