brl-subagent 2.3.5 → 2.3.7

package/src/session-manager.ts

@@ -1,8 +1,8 @@
 import { randomUUID } from 'crypto';
 import { join } from 'path';
 import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync } from 'fs';
-import type { BackgroundAgent, AgentStatus, GitMode, SubagentResult, SubagentRun, ThinkingLevel, SubagentToolOptions, UsageStats } from './types';
-import { EMPTY_USAGE, CUSTOM_ENTRY_TYPES, classifyError, SUBAGENT_ABORTED_MESSAGE } from './types';
+import type { BackgroundAgent, AgentStatus, GitMode, SubagentResult, SubagentRun, ThinkingLevel, SubagentToolOptions, UsageStats, ErrorCategory } from './types';
+import { EMPTY_USAGE, CUSTOM_ENTRY_TYPES, classifyError, classifyTerminalOutcome, isSubagentError, isProviderError, SUBAGENT_ABORTED_MESSAGE } from './types';
 import { accumulateUsage } from './runner';
 import * as eventBus from './event-bus';
 import * as transcript from './transcript';
@@ -230,7 +230,10 @@ export function setAgentResult(id: string, result: SubagentResult): BackgroundAg
   if (!agent) return null;
   
   agent.result = result;
-  agent.status = result.exitCode === 0 ? 'completed' : 'failed';
+  // Issue #179 (D1): honor the full terminal reason (stopReason error/aborted/
+  // length/incomplete), not exitCode alone — a mid-run provider death resolves
+  // with exitCode 0 and was previously recorded as 'completed'.
+  agent.status = isSubagentError(result) ? 'failed' : 'completed';
   agent.completedAt = Date.now();
   
   agents.set(id, agent);
@@ -238,6 +241,56 @@ export function setAgentResult(id: string, result: SubagentResult): BackgroundAg
   return agent;
 }
 
+/**
+ * Issue #179 (D4): when a run ends in a failure, the prose extracted by
+ * extractFinalOutput may come from an EARLIER turn — the failing turn carries
+ * no text of its own. Prefixing the failure reason makes the output honest
+ * instead of a plausible-looking success narrative.
+ */
+export function buildFailureHeadline(reason: string, output: string): string {
+  const trimmed = output.trim();
+  return trimmed ? `${reason}\n\n${trimmed}` : reason;
+}
+
+/**
+ * Issue #179 (D3/D4): a run that ended without a terminal answer must still
+ * record WHY. When the provider supplied no message, synthesize one from the
+ * stopReason so the run entry never claims a failure with an empty reason.
+ */
+function defaultTerminalMessage(stopReason: string | undefined): string {
+  switch (stopReason) {
+    case 'error':
+      return 'Run ended with a provider error (stopReason "error")';
+    case 'length':
+      return 'Run ended early: output length limit reached (stopReason "length")';
+    case 'toolUse':
+      return 'Run ended mid-turn without a final answer (stopReason "toolUse")';
+    case 'deferred':
+      return 'Run ended deferred without a final answer (stopReason "deferred")';
+    case 'pending':
+      return 'Run ended while still pending (stopReason "pending")';
+    default:
+      return 'Run ended without completing';
+  }
+}
+
+/**
+ * Issue #179 (C1 fix): a failed run entry/result must carry a terminal reason
+ * that AGREES with its status — never undefined, never "stop". Any reason the
+ * classifier already treats as a failure (error / length / toolUse / deferred
+ * / pending / aborted) is coherent and kept; a missing or success reason is
+ * coerced to the honest failure reason derived from the classified category.
+ */
+function coherentFailureReason(
+  stopReason: string | undefined,
+  errorCategory: ErrorCategory | undefined,
+): string {
+  if (stopReason && classifyTerminalOutcome(stopReason).status !== 'completed') {
+    return stopReason;
+  }
+  return errorCategory === 'aborted' ? 'aborted' : 'error';
+}
+
 /**
  * Extract the final assistant text from a session's messages.
  * Falls back to the LAST assistant message with non-empty text content — the
@@ -531,29 +584,51 @@ export async function spawnBackgroundSession(
   // ("done"/"failed"). The guard keeps the entry single-finalized even when a
   // settle handler throws after finalizing (markTerminalBestEffort catch-all).
   let runFinalized = false;
-  const finalizeRunEntry = (status: "done" | "failed", error?: string): void => {
+  const finalizeRunEntry = (
+    status: "done" | "failed",
+    error?: string,
+    terminal?: { stopReason?: string; errorCategory?: ErrorCategory },
+  ): void => {
     if (runFinalized) return;
     runFinalized = true;
     const usage = agent.result?.usage ?? EMPTY_USAGE;
     const finalOutput = agent.finalOutput ?? "";
-    // Issue #120 (Track 1): stamp the honest errorCategory on the background run
-    // record the same way the foreground path does (index.ts sets
-    // run.originalParams.errorCategory = classifyError(result)). Previously the
-    // background entry never carried a category, so background failures were
-    // invisible to the SLA errorCategoryBreakdown and to failure diagnostics.
+    // Issue #179 (D1/D2): the classifier's explicit category wins (it knows the
+    // terminal stopReason); otherwise fall back to the legacy message-based
+    // classification (refused spawns, sync throws, preflight rejections, the
+    // catch-all) so no failure is ever left uncategorized.
     const errorCategory =
-      status === "failed" && error
-        ? classifyError({
-            messages: [],
-            usage: { ...EMPTY_USAGE },
-            exitCode: 1,
-            stderr: "",
-            errorMessage: error,
-          })
+      status === "failed"
+        ? terminal?.errorCategory ??
+          (error
+            ? classifyError({
+                messages: [],
+                usage: { ...EMPTY_USAGE },
+                exitCode: 1,
+                stderr: "",
+                errorMessage: error,
+              })
+            : undefined)
         : undefined;
+    const stopReason =
+      status === "failed"
+        ? coherentFailureReason(
+            terminal?.stopReason ?? agent.result?.stopReason,
+            errorCategory,
+          )
+        : terminal?.stopReason ?? agent.result?.stopReason;
     const entry: SubagentRun = {
       ...run,
       status,
+      // Issue #179 (D2): the run entry carries the CLASSIFIED reason, not just
+      // an opaque error string.
+      stopReason,
+      errorCategory,
+      // Issue #179 (D3): work volume + terminal-error signal. `turns`/`tokensOut`
+      // are already in the usage data; recording them here makes "did nothing"
+      // (turns 0) explicit versus "did work then died" (turns > 0, error).
+      turns: usage.turns,
+      finalTurnError: isProviderError(stopReason),
       errorMessage: error,
       finishedAt: new Date().toISOString(),
       durationMs: Date.now() - startedAtMs,
@@ -570,6 +645,17 @@ export async function spawnBackgroundSession(
           : run.originalParams,
     };
     pi.appendEntry(CUSTOM_ENTRY_TYPES.run, entry);
+    // Issue #179 (D6): the explicit settle line — the log's job is to record the
+    // CLASSIFIED OUTCOME, which cwd alone can never convey.
+    log.info("Background run settled", {
+      agentId: id,
+      status,
+      stopReason,
+      turns: usage.turns,
+      tokensOut: usage.output,
+      errorCategory,
+      error: error ?? null,
+    });
   };
 
   // Start transcript for this agent
@@ -582,8 +668,16 @@ export async function spawnBackgroundSession(
   // final output while the session is still live, THEN release the ref — the
   // capture must always precede the release or the output dies with the
   // session graph. Single helper for all four settlement paths.
-  const captureAndReleaseSession = (): void => {
-    setAgentFinalOutput(id, extractFinalOutput(session));
+  //
+  // Issue #179 (D4): an optional failureHeadline is prepended when the run did
+  // NOT complete — the extracted prose may come from an earlier turn, so it
+  // must not be presented as the run's output unqualified.
+  const captureAndReleaseSession = (failureHeadline?: string): void => {
+    const output = extractFinalOutput(session);
+    setAgentFinalOutput(
+      id,
+      failureHeadline ? buildFailureHeadline(failureHeadline, output) : output,
+    );
     agent._sessionRef = undefined;
   };
 
@@ -895,7 +989,8 @@ export async function spawnBackgroundSession(
       //   1. stopAgent pre-set status to 'stopped' before calling abort();
       //   2. the last assistant message carries stopReason "aborted".
       const lastAssistant = [...(session.messages ?? [])].reverse().find(m => m.role === 'assistant');
-      const aborted = agent.status === 'stopped' || lastAssistant?.stopReason === 'aborted';
+      const terminalStopReason = lastAssistant?.stopReason;
+      const aborted = agent.status === 'stopped' || terminalStopReason === 'aborted';
       if (aborted) {
         // Session was aborted — mark stopped. If stopAgent already flipped the
         // status (pre-set 'stopped' + completedAt + event + transcript), only
@@ -931,13 +1026,70 @@ export async function spawnBackgroundSession(
         // (stop_subagent) sets no error, so fall back to the honest user-abort
         // stamp (→ 'aborted') instead of the old ambiguous 'Aborted or timed out'.
         recordSessionUsage();
-        finalizeRunEntry('failed', agent.error ?? SUBAGENT_ABORTED_MESSAGE);
+        finalizeRunEntry('failed', agent.error ?? SUBAGENT_ABORTED_MESSAGE, {
+          stopReason:
+            terminalStopReason && terminalStopReason !== 'stop'
+              ? terminalStopReason
+              : 'aborted',
+        });
         // Issue #31: capture the final output while the session is still
         // live, then release the ref on the terminal path (memory retention;
         // the poller treats a nulled ref on a terminal agent as expected).
         captureAndReleaseSession();
         return;
       }
+      // Issue #179 (D1/D2): prompt() RESOLVED — but a resolved prompt is NOT
+      // proof of success. The SDK's runWithLifecycle catches a mid-run provider
+      // death internally and resolves with an assistant message carrying
+      // stopReason "error"; the completion branch below would record it as a
+      // false success (exitCode 0, no category). Classify the terminal outcome
+      // from the last assistant message + the session error, reusing
+      // classifyError for the provider-error case.
+      const providerErrorMessage =
+        lastAssistant?.errorMessage ?? session.state?.errorMessage;
+      const outcome = classifyTerminalOutcome(terminalStopReason, providerErrorMessage);
+
+      if (outcome.status === 'failed') {
+        // Mid-run provider death / truncation / incomplete turn.
+        agent.status = 'failed';
+        agent.completedAt = Date.now();
+        const sanitizedError = sanitizeErrorMessage(
+          providerErrorMessage ?? defaultTerminalMessage(terminalStopReason),
+          effectiveCwd,
+        );
+        agent.error = sanitizedError;
+        const gitInfo = cleanupWorkBranch();
+        agent.result = {
+          ...(agent.result ?? {}),
+          exitCode: 1,
+          messages: agent.result?.messages ?? [],
+          stderr: agent.result?.stderr ?? '',
+          usage: agent.result?.usage ?? EMPTY_USAGE,
+          stopReason: terminalStopReason,
+          errorMessage: sanitizedError,
+          errorCategory: outcome.errorCategory,
+          ...(gitInfo.gitBranch
+            ? { gitBranch: gitInfo.gitBranch, gitDiff: gitInfo.gitDiff }
+            : {}),
+        } as SubagentResult;
+        // Issue #31: capture the final output while the session is still live.
+        // Issue #179 (D4): surface the failure as the HEADLINE — the extracted
+        // prose may come from an earlier turn, so it must not be presented as an
+        // unqualified success narrative.
+        captureAndReleaseSession(sanitizedError);
+        // Issue #122: fold the real usage (turns/tokens) the run burned.
+        recordSessionUsage();
+        agents.set(id, agent);
+        persistAgent(agent);
+        finalizeRunEntry('failed', sanitizedError, {
+          stopReason: terminalStopReason,
+          errorCategory: outcome.errorCategory,
+        });
+        transcript.completeTranscript(id, 'failed');
+        eventBus.emit(eventBus.createEvent('subagent:failed', id, { error: sanitizedError }));
+        return;
+      }
+
       // Session completed
       agent.status = 'completed';
       agent.completedAt = Date.now();
@@ -951,6 +1103,7 @@ export async function spawnBackgroundSession(
           messages: [],
           stderr: '',
           usage: agent.result?.usage ?? EMPTY_USAGE,
+          stopReason: terminalStopReason ?? 'stop',
           gitBranch: gitInfo.gitBranch,
           gitDiff: gitInfo.gitDiff,
         } as SubagentResult;
@@ -965,7 +1118,7 @@ export async function spawnBackgroundSession(
       agents.set(id, agent);
       persistAgent(agent);
       // Issue #98: mirror the agent-record flip in the session run entry.
-      finalizeRunEntry('done');
+      finalizeRunEntry('done', undefined, { stopReason: terminalStopReason ?? 'stop' });
       transcript.completeTranscript(id, 'completed');
       eventBus.emit(eventBus.createEvent('subagent:completed', id, {}));
     } catch (err) {
@@ -1009,7 +1162,9 @@ export async function spawnBackgroundSession(
         // agent.error ('Timed out...' → 'timeout'); a user cancel has no error
         // and stamps 'Subagent aborted by user' (→ 'aborted').
         recordSessionUsage();
-        finalizeRunEntry('failed', agent.error ?? SUBAGENT_ABORTED_MESSAGE);
+        finalizeRunEntry('failed', agent.error ?? SUBAGENT_ABORTED_MESSAGE, {
+          stopReason: 'aborted',
+        });
         // Issue #31: the stopped path is terminal too — capture + release.
         captureAndReleaseSession();
         transcript.completeTranscript(id, 'stopped');
@@ -1022,29 +1177,36 @@ export async function spawnBackgroundSession(
       // result errorMessage, and the subagent:failed event (DRY, PR #63 review).
       const sanitizedError = sanitizeErrorMessage(err.message, effectiveCwd);
       agent.error = sanitizedError;
-      if (gitInfo.gitBranch) {
-        agent.result = {
-          ...(agent.result ?? {}),
-          exitCode: 1,
-          messages: [],
-          stderr: '',
-          usage: agent.result?.usage ?? EMPTY_USAGE,
-          errorMessage: sanitizedError,
-          gitBranch: gitInfo.gitBranch,
-          gitDiff: gitInfo.gitDiff,
-        } as SubagentResult;
-      }
+      // Issue #179: record the failure on the result UNCONDITIONALLY (not only
+      // on the git-diff path) so a failed run never persists exitCode 0.
+      agent.result = {
+        ...(agent.result ?? {}),
+        exitCode: 1,
+        messages: agent.result?.messages ?? [],
+        stderr: agent.result?.stderr ?? '',
+        usage: agent.result?.usage ?? EMPTY_USAGE,
+        // Issue #179 (C1 fix): a genuine preflight/run failure always carries
+        // the failure reason — never leave the result with an undefined
+        // stopReason that downstream display/aggregate paths read as success.
+        stopReason: 'error',
+        errorMessage: sanitizedError,
+        ...(gitInfo.gitBranch
+          ? { gitBranch: gitInfo.gitBranch, gitDiff: gitInfo.gitDiff }
+          : {}),
+      } as SubagentResult;
       // Issue #31: capture the final output while the session is still live,
       // then release the ref before the branch's persist — the persisted
       // record is consistent and the live session graph is freed.
-      captureAndReleaseSession();
+      // Issue #179 (D4): lead with the failure reason (the prose may be from an
+      // earlier turn).
+      captureAndReleaseSession(sanitizedError);
       // Issue #122: fold any assistant turns the preflight/run did produce —
       // usually none (auth/model rejection) → honest zeros, never a crash.
       recordSessionUsage();
       agents.set(id, agent);
       persistAgent(agent);
       // Issue #98: mirror the agent-record flip in the session run entry.
-      finalizeRunEntry('failed', sanitizedError);
+      finalizeRunEntry('failed', sanitizedError, { stopReason: 'error' });
       transcript.completeTranscript(id, 'failed');
       eventBus.emit(eventBus.createEvent('subagent:failed', id, { error: sanitizedError }));
     } catch (err) {

package/src/state.ts

@@ -142,8 +142,6 @@ export class SessionState {
 			circuitBreaker: this.defaultCircuitBreaker(),
 			slaTrackingEnabled: false,
 			slaWindowSize: 50,
-			updateCheckEnabled: true,
-			lastUpdateCheck: 0,
 		};
 	}
 
@@ -168,8 +166,6 @@ export class SessionState {
 		slaTrackingEnabled: this.config.slaTrackingEnabled,
 		slaWindowSize: this.config.slaWindowSize,
 		lastSLAMetrics: this.config.lastSLAMetrics,
-		updateCheckEnabled: this.config.updateCheckEnabled,
-		lastUpdateCheck: this.config.lastUpdateCheck,
 		});
 	}
 
@@ -258,10 +254,6 @@ export class SessionState {
 			this.config.lastSLAMetrics = data.lastSLAMetrics as import("./types").SLAMetrics;
 		}
 
-		// Restore update check fields
-		if (typeof data.updateCheckEnabled === "boolean") this.config.updateCheckEnabled = data.updateCheckEnabled;
-		if (typeof data.lastUpdateCheck === "number" && data.lastUpdateCheck >= 0) this.config.lastUpdateCheck = data.lastUpdateCheck;
-
 		this.log?.info("State restored from session", {
 			model: data.model ? `${data.model.provider}/${data.model.id}` : "none",
 			thinkingLevel: data.maxThinkingLevel,
@@ -508,8 +500,6 @@ export class SessionState {
 		this.config.slaTrackingEnabled = false;
 		this.config.slaWindowSize = 50;
 		this.config.lastSLAMetrics = undefined;
-		this.config.updateCheckEnabled = true;
-		this.config.lastUpdateCheck = 0;
 	}
 }
 

package/src/templates.ts

@@ -407,7 +407,7 @@ export function validateTemplatePresetRefs(
 			dangling++;
 			log?.warn(
 				`Template "${template.name}" references preset "${template.preset}" which does not exist ` +
-				"— delegation will run preset-less with auto-route suppressed (issue #81)",
+				"— delegation will run preset-less with auto-route suppressed",
 				{ template: template.name, preset: template.preset },
 			);
 		}

package/src/transcript.ts

@@ -19,8 +19,9 @@ export function __setOutputDir(dir: string): void {
  * Ensure output directory exists
  */
 function ensureOutputDir(): void {
-  // F6 (issue #29): transcripts contain the full subagent conversation — the
-  // dir must be owner-only (0o700) so other local users cannot list the files.
+  // F6 (issue #29): transcripts may hold task/steering text — the dir must be
+  // owner-only (0o700) so other local users cannot list the files. NOTE: the
+  // transcript is NOT the full conversation (see appendEntry below).
   mkdirSync(OUTPUT_DIR, { recursive: true, mode: 0o700 });
 }
 
@@ -52,8 +53,9 @@ export function startTranscript(agentId: string, task: string): string {
     metadata: { task },
   };
   
-  // F6 (issue #29): transcripts hold the full conversation — append
-  // owner-only (0o600) on file CREATE (mode is not retroactive).
+  // F6 (issue #29): append owner-only (0o600) on file CREATE (mode is not
+  // retroactive). The file holds the system start entry plus any steering
+  // entries appended below — NOT the full conversation.
   appendFileSync(path, JSON.stringify(entry) + '\n', { encoding: 'utf-8', mode: 0o600 });
   return path;
 }
@@ -79,8 +81,11 @@ export function appendEntry(
     metadata,
   };
   
-  // F6 (issue #29): transcripts hold the full conversation — append
-  // owner-only (0o600) on file CREATE (mode is not retroactive).
+  // F6 (issue #29): append owner-only (0o600) on file CREATE (mode is not
+  // retroactive). NOTE (D5 / issue #179): this is NOT a conversation recorder —
+  // the only caller is steering (steerAgent), so the transcript holds the
+  // system start entry and steering lines. Do NOT describe it as the full
+  // conversation without actually recording one.
   appendFileSync(path, JSON.stringify(entry) + '\n', { encoding: 'utf-8', mode: 0o600 });
 }
 

package/src/tui.ts

@@ -337,28 +337,6 @@ export async function showCompletionNotifySelector(
 	onConfigChanged(ctx, `Completion notify mode set to ${result}`);
 }
 
-// ---------------------------------------------------------------------------
-// Update check toggle
-// ---------------------------------------------------------------------------
-
-export async function showUpdateCheckToggle(
-	ctx: ExtensionContext,
-	state: SessionState,
-	onConfigChanged: (ctx: ExtensionContext, msg: string) => void,
-): Promise<void> {
-	const items: SelectItem[] = [
-		{ value: "enabled", label: "Enabled", description: "Check for updates on session start" },
-		{ value: "disabled", label: "Disabled", description: "Skip update check" },
-	];
-
-	const result = await showSelectList(ctx, "Update Check", items, 5);
-	if (!result) return;
-
-	state.config.updateCheckEnabled = result === "enabled";
-	onConfigChanged(ctx, `Update check ${result}`);
-}
-
-// ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // E4: SLA tracking configuration
 // ---------------------------------------------------------------------------
@@ -1199,11 +1177,6 @@ export function getConfigMenuItems(state: SessionState): SelectItem[] {
 				? `Enabled (window: ${state.config.slaWindowSize})`
 				: "Disabled",
 		},
-		{
-			value: "update-check",
-			label: "Update Check",
-			description: state.config.updateCheckEnabled ? "Enabled" : "Disabled",
-		},
 	];
 }
 
@@ -2217,10 +2190,7 @@ function renderSubTaskSummary(
 	},
 	maxLines: number,
 ): string {
-	const isError =
-		result.exitCode !== 0 ||
-		result.stopReason === "error" ||
-		result.stopReason === "aborted";
+	const isError = isSubagentError(result);
 	const icon = isError
 		? theme.fg("error", "\u2717")
 		: theme.fg("success", "\u2713");
@@ -2240,12 +2210,7 @@ function renderCollapsedChain(
 	details: ChainDetails,
 	theme: Theme,
 ): string {
-	const allSucceeded = details.results.every(
-		(r) =>
-			r.exitCode === 0 &&
-			r.stopReason !== "error" &&
-			r.stopReason !== "aborted",
-	);
+	const allSucceeded = details.results.every((r) => !isSubagentError(r));
 	const icon = allSucceeded
 		? theme.fg("success", "\u2713")
 		: theme.fg("error", "\u2717");
@@ -2253,10 +2218,7 @@ function renderCollapsedChain(
 	let text = `${icon} ${theme.fg("toolTitle", theme.bold("chain"))} ${theme.fg("muted", `${details.completedSteps}/${details.totalSteps} steps${stoppedEarly}`)}`;
 
 	for (const r of details.results) {
-		const isErr =
-			r.exitCode !== 0 ||
-			r.stopReason === "error" ||
-			r.stopReason === "aborted";
+		const isErr = isSubagentError(r);
 		const statusIcon = isErr
 			? theme.fg("error", "\u2717")
 			: theme.fg("success", "\u2713");
@@ -2290,10 +2252,7 @@ function renderCollapsedParallel(
 	let text = `${icon} ${theme.fg("toolTitle", theme.bold("parallel"))} ${theme.fg("muted", `${details.succeeded}/${details.failed}/${details.results.length} total`)}`;
 
 	for (const r of details.results) {
-		const isErr =
-			r.exitCode !== 0 ||
-			r.stopReason === "error" ||
-			r.stopReason === "aborted";
+		const isErr = isSubagentError(r);
 		const statusIcon = isErr
 			? theme.fg("error", "\u2717")
 			: theme.fg("success", "\u2713");
@@ -2339,10 +2298,7 @@ function renderExpandedChain(
 	container.addChild(new Spacer(1));
 
 	for (const r of details.results) {
-		const isErr =
-			r.exitCode !== 0 ||
-			r.stopReason === "error" ||
-			r.stopReason === "aborted";
+		const isErr = isSubagentError(r);
 		const statusIcon = isErr
 			? theme.fg("error", "\u2717")
 			: theme.fg("success", "\u2713");
@@ -2424,10 +2380,7 @@ function renderExpandedParallel(
 	container.addChild(new Spacer(1));
 
 	for (const r of details.results) {
-		const isErr =
-			r.exitCode !== 0 ||
-			r.stopReason === "error" ||
-			r.stopReason === "aborted";
+		const isErr = isSubagentError(r);
 		const statusIcon = isErr
 			? theme.fg("error", "\u2717")
 			: theme.fg("success", "\u2713");
@@ -2801,12 +2754,7 @@ function renderCollapsedGraph(
 ): string {
 	const totalTasks = details.waves.reduce((s, w) => s + w.tasks.length, 0);
 	const allSucceeded = details.waves.every((w) =>
-		w.tasks.every(
-			(r) =>
-				r.exitCode === 0 &&
-				r.stopReason !== "error" &&
-				r.stopReason !== "aborted",
-		),
+		w.tasks.every((r) => !isSubagentError(r)),
 	);
 	const icon = allSucceeded
 		? theme.fg("success", "\u2713")
@@ -2817,22 +2765,16 @@ function renderCollapsedGraph(
 	const wavesToRender = details.waves.slice(0, maxWavesToShow);
 
 	for (const wave of wavesToRender) {
-		const waveOk = wave.tasks.every(
-			(r) =>
-				r.exitCode === 0 &&
-				r.stopReason !== "error" &&
-				r.stopReason !== "aborted",
-		);
+		const waveOk = wave.tasks.every((r) => !isSubagentError(r));
 		const waveIcon = waveOk
 			? theme.fg("success", "\u2713")
 			: theme.fg("error", "\u2717");
 		const modeLabel = wave.parallel ? "parallel" : "serial";
 		const taskLabels = wave.tasks.map((r) => {
 			const label = r.label || r.task.slice(0, 30);
-			const taskIcon =
-				r.exitCode === 0 && r.stopReason !== "error" && r.stopReason !== "aborted"
-					? theme.fg("success", "\u2713")
-					: theme.fg("error", "\u2717");
+			const taskIcon = !isSubagentError(r)
+				? theme.fg("success", "\u2713")
+				: theme.fg("error", "\u2717");
 			return `${taskIcon} ${theme.fg("dim", label)}`;
 		});
 		text += `
@@ -2870,12 +2812,7 @@ function renderExpandedGraph(
 	container.addChild(new Spacer(1));
 
 	for (const wave of details.waves) {
-		const waveOk = wave.tasks.every(
-			(r) =>
-				r.exitCode === 0 &&
-				r.stopReason !== "error" &&
-				r.stopReason !== "aborted",
-		);
+		const waveOk = wave.tasks.every((r) => !isSubagentError(r));
 		const waveIcon = waveOk
 			? theme.fg("success", "\u2713")
 			: theme.fg("error", "\u2717");
@@ -2889,10 +2826,7 @@ function renderExpandedGraph(
 		);
 
 		for (const r of wave.tasks) {
-			const isErr =
-				r.exitCode !== 0 ||
-				r.stopReason === "error" ||
-				r.stopReason === "aborted";
+			const isErr = isSubagentError(r);
 			const statusIcon = isErr
 				? theme.fg("error", "\u2717")
 				: theme.fg("success", "\u2713");