@ryan_nookpi/pi-extension-subagent 0.5.4 → 0.5.6

package/README.md

@@ -68,7 +68,7 @@ Run `/subagents`, `subagent agents`, or the `list-agents` tool to inspect discov
 
 ### Optional starter pack
 
-If no agents are found, `/subagents` can offer an optional, opinionated starter pack. It copies nine agent templates, two example workflow skills, and missing global `subagent` settings. Existing files and configured values are not overwritten.
+If no agents are found, `/subagents` can offer an optional, opinionated starter pack. It copies eight agent templates, two example workflow skills, and missing global `subagent` settings. Existing files and configured values are not overwritten.
 
 The starter pack is not required. Decline it if you prefer to define agents manually. It fills a missing `claudeRuntime` setting with `cli`; without that setting, the extension default is `sdk`.
 

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

@@ -5,6 +5,7 @@ export type SubagentErrorClass =
 	| "overloaded"
 	| "rate_limit"
 	| "tool_error"
+	| "network_error"
 	| "aborted"
 	| "process_error"
 	| "unknown";
@@ -18,6 +19,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,
@@ -34,15 +65,26 @@ const TOOL_ERROR_PATTERNS = [
 	/invalid tool/i,
 ];
 
+const NETWORK_PATTERNS = [/\bwebsocket\b/i, /\bconnection error\b/i];
+const PROCESS_SIGNAL_TERMINATION_PATTERN = /\bprocess terminated by signal\b/i;
+
 export function classifySubagentFailure(input: FailureTelemetryInput): SubagentErrorClass | undefined {
 	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";
+	const signalTerminated = PROCESS_SIGNAL_TERMINATION_PATTERN.test(input.stderr ?? "");
+	if (
+		!signalTerminated &&
+		(NETWORK_PATTERNS.some((pattern) => pattern.test(text)) ||
+			/^terminated\.?$/i.test(input.errorMessage?.trim() ?? ""))
+	) {
+		return "network_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.4",
+  "version": "0.5.6",
   "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/retry.ts

@@ -34,9 +34,13 @@ function buildFailureText(result: SingleResult): string {
 		.join("\n");
 }
 
+const PROCESS_SIGNAL_TERMINATION_PATTERN = /\bprocess terminated by signal\b/i;
+
 const TRANSIENT_FAILURE_PATTERNS: RegExp[] = [
 	/\bnetwork\b/i,
+	/\bwebsocket\b/i,
 	/\bfetch failed\b/i,
+	/\bconnection error\b/i,
 	/\bconnection reset\b/i,
 	/\bsocket hang up\b/i,
 	/\btemporar(?:y|ily) unavailable\b/i,
@@ -70,12 +74,18 @@ function matchesTransientPattern(text: string): boolean {
 
 export function diagnoseRetryableResult(result: SingleResult): RetryDecision {
 	if (result.stopReason === "aborted") return { retryable: false };
+	if (PROCESS_SIGNAL_TERMINATION_PATTERN.test(result.stderr)) return { retryable: false };
 
 	const finalOutput = getFinalOutput(result.messages).trim();
 	if (result.exitCode === 0 && result.stopReason !== "error" && finalOutput) {
 		return { retryable: false };
 	}
 
+	const errorMessage = result.errorMessage?.trim();
+	if (errorMessage && /^terminated\.?$/i.test(errorMessage)) {
+		return { retryable: true, reason: errorMessage };
+	}
+
 	const failureText = buildFailureText(result);
 	if (!failureText) return { retryable: false };
 	if (!matchesTransientPattern(failureText)) return { retryable: false };

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/starter-pack.ts

@@ -11,7 +11,6 @@ export const STARTER_AGENT_NAMES = [
 	"reviewer",
 	"searcher",
 	"security-auditor",
-	"simplifier",
 	"verifier",
 	"worker",
 ] as const;
@@ -220,7 +219,7 @@ export async function offerStarterPackIfEmpty(
 
 	const accepted = await ctx.ui.confirm(
 		"Install starter subagents?",
-		"No subagent definitions were found. Install 9 portable English agents, the stress-interview and self-healing skills, and missing subagent settings? Existing files and configured values will not be overwritten.",
+		"No subagent definitions were found. Install 8 portable English agents, the stress-interview and self-healing skills, and missing subagent settings? Existing files and configured values will not be overwritten.",
 	);
 	if (!accepted) return { status: "declined", discovery };