@gajae-code/coding-agent 0.16.7 → 0.17.1

package/src/sdk/bus/doctor-daemon-restart.ts

@@ -0,0 +1,92 @@
+export type DoctorDaemonOwner = "telegram" | "discord" | "slack";
+
+export interface DoctorDaemonIdentity {
+	owner: DoctorDaemonOwner;
+	ownerId: string;
+	generation: number;
+	incarnation: string;
+}
+
+export interface DoctorDaemonOccupancy {
+	attached: number;
+	inflight: number;
+	inbound: number;
+	outbound: number;
+	cleanup: number;
+}
+
+const DOCTOR_DAEMON_OCCUPANCY_KEYS = ["attached", "inflight", "inbound", "outbound", "cleanup"] as const;
+
+export interface DoctorDaemonStatus extends DoctorDaemonIdentity {
+	requestId: string;
+	phase: "idle" | "prepared" | "committed" | "cancelled" | "expired";
+	admitting: boolean;
+	occupancy: DoctorDaemonOccupancy;
+	leaseExpiresAt: number;
+}
+
+export interface DoctorDaemonControlRequest extends DoctorDaemonIdentity {
+	version: 1;
+	requestId: string;
+	action: "prepare" | "commit" | "cancel" | "status";
+	createdAt: number;
+	leaseExpiresAt?: number;
+}
+
+export function doctorDaemonOccupancyEmpty(): DoctorDaemonOccupancy {
+	return { attached: 0, inflight: 0, inbound: 0, outbound: 0, cleanup: 0 };
+}
+
+/**
+ * True only when every named occupancy category is an explicit, valid,
+ * zero-valued integer. An empty object, a partial object, or an object with
+ * extra/malformed keys is never vacuously "settled" — `Object.values({}).
+ * every(...)` was previously `true` for `{}` because there is nothing to
+ * iterate; this checks the exact required key set instead.
+ */
+export function doctorDaemonOccupancySettled(occupancy: DoctorDaemonOccupancy | undefined): boolean {
+	if (!occupancy || typeof occupancy !== "object") return false;
+	if (Object.keys(occupancy).length !== DOCTOR_DAEMON_OCCUPANCY_KEYS.length) return false;
+	return DOCTOR_DAEMON_OCCUPANCY_KEYS.every(key => {
+		const value = occupancy[key];
+		return typeof value === "number" && Number.isSafeInteger(value) && value === 0;
+	});
+}
+
+export function doctorDaemonIdentityMatches(
+	left: DoctorDaemonIdentity | undefined,
+	right: DoctorDaemonIdentity,
+): boolean {
+	return (
+		left?.owner === right.owner &&
+		left?.ownerId === right.ownerId &&
+		left?.generation === right.generation &&
+		left?.incarnation === right.incarnation
+	);
+}
+
+export function isDoctorDaemonControlRequest(value: unknown): value is DoctorDaemonControlRequest {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value as Record<string, unknown>;
+	return (
+		candidate.version === 1 &&
+		typeof candidate.requestId === "string" &&
+		candidate.requestId.length > 0 &&
+		(candidate.action === "prepare" ||
+			candidate.action === "commit" ||
+			candidate.action === "cancel" ||
+			candidate.action === "status") &&
+		(candidate.owner === "telegram" || candidate.owner === "discord" || candidate.owner === "slack") &&
+		typeof candidate.ownerId === "string" &&
+		candidate.ownerId.length > 0 &&
+		typeof candidate.generation === "number" &&
+		Number.isSafeInteger(candidate.generation) &&
+		candidate.generation >= 0 &&
+		typeof candidate.incarnation === "string" &&
+		candidate.incarnation.length > 0 &&
+		typeof candidate.createdAt === "number" &&
+		Number.isFinite(candidate.createdAt) &&
+		(candidate.leaseExpiresAt === undefined ||
+			(typeof candidate.leaseExpiresAt === "number" && Number.isFinite(candidate.leaseExpiresAt)))
+	);
+}

package/src/sdk/bus/index.ts

@@ -27,7 +27,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
-import { type RunSettlementProof, ThinkingLevel } from "@gajae-code/agent-core";
+import { isNonDispatchedToolEvent, type RunSettlementProof, ThinkingLevel } from "@gajae-code/agent-core";
 import type { ImageContent, TextContent, Tool } from "@gajae-code/ai/core";
 import type { NotificationServer as NativeNotificationServer } from "@gajae-code/natives";
 
@@ -90,7 +90,7 @@ import { acpFinalTextFromMessage } from "../acp/final-text";
 import { ensureBroker } from "../broker/ensure";
 import { publishSessionHostRuntimeEvidence, type SessionHostRuntimePublication } from "../broker/lifecycle";
 import { processIncarnation } from "../broker/process-incarnation";
-import { resolveSessionLocator, SessionIndex } from "../broker/session-index";
+import { resolveSessionLocator, SessionIndex, type SessionIndexEvent } from "../broker/session-index";
 import {
 	CAP_GATED_FRAME_KINDS,
 	createSdkSurfaceFactory,
@@ -114,7 +114,19 @@ import {
 	syntheticModelInputError,
 	syntheticNamespaceCollision,
 } from "../model-profile-model";
-import { formatPromptFailureForLocalLog, sanitizePromptFailure } from "../prompt-failure";
+import {
+	createPromptDeadlineLease,
+	isAttributableProgressEventType,
+	type PromptDeadlineLease,
+	promptDeadlineAt,
+	recordAttributableProgress,
+} from "../prompt-deadline-lease";
+import {
+	assistantFailureCode,
+	failedPromptOutcome,
+	formatPromptFailureForLocalLog,
+	sanitizePromptFailure,
+} from "../prompt-failure";
 import { PROMPT_CLIENT_REF_MAX_LENGTH, type SdkPromptTerminalOutcome } from "../prompt-status";
 import { OPERATIONS } from "../protocol/operation-registry";
 import {
@@ -2389,6 +2401,7 @@ function sdkQuerySurface(
 		status: "unknown",
 	}),
 	getRuntimeHost: () => SessionSdkHost | undefined = () => undefined,
+	primaryControlSurface: "cli" | "sdk" = "sdk",
 ): SessionSurface {
 	return createSdkSurfaceFactory({
 		ctx,
@@ -2402,6 +2415,7 @@ function sdkQuerySurface(
 		steerStatusLookup,
 		hostTools: () => getInstalledDefinitions("host_tools") !== undefined,
 		getRuntimeHost,
+		primaryControlSurface,
 	}).query;
 }
 
@@ -4052,6 +4066,8 @@ export function createNotificationsExtension(
 		controller?: NotificationSessionController;
 		/** Whether this host mode can own the root SDK endpoint. Default: true. */
 		sdkHostModeSupported?: boolean;
+		/** Startup surface that owns host-level permission and lifecycle authority. */
+		primaryControlSurface?: "cli" | "sdk";
 		/** In-memory master capability for private broker verification only. */
 		masterCapability?: string;
 		/** Opaque direct-role epoch this effective host may adopt. */
@@ -4775,8 +4791,22 @@ export function createNotificationsExtension(
 			/** Fatal/uncertain closure: transport-level only, never a semantic terminal. */
 			fatal?: boolean;
 			createdAt: number;
-			deadlineMs: number;
+			/**
+			 * Bounded progress-aware terminal deadline: the inactivity window renews
+			 * on attributable tool progress correlated to this exact accepted prompt,
+			 * up to a hard maximum runtime anchored to acceptance.
+			 */
+			deadlineLease: PromptDeadlineLease;
 			deadlineTimer?: Parameters<typeof clearTimeout>[0];
+			/**
+			 * Identity of the in-flight deadline expiry attempt (set synchronously
+			 * by the firing deadline timer, cleared when the attempt completes or
+			 * is superseded). Fresh attributable progress recorded while the
+			 * attempt awaits durable reconciliation advances the lease generation;
+			 * the attempt must then back off instead of terminalizing a live prompt
+			 * (mirrors PromptDeadlineManager).
+			 */
+			deadlineAttempt?: { lease: PromptDeadlineLease; generation: number };
 			phase: "active" | "outcome_claimed" | "terminalizing" | "publication_closed" | "delivered";
 			outcome?: SdkPromptTerminalOutcome;
 			/** Agent-owned resource run captured at acceptance; cleanup targets only this handle. */
@@ -4991,10 +5021,59 @@ export function createNotificationsExtension(
 				finalizePrompt(key, correlation);
 			}
 		};
+		const readFiniteSetting = (key: "sdk.promptDeadlineMs" | "sdk.promptMaxRuntimeMs", fallback: number): number => {
+			const value = settings?.get(key);
+			return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+		};
+		/**
+		 * (Re)arm the accepted prompt's terminal deadline from its current lease.
+		 * `terminalizePrompt` stays the single authoritative terminal owner; this
+		 * only decides when it is invoked.
+		 */
+		const armPromptDeadline = (key: string, correlation: { commandId: string; turnId: string }) => {
+			const submission = promptSubmissions.get(key);
+			if (!submission) return;
+			const lease = submission.deadlineLease;
+			if (submission.deadlineTimer) clearTimeout(submission.deadlineTimer);
+			submission.deadlineTimer = setTimeout(
+				() => {
+					const current = promptSubmissions.get(key);
+					// Identity fencing: a discarded, evicted or re-accepted submission is
+					// never terminalized by a predecessor's timer.
+					if (!current || current.deadlineLease !== lease) return;
+					// Progress delivered while this timer was pending renews the lease, so
+					// re-arm instead of terminalizing a demonstrably live prompt.
+					if (Date.now() < promptDeadlineAt(lease)) {
+						armPromptDeadline(key, correlation);
+						return;
+					}
+					// Register the expiry attempt BEFORE the awaited durable claim:
+					// progress arriving while the claim is in flight must supersede
+					// this attempt (see the post-claim fence in terminalizePrompt).
+					current.deadlineAttempt = { lease, generation: lease.generation };
+					void terminalizePrompt(
+						correlation,
+						{
+							kind: "failed",
+							code: "prompt_deadline_exceeded",
+							message: "Prompt deadline exceeded.",
+							provenance: "deadline",
+							phase: "submission",
+							category: "deadline",
+						},
+						{ fence: true },
+						{ diagnostic: { reason: "Prompt deadline exceeded." } },
+					);
+				},
+				Math.max(0, promptDeadlineAt(lease) - Date.now()),
+			);
+		};
 		const emitPromptEvent = (event: AgentSessionEvent) => {
 			if (!runtime?.activePromptCorrelation) return;
 			cleanupPromptRecords();
 			const correlation = runtime.activePromptCorrelation;
+			// Renewal is attributed exactly like the correlated delivery below.
+			renewPromptDeadline(correlation, event);
 			const submission = promptSubmissions.get(promptSubmissionKey(correlation));
 			if (!submission || submission.abandoned) return;
 			const frame = {
@@ -5014,6 +5093,59 @@ export function createNotificationsExtension(
 				abandonPrompt(submission);
 			}
 		};
+		/**
+		 * Status of a registered deadline expiry attempt after an awaited
+		 * reconciliation transition (mirrors PromptDeadlineManager).
+		 * - "current": no superseding progress; the attempt may proceed.
+		 * - "superseded": fresh attributable progress renewed the lease past now.
+		 *   The hard cap needs no special case: promptDeadlineAt is the minimum
+		 *   of the renewed window and acceptedAt+maxMs, so progress at an
+		 *   already-due cap still reads expired and the attempt proceeds.
+		 * - "stale": the submission was cleared, evicted or re-accepted under
+		 *   this attempt; it must touch nothing.
+		 */
+		type DeadlineAttemptStatus = "current" | "superseded" | "stale";
+		const deadlineAttemptStatus = (
+			key: string,
+			submission: PromptSubmission,
+			attempt: { lease: PromptDeadlineLease; generation: number },
+		): DeadlineAttemptStatus => {
+			if (promptSubmissions.get(key) !== submission || submission.deadlineLease !== attempt.lease) return "stale";
+			const lease = submission.deadlineLease;
+			if (lease.generation !== attempt.generation && Date.now() < promptDeadlineAt(lease)) return "superseded";
+			return "current";
+		};
+		/**
+		 * Renew the accepted prompt's deadline on attributable progress. The
+		 * allowlist stays owned by the shared lease module, so streaming chatter,
+		 * tool updates, heartbeats and retry bookkeeping never renew. Pairing-only
+		 * synthetic tool pairs (never dispatched, marked via the dispatch-identity
+		 * side channel rather than the wire) never renew either: they prove
+		 * pairing, not progress. Only a pre-terminal submission may re-arm behind
+		 * its terminal owner; progress arriving while a deadline expiry attempt
+		 * awaits durable reconciliation is recorded (advancing the attempt fence)
+		 * but never re-arms — the attempt itself reschedules on supersession.
+		 */
+		const renewPromptDeadline = (correlation: { commandId: string; turnId: string }, event: { type: string }) => {
+			if (!isAttributableProgressEventType(event.type) || isNonDispatchedToolEvent(event)) return;
+			const key = promptSubmissionKey(correlation);
+			const submission = promptSubmissions.get(key);
+			if (!submission) return;
+			if (
+				submission.deadlineAttempt &&
+				submission.deadlineLease === submission.deadlineAttempt.lease &&
+				(submission.phase === "outcome_claimed" || submission.phase === "terminalizing")
+			) {
+				recordAttributableProgress(submission.deadlineLease, Date.now());
+				return;
+			}
+			if (submission.terminal || submission.phase !== "active") return;
+			const generation = submission.deadlineLease.generation;
+			recordAttributableProgress(submission.deadlineLease, Date.now());
+			// Monotonic: stale or out-of-order progress never moves the lease.
+			if (submission.deadlineLease.generation === generation) return;
+			armPromptDeadline(key, correlation);
+		};
 		const flushPromptLifecycle = (key: string, submission: PromptSubmission) => {
 			for (const frame of submission.bufferedFrames.splice(0)) {
 				try {
@@ -5073,7 +5205,11 @@ export function createNotificationsExtension(
 				terminal: false,
 				retainCorrelation: trackReconciliation,
 				createdAt: Date.now(),
-				deadlineMs: settings?.get("sdk.promptDeadlineMs") ?? 1_800_000,
+				deadlineLease: createPromptDeadlineLease({
+					now: Date.now(),
+					leaseMs: readFiniteSetting("sdk.promptDeadlineMs", 1_800_000),
+					maxMs: readFiniteSetting("sdk.promptMaxRuntimeMs", 21_600_000),
+				}),
 				phase: "active",
 				// Bound to the Agent run at `agent_start`; acceptance precedes execution.
 				executionHandle: undefined,
@@ -5081,21 +5217,12 @@ export function createNotificationsExtension(
 				reconciliationKind,
 				bufferedFrames: [],
 			};
-			promptSubmissions.set(promptSubmissionKey(correlation), submission);
+			const key = promptSubmissionKey(correlation);
+			promptSubmissions.set(key, submission);
 			if (trackReconciliation) await notePromptReconciliationAccepted(correlation, clientRef);
-			submission.deadlineTimer = setTimeout(() => {
-				void terminalizePrompt(
-					correlation,
-					{
-						kind: "failed",
-						code: "prompt_deadline_exceeded",
-						message: "Prompt deadline exceeded.",
-						provenance: "deadline",
-					},
-					{ fence: true },
-					{ diagnostic: { reason: "Prompt deadline exceeded." } },
-				);
-			}, submission.deadlineMs);
+			// Armed only after the durable accept: a rolled-back acceptance
+			// (`discardPromptAcceptance`) must leave no deadline behind.
+			if (promptSubmissions.get(key) === submission) armPromptDeadline(key, correlation);
 		};
 		/** Roll back process-local registration when durable acceptance failed. */
 		const discardPromptAcceptance = (correlation: { commandId: string; turnId: string }) => {
@@ -5123,6 +5250,7 @@ export function createNotificationsExtension(
 			code: string,
 			message: string,
 		) => {
+			submission.deadlineAttempt = undefined;
 			if (submission.deadlineTimer) clearTimeout(submission.deadlineTimer);
 			if (!submission.terminal) {
 				submission.terminal = true;
@@ -5220,10 +5348,29 @@ export function createNotificationsExtension(
 				// The claim is the durability boundary: without it nothing may be published
 				// and the endpoint must fail closed so the client rejects exactly once. The
 				// last durable record stays active for restart recovery.
+				submission.deadlineAttempt = undefined;
 				logger.warn(`sdk: prompt claim persistence failed: ${String(error)}`);
 				failPromptClosed(correlation, submission, "terminal_uncertain", "Prompt reconciliation is unavailable.");
 				return;
 			}
+			// Deadline-attempt fence across the awaited claim (mirrors
+			// PromptDeadlineManager): fresh attributable progress recorded while
+			// the claim was in flight advances the lease generation. The pending
+			// attempt must then back off — reset to active and reschedule —
+			// instead of fencing and publishing a deadline terminal for a live
+			// prompt. A re-accepted or evicted submission is never touched.
+			const deadlineAttempt = submission.deadlineAttempt;
+			if (deadlineAttempt) {
+				const key = promptSubmissionKey(correlation);
+				const status = deadlineAttemptStatus(key, submission, deadlineAttempt);
+				if (status === "stale") return;
+				if (status === "superseded") {
+					submission.deadlineAttempt = undefined;
+					submission.phase = "active";
+					armPromptDeadline(key, correlation);
+					return;
+				}
+			}
 			submission.outcome = winner;
 			submission.phase = "terminalizing";
 			if (options.fence) {
@@ -5292,14 +5439,41 @@ export function createNotificationsExtension(
 				}
 				if (capture) capture.proof = proof;
 			}
+			// Second deadline-attempt fence across the awaited fencing transition:
+			// progress recorded while fencing was in flight supersedes exactly
+			// like progress during the claim. Non-deadline attempts skip this —
+			// their attempt identity was never registered.
+			if (deadlineAttempt) {
+				const key = promptSubmissionKey(correlation);
+				const status = deadlineAttemptStatus(key, submission, deadlineAttempt);
+				if (status === "stale") return;
+				if (status === "superseded") {
+					submission.deadlineAttempt = undefined;
+					submission.phase = "active";
+					armPromptDeadline(key, correlation);
+					return;
+				}
+			}
 			try {
-				await kindReconciliation.finalizeOutcome(
-					submission.reconciliationKind,
-					correlation,
-					winner,
-					extra?.error,
-					extra?.finalText,
-				);
+				if (deadlineAttempt) {
+					await kindReconciliation.finalizeOutcome(
+						submission.reconciliationKind,
+						correlation,
+						winner,
+						() =>
+							deadlineAttemptStatus(promptSubmissionKey(correlation), submission, deadlineAttempt) === "current",
+						extra?.error,
+						extra?.finalText,
+					);
+				} else {
+					await kindReconciliation.finalizeOutcome(
+						submission.reconciliationKind,
+						correlation,
+						winner,
+						extra?.error,
+						extra?.finalText,
+					);
+				}
 			} catch (error) {
 				// The durable pending claim survives; publishing an unpersisted terminal
 				// would contradict it, so fail the endpoint closed instead.
@@ -5307,6 +5481,18 @@ export function createNotificationsExtension(
 				failPromptClosed(correlation, submission, "terminal_uncertain", "Prompt reconciliation is unavailable.");
 				return;
 			}
+			if (deadlineAttempt) {
+				const key = promptSubmissionKey(correlation);
+				const status = deadlineAttemptStatus(key, submission, deadlineAttempt);
+				if (status === "stale") return;
+				if (status === "superseded") {
+					submission.deadlineAttempt = undefined;
+					submission.phase = "active";
+					armPromptDeadline(key, correlation);
+					return;
+				}
+				submission.deadlineAttempt = undefined;
+			}
 			if (submission.deadlineTimer) clearTimeout(submission.deadlineTimer);
 			if (!recordPromptTerminal(correlation)) return;
 			if (!runtime) {
@@ -5343,7 +5529,10 @@ export function createNotificationsExtension(
 						type: "agent_failed",
 						sessionId: runtime.id,
 						...correlation,
-						error: extra?.error ?? { code: winner.code, message: winner.message },
+						error:
+							extra?.error !== undefined
+								? { code: extra.error.code, message: winner.message }
+								: { code: winner.code, message: winner.message },
 						outcome: winner,
 					});
 				} else {
@@ -5401,12 +5590,12 @@ export function createNotificationsExtension(
 				error: formatPromptFailureForLocalLog(error),
 			});
 			const sanitized = sanitizePromptFailure(error);
-			const outcome: SdkPromptTerminalOutcome = {
-				kind: "failed",
+			const outcome: SdkPromptTerminalOutcome = failedPromptOutcome({
 				code: "prompt_failed",
-				message: sanitized.message,
 				provenance: "agent_failed",
-			};
+				providerCode: sanitized.code,
+				evidence: {},
+			});
 			// This rejection bypasses `agent_end`, so record its local-only reason at
 			// the accepted submission failure boundary before terminalization begins.
 			logger.error("sdk_prompt_terminal_failed", {
@@ -5469,6 +5658,7 @@ export function createNotificationsExtension(
 				selector => kindReconciliation.lookupResult(selector.kind, selector),
 				selector => kindReconciliation.lookupSteer(selector),
 				() => host,
+				options.primaryControlSurface ?? "sdk",
 			),
 			id,
 			revisions,
@@ -7813,6 +8003,7 @@ export function createNotificationsExtension(
 						processIncarnation: hostProcessIncarnation,
 					});
 					throwIfLifecycleStopped();
+					let registration: SessionIndexEvent | undefined;
 					await host.registerWithBroker({
 						// The endpoint is written before registration. Its exact mtime
 						// binds this index generation to that discovery record.
@@ -7826,7 +8017,7 @@ export function createNotificationsExtension(
 								processIncarnation: hostProcessIncarnation,
 								direct,
 							});
-							await index.append({
+							registration = await index.append({
 								type: "host_registered",
 								...input,
 								locator,
@@ -7843,13 +8034,16 @@ export function createNotificationsExtension(
 							});
 						},
 						unregister: async input => {
-							await index.append({
-								type: "host_unregistered",
-								...input,
-								locator,
-								pid: process.pid,
-								...(lifecycleRequestId ? { lifecycleRequestId } : {}),
-							});
+							const expected = registration;
+							if (
+								!expected ||
+								expected.sessionId !== input.sessionId ||
+								expected.endpointGeneration !== input.endpointGeneration ||
+								path.resolve(expected.locator.stateRoot) !== path.resolve(input.stateRoot)
+							)
+								return;
+							await index.unregisterIfCurrent(expected);
+							if (registration === expected) registration = undefined;
 						},
 					});
 					throwIfLifecycleStopped();
@@ -8768,8 +8962,15 @@ export function createNotificationsExtension(
 		if (correlation) {
 			const assistants = (Array.isArray(event.messages) ? [...event.messages].reverse() : []).filter(
 				message => message && typeof message === "object" && (message as { role?: unknown }).role === "assistant",
-			) as Array<{ stopReason?: unknown; errorKind?: unknown }>;
+			) as Array<{ stopReason?: unknown; errorKind?: unknown; errorCode?: unknown }>;
 			const finalAssistant = assistants[0];
+			const terminalAssistant = assistants.find(
+				message =>
+					(message as { stopReason?: unknown }).stopReason === "error" ||
+					(message as { stopReason?: unknown }).stopReason === "aborted",
+			) as
+				| { stopReason?: "error" | "aborted"; errorMessage?: unknown; errorKind?: unknown; errorCode?: unknown }
+				| undefined;
 			const pendingOutcome = rt.peekPromptPendingOutcome(correlation);
 			let outcome: SdkPromptTerminalOutcome;
 			if (pendingOutcome) outcome = pendingOutcome;
@@ -8786,24 +8987,24 @@ export function createNotificationsExtension(
 				finalAssistant?.stopReason !== "aborted"
 			)
 				outcome = { kind: "stopped", reason: "end_turn", provenance: "agent" };
-			else
-				outcome = {
-					kind: "failed",
+			else {
+				// The provider/agent's own bounded classifier travels on the terminal
+				// assistant message; the phase is finalized against the durable record
+				// (startedAt) when the outcome is claimed.
+				const providerCode = assistantFailureCode(terminalAssistant);
+				outcome = failedPromptOutcome({
 					code: "prompt_failed",
-					message: "Prompt submission failed.",
 					provenance: "agent_failed",
-				};
+					...(providerCode !== undefined ? { providerCode } : {}),
+					evidence: {},
+				});
+			}
 			const successAssistant = assistants.find(
 				message => (message as { stopReason?: unknown }).stopReason === "stop",
 			);
 			const finalText = successAssistant ? acpFinalTextFromMessage(successAssistant).text : "";
 			// The normalized outcome is the ACP contract; existing SDK clients keep the
 			// legacy failure discriminator on the wire and in the reconciliation record.
-			const terminalAssistant = assistants.find(
-				message =>
-					(message as { stopReason?: unknown }).stopReason === "error" ||
-					(message as { stopReason?: unknown }).stopReason === "aborted",
-			) as { stopReason?: "error" | "aborted"; errorMessage?: unknown; errorKind?: unknown } | undefined;
 			const legacyCode =
 				event.stopReason === "cancelled"
 					? "cancelled"
@@ -8835,7 +9036,7 @@ export function createNotificationsExtension(
 					? {
 							// Only the legacy discriminator is preserved; provider text is never
 							// retained, matching `sanitizePromptFailure`.
-							error: { code: legacyCode, message: "Prompt submission failed." },
+							error: { code: legacyCode, message: outcome.message },
 						}
 					: {}),
 			});