@ryan_nookpi/pi-extension-subagent 0.5.3 → 0.5.5

package/commands.ts

@@ -35,6 +35,12 @@ import {
 	shouldSummarizeSubagentTask,
 	summarizeSubagentDisplayTask,
 } from "./display-task.js";
+import {
+	classifySubagentFailure,
+	getSubagentRunStatusLabel,
+	getSubagentTerminalLabel,
+	isSubagentAbort,
+} from "./failure-telemetry.js";
 import {
 	AGENT_NAME_PALETTE,
 	agentBgIndex,
@@ -215,10 +221,11 @@ class SubagentHistoryOverlay {
 			const marker = isSelected ? "▸" : " ";
 
 			// Status color
+			const statusLabel = getSubagentRunStatusLabel(run.status, run.errorClass);
 			let statusColor: "success" | "error" | "warning" | "dim" = "dim";
-			if (run.status === "done") statusColor = "success";
-			else if (run.status === "error") statusColor = "error";
-			else if (run.status === "running") statusColor = "warning";
+			if (statusLabel === "done") statusColor = "success";
+			else if (statusLabel === "error") statusColor = "error";
+			else if (statusLabel === "running" || statusLabel === "aborted") statusColor = "warning";
 
 			const timeLabel = new Date(run.startedAt).toLocaleTimeString([], {
 				hour: "2-digit",
@@ -227,7 +234,7 @@ class SubagentHistoryOverlay {
 			});
 
 			const removedBadge = run.removed ? theme.fg("dim", " [removed]") : "";
-			const statusStr = theme.fg(statusColor, `[${run.status}]`);
+			const statusStr = theme.fg(statusColor, `[${statusLabel}]`);
 			const agentStr = theme.fg("accent", run.agent);
 			const taskPreview = run.task
 				.replace(/\s*\n+\s*/g, " ")
@@ -395,7 +402,7 @@ function attachRunResponseToEditor(ctx: ExtensionContext, run: CommandRunState,
 async function showRunLatestResponseOverlay(ctx: ExtensionContext, run: CommandRunState): Promise<void> {
 	const response = getRunLatestResponse(run);
 	const contextLabel = run.contextMode === "main" ? "main" : "sub";
-	const subtitle = `#${run.id} · ${run.agent} · ${run.status} · ctx:${contextLabel} · turn:${run.turnCount ?? DEFAULT_TURN_COUNT}`;
+	const subtitle = `#${run.id} · ${run.agent} · ${getSubagentRunStatusLabel(run.status, run.errorClass)} · ctx:${contextLabel} · turn:${run.turnCount ?? DEFAULT_TURN_COUNT}`;
 
 	await ctx.ui.custom(
 		(tui, theme, _kb, done) => {
@@ -520,7 +527,11 @@ function restoreRunsFromSession(store: SubagentStore, ctx: any, pi?: ExtensionAP
 	try {
 		const entries = ctx.sessionManager.getEntries();
 		const restoredRuns = new Map<number, CommandRunState>();
-		const removedRunIds = new Set<number>();
+		const removedRuns = new Map<
+			number,
+			{ entryIndex: number; startedAt?: number; aborted: boolean; message?: string }
+		>();
+		const latestRunEntryIndexes = new Map<number, number>();
 		const displayTaskUpdates = new Map<number, { task?: string; displayTask?: string; startedAt?: number }>();
 		let maxRunId = 0;
 
@@ -541,13 +552,19 @@ function restoreRunsFromSession(store: SubagentStore, ctx: any, pi?: ExtensionAP
 		store.currentParentSessionFile = latestParentSessionFile;
 
 		// First pass: collect removed run IDs and persisted displayTask updates
-		for (const entry of entries) {
+		for (const [entryIndex, entry] of entries.entries()) {
 			if (entry.type === "custom") {
 				const ce = entry as any;
 				if (ce.customType === "subagent-removed") {
 					sawSubagentMarkers = true;
 					if (ce.data?.runId != null) {
-						removedRunIds.add(ce.data.runId);
+						removedRuns.set(ce.data.runId, {
+							entryIndex,
+							startedAt: toValidTimestampMs(ce.data?.startedAt),
+							aborted:
+								ce.data?.status === "aborted" || ce.data?.errorClass === "aborted" || ce.data?.stopReason === "aborted",
+							message: typeof ce.data?.message === "string" ? ce.data.message : undefined,
+						});
 					}
 					continue;
 				}
@@ -562,7 +579,7 @@ function restoreRunsFromSession(store: SubagentStore, ctx: any, pi?: ExtensionAP
 			}
 		}
 
-		for (const entry of entries) {
+		for (const [entryIndex, entry] of entries.entries()) {
 			if (entry.type !== "custom_message") continue;
 			const cm = entry as any;
 			if (cm.customType !== "subagent-command" && cm.customType !== "subagent-tool") continue;
@@ -571,6 +588,7 @@ function restoreRunsFromSession(store: SubagentStore, ctx: any, pi?: ExtensionAP
 			if (!d || typeof d.runId !== "number") continue;
 
 			const runId = d.runId;
+			latestRunEntryIndexes.set(runId, entryIndex);
 			if (runId > maxRunId) maxRunId = runId;
 
 			const existing = restoredRuns.get(runId);
@@ -584,11 +602,12 @@ function restoreRunsFromSession(store: SubagentStore, ctx: any, pi?: ExtensionAP
 
 			// Determine final status primarily from structured metadata.
 			const content = typeof cm.content === "string" ? cm.content : "";
+			const firstContentLine = content.split("\n", 1)[0]?.trim() ?? "";
 			const statusRaw = typeof d.status === "string" ? d.status.trim().toLowerCase() : "";
 			const statusFromDetails: "done" | "error" | null =
 				statusRaw === "done" || statusRaw === "completed"
 					? "done"
-					: statusRaw === "error" || statusRaw === "failed"
+					: statusRaw === "error" || statusRaw === "failed" || statusRaw === "aborted"
 						? "error"
 						: null;
 			const statusFromExitCode: "done" | "error" | null =
@@ -597,13 +616,25 @@ function restoreRunsFromSession(store: SubagentStore, ctx: any, pi?: ExtensionAP
 				typeof d.error === "string" && d.error.trim() ? "error" : null;
 
 			// Legacy fallback for old sessions where structured fields are missing.
-			const legacyStatusFromContent: "done" | "error" | null = content.includes("] completed")
+			const legacyStatusFromContent: "done" | "error" | null = firstContentLine.includes("] completed")
 				? "done"
-				: content.includes("] failed") || content.includes("] error")
+				: firstContentLine.includes("] failed") ||
+						firstContentLine.includes("] error") ||
+						firstContentLine.includes("] aborted")
 					? "error"
 					: null;
 
 			const finalStatus = statusFromDetails ?? statusFromExitCode ?? statusFromErrorField ?? legacyStatusFromContent;
+			const hasStructuredTerminalOutcome =
+				statusFromDetails !== null ||
+				statusFromExitCode !== null ||
+				typeof d.stopReason === "string" ||
+				typeof d.errorClass === "string";
+			const isAbortedCompletion =
+				d.stopReason === "aborted" ||
+				d.errorClass === "aborted" ||
+				statusRaw === "aborted" ||
+				(!hasStructuredTerminalOutcome && firstContentLine.includes("] aborted"));
 
 			// Derive source from customType for backward-compatible restored run metadata.
 			const restoredSource: "tool" | "command" = cm.customType === "subagent-tool" ? "tool" : "command";
@@ -648,7 +679,7 @@ function restoreRunsFromSession(store: SubagentStore, ctx: any, pi?: ExtensionAP
 					contextMode: d.contextMode ?? existing?.contextMode,
 					usage: d.usage ?? existing?.usage,
 					model: d.model ?? existing?.model,
-					errorClass: d.errorClass ?? existing?.errorClass,
+					errorClass: d.errorClass ?? (isAbortedCompletion ? "aborted" : existing?.errorClass),
 					peakContextTokens: d.peakContextTokens ?? existing?.peakContextTokens,
 					lastToolName: d.lastToolName ?? existing?.lastToolName,
 					lastToolOutputChars: d.lastToolOutputChars ?? existing?.lastToolOutputChars,
@@ -723,8 +754,26 @@ function restoreRunsFromSession(store: SubagentStore, ctx: any, pi?: ExtensionAP
 		}
 
 		for (const [id, run] of restoredRuns) {
-			if (removedRunIds.has(id)) {
-				store.commandRuns.set(id, { ...run, removed: true }); // restore removed runs while preserving removed=true
+			const removal = removedRuns.get(id);
+			const latestRunEntryIndex = latestRunEntryIndexes.get(id) ?? -1;
+			const removalApplies = removal
+				? removal.startedAt !== undefined
+					? removal.startedAt === run.startedAt
+					: removal.entryIndex > latestRunEntryIndex
+				: false;
+			if (removal && removalApplies) {
+				store.commandRuns.set(id, {
+					...run,
+					...(removal.aborted
+						? {
+								status: "error" as const,
+								errorClass: "aborted" as const,
+								lastLine: removal.message ?? run.lastLine,
+								lastOutput: removal.message ?? run.lastOutput,
+							}
+						: {}),
+					removed: true,
+				});
 				continue;
 			}
 			store.commandRuns.set(id, run);
@@ -1107,6 +1156,13 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 				const targetRunId = Number(firstToken);
 				const targetRun = continuationRun;
 
+				if (targetRun.abortPending) {
+					ctx.ui.notify(
+						`Subagent #${targetRunId} is still aborting. Wait for cancellation to settle before continuing it.`,
+						"warning",
+					);
+					return;
+				}
 				if (targetRun.status === "running") {
 					ctx.ui.notify(`Subagent #${targetRunId} is already running.`, "warning");
 					return;
@@ -1274,6 +1330,7 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 				runState.lastRetryReason = undefined;
 				runState.errorClass = undefined;
 				runState.autoAbortReason = undefined;
+				runState.abortPending = false;
 				runState.removed = false;
 				runState.deliveryMode = deliveryMode;
 				runState.turnCount = Math.max(DEFAULT_TURN_COUNT, runState.turnCount || DEFAULT_TURN_COUNT) + 1;
@@ -1509,6 +1566,22 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 					updateRunFromResult(runState, result);
 					const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
 					runState.status = isError ? "error" : "done";
+					if (isError) {
+						runState.errorClass =
+							result.errorClass ??
+							classifySubagentFailure({
+								failed: true,
+								stopReason: result.stopReason,
+								exitCode: result.exitCode,
+								errorMessage: result.errorMessage,
+								stderr: result.stderr,
+								output: getFinalOutput(result.messages),
+							});
+					}
+					const terminalLabel = getSubagentTerminalLabel(isError, {
+						stopReason: result.stopReason,
+						errorClass: runState.errorClass,
+					});
 					runState.elapsedMs = Date.now() - runState.startedAt;
 					updateCommandRunsWidget(store);
 
@@ -1527,7 +1600,7 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 					const completionMessage = {
 						customType: "subagent-command" as const,
 						content:
-							`[subagent:${selectedAgent}#${runId}] ${isError ? "failed" : "completed"}` +
+							`[subagent:${selectedAgent}#${runId}] ${terminalLabel}` +
 							`\nPrompt: ${truncateLines(taskForDisplay, 2)}` +
 							(usage ? `\nUsage: ${usage}` : "") +
 							(runState.retryCount ? `\nRetries: ${runState.retryCount}/${MAX_SUBAGENT_AUTO_RETRIES}` : "") +
@@ -1548,6 +1621,7 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 							elapsedMs: runState.elapsedMs,
 							lastActivityAt: runState.lastActivityAt,
 							exitCode: result.exitCode,
+							stopReason: result.stopReason,
 							usage: result.usage,
 							model: result.model,
 							source: result.agentSource,
@@ -1570,24 +1644,27 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 							runId,
 							`Hidden subagent #${runId} · ${selectedAgent}`,
 							completionMessage.content,
-							isError
-								? `hidden subagent #${runId} (${selectedAgent}) failed`
-								: `hidden subagent #${runId} (${selectedAgent}) completed`,
-							isError ? "error" : "info",
+							`hidden subagent #${runId} (${selectedAgent}) ${terminalLabel}`,
+							terminalLabel === "completed" ? "info" : terminalLabel === "aborted" ? "warning" : "error",
 						);
 					} else {
 						deliverOrQueueCompletion(store, pi, ctx, runId, runState, completionMessage);
 						ctx.ui.notify(
-							isError
-								? `subagent #${runId} (${selectedAgent}) failed`
-								: `subagent #${runId} (${selectedAgent}) completed`,
-							isError ? "error" : "info",
+							`subagent #${runId} (${selectedAgent}) ${terminalLabel}`,
+							terminalLabel === "completed" ? "info" : terminalLabel === "aborted" ? "warning" : "error",
 						);
 					}
 				} catch (error: any) {
 					if (runState.removed || store.disposed) return;
 					runState.status = "error";
-					runState.errorClass = "process_error";
+					runState.errorClass = isSubagentAbort({
+						signal: runState.abortController?.signal,
+						autoAbortReason: runState.autoAbortReason,
+						error,
+					})
+						? "aborted"
+						: "process_error";
+					const terminalLabel = getSubagentTerminalLabel(true, { errorClass: runState.errorClass });
 					runState.elapsedMs = Date.now() - runState.startedAt;
 					runState.lastLine =
 						runState.autoAbortReason ?? (error?.message ? String(error.message) : "Subagent execution failed");
@@ -1596,7 +1673,7 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 					const cmdErrorMessage = {
 						customType: "subagent-command" as const,
 						content:
-							`[subagent:${selectedAgent}#${runId}] failed` +
+							`[subagent:${selectedAgent}#${runId}] ${terminalLabel}` +
 							`\nPrompt: ${truncateLines(taskForDisplay, 2)}` +
 							`\n\n${runState.lastLine}`,
 						display: true,
@@ -1615,6 +1692,7 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 							lastActivityAt: runState.lastActivityAt,
 							error: runState.lastLine,
 							errorClass: runState.errorClass,
+							stopReason: runState.errorClass === "aborted" ? "aborted" : undefined,
 							peakContextTokens: runState.peakContextTokens,
 							lastToolName: runState.lastToolName,
 							lastToolOutputChars: runState.lastToolOutputChars,
@@ -1632,16 +1710,20 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 							runId,
 							`Hidden subagent #${runId} · ${selectedAgent}`,
 							cmdErrorMessage.content,
-							`hidden subagent #${runId} failed: ${runState.lastLine}`,
-							"error",
+							`hidden subagent #${runId} ${terminalLabel}: ${runState.lastLine}`,
+							terminalLabel === "aborted" ? "warning" : "error",
 						);
 					} else {
 						deliverOrQueueCompletion(store, pi, ctx, runId, runState, cmdErrorMessage);
-						ctx.ui.notify(`subagent #${runId} failed: ${runState.lastLine}`, "error");
+						ctx.ui.notify(
+							`subagent #${runId} ${terminalLabel}: ${runState.lastLine}`,
+							terminalLabel === "aborted" ? "warning" : "error",
+						);
 					}
 				} finally {
 					clearInterval(tick);
 					runState.abortController = undefined;
+					runState.abortPending = false;
 					if (!store.disposed) {
 						trimCommandRunHistory(store, {
 							maxRuns: 10,
@@ -1783,7 +1865,7 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 				run.status === "running" ? "(still running; no final output yet)" : run.lastLine || "(no output captured)";
 			const contextLabel = run.contextMode === "main" ? "main" : "isolated";
 			const content =
-				`Subagent #${run.id} [${run.status}] ${run.agent} ctx:${contextLabel} turn:${run.turnCount ?? DEFAULT_TURN_COUNT} ${elapsedSec}s tools:${run.toolCalls}` +
+				`Subagent #${run.id} [${getSubagentRunStatusLabel(run.status, run.errorClass)}] ${run.agent} ctx:${contextLabel} turn:${run.turnCount ?? DEFAULT_TURN_COUNT} ${elapsedSec}s tools:${run.toolCalls}` +
 				`\n${run.task}` +
 				usageLine +
 				`\n\n${output || fallback}`;
@@ -1840,7 +1922,7 @@ export function registerAll(pi: ExtensionAPI, store: SubagentStore): SubagentReg
 						.replace(/\s*\n+\s*/g, " ")
 						.trim()
 						.slice(0, COMMAND_TASK_PREVIEW_CHARS);
-					return `#${r.id} [${r.status}]${removed} ${r.agent}: ${task}`;
+					return `#${r.id} [${getSubagentRunStatusLabel(r.status, r.errorClass)}]${removed} ${r.agent}: ${task}`;
 				});
 				ctx.ui.notify(lines.join("\n"), "info");
 				return;

package/failure-telemetry.ts

@@ -18,6 +18,36 @@ export interface FailureTelemetryInput {
 	output?: string;
 }
 
+export interface AbortTelemetryInput {
+	stopReason?: string;
+	errorClass?: SubagentErrorClass;
+	signal?: AbortSignal;
+	autoAbortReason?: string;
+	error?: unknown;
+}
+
+export function isSubagentAbort(input: AbortTelemetryInput): boolean {
+	return (
+		input.stopReason === "aborted" ||
+		input.errorClass === "aborted" ||
+		input.signal?.aborted === true ||
+		Boolean(input.autoAbortReason) ||
+		(input.error instanceof Error && input.error.message === "Subagent was aborted")
+	);
+}
+
+export function getSubagentTerminalLabel(
+	failed: boolean,
+	input: AbortTelemetryInput,
+): "completed" | "aborted" | "failed" {
+	if (!failed) return "completed";
+	return isSubagentAbort(input) ? "aborted" : "failed";
+}
+
+export function getSubagentRunStatusLabel(status: string, errorClass?: SubagentErrorClass): string {
+	return errorClass === "aborted" ? "aborted" : status;
+}
+
 const OVERLOADED_PATTERNS = [
 	/servers? (?:are|is) currently overloaded/i,
 	/server overloaded/i,
@@ -38,10 +68,10 @@ export function classifySubagentFailure(input: FailureTelemetryInput): SubagentE
 	if (!input.failed) return undefined;
 	const text = [input.errorMessage, input.stderr, input.output].filter(Boolean).join("\n");
 
+	if (input.stopReason === "aborted") return "aborted";
 	if (isContextOverflowText(text)) return "context_overflow";
 	if (OVERLOADED_PATTERNS.some((pattern) => pattern.test(text))) return "overloaded";
 	if (RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(text))) return "rate_limit";
-	if (input.stopReason === "aborted") return "aborted";
 	if (TOOL_ERROR_PATTERNS.some((pattern) => pattern.test(text))) return "tool_error";
 	if ((input.exitCode ?? 0) !== 0) return "process_error";
 	return "unknown";

package/lifecycle.ts

@@ -36,6 +36,7 @@ function reconcileRunWithPersistedSession(run: CommandRunState): void {
 		snapshot.completionMarker?.exitCode ??
 		(snapshot.terminalStopReason === "error" || snapshot.terminalStopReason === "aborted" ? 1 : 0);
 	run.status = exitCode === 0 ? "done" : "error";
+	if (snapshot.terminalStopReason === "aborted") run.errorClass = "aborted";
 	if (snapshot.finalOutput) {
 		run.lastOutput = snapshot.finalOutput;
 		run.lastLine = getLastNonEmptyLine(snapshot.finalOutput) || run.lastLine;
@@ -90,7 +91,7 @@ export function shutdownSubagentRuns(store: SubagentStore, pi: ExtensionAPI, rea
 			pi.sendMessage(
 				{
 					customType: run.source === "tool" ? "subagent-tool" : "subagent-command",
-					content: `[subagent:${run.agent}#${runId}] failed\n\n${message}`,
+					content: `[subagent:${run.agent}#${runId}] aborted\n\n${message}`,
 					display: false,
 					details: {
 						runId,
@@ -100,6 +101,7 @@ export function shutdownSubagentRuns(store: SubagentStore, pi: ExtensionAPI, rea
 						status: "error",
 						error: message,
 						errorClass: run.errorClass,
+						stopReason: "aborted",
 						peakContextTokens: run.peakContextTokens,
 						lastToolName: run.lastToolName,
 						lastToolOutputChars: run.lastToolOutputChars,
@@ -155,7 +157,9 @@ export function checkForHungRuns(store: SubagentStore, _pi: ExtensionAPI): void
 		run.lastLine = reason;
 		run.lastOutput = reason;
 		run.status = "error";
+		run.errorClass = "aborted";
 		run.autoAbortReason = reason;
+		run.abortPending = Boolean(controller);
 
 		if (controller) {
 			controller.abort({ source: "hang_timeout", runId, idleMs, reason });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryan_nookpi/pi-extension-subagent",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Asynchronous subagent delegation for pi with run, batch, chain, and continuation workflows.",
   "license": "MIT",
   "repository": {

package/replay.ts

@@ -44,6 +44,7 @@ import {
 	TOOL_RESULT_DETAILS_SUMMARY_MAX_CHARS,
 	USAGE_EXTRA_ROWS,
 } from "./constants.js";
+import { getSubagentRunStatusLabel } from "./failure-telemetry.js";
 import { formatUsageStats, truncatePlainToWidth } from "./format.js";
 import type { CommandRunState, SessionReplayItem } from "./types.js";
 import { formatDuration, formatDurationBetween } from "./utils/time-utils.js";
@@ -351,7 +352,7 @@ export class SubagentSessionReplayOverlay {
 					theme.fg("toolTitle", theme.bold(`#${this.run.id} ${this.run.agent}`)) +
 					theme.fg(
 						"dim",
-						`  [${this.run.status}] ctx:${contextLabel} turn:${this.run.turnCount ?? DEFAULT_TURN_COUNT}  ${elapsedLabel}  tools:${this.run.toolCalls}`,
+						`  [${getSubagentRunStatusLabel(this.run.status, this.run.errorClass)}] ctx:${contextLabel} turn:${this.run.turnCount ?? DEFAULT_TURN_COUNT}  ${elapsedLabel}  tools:${this.run.toolCalls}`,
 					),
 				0,
 				0,

package/run-utils.ts

@@ -8,6 +8,7 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { FINISHED_GROUP_TTL_MS, MAX_FINISHED_GROUPS, STATUS_OUTPUT_PREVIEW_MAX_CHARS } from "./constants.js";
+import { getSubagentRunStatusLabel } from "./failure-telemetry.js";
 import type { SubagentStore } from "./store.js";
 import type {
 	BatchGroupState,
@@ -57,7 +58,7 @@ export interface ClearFinishedRunsOptions {
 export function formatCommandRunSummary(run: CommandRunState): string {
 	const elapsedSec = Math.max(0, Math.round(run.elapsedMs / 1000));
 	const contextLabel = run.contextMode === "main" ? "main" : "isolated";
-	return `#${run.id} [${run.status}] ${run.agent} ctx:${contextLabel} turn:${run.turnCount ?? 1} ${elapsedSec}s tools:${run.toolCalls}`;
+	return `#${run.id} [${getSubagentRunStatusLabel(run.status, run.errorClass)}] ${run.agent} ctx:${contextLabel} turn:${run.turnCount ?? 1} ${elapsedSec}s tools:${run.toolCalls}`;
 }
 
 /**
@@ -95,12 +96,19 @@ export function removeRun(store: SubagentStore, runId: number, options: RemoveRu
 	const globalEntry = store.globalLiveRuns.get(runId);
 	const controller = run.abortController ?? globalEntry?.abortController;
 
-	if (abortIfRunning && run.status === "running" && controller) {
+	if (abortIfRunning && run.status === "running") {
 		const reason = options.reason ?? "Aborting by remove...";
+		run.status = "error";
+		run.errorClass = "aborted";
+		run.elapsedMs = Date.now() - run.startedAt;
+		run.lastActivityAt = Date.now();
 		run.lastLine = reason;
 		run.lastOutput = reason;
-		controller.abort({ source: "remove_run", runId, reason, removalReason: options.removalReason });
-		aborted = true;
+		run.abortPending = Boolean(controller);
+		if (controller) {
+			controller.abort({ source: "remove_run", runId, reason, removalReason: options.removalReason });
+			aborted = true;
+		}
 	}
 
 	run.abortController = undefined;
@@ -112,6 +120,13 @@ export function removeRun(store: SubagentStore, runId: number, options: RemoveRu
 	if (persistRemovedEntry && options.pi && run.deliveryMode !== "humanOnly") {
 		const payload: Record<string, unknown> = { runId };
 		if (options.removalReason) payload.reason = options.removalReason;
+		if (run.errorClass === "aborted") {
+			payload.startedAt = run.startedAt;
+			payload.status = "aborted";
+			payload.errorClass = "aborted";
+			payload.stopReason = "aborted";
+			payload.message = run.lastLine;
+		}
 		try {
 			options.pi.appendEntry("subagent-removed", payload);
 		} catch {
@@ -225,16 +240,19 @@ export function snapshotBatchGroup(
 	terminalStatus: FinishedGroupSnapshot["terminalStatus"],
 ): FinishedGroupSnapshot {
 	let failed = 0;
+	let aborted = 0;
 	const members: FinishedGroupMember[] = batch.runIds.map((runId) => {
 		const run = store.commandRuns.get(runId);
 		if (!run) {
-			if (batch.failedRunIds.has(runId)) failed++;
+			if (batch.abortedRunIds.has(runId)) aborted++;
+			else if (batch.failedRunIds.has(runId)) failed++;
 			return {
 				summaryLine: `#${runId} [gone] (run no longer available)`,
 				output: batch.pendingResults.get(runId)?.trim() || "(no output)",
 			};
 		}
-		if (run.status === "error" || batch.failedRunIds.has(runId)) failed++;
+		if (run.errorClass === "aborted" || batch.abortedRunIds.has(runId)) aborted++;
+		else if (run.status === "error" || batch.failedRunIds.has(runId)) failed++;
 		return { summaryLine: formatCommandRunSummary(run), output: memberOutput(run, batch.pendingResults.get(runId)) };
 	});
 	return {
@@ -244,6 +262,7 @@ export function snapshotBatchGroup(
 		finishedAt: Date.now(),
 		total: batch.runIds.length,
 		failed,
+		aborted,
 		members,
 	};
 }
@@ -265,6 +284,7 @@ export function snapshotPipeline(
 		finishedAt: Date.now(),
 		total: pipeline.stepResults.length,
 		failed: pipeline.stepResults.filter((step) => step.status === "error").length,
+		aborted: pipeline.stepResults.filter((step) => step.status === "aborted").length,
 		members,
 	};
 }
@@ -304,9 +324,10 @@ function formatFinishedAge(finishedAt: number, now = Date.now()): string {
 export function formatFinishedGroupStatus(snapshot: FinishedGroupSnapshot, detailed: boolean): string {
 	const label = snapshot.kind === "batch" ? "subagent-batch" : "subagent-chain";
 	const failedSuffix = snapshot.failed > 0 ? `, ${snapshot.failed} failed` : "";
+	const abortedSuffix = snapshot.aborted > 0 ? `, ${snapshot.aborted} aborted` : "";
 	const header = `[${label}#${snapshot.groupId}] ${snapshot.terminalStatus} · ${snapshot.total} ${
 		snapshot.kind === "batch" ? "runs" : "steps"
-	}${failedSuffix} · finished ${formatFinishedAge(snapshot.finishedAt)}`;
+	}${failedSuffix}${abortedSuffix} · finished ${formatFinishedAge(snapshot.finishedAt)}`;
 	const body = snapshot.members
 		.map((member) => {
 			if (!detailed) return member.summaryLine;

package/tool-execute.ts

@@ -32,7 +32,13 @@ import {
 	summarizeSubagentDisplayTask,
 } from "./display-task.js";
 import { ESCALATION_EXIT_CODE, readAndConsumeEscalation } from "./escalation.js";
-import { classifySubagentFailure, type SubagentErrorClass } from "./failure-telemetry.js";
+import {
+	classifySubagentFailure,
+	getSubagentRunStatusLabel,
+	getSubagentTerminalLabel,
+	isSubagentAbort,
+	type SubagentErrorClass,
+} from "./failure-telemetry.js";
 import {
 	formatContextUsageBar,
 	formatUsageStats,
@@ -299,6 +305,9 @@ export function diagnoseResultFailure(result: SingleResult): ResultFailureDiagno
 			output: finalOutput,
 		});
 
+	if (result.stopReason === "aborted") {
+		return { failed: true, errorClass: "aborted", reason: "Subagent execution was aborted." };
+	}
 	if (result.exitCode !== 0 || result.stopReason === "error") {
 		const overflowText = result.errorMessage || result.stderr || finalOutput;
 		if (isContextOverflowText(overflowText)) {
@@ -324,8 +333,6 @@ export function diagnoseResultFailure(result: SingleResult): ResultFailureDiagno
 	}
 	if (result.stopReason === "error")
 		return { failed: true, errorClass, reason: result.errorMessage || "Subagent reported stopReason=error." };
-	if (result.stopReason === "aborted")
-		return { failed: true, errorClass: errorClass ?? "aborted", reason: "Subagent execution was aborted." };
 
 	const hasAssistantText = finalOutput.length > 0;
 	if (hasAssistantText) return { failed: false };
@@ -469,13 +476,42 @@ function buildRunStartMessage(runState: CommandRunState, status: "started" | "re
 	};
 }
 
+function getFinalizedRunLabel(finalized: FinalizedRun): "completed" | "aborted" | "failed" {
+	return getSubagentTerminalLabel(finalized.isError, {
+		stopReason: finalized.result?.stopReason,
+		errorClass: finalized.runState.errorClass,
+		autoAbortReason: finalized.runState.autoAbortReason,
+	});
+}
+
+function getFinalizedRunStatus(finalized: FinalizedRun): PipelineStepResult["status"] {
+	const label = getFinalizedRunLabel(finalized);
+	return label === "completed" ? "done" : label === "aborted" ? "aborted" : "error";
+}
+
+function resolveGroupTerminalStatus(failed: number, aborted: number): "completed" | "error" | "aborted" {
+	if (failed > 0) return "error";
+	if (aborted > 0) return "aborted";
+	return "completed";
+}
+
+function recordBatchResult(batch: BatchGroupState, finalized: FinalizedRun): void {
+	const runId = finalized.runState.id;
+	const status = finalized.runState.removed ? "aborted" : getFinalizedRunStatus(finalized);
+	batch.completedRunIds.add(runId);
+	if (status === "aborted") batch.abortedRunIds.add(runId);
+	else if (status === "error") batch.failedRunIds.add(runId);
+	batch.pendingResults.set(runId, finalized.rawOutput);
+}
+
 function buildRunCompletionMessage(finalized: FinalizedRun, options?: { display?: boolean }) {
-	const { runState, result, isError, rawOutput } = finalized;
+	const { runState, result, rawOutput } = finalized;
 	const usage = result ? formatUsageStats(result.usage, result.model) : "";
+	const terminalLabel = getFinalizedRunLabel(finalized);
 	return {
 		customType: "subagent-tool" as const,
 		content:
-			`[subagent:${runState.agent}#${runState.id}] ${isError ? "failed" : "completed"}` +
+			`[subagent:${runState.agent}#${runState.id}] ${terminalLabel}` +
 			`\nPrompt: ${truncateLines(runState.task, 2)}` +
 			(usage ? `\nUsage: ${usage}` : "") +
 			(runState.thoughtText ? `\nThought: ${runState.thoughtText}` : "") +
@@ -495,6 +531,7 @@ function buildRunCompletionMessage(finalized: FinalizedRun, options?: { display?
 			elapsedMs: runState.elapsedMs,
 			lastActivityAt: runState.lastActivityAt,
 			exitCode: result?.exitCode,
+			stopReason: result?.stopReason ?? (runState.errorClass === "aborted" ? "aborted" : undefined),
 			usage: result?.usage,
 			model: result?.model,
 			source: result?.agentSource,
@@ -560,6 +597,7 @@ function finalizeRunState(runState: CommandRunState, result: SingleResult): Fina
 
 	if (runState.autoAbortReason) {
 		runState.status = "error";
+		runState.errorClass = "aborted";
 		runState.elapsedMs = Date.now() - runState.startedAt;
 		runState.lastOutput = runState.autoAbortReason;
 		runState.lastLine = runState.autoAbortReason;
@@ -606,29 +644,46 @@ function finalizeRunState(runState: CommandRunState, result: SingleResult): Fina
 	return { runState, result, isError, rawOutput };
 }
 
-function formatBatchSummary(batchId: string, runs: CommandRunState[], terminalStatus: "completed" | "error"): string {
-	const headerStatus = runs.map((run) => `#${run.id} ${run.status === "done" ? "done" : "error"}`).join(", ");
+function formatOutcomeCounts(failed: number, aborted: number): string {
+	return [failed > 0 ? `${failed} failed` : "", aborted > 0 ? `${aborted} aborted` : ""].filter(Boolean).join(", ");
+}
+
+function formatBatchSummary(
+	batchId: string,
+	runs: CommandRunState[],
+	terminalStatus: "completed" | "error" | "aborted",
+): string {
+	const statuses = runs.map((run) => getSubagentRunStatusLabel(run.status, run.errorClass));
+	const headerStatus = runs.map((run, index) => `#${run.id} ${statuses[index]}`).join(", ");
+	const outcomeCounts = formatOutcomeCounts(
+		statuses.filter((status) => status === "error").length,
+		statuses.filter((status) => status === "aborted").length,
+	);
 	const body = runs
 		.map((run) => {
 			const summary = run.lastOutput?.trim() || run.lastLine?.trim() || "(no output)";
 			return `#${run.id} ${run.agent}\n- ${summary}`;
 		})
 		.join("\n\n");
-	return `[subagent-batch#${batchId}] ${terminalStatus}\nRuns: ${headerStatus}\n\n${body}`;
+	return `[subagent-batch#${batchId}] ${terminalStatus}\nRuns: ${headerStatus}${outcomeCounts ? `\nOutcomes: ${outcomeCounts}` : ""}\n\n${body}`;
 }
 
 function formatPipelineSummary(
 	pipelineId: string,
 	stepResults: PipelineStepResult[],
-	terminalStatus: "completed" | "stopped" | "error",
+	terminalStatus: "completed" | "stopped" | "error" | "aborted",
 ): string {
+	const outcomeCounts = formatOutcomeCounts(
+		stepResults.filter((step) => step.status === "error").length,
+		stepResults.filter((step) => step.status === "aborted").length,
+	);
 	const steps = stepResults
 		.map(
 			(step, index) =>
 				`Step ${index + 1} · #${step.runId} ${step.agent} · ${step.status}\nTask: ${step.task}\n${step.output}`,
 		)
 		.join("\n\n");
-	return `[subagent-chain#${pipelineId}] ${terminalStatus}\n\n${steps}`;
+	return `[subagent-chain#${pipelineId}] ${terminalStatus}${outcomeCounts ? `\nOutcomes: ${outcomeCounts}` : ""}\n\n${steps}`;
 }
 
 function previewOutput(output: string): string {
@@ -642,9 +697,10 @@ function formatBatchGroupStatus(store: SubagentStore, batch: BatchGroupState, de
 	const total = batch.runIds.length;
 	const done = batch.completedRunIds.size;
 	const failed = batch.failedRunIds.size;
+	const aborted = batch.abortedRunIds.size;
 	const header = `[subagent-batch#${batch.batchId}] running · ${done}/${total} finished${
 		failed > 0 ? `, ${failed} failed` : ""
-	}`;
+	}${aborted > 0 ? `, ${aborted} aborted` : ""}`;
 	const body = batch.runIds
 		.map((runId) => {
 			const run = store.commandRuns.get(runId);
@@ -735,7 +791,13 @@ function isInteractiveTuiContext(ctx: SubagentToolExecuteContext): boolean {
 
 function finalizeRunError(runState: CommandRunState, error: unknown): FinalizedRun {
 	runState.status = "error";
-	runState.errorClass = "process_error";
+	runState.errorClass = isSubagentAbort({
+		signal: runState.abortController?.signal,
+		autoAbortReason: runState.autoAbortReason,
+		error,
+	})
+		? "aborted"
+		: "process_error";
 	runState.elapsedMs = Date.now() - runState.startedAt;
 	runState.lastLine =
 		runState.autoAbortReason ?? (error instanceof Error ? error.message : "Subagent execution failed");
@@ -1266,6 +1328,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 		function clearRunAbortState(runState: CommandRunState): void {
 			clearParentAbortListener(runState.id);
 			runState.abortController = undefined;
+			runState.abortPending = false;
 		}
 
 		function registerRunLaunch(config: RunLaunchConfig): CommandRunState {
@@ -1289,6 +1352,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 				runState.lastRetryReason = undefined;
 				runState.errorClass = undefined;
 				runState.autoAbortReason = undefined;
+				runState.abortPending = false;
 				runState.removed = false;
 				runState.turnCount = Math.max(DEFAULT_TURN_COUNT, runState.turnCount || DEFAULT_TURN_COUNT) + 1;
 				runState.contextMode = runState.contextMode ?? (config.inheritMainContext ? "main" : "sub");
@@ -1350,15 +1414,17 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 
 		function launchRunInBackground(runState: CommandRunState, taskForAgent: string): Promise<FinalizedRun> {
 			let claudeCheckpointSent = !!runState.claudeSessionId;
+			const abortSignal = runState.abortController?.signal;
 			const recordActivity = createRunActivityRecorder(pi, runState, (model) => resolveContextWindow(ctx, model));
-			return enqueueSubagentInvocation(() =>
-				runSingleAgent(
+			return enqueueSubagentInvocation(async () => {
+				if (runState.removed || abortSignal?.aborted) throw new Error("Subagent was aborted");
+				return runSingleAgent(
 					ctx.cwd,
 					agents,
 					runState.agent,
 					taskForAgent,
 					runState.pipelineStepIndex,
-					runState.abortController?.signal,
+					abortSignal,
 					(partial) => {
 						if (runState.removed || store.disposed) return;
 						const current = partial.details?.results?.[0];
@@ -1382,8 +1448,12 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 						persistedSessionBaseOffset: runState.persistedSessionBaseOffset,
 						onDiagnostic: createRunDiagnosticSink(pi, runState),
 					},
-				),
-			).then((result) => finalizeRunState(runState, result));
+				);
+			}).then((result) =>
+				runState.removed || abortSignal?.aborted
+					? finalizeRunError(runState, new Error("Subagent was aborted"))
+					: finalizeRunState(runState, result),
+			);
 		}
 
 		if (hasSingle) {
@@ -1405,6 +1475,20 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 						isError: true,
 					};
 				}
+				if (continueFromRun.abortPending) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: withIdleRunWarning(
+									`Subagent #${continuationRunId} is still aborting. Wait for cancellation to settle before continuing it.`,
+								),
+							},
+						],
+						details: makeDetails("single"),
+						isError: true,
+					};
+				}
 				if (continueFromRun.status === "running") {
 					return {
 						content: [
@@ -1473,7 +1557,6 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 				existingRunState: continueFromRun,
 			});
 			const launchSummary = toLaunchSummary(runState, continueFromRun ? "continue" : "run");
-			const startedState = continueFromRun ? "resumed" : "started";
 
 			if (!shouldRunAsync) {
 				let finalized: FinalizedRun;
@@ -1506,7 +1589,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 				};
 			}
 
-			pi.sendMessage(buildRunStartMessage(runState, startedState), { deliverAs: "followUp", triggerTurn: false });
+			// No run-start sendMessage here: mid-turn triggerTurn:false messages land between tool call and result (pi #8537).
 			ctx.ui?.notify?.(
 				`${continueFromRun ? `Resumed subagent #${runState.id}` : `Started subagent #${runState.id}`}: ${resolvedAgent}`,
 				"info",
@@ -1531,6 +1614,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 						return;
 					}
 
+					const terminalLabel = getFinalizedRunLabel(finalized);
 					const completionMessage = buildRunCompletionMessage(finalized);
 					if (isInOriginSession(ctx, originSessionFile)) {
 						pi.sendMessage(completionMessage, { deliverAs: "followUp", triggerTurn: true });
@@ -1541,14 +1625,13 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 					}
 
 					ctx.ui?.notify?.(
-						finalized.isError
-							? `subagent tool run #${runState.id} (${resolvedAgent}) failed`
-							: `subagent tool run #${runState.id} (${resolvedAgent}) completed`,
-						finalized.isError ? "error" : "info",
+						`subagent tool run #${runState.id} (${resolvedAgent}) ${terminalLabel}`,
+						terminalLabel === "completed" ? "info" : terminalLabel === "aborted" ? "warning" : "error",
 					);
 				} catch (error: unknown) {
 					if (runState.removed || store.disposed) return;
 					const finalized = finalizeRunError(runState, error);
+					const terminalLabel = getFinalizedRunLabel(finalized);
 					const errorMessage = buildRunCompletionMessage(finalized);
 					if (isInOriginSession(ctx, originSessionFile)) {
 						pi.sendMessage(errorMessage, { deliverAs: "followUp", triggerTurn: true });
@@ -1557,7 +1640,10 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 						const entry = store.globalLiveRuns.get(runState.id);
 						if (entry) entry.pendingCompletion = makePendingCompletion(errorMessage, true);
 					}
-					ctx.ui?.notify?.(`subagent tool run #${runState.id} failed: ${runState.lastLine}`, "error");
+					ctx.ui?.notify?.(
+						`subagent tool run #${runState.id} ${terminalLabel}: ${runState.lastLine}`,
+						terminalLabel === "aborted" ? "warning" : "error",
+					);
 					updateCommandRunsWidget(store);
 				} finally {
 					clearRunAbortState(runState);
@@ -1628,6 +1714,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 				runIds: runStates.map(({ runState }) => runState.id),
 				completedRunIds: new Set(),
 				failedRunIds: new Set(),
+				abortedRunIds: new Set(),
 				originSessionFile,
 				createdAt: Date.now(),
 				pendingResults: new Map(),
@@ -1647,11 +1734,18 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 					}),
 				);
 				const orderedRuns = runStates.map(({ runState }) => runState);
-				const hasError = finalizedRuns.some((finalized) => finalized.isError);
-				const content = formatBatchSummary(batchId, orderedRuns, hasError ? "error" : "completed");
 				const batchForSnapshot = store.batchGroups.get(batchId);
-				if (batchForSnapshot)
-					retireFinishedGroup(store, snapshotBatchGroup(store, batchForSnapshot, hasError ? "error" : "completed"));
+				if (batchForSnapshot) {
+					for (const finalized of finalizedRuns) recordBatchResult(batchForSnapshot, finalized);
+				}
+				const terminalStatus = resolveGroupTerminalStatus(
+					batchForSnapshot?.failedRunIds.size ?? 0,
+					batchForSnapshot?.abortedRunIds.size ?? 0,
+				);
+				const content = formatBatchSummary(batchId, orderedRuns, terminalStatus);
+				if (batchForSnapshot) {
+					retireFinishedGroup(store, snapshotBatchGroup(store, batchForSnapshot, terminalStatus));
+				}
 				for (const { runState } of runStates) cleanupRunAfterFinalDelivery(runState.id);
 				clearPendingGroupCompletion("batch", batchId);
 				store.batchGroups.delete(batchId);
@@ -1673,7 +1767,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 							.filter((result): result is SingleResult => Boolean(result)),
 						runStates.map(({ runState }) => toLaunchSummary(runState, "batch")),
 					),
-					isError: hasError,
+					isError: terminalStatus !== "completed",
 				};
 			}
 
@@ -1684,16 +1778,14 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 
 						const batch = store.batchGroups.get(batchId);
 						if (!batch) return;
-						batch.completedRunIds.add(runState.id);
-						if (finalized.isError) batch.failedRunIds.add(runState.id);
-						batch.pendingResults.set(runState.id, finalized.rawOutput);
+						recordBatchResult(batch, finalized);
 						updateCommandRunsWidget(store);
 
 						if (batch.completedRunIds.size === batch.runIds.length) {
 							const orderedRuns = batch.runIds
 								.map((runId) => store.commandRuns.get(runId))
 								.filter((run): run is CommandRunState => Boolean(run));
-							const batchTerminalStatus = batch.failedRunIds.size > 0 ? "error" : "completed";
+							const batchTerminalStatus = resolveGroupTerminalStatus(batch.failedRunIds.size, batch.abortedRunIds.size);
 							const content = formatBatchSummary(batchId, orderedRuns, batchTerminalStatus);
 							const message = {
 								customType: "subagent-tool" as const,
@@ -1702,7 +1794,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 								details: {
 									batchId,
 									runIds: batch.runIds,
-									status: batch.failedRunIds.size > 0 ? "error" : "done",
+									status: batchTerminalStatus === "completed" ? "done" : batchTerminalStatus,
 									runSummaries: orderedRuns.map((run) => buildRunAnalyticsSummary(run)),
 								},
 							};
@@ -1730,38 +1822,36 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 								removalReason: "trim",
 							});
 							ctx.ui?.notify?.(
-								batch.failedRunIds.size > 0
+								batchTerminalStatus === "error"
 									? `subagent batch ${batchId} finished with errors`
-									: `subagent batch ${batchId} completed`,
-								batch.failedRunIds.size > 0 ? "error" : "info",
+									: batchTerminalStatus === "aborted"
+										? `subagent batch ${batchId} aborted`
+										: `subagent batch ${batchId} completed`,
+								batchTerminalStatus === "error" ? "error" : batchTerminalStatus === "aborted" ? "warning" : "info",
 							);
 						}
 					} catch (error: unknown) {
-						runState.status = "error";
-						runState.elapsedMs = Date.now() - runState.startedAt;
-						runState.lastLine = error instanceof Error ? error.message : "Subagent execution failed";
-						runState.lastOutput = runState.lastLine;
+						const finalized = finalizeRunError(runState, error);
 						const batch = store.batchGroups.get(batchId);
 						if (!batch) return;
-						batch.completedRunIds.add(runState.id);
-						batch.failedRunIds.add(runState.id);
-						batch.pendingResults.set(runState.id, runState.lastLine);
+						recordBatchResult(batch, finalized);
 						if (batch.completedRunIds.size === batch.runIds.length) {
 							const orderedRuns = batch.runIds
 								.map((runId) => store.commandRuns.get(runId))
 								.filter((run): run is CommandRunState => Boolean(run));
+							const batchTerminalStatus = resolveGroupTerminalStatus(batch.failedRunIds.size, batch.abortedRunIds.size);
 							const message = {
 								customType: "subagent-tool" as const,
-								content: formatBatchSummary(batchId, orderedRuns, "error"),
+								content: formatBatchSummary(batchId, orderedRuns, batchTerminalStatus),
 								display: true,
 								details: {
 									batchId,
 									runIds: batch.runIds,
-									status: "error",
+									status: batchTerminalStatus,
 									runSummaries: orderedRuns.map((run) => buildRunAnalyticsSummary(run)),
 								},
 							};
-							retireFinishedGroup(store, snapshotBatchGroup(store, batch, "error"));
+							retireFinishedGroup(store, snapshotBatchGroup(store, batch, batchTerminalStatus));
 							if (isInOriginSession(ctx, batch.originSessionFile)) {
 								pi.sendMessage(message, { deliverAs: "followUp", triggerTurn: true });
 								clearPendingGroupCompletion("batch", batchId);
@@ -1779,6 +1869,8 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 							}
 						}
 						updateCommandRunsWidget(store);
+					} finally {
+						clearRunAbortState(runState);
 					}
 				})();
 			}
@@ -1830,7 +1922,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 
 			if (!shouldRunAsync) {
 				let previousOutput = "";
-				let terminalStatus: "completed" | "stopped" | "error" = "completed";
+				let terminalStatus: "completed" | "stopped" | "error" | "aborted" = "completed";
 				const finalizedRuns: FinalizedRun[] = [];
 				const pipeline = store.pipelines.get(pipelineId);
 				if (!pipeline) {
@@ -1897,29 +1989,30 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 						finalizedRuns.push(finalized);
 
 						if (runState.removed) {
-							terminalStatus = finalized.isError ? "error" : "stopped";
+							terminalStatus = "aborted";
 							pipeline.stepResults.push({
 								runId: runState.id,
 								agent: runState.agent,
 								task: step.task,
 								output: finalized.rawOutput || "Run removed before pipeline completion.",
-								status: "error",
+								status: "aborted",
 							});
 							break;
 						}
 
+						const stepStatus = getFinalizedRunStatus(finalized);
 						pipeline.stepResults.push({
 							runId: runState.id,
 							agent: runState.agent,
 							task: step.task,
 							output: finalized.rawOutput,
-							status: finalized.isError ? "error" : "done",
+							status: stepStatus,
 						});
 						previousOutput = finalized.rawOutput;
 						updateCommandRunsWidget(store);
 
-						if (finalized.isError) {
-							terminalStatus = "error";
+						if (stepStatus !== "done") {
+							terminalStatus = stepStatus;
 							break;
 						}
 					}
@@ -1935,7 +2028,9 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 				}
 
 				const hasError = pipeline.stepResults.some((step) => step.status === "error");
-				if (terminalStatus === "completed" && hasError) terminalStatus = "error";
+				const hasAborted = pipeline.stepResults.some((step) => step.status === "aborted");
+				if (hasError) terminalStatus = "error";
+				else if (terminalStatus === "completed" && hasAborted) terminalStatus = "aborted";
 				const content = formatPipelineSummary(pipelineId, pipeline.stepResults, terminalStatus);
 				retireFinishedGroup(store, snapshotPipeline(pipeline, terminalStatus));
 				for (const runId of pipeline.stepRunIds) cleanupRunAfterFinalDelivery(runId);
@@ -1965,7 +2060,7 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 
 			void (async () => {
 				let previousOutput = "";
-				let terminalStatus: "completed" | "stopped" | "error" = "completed";
+				let terminalStatus: "completed" | "stopped" | "error" | "aborted" = "completed";
 				try {
 					for (let index = 0; index < steps.length; index++) {
 						const pipeline = store.pipelines.get(pipelineId);
@@ -2023,13 +2118,13 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 							clearRunAbortState(runState);
 						}
 						if (runState.removed) {
-							terminalStatus = finalized.isError ? "error" : "stopped";
+							terminalStatus = "aborted";
 							pipeline.stepResults.push({
 								runId: runState.id,
 								agent: runState.agent,
 								task: step.task,
 								output: finalized.rawOutput || "Run removed before pipeline completion.",
-								status: "error",
+								status: "aborted",
 							});
 							break;
 						}
@@ -2039,14 +2134,14 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 							agent: runState.agent,
 							task: step.task,
 							output: finalized.rawOutput,
-							status: finalized.isError ? "error" : "done",
+							status: getFinalizedRunStatus(finalized),
 						};
 						pipeline.stepResults.push(stepResult);
 						previousOutput = finalized.rawOutput;
 						updateCommandRunsWidget(store);
 
-						if (finalized.isError) {
-							terminalStatus = "error";
+						if (stepResult.status !== "done") {
+							terminalStatus = stepResult.status;
 							break;
 						}
 					}
@@ -2066,9 +2161,9 @@ export function createSubagentToolExecute(pi: ExtensionAPI, store: SubagentStore
 					const pipeline = store.pipelines.get(pipelineId);
 					if (pipeline) {
 						const hasError = pipeline.stepResults.some((step) => step.status === "error");
-						if (terminalStatus === "completed" && hasError) {
-							terminalStatus = "error";
-						}
+						const hasAborted = pipeline.stepResults.some((step) => step.status === "aborted");
+						if (hasError) terminalStatus = "error";
+						else if (terminalStatus === "completed" && hasAborted) terminalStatus = "aborted";
 						const orderedRuns = pipeline.stepRunIds
 							.map((runId) => store.commandRuns.get(runId))
 							.filter((run): run is CommandRunState => Boolean(run));

package/types.ts

@@ -106,6 +106,8 @@ export interface CommandRunState {
 	lastToolOutputChars?: number;
 	/** Hang detector reason preserved until the normal finalizer emits the sole completion. */
 	autoAbortReason?: string;
+	/** True while a removed invocation is still settling; blocks same-ID continuation races. */
+	abortPending?: boolean;
 	runtime?: AgentRuntime;
 	claudeSessionId?: string;
 	claudeProjectDir?: string;
@@ -172,6 +174,7 @@ export interface BatchGroupState {
 	runIds: number[];
 	completedRunIds: Set<number>;
 	failedRunIds: Set<number>;
+	abortedRunIds: Set<number>;
 	originSessionFile: string;
 	createdAt: number;
 	pendingResults: Map<number, string>;
@@ -183,7 +186,7 @@ export interface PipelineStepResult {
 	agent: string;
 	task: string;
 	output: string;
-	status: "done" | "error";
+	status: "done" | "error" | "aborted";
 }
 
 export interface PipelineState {
@@ -213,10 +216,11 @@ export interface FinishedGroupMember {
 export interface FinishedGroupSnapshot {
 	groupId: string;
 	kind: "batch" | "chain";
-	terminalStatus: "completed" | "error" | "stopped";
+	terminalStatus: "completed" | "error" | "aborted" | "stopped";
 	finishedAt: number;
 	total: number;
 	failed: number;
+	aborted: number;
 	members: FinishedGroupMember[];
 }
 

package/widget.ts

@@ -5,6 +5,7 @@
 import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Box, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { HANG_WARNING_IDLE_MS, PARENT_HINT } from "./constants.js";
+import { getSubagentRunStatusLabel } from "./failure-telemetry.js";
 import {
 	AGENT_NAME_PALETTE,
 	agentBgIndex,
@@ -79,9 +80,12 @@ export function cleanupCommandRunsWidgetTimer(): void {
 }
 
 function getStatusVisual(run: CommandRunState): { statusColor: ThemeColor; statusIcon: string } {
-	const statusColor: ThemeColor = run.status === "running" ? "warning" : run.status === "done" ? "success" : "error";
+	const statusLabel = getSubagentRunStatusLabel(run.status, run.errorClass);
+	const statusColor: ThemeColor =
+		statusLabel === "running" || statusLabel === "aborted" ? "warning" : statusLabel === "done" ? "success" : "error";
 	const spinnerFrame = SPINNER_FRAMES[Math.floor(Date.now() / SPINNER_INTERVAL_MS) % SPINNER_FRAMES.length];
-	const statusIcon = run.status === "running" ? spinnerFrame : run.status === "done" ? "✓" : "✗";
+	const statusIcon =
+		statusLabel === "running" ? spinnerFrame : statusLabel === "done" ? "✓" : statusLabel === "aborted" ? "■" : "✗";
 	return { statusColor, statusIcon };
 }