@gajae-code/coding-agent 0.11.0 → 0.11.1

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(

package/src/tools/subagent.ts

@@ -80,8 +80,17 @@ export interface SubagentSnapshot {
 	modelFellBack?: boolean;
 }
 
+export type SubagentAwaitOutcome = "completed" | "timed_out" | "interrupted";
+
+const AWAIT_INTERRUPTED_GUIDANCE =
+	"Await interrupted; this subagent continues. Inspect its current state or cancel it only when necessary.";
+
 export interface SubagentToolDetails {
 	subagents: SubagentSnapshot[];
+	/** Await outcome for a live await receipt; omitted when no wait was started. */
+	awaitOutcome?: SubagentAwaitOutcome;
+	/** True only when the parent await was interrupted; the child was not cancelled. */
+	interrupted?: true;
 }
 
 export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentToolDetails> {
@@ -370,35 +379,50 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		// the viewport (the source of the await-panel repaint storms).
 		emitIfChanged(true);
 
-		let timedOut = false;
+		let awaitOutcome: SubagentAwaitOutcome;
+		const { promise: timeoutPromise, resolve: resolveTimeout } = Promise.withResolvers<SubagentAwaitOutcome>();
+		const timeoutTimer = setTimeout(() => resolveTimeout("timed_out"), timeoutMs);
+		const completionPromise = Promise.all(runningJobs.map(job => job.promise)).then(() => "completed" as const);
+		let onAbort: (() => void) | undefined;
 		try {
-			const completionPromise = Promise.all(runningJobs.map(job => job.promise));
-			const timeoutPromise = Bun.sleep(timeoutMs).then(() => {
-				timedOut = true;
-			});
 			if (signal) {
-				const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<void>();
-				const onAbort = () => abortResolve();
-				signal.addEventListener("abort", onAbort, { once: true });
-				try {
-					await Promise.race([completionPromise, timeoutPromise, abortPromise]);
-				} finally {
-					signal.removeEventListener("abort", onAbort);
-				}
+				const { promise: abortPromise, resolve: resolveAbort } = Promise.withResolvers<SubagentAwaitOutcome>();
+				onAbort = () => resolveAbort("interrupted");
+				if (signal.aborted) onAbort();
+				else signal.addEventListener("abort", onAbort, { once: true });
+				awaitOutcome = await Promise.race([completionPromise, timeoutPromise, abortPromise]);
 			} else {
-				await Promise.race([completionPromise, timeoutPromise]);
+				awaitOutcome = await Promise.race([completionPromise, timeoutPromise]);
 			}
 		} finally {
-			manager.unwatchJobs(watchedJobIds);
+			clearTimeout(timeoutTimer);
+			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
 			if (progressTimer) clearInterval(progressTimer);
 		}
+		if (awaitOutcome !== "interrupted") {
+			const terminalWatchedJobIds = watchedJobIds.filter(jobId => {
+				const status = manager.getJob(jobId)?.status;
+				return status === "completed" || status === "failed" || status === "cancelled";
+			});
+			manager.acknowledgeDeliveries(terminalWatchedJobIds);
+		}
+		manager.unwatchJobs(watchedJobIds);
 
-		return await this.#buildRecordResult(manager, records, {
-			title: "Subagent await",
-			notFoundIds,
-			timedOut,
+		const finalRecords = this.#visibleRecordsByIds(
+			manager,
+			records.map(record => record.subagentId),
+			ownerFilter,
+		);
+		const finalNotFoundIds = [...new Set([...notFoundIds, ...records.map(record => record.subagentId)])].filter(
+			id => !finalRecords.some(record => record.subagentId === id),
+		);
+		return await this.#buildRecordResult(manager, finalRecords, {
+			title: awaitOutcome === "interrupted" ? "Subagent await interrupted" : "Subagent await",
+			notFoundIds: finalNotFoundIds,
+			timedOut: awaitOutcome === "timed_out",
 			verbosity: params.verbosity ?? "receipt",
 			attachLiveProgress: true,
+			awaitOutcome,
 		});
 	}
 
@@ -516,6 +540,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			timedOut?: boolean;
 			verbosity?: SubagentParams["verbosity"];
 			attachLiveProgress?: boolean;
+			awaitOutcome?: SubagentAwaitOutcome;
 		},
 	): Promise<AgentToolResult<SubagentToolDetails>> {
 		const verifiedOutputIds = await this.#verifiedOutputIds(records);
@@ -530,18 +555,34 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		for (const id of options.notFoundIds ?? []) {
 			snapshots.push(this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."));
 		}
-		manager.acknowledgeDeliveries(
-			snapshots
-				.filter(
-					s =>
-						s.status !== "running" && s.status !== "paused" && s.status !== "queued" && s.status !== "not_found",
-				)
-				.map(s => s.jobId),
-		);
-		return this.#buildSnapshotResult(snapshots, options.title);
+		if (options.awaitOutcome !== "interrupted") {
+			manager.acknowledgeDeliveries(
+				snapshots
+					.filter(
+						s =>
+							s.status !== "running" &&
+							s.status !== "paused" &&
+							s.status !== "queued" &&
+							s.status !== "not_found",
+					)
+					.map(s => s.jobId),
+			);
+		}
+		if (options.awaitOutcome === "interrupted") {
+			for (const snapshot of snapshots) {
+				if (snapshot.status === "running" || snapshot.status === "paused" || snapshot.status === "queued") {
+					snapshot.guidance = AWAIT_INTERRUPTED_GUIDANCE;
+				}
+			}
+		}
+		return this.#buildSnapshotResult(snapshots, options.title, options.awaitOutcome);
 	}
 
-	#buildSnapshotResult(snapshots: SubagentSnapshot[], title: string): AgentToolResult<SubagentToolDetails> {
+	#buildSnapshotResult(
+		snapshots: SubagentSnapshot[],
+		title: string,
+		awaitOutcome?: SubagentAwaitOutcome,
+	): AgentToolResult<SubagentToolDetails> {
 		const lines = [`## ${title} (${snapshots.length})`, ""];
 		for (const snapshot of snapshots) {
 			lines.push(`### ${snapshot.id} — ${snapshot.status}`);
@@ -571,7 +612,11 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		}
 		return {
 			content: [{ type: "text", text: lines.join("\n").trimEnd() }],
-			details: { subagents: snapshots },
+			details: {
+				subagents: snapshots,
+				...(awaitOutcome ? { awaitOutcome } : {}),
+				...(awaitOutcome === "interrupted" ? { interrupted: true } : {}),
+			},
 		};
 	}
 
@@ -778,8 +823,15 @@ function previewJobOutput(
  * countdown ticking is sacrificed by design; every real transition still changes
  * the signature.
  */
-export function subagentAwaitRenderedStateSignature(subagents: readonly SubagentSnapshot[]): string {
-	return JSON.stringify(subagents.map(canonicalizeSnapshotForSignature));
+export function subagentAwaitRenderedStateSignature(
+	subagents: readonly SubagentSnapshot[],
+	receipt?: Pick<SubagentToolDetails, "awaitOutcome" | "interrupted">,
+): string {
+	return JSON.stringify({
+		awaitOutcome: receipt?.awaitOutcome ?? null,
+		interrupted: receipt?.interrupted === true,
+		subagents: subagents.map(canonicalizeSnapshotForSignature),
+	});
 }
 
 function canonicalizeSnapshotForSignature(snapshot: SubagentSnapshot): unknown {