@gajae-code/coding-agent 0.18.11 → 0.18.12

package/src/tools/descriptors.ts

@@ -84,6 +84,9 @@ export class LazyAgentTool implements AgentTool<any, any, any> {
 	#loader?: () => ToolDescriptorLoadResult;
 	#session?: ToolSession;
 	#loadPromise?: Promise<AgentTool<any, any, any>>;
+	#loadGeneration = 0;
+	#loadToken?: object;
+	#expectedCwd?: string;
 
 	constructor(
 		descriptor: ToolDescriptor,
@@ -97,9 +100,31 @@ export class LazyAgentTool implements AgentTool<any, any, any> {
 		this.#session = session;
 	}
 
+	/** Clear a session-bound materialization after its owning session moves. */
+	invalidateForSessionMove(expectedCwd?: string): void {
+		this.#loadGeneration++;
+		this.#tool = undefined;
+		this.#loadPromise = undefined;
+		this.#loadToken = undefined;
+		this.#expectedCwd = expectedCwd;
+		if (!this.#loader && this.#session) {
+			const session = this.#session;
+			this.#loader = () => this.descriptor.load(session);
+		}
+	}
+
 	async #get(): Promise<AgentTool<any, any, any>> {
+		const sessionCwd = this.#session?.cwd;
+		if (this.#expectedCwd !== undefined && sessionCwd !== this.#expectedCwd) {
+			throw new ToolError(
+				`Tool "${this.descriptor.metadata.name}" session cwd changed outside a committed move (expected ${this.#expectedCwd}, got ${sessionCwd ?? "unknown"})`,
+			);
+		}
 		if (this.#tool) return this.#tool;
 		if (!this.#loadPromise) {
+			const generation = this.#loadGeneration;
+			const token = {};
+			this.#loadToken = token;
 			const load = this.#loader;
 			this.#loadPromise = Promise.resolve()
 				.then(() => {
@@ -108,11 +133,14 @@ export class LazyAgentTool implements AgentTool<any, any, any> {
 				})
 				.then(tool => {
 					if (!tool) throw new ToolError(`Tool "${this.descriptor.metadata.name}" failed to load`);
-					this.#tool = tool;
+					if (generation === this.#loadGeneration && this.#loadToken === token) this.#tool = tool;
 					return tool;
 				})
 				.catch(error => {
-					this.#loadPromise = undefined;
+					if (generation === this.#loadGeneration && this.#loadToken === token) {
+						this.#loadPromise = undefined;
+						this.#loadToken = undefined;
+					}
 					if (error instanceof ToolError) throw error;
 					throw new ToolError(
 						`Tool "${this.descriptor.metadata.name}" failed to load implementation: ${error instanceof Error ? error.message : String(error)}`,
@@ -270,6 +298,7 @@ function availableFor(name: string, session: ToolSession, context = defaultAvail
 	if (name === "ast_grep") return Boolean(session.settings.get("astGrep.enabled"));
 	if (name === "ast_edit") return Boolean(session.settings.get("astEdit.enabled"));
 	if (name === "render_mermaid") return Boolean(session.settings.get("renderMermaid.enabled"));
+	if (name === "report_issue") return Boolean(session.settings.get("reportIssue.enabled"));
 	if (name === "web_search") return Boolean(session.settings.get("web_search.enabled"));
 	if (name === "search_tool_bm25") return context.discoveryActive ?? resolveDiscoveryActive(session);
 	if (name === "calc") return Boolean(session.settings.get("calc.enabled"));
@@ -389,6 +418,8 @@ const loaders: Record<string, Loader> = {
 		cached("goal", () => import("../goals/tools/goal-tool")).then(module => new module.GoalTool(session)),
 	move_session: session =>
 		cached("move_session", () => import("./move-session")).then(module => new module.MoveSessionTool(session)),
+	report_issue: session =>
+		cached("report_issue", () => import("./report-issue")).then(module => new module.ReportIssueTool(session)),
 	yield: session => cached("yield", () => import("./yield")).then(module => new module.YieldTool(session)),
 	report_finding: _session => cached("review", () => import("./review")).then(module => module.reportFindingTool),
 	resolve: session => cached("resolve", () => import("./resolve")).then(module => new module.ResolveTool(session)),
@@ -481,6 +512,7 @@ const names: Array<[name: string, label: string, summary: string | undefined, lo
 		["skill", "Skill", "Chain into another available skill", "essential"],
 		["goal", "Goal", undefined, "essential"],
 		["move_session", "Move Session", undefined, "essential"],
+		["report_issue", "Report Issue", "Record a tool that behaved inconsistently with its description", "essential"],
 	];
 
 const sessionDescriptions: Readonly<Record<string, ToolDescriptorMetadata["descriptionForSession"]>> = {

package/src/tools/fetch.ts

@@ -677,12 +677,13 @@ async function handleSpecialUrls(
 	timeout: number,
 	signal: AbortSignal | undefined,
 	storage: AgentStorage | null,
+	settings: Settings,
 ): Promise<FetchRenderResult | null> {
 	for (const handler of getSpecialHandlers()) {
 		if (signal?.aborted) {
 			throw new ToolAbortError();
 		}
-		const result = await handler(url, timeout, signal, storage);
+		const result = await handler(url, timeout, signal, storage, settings);
 		if (result) return result;
 	}
 	return null;
@@ -766,7 +767,7 @@ async function renderUrl(
 
 	// Step 1: Try special handlers for known sites (unless raw mode)
 	if (!raw) {
-		const specialResult = await handleSpecialUrls(url, timeout, signal, storage);
+		const specialResult = await handleSpecialUrls(url, timeout, signal, storage, settings);
 		if (specialResult) return specialResult;
 	}
 

package/src/tools/index.ts

@@ -364,6 +364,8 @@ export interface ToolSession {
 	 * directory, or escapes the current scope.
 	 */
 	rescopeSessionCwd?: (path: string) => Promise<{ from: string; to: string }>;
+	/** Live ACP/SDK approval mode. Task children copy this at spawn; absent means `allow`. */
+	getSdkPermissionMode?: () => "prompt" | "allow" | "deny";
 	/** Bridge to the connected client (e.g. ACP editor host). Tools should route fs/terminal/permission requests through this when available. */
 	getClientBridge?: () => ClientBridge | undefined;
 	/** Get compact conversation context for subagents (excludes tool results, system prompts) */

package/src/tools/output-meta.ts

@@ -20,13 +20,14 @@ import {
 	formatMiddleElisionMarker,
 	type OutputSummary,
 	type ReadWindow,
+	runWithOutputRedaction,
 	type TruncationResult,
 	truncateMiddle,
 	truncateTail,
 } from "../session/streaming-output";
 
 import { formatBytes, wrapBrackets } from "./render-utils";
-import { renderError, ToolError } from "./tool-errors";
+import { renderError, ToolError, throwIfAborted } from "./tool-errors";
 
 /**
  * Truncation metadata for the output notice.
@@ -1155,6 +1156,19 @@ async function enforceInlineResultBackstop(
 // Tool wrapper
 // =============================================================================
 
+async function outputRedactionFor(settings: Settings): Promise<readonly string[] | undefined> {
+	const { collectEnvSecrets, loadSecrets } = await import("../secrets");
+	const entries = [...(await loadSecrets(settings.getCwd(), settings.getAgentDir())), ...collectEnvSecrets()];
+	const plain: string[] = [];
+	const seen = new Set<string>();
+	for (const entry of entries) {
+		if (entry.type !== "plain" || entry.content.length === 0 || seen.has(entry.content)) continue;
+		seen.add(entry.content);
+		plain.push(entry.content);
+	}
+	return plain.length > 0 ? plain : undefined;
+}
+
 async function wrappedExecute(
 	this: AgentTool & { [kUnwrappedExecute]: AgentToolExecFn },
 	toolCallId: string,
@@ -1166,7 +1180,14 @@ async function wrappedExecute(
 	const originalExecute = this[kUnwrappedExecute];
 
 	try {
-		let result = await originalExecute.call(this, toolCallId, params, signal, onUpdate, context);
+		const settings = context?.settings;
+		let plainSecrets: readonly string[] | undefined;
+		if (settings?.get("secrets.enabled") === true) {
+			plainSecrets = await outputRedactionFor(settings);
+			throwIfAborted(signal);
+		}
+		const run = () => originalExecute.call(this, toolCallId, params, signal, onUpdate, context);
+		let result = plainSecrets ? await runWithOutputRedaction(plainSecrets, run) : await run();
 
 		// Spill large results to artifact, truncate to tail
 		result = await spillLargeResultToArtifact(result, this.name, context);

package/src/tools/python.ts

@@ -31,7 +31,7 @@ export interface SessionPythonToolInput {
 	/** Resolve the GJC session id used for the kernel owner and transcript paths. */
 	getSessionId: () => string | null;
 	/** Register cleanup with the current logical session lifecycle. */
-	registerSessionCleanup: (cleanup: () => Promise<void> | void) => (() => void) | void;
+	registerSessionCleanup: (cleanup: () => Promise<void> | void) => (() => void) | undefined;
 	/** Reject execution after the owning session has begun disposal. */
 	assertEvalExecutionAllowed?: () => void;
 	/** Track this whole invocation through its transcript append. */

package/src/tools/read.ts

@@ -26,9 +26,9 @@ import {
 	formatMiddleElisionMarker,
 	truncateHead,
 	truncateHeadBytes,
-	truncateLine,
 	truncateMiddleWindows,
 	truncateTailBytes,
+	truncateTextWithSecretAwareness,
 } from "../session/streaming-output";
 import { fileHyperlink, renderCodeCell, renderMarkdownCell, renderStatusLine, tryResolveInternalUrlSync } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
@@ -253,12 +253,7 @@ function renderReadWindow(
 		const hash = shouldAddHashLines && segment.kind === "lines";
 		const numbers = !hash && shouldAddLineNumbers;
 		const renderContent =
-			!hash && maxColumns > 0
-				? segment.content
-						.split("\n")
-						.map(line => truncateLine(line, maxColumns).text)
-						.join("\n")
-				: segment.content;
+			!hash && maxColumns > 0 ? truncateTextWithSecretAwareness(segment.content, maxColumns).text : segment.content;
 		return formatTextWithMode(renderContent, segment.origin.startLine, hash, numbers);
 	};
 	const marker = formatMiddleElisionMarker(window.elidedLines, window.elidedBytes);
@@ -1906,17 +1901,12 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				// A partial line is a byte suffix, not a complete source line. Never
 				// give it an anchor that could make the preview look fully readable.
 				const numbers = !hash && shouldAddLineNumbers && segment.kind === "lines";
-				const renderContent =
-					!options.raw && !hash && maxColumns > 0
-						? segment.content
-								.split("\n")
-								.map(line => {
-									const result = truncateLine(line, maxColumns);
-									if (result.wasTruncated) columnTruncated = maxColumns;
-									return result.text;
-								})
-								.join("\n")
-						: segment.content;
+				let renderContent = segment.content;
+				if (!options.raw && !hash && maxColumns > 0) {
+					const result = truncateTextWithSecretAwareness(segment.content, maxColumns);
+					if (result.wasTruncated) columnTruncated = maxColumns;
+					renderContent = result.text;
+				}
 				return formatTextWithMode(renderContent, segment.origin.startLine, hash, numbers);
 			};
 			let text = "";
@@ -2097,12 +2087,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const collectedLines = streamResult.lines;
 			const cacheLines = collectedLines.slice();
 			if (!rawSelector && !shouldAddHashLines && maxColumns > 0) {
-				for (let i = 0; i < collectedLines.length; i++) {
-					const { text, wasTruncated } = truncateLine(collectedLines[i], maxColumns);
-					if (wasTruncated) {
-						collectedLines[i] = text;
-						columnTruncated = maxColumns;
-					}
+				const clipped = truncateTextWithSecretAwareness(collectedLines.join("\n"), maxColumns);
+				if (clipped.wasTruncated) {
+					collectedLines.splice(0, collectedLines.length, ...clipped.text.split("\n"));
+					columnTruncated = maxColumns;
 				}
 			}
 
@@ -3136,11 +3124,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						const directionalMaxColumns = rawSelector ? 0 : resolveOutputMaxColumns(this.session.settings);
 						if (!rawSelector && !shouldAddDirectionalHashLines && directionalMaxColumns > 0) {
 							for (const segment of windowSegments(window)) {
-								if (
-									segment.content
-										.split("\n")
-										.some(line => truncateLine(line, directionalMaxColumns).wasTruncated)
-								) {
+								if (truncateTextWithSecretAwareness(segment.content, directionalMaxColumns).wasTruncated) {
 									columnTruncated = directionalMaxColumns;
 									break;
 								}
@@ -3268,12 +3252,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						const shouldAddHashLines = !rawSelector && displayMode.hashLines;
 						const maxColumns = resolveOutputMaxColumns(this.session.settings);
 						if (!rawSelector && !shouldAddHashLines && maxColumns > 0) {
-							for (let i = 0; i < collectedLines.length; i++) {
-								const { text, wasTruncated } = truncateLine(collectedLines[i], maxColumns);
-								if (wasTruncated) {
-									collectedLines[i] = text;
-									columnTruncated = maxColumns;
-								}
+							const clipped = truncateTextWithSecretAwareness(collectedLines.join("\n"), maxColumns);
+							if (clipped.wasTruncated) {
+								collectedLines.splice(0, collectedLines.length, ...clipped.text.split("\n"));
+								columnTruncated = maxColumns;
 							}
 						}
 

package/src/tools/report-issue.ts

@@ -0,0 +1,184 @@
+/**
+ * `report_issue` — local auto-QA for tool behavior.
+ *
+ * The model records a tool whose output contradicts that tool's own
+ * description. Reports are appended to a local SQLite database
+ * (`~/.gjc/tool-issues.db`); nothing leaves the machine. Inspect them with the
+ * read tool's SQLite support, e.g.
+ * `gjc read '~/.gjc/tool-issues.db?q=SELECT tool, count(*) FROM tool_issues GROUP BY tool'`.
+ *
+ * Inspired by oh-my-pi's `xd://report_issue` auto-QA device; collector push
+ * and consent prompts are intentionally not part of this local-only port.
+ */
+import { Database } from "bun:sqlite";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { AgentTool, AgentToolResult } from "@gajae-code/agent-core";
+import { getToolIssuesDbPath, logger, prompt, VERSION } from "@gajae-code/utils";
+import * as z from "zod/v4";
+import reportIssueDescription from "../prompts/tools/report-issue.md" with { type: "text" };
+import type { ToolSession } from "./index";
+import { ToolError } from "./tool-errors";
+
+/** Upper bound on the stored tool name, in UTF-8 bytes. */
+const MAX_TOOL_BYTES = 128;
+/** Upper bound on the stored report body, in characters. */
+const MAX_REPORT_CHARS = 4_000;
+
+const reportIssueSchema = z.object({
+	tool: z.string().describe("name of the tool that misbehaved"),
+	report: z.string().describe("what was called, what was expected, what happened"),
+});
+
+export type ReportIssueToolInput = z.infer<typeof reportIssueSchema>;
+
+export interface ReportIssueToolDetails {
+	recorded: boolean;
+	tool: string;
+}
+
+export interface ToolIssueEntry {
+	tool: string;
+	report: string;
+	model: string | null;
+	sessionId: string | null;
+}
+
+/**
+ * Open the database for a single report. Reports are rare, so no connection is cached: a file the
+ * user deleted is recreated on the next report, and no handle keeps the file locked between reports.
+ */
+async function openToolIssueDb(dbPath: string): Promise<Database> {
+	// Only a directory created here gets 0700; an existing shared config/data root keeps its mode.
+	await fs.mkdir(path.dirname(dbPath), { recursive: true, mode: 0o700 });
+	// Create (or tighten) the database file before SQLite opens it. SQLite's unix VFS creates the
+	// WAL/SHM sidecars with the main file's permissions, so they are private from their first byte.
+	const handle = await fs.open(dbPath, "a", 0o600);
+	try {
+		if (process.platform !== "win32") await handle.chmod(0o600);
+	} finally {
+		await handle.close();
+	}
+	const db = new Database(dbPath);
+	try {
+		db.run(`
+			PRAGMA busy_timeout=5000;
+			PRAGMA journal_mode=WAL;
+			CREATE TABLE IF NOT EXISTS tool_issues (
+				id          INTEGER PRIMARY KEY AUTOINCREMENT,
+				created_at  TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+				tool        TEXT    NOT NULL,
+				report      TEXT    NOT NULL,
+				model       TEXT,
+				gjc_version TEXT    NOT NULL,
+				session_id  TEXT
+			);
+			CREATE INDEX IF NOT EXISTS idx_tool_issues_tool_created ON tool_issues(tool, created_at);
+		`);
+	} catch (error) {
+		db.close();
+		throw error;
+	}
+	return db;
+}
+
+function truncateUtf8(text: string, maxBytes: number): string {
+	const bytes = Buffer.from(text, "utf8");
+	if (bytes.length <= maxBytes) return text;
+	// Decoding a cut multi-byte sequence yields U+FFFD; drop it.
+	return bytes
+		.subarray(0, maxBytes)
+		.toString("utf8")
+		.replace(/\uFFFD+$/u, "");
+}
+
+/**
+ * Truncate text by complete Unicode code points, avoiding incomplete surrogate pairs.
+ * JavaScript strings use UTF-16 encoding, where astral characters use two code units
+ * (high surrogate + low surrogate). We must count actual code points, not UTF-16 code units.
+ */
+function truncateByCodePoint(text: string, maxChars: number): string {
+	let codePointCount = 0;
+	let result = "";
+	// Iterate through actual code points using for-of, which handles surrogate pairs correctly
+	for (const codePoint of text) {
+		if (codePointCount >= maxChars) break;
+		result += codePoint;
+		codePointCount++;
+	}
+	return result;
+}
+
+function codePointLength(text: string): number {
+	let count = 0;
+	for (const _ of text) count++;
+	return count;
+}
+
+/** Normalize and clamp a report to the stored field limits. */
+export function normalizeToolIssue(tool: string, report: string): { tool: string; report: string } {
+	const normalizedTool = truncateUtf8(tool.trim(), MAX_TOOL_BYTES);
+	const trimmedReport = report.trim();
+	const normalizedReport =
+		codePointLength(trimmedReport) > MAX_REPORT_CHARS
+			? `${truncateByCodePoint(trimmedReport, MAX_REPORT_CHARS - 1)}…`
+			: trimmedReport;
+	return { tool: normalizedTool, report: normalizedReport };
+}
+
+/** Append one report to the tool-issue database at `dbPath`. */
+export async function recordToolIssue(dbPath: string, entry: ToolIssueEntry): Promise<void> {
+	const db = await openToolIssueDb(dbPath);
+	try {
+		db.run("INSERT INTO tool_issues (tool, report, model, gjc_version, session_id) VALUES (?, ?, ?, ?, ?)", [
+			entry.tool,
+			entry.report,
+			entry.model,
+			VERSION,
+			entry.sessionId,
+		]);
+	} finally {
+		db.close();
+	}
+}
+
+export class ReportIssueTool implements AgentTool<typeof reportIssueSchema, ReportIssueToolDetails> {
+	readonly name = "report_issue";
+	readonly label = "Report Issue";
+	readonly loadMode = "essential" as const;
+	readonly description = prompt.render(reportIssueDescription);
+	readonly parameters = reportIssueSchema;
+	readonly strict = true;
+	readonly intent = "omit" as const;
+	readonly #session: ToolSession;
+	readonly #dbPath: string;
+
+	constructor(session: ToolSession, dbPath: string = getToolIssuesDbPath()) {
+		this.#session = session;
+		this.#dbPath = dbPath;
+	}
+
+	async execute(_toolCallId: string, params: ReportIssueToolInput): Promise<AgentToolResult<ReportIssueToolDetails>> {
+		const { tool, report } = normalizeToolIssue(params.tool, params.report);
+		if (!tool) throw new ToolError("tool must name the tool that misbehaved.");
+		if (!report) throw new ToolError("report must describe the unexpected behavior.");
+		try {
+			await recordToolIssue(this.#dbPath, {
+				tool,
+				report,
+				model: this.#session.getActiveModelString?.() ?? null,
+				sessionId: this.#session.getSessionId?.() ?? null,
+			});
+		} catch (error) {
+			logger.warn("report_issue: failed to record tool issue", { error: String(error), dbPath: this.#dbPath });
+			return {
+				content: [{ type: "text", text: "Report could not be stored locally; continue the task." }],
+				details: { recorded: false, tool },
+			};
+		}
+		return {
+			content: [{ type: "text", text: "Recorded. Continue the task." }],
+			details: { recorded: true, tool },
+		};
+	}
+}

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(