@gajae-code/coding-agent 0.18.11 → 0.19.0

package/src/tools/subagent-render.ts

@@ -8,8 +8,9 @@
  * producer is available (resumed-from-disk or backward-compat records).
  */
 import type { Component } from "@gajae-code/tui";
-import { Text } from "@gajae-code/tui";
+import { getKeybindings, Text } from "@gajae-code/tui";
 import { formatNumber } from "@gajae-code/utils";
+import { isSettingsInitialized, settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import { providerRetryPhaseLabel } from "../task/provider-retry-status";
@@ -18,21 +19,26 @@ import {
 	formatDuration,
 	formatStatusIcon,
 	getPreviewLines,
+	pluralize,
 	replaceTabs,
 	type ToolUIStatus,
 	truncateToWidth,
+	wrapTextWithAnsi,
 } from "./render-utils";
 import {
 	SUBAGENT_ACTIVITY_BUCKET_MS,
+	SUBAGENT_COMPACT_IDLE_MS,
 	type SubagentLiveProgress,
 	type SubagentSnapshot,
 	type SubagentToolDetails,
 	subagentAwaitRenderedStateSignature,
+	summarizeSubagentGroup,
 } from "./subagent";
 
 export { subagentAwaitRenderedStateSignature } from "./subagent";
 
 const PREVIEW_LINES_COLLAPSED = 1;
+const GUIDANCE_MAX_LINES = 12;
 const PREVIEW_LINES_EXPANDED = 4;
 const PREVIEW_LINE_WIDTH = 80;
 
@@ -114,10 +120,90 @@ function collectProviderDegradationGroups(
 		.sort((a, b) => b.count - a.count || a.provider.localeCompare(b.provider));
 }
 
+function compactSubagentPanelEnabled(): boolean {
+	return isSettingsInitialized() && settings.get("task.compactSubagentPanel") === true;
+}
+
+// One summary line for the whole group. Counts only, so the line stays O(1) in the
+// number of subagents; each subagent is still one expand toggle away.
+function renderCompactSubagentSummary(subagents: readonly SubagentSnapshot[], theme: Theme): string {
+	const summary = summarizeSubagentGroup(subagents, Date.now());
+	const parts: string[] = [];
+	if (summary.running > 0) parts.push(`${summary.running} ${pluralize("subagent", summary.running)} running`);
+	// Attention-worthy counts come first so a narrow terminal truncates the rest.
+	if (summary.failed > 0) parts.push(`${summary.failed} failed`);
+	if (summary.retrying > 0) parts.push(`${summary.retrying} retrying`);
+	if (summary.idle > 0) parts.push(`${summary.idle} idle >${SUBAGENT_COMPACT_IDLE_MS / 1000}s`);
+	if (summary.queued > 0) parts.push(`${summary.queued} queued`);
+	if (summary.paused > 0) parts.push(`${summary.paused} paused`);
+	if (summary.completed > 0) parts.push(`${summary.completed} done`);
+	if (summary.cancelled > 0) parts.push(`${summary.cancelled} cancelled`);
+	return `  ${theme.fg("dim", parts.join(" · "))}`;
+}
+
+// At most one warning row in compact mode, however many providers degrade, so the
+// collapsed height stays independent of the subagent count. The expanded view keeps
+// one row per provider.
+function renderCompactDegradationLine(
+	groups: ReadonlyArray<{ provider: string; count: number }>,
+	theme: Theme,
+): string | undefined {
+	const [worst] = groups;
+	if (!worst) return undefined;
+	const more = groups.length > 1 ? ` (+${groups.length - 1} more ${pluralize("provider", groups.length - 1)})` : "";
+	return `  ${theme.fg("warning", `provider degraded: ${worst.count} subagents retrying on ${worst.provider}${more}`)}`;
+}
+
+// The expand hint gets its own line so a long summary never truncates it away.
+function renderCompactSubagentHint(running: boolean, theme: Theme): string {
+	const expandKey = getKeybindings().getKeys("app.tools.expand")[0];
+	const hints = [expandKey ? `${expandKey} to list each` : "expand tool output to list each"];
+	if (running) hints.push("ctrl+s to observe sessions");
+	return `  ${theme.fg("dim", `(${hints.join(" · ")})`)}`;
+}
+
 function boundSubagentBodyLines(lines: string[], width: number): string[] {
 	return lines.map(line => (line.length > 0 ? truncateToWidth(replaceTabs(line), width, Ellipsis.Omit) : ""));
 }
 
+// Guidance is an instruction the caller must act on (e.g. "inspect before
+// cancelling" after an await timeout), so it wraps to the terminal width instead
+// of being cut to one preview line.
+function renderSubagentGuidanceLines(snapshot: SubagentSnapshot, width: number, theme: Theme): string[] {
+	const guidance = snapshot.guidance?.trim();
+	if (!guidance) return [];
+	const indent = "  ";
+	const wrapWidth = Math.max(1, width - indent.length);
+	const wrapped = guidance.split("\n").flatMap(segment => wrapTextWithAnsi(replaceTabs(segment), wrapWidth));
+	// Still bounded: producer guidance is a short fixed sentence, so the cap only
+	// bites on pathologically narrow terminals.
+	if (wrapped.length > GUIDANCE_MAX_LINES) {
+		wrapped.length = GUIDANCE_MAX_LINES;
+		wrapped[GUIDANCE_MAX_LINES - 1] = truncateToWidth(
+			`${wrapped[GUIDANCE_MAX_LINES - 1]!}…`,
+			wrapWidth,
+			Ellipsis.Unicode,
+		);
+	}
+	return wrapped.map(line => `${indent}${theme.fg("dim", line)}`);
+}
+
+function renderBoundSubagentBody(
+	snapshot: SubagentSnapshot,
+	expanded: boolean,
+	width: number,
+	theme: Theme,
+	staticTime: boolean,
+): string[] {
+	return boundSubagentBodyLines(
+		[
+			...renderSubagentSnapshotBody(snapshot, expanded, theme, staticTime),
+			...renderSubagentGuidanceLines(snapshot, width, theme),
+		],
+		width,
+	);
+}
+
 function renderCachedSubagentBody(
 	snapshot: SubagentSnapshot,
 	signature: string,
@@ -133,7 +219,7 @@ function renderCachedSubagentBody(
 		subagentBodyCache.set(key, hit);
 		return hit;
 	}
-	const lines = boundSubagentBodyLines(renderSubagentSnapshotBody(snapshot, expanded, theme), width);
+	const lines = renderBoundSubagentBody(snapshot, expanded, width, theme, true);
 	subagentBodyRenderCount += 1;
 	subagentBodyCache.set(key, lines);
 	if (subagentBodyCache.size > SUBAGENT_BODY_CACHE_MAX) {
@@ -150,7 +236,7 @@ function renderDynamicSubagentBody(
 	theme: Theme,
 ): string[] {
 	subagentBodyRenderCount += 1;
-	return boundSubagentBodyLines(renderSubagentSnapshotBody(snapshot, expanded, theme, false), width);
+	return renderBoundSubagentBody(snapshot, expanded, width, theme, false);
 }
 
 function statusIconKind(status: SubagentSnapshot["status"]): ToolUIStatus {
@@ -363,11 +449,7 @@ function renderSubagentSnapshotBody(
 		}
 	}
 
-	if (snapshot.guidance) {
-		for (const line of getPreviewLines(snapshot.guidance, 1, PREVIEW_LINE_WIDTH, Ellipsis.Unicode)) {
-			lines.push(`  ${theme.fg("dim", replaceTabs(line))}`);
-		}
-	}
+	// `snapshot.guidance` is appended by renderBoundSubagentBody, wrapped to width.
 
 	return lines;
 }
@@ -421,6 +503,29 @@ export const subagentToolRenderer = {
 					theme,
 				);
 				const out: string[] = [truncateToWidth(replaceTabs(header), width, Ellipsis.Omit)];
+				const liveProgress = subagents.flatMap(snapshot =>
+					snapshot.progress && snapshot.liveProgressAvailable !== false ? [snapshot.progress] : [],
+				);
+				const degradationGroups = collectProviderDegradationGroups(liveProgress);
+				// Compact applies only to live await progress. Final results (timeout
+				// guidance, failure and completion receipts, status/steer replies) keep
+				// the full per-subagent rendering.
+				if (!expanded && options.isPartial && compactSubagentPanelEnabled()) {
+					out.push(
+						truncateToWidth(replaceTabs(renderCompactSubagentSummary(subagents, theme)), width, Ellipsis.Unicode),
+					);
+					const compactDegradation = renderCompactDegradationLine(degradationGroups, theme);
+					if (compactDegradation)
+						out.push(truncateToWidth(replaceTabs(compactDegradation), width, Ellipsis.Unicode));
+					out.push(
+						truncateToWidth(
+							replaceTabs(renderCompactSubagentHint(runningCount > 0, theme)),
+							width,
+							Ellipsis.Unicode,
+						),
+					);
+					return out;
+				}
 				// Discoverability: the inline panel is a bounded preview; the session
 				// observer (ctrl+s) streams the full per-subagent message history.
 				if (runningCount > 0) {
@@ -432,10 +537,7 @@ export const subagentToolRenderer = {
 						),
 					);
 				}
-				const liveProgress = subagents.flatMap(snapshot =>
-					snapshot.progress && snapshot.liveProgressAvailable !== false ? [snapshot.progress] : [],
-				);
-				for (const group of collectProviderDegradationGroups(liveProgress)) {
+				for (const group of degradationGroups) {
 					out.push(
 						truncateToWidth(
 							replaceTabs(

package/src/tools/subagent.ts

@@ -6,6 +6,7 @@ import { type AsyncJob, AsyncJobManager, jobElapsedMs, type SubagentRecord } fro
 import subagentDescription from "../prompts/tools/subagent.md" with { type: "text" };
 import type { AgentProgress, AgentSource, LocalErrorSummary } from "../task/types";
 import { Ellipsis, truncateToWidth } from "../tui";
+import { wrapUntrustedContent } from "./fetch";
 import type { ToolSession } from "./index";
 import { replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
@@ -540,8 +541,11 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			if (!onUpdate || streamingDisabled) return;
 			try {
 				const result = this.#progressResult(manager, records, true);
-				const signature = subagentAwaitRenderedStateSignature(result.details?.subagents ?? []);
 				const t = nowMs();
+				const snapshots = result.details?.subagents ?? [];
+				const signature = this.session.settings.get("task.compactSubagentPanel")
+					? subagentCompactRenderedStateSignature(snapshots, Date.now())
+					: subagentAwaitRenderedStateSignature(snapshots);
 				const livenessDue = force || t - lastEmitMs >= livenessIntervalMs;
 				if (!livenessDue && signature === lastEmittedSignature) return;
 				lastEmittedSignature = signature;
@@ -796,7 +800,11 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			}
 			if (snapshot.description) lines.push(`Description: ${snapshot.description}`);
 			if (snapshot.outputRef) lines.push(`Output: ${snapshot.outputRef}`);
-			if (snapshot.setupFailureSummary) lines.push(`Setup failure: ${snapshot.setupFailureSummary}`);
+			// A markdown fence is not a boundary: subagent text can contain ``` and
+			// close it, leaving the rest as raw tool-result text. Frame the data.
+			if (snapshot.setupFailureSummary) {
+				lines.push(wrapUntrustedContent(`Setup failure: ${snapshot.setupFailureSummary}`));
+			}
 			if (snapshot.localErrorSummary) {
 				const local = snapshot.localErrorSummary;
 				lines.push(`Local failure (${local.kind}): ${local.summary}`);
@@ -813,13 +821,14 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 					);
 				}
 			}
-			if (snapshot.assignment) lines.push("Assignment:", "```", snapshot.assignment, "```");
+			if (snapshot.assignment) lines.push(wrapUntrustedContent(`Assignment:\n${snapshot.assignment}`));
 			if (snapshot.steerMessage) {
-				lines.push(`Steer (${snapshot.steerState ?? "queued"}):`, "```", snapshot.steerMessage, "```");
+				lines.push(wrapUntrustedContent(`Steer (${snapshot.steerState ?? "queued"}):\n${snapshot.steerMessage}`));
 				lines.push(STEER_QUEUED_GUIDANCE);
 			}
 			if (snapshot.resultPreview) {
-				lines.push(snapshot.errorText ? "Error preview:" : "Result preview:", "```", snapshot.resultPreview, "```");
+				const previewLabel = snapshot.errorText ? "Error preview:" : "Result preview:";
+				lines.push(wrapUntrustedContent(`${previewLabel}\n${snapshot.resultPreview}`));
 				if (snapshot.truncated)
 					lines.push("Preview truncated; use the output ref or explicit ids with `verbosity=full` for more.");
 			}
@@ -1136,6 +1145,110 @@ export function subagentAwaitRenderedStateSignature(
 	});
 }
 
+/** A running subagent with no activity for longer than this counts as idle in the compact panel. */
+export const SUBAGENT_COMPACT_IDLE_MS = 30_000;
+
+/** Group counts behind the compact await panel's single summary line. */
+export interface SubagentGroupSummary {
+	running: number;
+	idle: number;
+	retrying: number;
+	queued: number;
+	paused: number;
+	completed: number;
+	failed: number;
+	cancelled: number;
+	/** Running subagents in provider retry, per provider; drives the degradation warning. */
+	retryingByProvider: Record<string, number>;
+}
+
+export function summarizeSubagentGroup(subagents: readonly SubagentSnapshot[], nowMs: number): SubagentGroupSummary {
+	const summary: SubagentGroupSummary = {
+		running: 0,
+		idle: 0,
+		retrying: 0,
+		queued: 0,
+		paused: 0,
+		completed: 0,
+		failed: 0,
+		cancelled: 0,
+		retryingByProvider: {},
+	};
+	for (const snapshot of subagents) {
+		switch (snapshot.status) {
+			case "running": {
+				summary.running += 1;
+				const live = snapshot.liveProgressAvailable !== false ? snapshot.progress : undefined;
+				if (live?.status === "running" && live.retryState) {
+					summary.retrying += 1;
+					const provider = live.retryState.provider ?? "provider";
+					summary.retryingByProvider[provider] = (summary.retryingByProvider[provider] ?? 0) + 1;
+				}
+				// Before its first activity a subagent has no timestamp; its elapsed job time
+				// is then the age, so one stalled from the start still turns idle.
+				const quietMs = live?.lastActivityMs !== undefined ? nowMs - live.lastActivityMs : snapshot.durationMs;
+				if (quietMs > SUBAGENT_COMPACT_IDLE_MS) summary.idle += 1;
+				break;
+			}
+			case "queued":
+				summary.queued += 1;
+				break;
+			case "paused":
+				summary.paused += 1;
+				break;
+			case "completed":
+			case "already_completed":
+				summary.completed += 1;
+				break;
+			case "failed":
+			case "not_found":
+				summary.failed += 1;
+				break;
+			case "cancelled":
+				summary.cancelled += 1;
+				break;
+		}
+	}
+	return summary;
+}
+
+/**
+ * The compact degradation row shows only the most-degraded provider, its count, and
+ * how many other providers degrade (providers with a single retrying subagent are
+ * not a degradation). Signing exactly that keeps invisible per-provider churn from
+ * re-emitting.
+ */
+function compactDegradationSignature(
+	retryingByProvider: Record<string, number>,
+): { provider: string; count: number; moreProviders: number } | null {
+	const groups = Object.entries(retryingByProvider)
+		.filter(([, count]) => count > 1)
+		.sort(([a, countA], [b, countB]) => countB - countA || a.localeCompare(b));
+	const [worst] = groups;
+	return worst ? { provider: worst[0], count: worst[1], moreProviders: groups.length - 1 } : null;
+}
+
+/**
+ * Rendered-state signature for the compact await panel. It covers only what the
+ * compact view shows (group counts and the single degradation row), so per-subagent activity that does not move
+ * a count no longer re-emits: the update rate is bounded by count transitions and
+ * the liveness interval instead of growing with the number of live subagents.
+ */
+export function subagentCompactRenderedStateSignature(
+	subagents: readonly SubagentSnapshot[],
+	nowMs: number,
+	receipt?: Pick<SubagentToolDetails, "awaitOutcome" | "interrupted">,
+): string {
+	return JSON.stringify({
+		awaitOutcome: receipt?.awaitOutcome ?? null,
+		interrupted: receipt?.interrupted === true,
+		summary: (({ retryingByProvider, ...counts }) => ({
+			...counts,
+			degradation: compactDegradationSignature(retryingByProvider),
+		}))(summarizeSubagentGroup(subagents, nowMs)),
+	});
+}
+
 function canonicalizeSnapshotForSignature(snapshot: SubagentSnapshot): unknown {
 	return {
 		id: snapshot.id,