@gajae-code/coding-agent 0.11.0 → 0.11.2

package/src/tools/index.ts

@@ -1,9 +1,10 @@
 import type { AgentTelemetryConfig, AgentTool } from "@gajae-code/agent-core";
 import type { Model, ServiceTier, ToolChoice } from "@gajae-code/ai";
-import { $env, $flag, logger } from "@gajae-code/utils";
+import { $env, logger } from "@gajae-code/utils";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import { EditTool } from "../edit";
+import { isTruthyPythonFlag } from "../eval/py/env";
 import { checkPythonKernelAvailability } from "../eval/py/kernel";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
@@ -114,7 +115,6 @@ export type ContextFileEntry = {
 	depth?: number;
 };
 
-export type { DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
 export type {
 	DiscoverableTool,
 	DiscoverableToolSearchIndex,
@@ -278,6 +278,8 @@ export interface ToolSession {
 	bashRestrictionProfile?: BashRestrictionProfile;
 	/** Optional per-session allowlist for tools exposed through search_tool_bm25. */
 	discoverableToolAllowedNames?: readonly string[];
+	/** Throw instead of warn when toolNames contains an unknown name. */
+	strictToolNames?: boolean;
 	/** Get artifacts directory for artifact:// URLs */
 	getArtifactsDir?: () => string | null;
 	/** Get the ArtifactManager backing this session (shared across parent + subagents). */
@@ -326,18 +328,6 @@ export interface ToolSession {
 	getTodoPhases?: () => TodoPhase[];
 	/** Replace cached todo phases for this session. */
 	setTodoPhases?: (phases: TodoPhase[]) => void;
-	/** Whether MCP tool discovery is active for this session. */
-	isMCPDiscoveryEnabled?: () => boolean;
-	/** Get hidden-but-discoverable MCP tools for search_tool_bm25 prompts and fallbacks.
-	 * @deprecated Use getDiscoverableTools with source filter instead. */
-	getDiscoverableMCPTools?: () => import("../runtime-mcp/discoverable-tool-metadata").DiscoverableMCPTool[];
-	/** Get the cached discoverable MCP search index for search_tool_bm25 execution.
-	 * @deprecated Use getDiscoverableToolSearchIndex instead. */
-	getDiscoverableMCPSearchIndex?: () => import("../tool-discovery/tool-index").DiscoverableMCPSearchIndex;
-	/** Get MCP tools activated by prior search_tool_bm25 calls. */
-	getSelectedMCPToolNames?: () => string[];
-	/** Merge MCP tool selections into the active session tool set. */
-	activateDiscoveredMCPTools?: (toolNames: string[]) => Promise<string[]>;
 	// ── Generic tool discovery (unified — covers built-in + MCP + extension) ──
 	/** Whether any form of tool discovery is active (tools.discoveryMode !== "off" or mcp.discoveryMode). */
 	isToolDiscoveryEnabled?: () => boolean;
@@ -511,20 +501,67 @@ export interface EvalBackendsAllowance {
 }
 
 /**
- * Parse PI_PY / PI_JS environment variables. Each is a boolean flag; unset
- * means "not specified, defer to settings". Returns null when neither is set
+ * Parse the `GJC_PY` multi-value token into per-backend booleans.
+ *
+ * Tokens (case-insensitive):
+ * - `0` / `bash` → JavaScript only (`{ py: false, js: true }`)
+ * - `1` / `py`   → Python only (`{ py: true, js: false }`)
+ * - `js`         → JavaScript only (`{ py: false, js: true }`)
+ * - `mix` / `both` → both backends (`{ py: true, js: true }`)
+ *
+ * Returns `null` when `GJC_PY` is unset, empty, or holds an unrecognized
+ * token, so the caller can fall back to the legacy `PI_PY` / `PI_JS` flags or
+ * per-key settings. This matches the documented contract that invalid values
+ * are ignored.
+ */
+export function parseGjcPy(env: Record<string, string | undefined>): { py: boolean; js: boolean } | null {
+	const raw = env.GJC_PY;
+	if (raw === undefined) return null;
+	const token = raw.trim().toLowerCase();
+	if (token === "") return null;
+	switch (token) {
+		case "0":
+		case "bash":
+			return { py: false, js: true };
+		case "1":
+		case "py":
+			return { py: true, js: false };
+		case "js":
+			return { py: false, js: true };
+		case "mix":
+		case "both":
+			return { py: true, js: true };
+		default:
+			return null;
+	}
+}
+
+/**
+ * Parse legacy `PI_PY` / `PI_JS` boolean flags. Each is a boolean flag; unset
+ * means "not specified, defer to settings". Returns `null` when neither is set
  * so the caller can fall through to `readEvalBackendsAllowance` per key.
  */
-function getEvalBackendsFromEnv(): EvalBackendsAllowance | null {
-	const pyEnv = $env.PI_PY;
-	const jsEnv = $env.PI_JS;
+function parseLegacyEvalEnvFlags(env: Record<string, string | undefined>): EvalBackendsAllowance | null {
+	const pyEnv = env.PI_PY;
+	const jsEnv = env.PI_JS;
 	if (pyEnv === undefined && jsEnv === undefined) return null;
 	return {
-		python: pyEnv === undefined ? true : $flag("PI_PY"),
-		js: jsEnv === undefined ? true : $flag("PI_JS"),
+		python: pyEnv === undefined ? true : isTruthyPythonFlag(pyEnv),
+		js: jsEnv === undefined ? true : isTruthyPythonFlag(jsEnv),
 	};
 }
 
+/**
+ * Resolve eval-backend allowance from environment only. `GJC_PY` wins when set
+ * to a recognized token; otherwise the legacy `PI_PY` / `PI_JS` flags apply.
+ * Returns `null` when no env override is set so the caller can defer to settings.
+ */
+export function resolveEvalBackendsFromEnv(env: Record<string, string | undefined>): EvalBackendsAllowance | null {
+	const gjc = parseGjcPy(env);
+	if (gjc) return { python: gjc.py, js: gjc.js };
+	return parseLegacyEvalEnvFlags(env);
+}
+
 /** Read per-backend allowance from settings (defaults true). */
 export function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAllowance {
 	return {
@@ -534,13 +571,20 @@ export function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAll
 }
 
 /**
- * Materialize the active eval backend allowance: PI_PY / PI_JS env flags
- * override the per-key settings; otherwise settings (defaults true) win.
+ * Materialize the active eval backend allowance. `GJC_PY` takes precedence
+ * over the legacy `PI_PY` / `PI_JS` env flags, which in turn override the
+ * per-key settings (defaults true). When no env override is set, settings win.
  */
 export function resolveEvalBackends(session: ToolSession): EvalBackendsAllowance {
-	return getEvalBackendsFromEnv() ?? readEvalBackendsAllowance(session);
+	return resolveEvalBackendsFromEnv($env) ?? readEvalBackendsAllowance(session);
 }
 
+export {
+	resolvePythonIntegrationGate,
+	resolvePythonIpcTrace,
+	resolvePythonSkipCheck,
+} from "../eval/py/env";
+
 /**
  * Create tools from BUILTIN_TOOLS registry.
  */
@@ -670,6 +714,14 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		requestedTools.push("yield");
 	}
 
+	if (requestedTools) {
+		const unknownToolNames = requestedTools.filter(name => !allToolsByRequestName.has(name));
+		if (unknownToolNames.length > 0) {
+			const message = `Unknown tool name${unknownToolNames.length === 1 ? "" : "s"}: ${unknownToolNames.join(", ")}`;
+			if (session.strictToolNames) throw new Error(message);
+			logger.warn(message);
+		}
+	}
 	const filteredRequestedTools = requestedTools
 		?.map(name => allToolsByRequestName.get(name))
 		.filter((entry): entry is [string, ToolFactory] => entry !== undefined)

package/src/tools/output-meta.ts

@@ -15,6 +15,7 @@ import type { ImageContent, TextContent } from "@gajae-code/ai";
 import { getDefault, type Settings } from "../config/settings";
 import { formatGroupedDiagnosticMessages } from "../lsp/utils";
 import type { Theme } from "../modes/theme/theme";
+import { sessionArtifactCapability } from "../session/session-manager";
 import { type OutputSummary, type TruncationResult, truncateMiddle, truncateTail } from "../session/streaming-output";
 import { formatBytes, wrapBrackets } from "./render-utils";
 import { renderError } from "./tool-errors";
@@ -103,6 +104,7 @@ export interface TruncationTextOptions {
 	totalLines?: number;
 	totalBytes?: number;
 	maxBytes?: number;
+	artifactId?: string;
 }
 
 /**
@@ -288,6 +290,7 @@ export class OutputMetaBuilder {
 			outputLines,
 			outputBytes,
 			maxBytes: options.maxBytes,
+			artifactId: options.artifactId,
 			shownRange: { start: shownStart, end: shownEnd },
 			nextOffset: options.direction === "head" ? shownEnd + 1 : undefined,
 		};
@@ -593,13 +596,17 @@ export function resolveOutputMaxColumns(s: Settings | undefined): number {
  * is 0, falls back to tail-only truncation. Skips when the tool already
  * saved its own artifact (e.g. bash/python via OutputSink).
  */
+function artifactCapabilityForContext(context: AgentToolContext | undefined) {
+	return sessionArtifactCapability(context?.sessionManager);
+}
+
 async function spillLargeResultToArtifact(
 	result: AgentToolResult,
 	toolName: string,
 	context: AgentToolContext | undefined,
 ): Promise<AgentToolResult> {
-	const sessionManager = context?.sessionManager;
-	if (!sessionManager) return result;
+	const artifactCapability = artifactCapabilityForContext(context);
+	if (!artifactCapability) return result;
 	const { threshold, readThreshold, tailBytes, tailLines, headBytes } = getSpillConfig(context?.settings);
 	// `read` manages its own per-range truncation, but the combined multi-range
 	// output has no cap — enforce a read-specific (higher) combined threshold
@@ -625,7 +632,7 @@ async function spillLargeResultToArtifact(
 	if (totalBytes <= effectiveThreshold) return result;
 
 	// Save full output as artifact
-	const artifactId = await sessionManager.saveArtifact(fullText, toolName);
+	const artifactId = await artifactCapability.saveArtifact(fullText, toolName);
 	if (!artifactId) return result;
 
 	// Truncate: middle elision when a head budget is configured, otherwise tail-only.
@@ -735,8 +742,9 @@ async function enforceInlineResultBackstop(
 	// full output so the truncated view keeps a reference to the complete text.
 	const existingMeta: OutputMeta | undefined = result.details?.meta;
 	let artifactId = existingMeta?.truncation?.artifactId;
-	if (!artifactId) {
-		artifactId = (await context?.sessionManager?.saveArtifact(fullText, toolName)) ?? undefined;
+	const artifactCapability = artifactCapabilityForContext(context);
+	if (!artifactId && artifactCapability) {
+		artifactId = (await artifactCapability.saveArtifact(fullText, toolName)) ?? undefined;
 	}
 
 	// Budget head+tail below the cap, reserving room for the elision marker so the

package/src/tools/read.ts

@@ -53,6 +53,7 @@ import {
 	type ReadUrlToolDetails,
 	renderReadUrlCall,
 	renderReadUrlResult,
+	wrapUntrustedContent,
 } from "./fetch";
 import { applyListLimit } from "./list-limit";
 import {
@@ -487,6 +488,38 @@ const readSchema = z
 
 export type ReadToolInput = z.infer<typeof readSchema>;
 
+const UNSAFE_SUMMARY_PATH =
+	/(?:\b(?:https?|wss?):\/\/|\b(?:api[-_ ]?key|access[-_ ]?token|bearer|secret|password)\b|\b(?:sk|pk|rk)-[A-Za-z0-9_-]{12,})/i;
+
+/** Project paths and output sizes without exposing read content or remote URLs. */
+export function summarizeReadToolActivity(kind: "args" | "result", value: unknown): string | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	if (kind === "args") {
+		const readPath = record.path;
+		if (
+			typeof readPath !== "string" ||
+			readPath.length === 0 ||
+			readPath.length > 100 ||
+			UNSAFE_SUMMARY_PATH.test(readPath)
+		) {
+			return undefined;
+		}
+		return readPath;
+	}
+	if (!Array.isArray(record.content)) return undefined;
+	const text = record.content
+		.filter(
+			(block): block is { type: unknown; text: unknown } =>
+				typeof block === "object" && block !== null && "type" in block && "text" in block,
+		)
+		.filter(block => block.type === "text" && typeof block.text === "string")
+		.map(block => block.text as string)
+		.join("\n");
+	const lines = text.length === 0 ? 0 : text.split("\n").length;
+	return `${lines} lines, ${Buffer.byteLength(text, "utf-8")} bytes`;
+}
+
 export interface ReadToolDetails {
 	kind?: "file" | "url";
 	truncation?: TruncationResult;
@@ -667,6 +700,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly parameters = readSchema;
 	readonly nonAbortable = true;
 	readonly strict = true;
+	readonly safeSummary = summarizeReadToolActivity;
 
 	readonly #autoResizeImages: boolean;
 	readonly #defaultLimit: number;
@@ -788,6 +822,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			ignoreResultLimits?: boolean;
 			raw?: boolean;
 			immutable?: boolean;
+			wrapUntrusted?: boolean;
 		},
 	): AgentToolResult<ReadToolDetails> {
 		const displayMode = resolveFileDisplayMode(this.session, { raw: options.raw, immutable: options.immutable });
@@ -893,7 +928,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			outputText = formatText(truncation.content, startLineDisplay);
 		}
 
-		resultBuilder.text(outputText);
+		resultBuilder.text(options.wrapUntrusted ? wrapUntrustedContent(outputText) : outputText);
 		if (truncationInfo) {
 			resultBuilder.truncation(truncationInfo.result, truncationInfo.options);
 		}
@@ -1469,6 +1504,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					sourceUrl: cached.details.finalUrl,
 					entityLabel: "URL output",
 					immutable: true,
+					wrapUntrusted: true,
 				});
 			}
 			return executeReadUrl(this.session, { path: parsedUrlTarget.path, raw: parsedUrlTarget.raw }, signal);

package/src/tools/resource-gc.ts

@@ -177,7 +177,7 @@ function ownerBrowserPolicy(snapshot: TabGcSnapshot): BrowserGcPolicy | null {
 /** Coarse, ordering-only eligibility; the live recheck in releaseTabIfGcEligible is authoritative. */
 function isCoarselyEligible(snapshot: TabGcSnapshot): boolean {
 	return (
-		snapshot.state === "alive" &&
+		(snapshot.state === "alive" || snapshot.state === "dead") &&
 		snapshot.pendingCount === 0 &&
 		(snapshot.kindTag === "headless" || snapshot.kindTag === "spawned")
 	);
@@ -230,7 +230,7 @@ function evaluateRssPressureWarning(d: ResourceGcDeps): void {
 		return;
 	}
 	const reclaimableRemains = collectIdleCandidates(d).some(
-		c => c.snapshot.ownerId !== undefined && pressured.has(c.snapshot.ownerId),
+		c => c.snapshot.state === "alive" && c.snapshot.ownerId !== undefined && pressured.has(c.snapshot.ownerId),
 	);
 	if (reclaimableRemains) {
 		rssWarningActive = false;

package/src/tools/search-tool-bm25.ts

@@ -10,21 +10,13 @@ import {
 	buildDiscoverableToolSearchIndex,
 	type DiscoverableTool,
 	type DiscoverableToolSearchIndex,
-	formatDiscoverableToolServerSummary,
 	searchDiscoverableTools,
-	summarizeDiscoverableTools,
 } from "../tool-discovery/tool-index";
 import { renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
 import { formatCount, replaceTabs, TRUNCATE_LENGTHS } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
-// Re-export legacy MCP types for back-compat (tests and external callers may reference them)
-export type {
-	DiscoverableMCPSearchIndex,
-	DiscoverableMCPTool,
-} from "../runtime-mcp/discoverable-tool-metadata";
-
 const DEFAULT_LIMIT = 8;
 const TOOL_DISCOVERY_TITLE = "Tool Discovery";
 const COLLAPSED_MATCH_LIMIT = 5;
@@ -78,24 +70,9 @@ function buildSearchToolBm25Content(details: SearchToolBm25Details): string {
 	});
 }
 
-/** Get discoverable tools for description rendering. Falls back to empty array on error. */
 function getDiscoverableToolsForDescription(session: ToolSession): DiscoverableTool[] {
 	try {
-		// Prefer generic method; fall back to legacy MCP-only
-		if (session.getDiscoverableTools) {
-			return session.getDiscoverableTools();
-		}
-		// Legacy MCP path — adapt DiscoverableMCPTool (with `description`) → DiscoverableTool.
-		const legacy = session.getDiscoverableMCPTools?.() ?? [];
-		return legacy.map(t => ({
-			name: t.name,
-			label: t.label,
-			summary: t.description,
-			source: "mcp" as const,
-			serverName: t.serverName,
-			mcpToolName: t.mcpToolName,
-			schemaKeys: t.schemaKeys,
-		}));
+		return session.getDiscoverableTools?.() ?? [];
 	} catch {
 		return [];
 	}
@@ -103,36 +80,18 @@ function getDiscoverableToolsForDescription(session: ToolSession): DiscoverableT
 
 function getDiscoverableToolSearchIndexForExecution(session: ToolSession): DiscoverableToolSearchIndex {
 	try {
-		// Prefer generic cached index
-		if (session.getDiscoverableToolSearchIndex) {
-			const cached = session.getDiscoverableToolSearchIndex();
-			if (cached) return cached;
-		}
-		// Legacy MCP: use cached MCP index. Its documents expose `tool.description` as well as
-		// `tool.summary`, so it is structurally compatible with DiscoverableToolSearchIndex.
-		const mcpCached = session.getDiscoverableMCPSearchIndex?.();
-		if (mcpCached) return mcpCached as unknown as DiscoverableToolSearchIndex;
+		const cached = session.getDiscoverableToolSearchIndex?.();
+		if (cached) return cached;
 	} catch {}
 	return buildDiscoverableToolSearchIndex(getDiscoverableToolsForDescription(session));
 }
 
-/** Resolve the effective selected tool names (generic or legacy MCP). */
 function getSelectedToolNames(session: ToolSession): string[] {
-	if (session.getSelectedDiscoveredToolNames) {
-		return session.getSelectedDiscoveredToolNames();
-	}
-	return session.getSelectedMCPToolNames?.() ?? [];
+	return session.getSelectedDiscoveredToolNames?.() ?? [];
 }
 
-/** Activate tools (generic or legacy MCP fallback). */
 async function activateTools(session: ToolSession, toolNames: string[]): Promise<string[]> {
-	if (session.activateDiscoveredTools) {
-		return session.activateDiscoveredTools(toolNames);
-	}
-	if (session.activateDiscoveredMCPTools) {
-		return session.activateDiscoveredMCPTools(toolNames);
-	}
-	return [];
+	return (await session.activateDiscoveredTools?.(toolNames)) ?? [];
 }
 
 type DiscoveryExecutionSession = ToolSession & {
@@ -140,39 +99,19 @@ type DiscoveryExecutionSession = ToolSession & {
 };
 
 function supportsToolDiscoveryExecution(session: ToolSession): session is DiscoveryExecutionSession {
-	// Supports generic discovery
-	if (
+	return (
 		typeof session.isToolDiscoveryEnabled === "function" &&
 		typeof session.getSelectedDiscoveredToolNames === "function" &&
 		typeof session.activateDiscoveredTools === "function"
-	) {
-		return true;
-	}
-	// Supports legacy MCP discovery
-	if (
-		typeof session.isMCPDiscoveryEnabled === "function" &&
-		typeof session.getSelectedMCPToolNames === "function" &&
-		typeof session.activateDiscoveredMCPTools === "function"
-	) {
-		return true;
-	}
-	return false;
+	);
 }
 
 function isDiscoveryEnabled(session: ToolSession): boolean {
-	if (typeof session.isToolDiscoveryEnabled === "function") {
-		return session.isToolDiscoveryEnabled();
-	}
-	return session.isMCPDiscoveryEnabled?.() ?? false;
+	return session.isToolDiscoveryEnabled?.() ?? false;
 }
 
-export function renderSearchToolBm25Description(discoverableTools: DiscoverableTool[] = []): string {
-	const summary = summarizeDiscoverableTools(discoverableTools);
-	return prompt.render(searchToolBm25Description, {
-		discoverableMCPToolCount: summary.toolCount,
-		discoverableMCPServerSummaries: summary.servers.map(formatDiscoverableToolServerSummary),
-		hasDiscoverableMCPServers: summary.servers.length > 0,
-	});
+export function renderSearchToolBm25Description(): string {
+	return prompt.render(searchToolBm25Description, {});
 }
 
 function renderMatchLines(match: SearchToolBm25Match, theme: Theme): string[] {
@@ -209,9 +148,7 @@ export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema
 	readonly name = "search_tool_bm25";
 	readonly label = "SearchTools";
 	readonly loadMode = "essential";
-	get description(): string {
-		return renderSearchToolBm25Description(getDiscoverableToolsForDescription(this.session));
-	}
+	readonly description = renderSearchToolBm25Description();
 	readonly parameters = searchToolBm25Schema;
 	readonly strict = true;
 

package/src/tools/subagent-render.ts

@@ -23,6 +23,8 @@ import {
 } from "./render-utils";
 import { type SubagentSnapshot, type SubagentToolDetails, subagentAwaitRenderedStateSignature } from "./subagent";
 
+export { subagentAwaitRenderedStateSignature } from "./subagent";
+
 const PREVIEW_LINES_COLLAPSED = 1;
 const PREVIEW_LINES_EXPANDED = 4;
 const PREVIEW_LINE_WIDTH = 80;
@@ -128,7 +130,7 @@ function renderSubagentStatusLine(snapshot: SubagentSnapshot, theme: Theme, spin
 		theme,
 		snapshot.status === "running" ? spinnerFrame : undefined,
 	);
-	const id = theme.fg("muted", snapshot.id);
+	const id = theme.fg("muted", truncateToWidth(replaceTabs(snapshot.id), PREVIEW_LINE_WIDTH, Ellipsis.Unicode));
 	const status = theme.fg("dim", snapshot.status);
 	const duration = theme.fg("dim", formatDuration(snapshot.durationMs));
 	return `${icon} ${id} ${status} ${duration}`;
@@ -195,7 +197,12 @@ function renderSubagentSnapshotBody(snapshot: SubagentSnapshot, expanded: boolea
 		}
 	}
 
-	if (snapshot.guidance) lines.push(`  ${theme.fg("dim", snapshot.guidance)}`);
+	if (snapshot.guidance) {
+		for (const line of getPreviewLines(snapshot.guidance, 1, PREVIEW_LINE_WIDTH, Ellipsis.Unicode)) {
+			lines.push(`  ${theme.fg("dim", replaceTabs(line))}`);
+		}
+	}
+
 	return lines;
 }
 
@@ -218,6 +225,7 @@ export const subagentToolRenderer = {
 		}
 
 		const runningCount = subagents.filter(s => s.status === "running").length;
+		const interrupted = result.details?.interrupted === true;
 
 		// Each snapshot's rendered-state signature is constant for this component
 		// instance, so compute them at most once; the heavy per-subagent bodies are
@@ -232,11 +240,12 @@ export const subagentToolRenderer = {
 				// it is never gated by the heavy body cache.
 				const header = renderStatusLine(
 					{
-						icon: runningCount > 0 ? "info" : "success",
-						spinnerFrame: runningCount > 0 ? options.spinnerFrame : undefined,
-						title: "Subagent",
-						description:
-							runningCount > 0
+						icon: interrupted ? "warning" : runningCount > 0 ? "info" : "success",
+						spinnerFrame: !interrupted && runningCount > 0 ? options.spinnerFrame : undefined,
+						title: interrupted ? "Subagent await interrupted" : "Subagent",
+						description: interrupted
+							? "child subagents continue"
+							: runningCount > 0
 								? `awaiting ${runningCount} of ${subagents.length}`
 								: `${subagents.length} ${subagents.length === 1 ? "subagent" : "subagents"}`,
 					},
@@ -249,7 +258,9 @@ export const subagentToolRenderer = {
 					out.push(truncateToWidth(`  ${theme.fg("dim", "(ctrl+s to observe sessions)")}`, width, Ellipsis.Omit));
 				}
 
-				snapshotSignatures ??= subagents.map(snapshot => subagentAwaitRenderedStateSignature([snapshot]));
+				snapshotSignatures ??= subagents.map(snapshot =>
+					subagentAwaitRenderedStateSignature([snapshot], result.details),
+				);
 				subagents.forEach((snapshot, index) => {
 					// Fresh per-subagent status line (cheap), then the cached heavy body.
 					out.push(