@gajae-code/coding-agent 0.11.0 → 0.11.1

package/src/sdk/bus/index.ts

@@ -874,6 +874,10 @@ interface SessionRuntime {
 	redact: boolean;
 	/** True only after the exact host generation was registered with the broker index. */
 	brokerRegistrationActive: boolean;
+	/** Terminal cleanup proof retained across retries; each owner is released at most once after proof. */
+	hostStopped: boolean;
+	serverStopped: boolean;
+	brokerRegistrationReleased: boolean;
 	verbosity: "lean" | "verbose";
 	sessionTag: string;
 	/** Whether the agent loop is currently running (drives the typing indicator). */
@@ -2294,6 +2298,9 @@ export function createNotificationsExtension(
 			getConfig: () => resolveSettings(options.settings).cfg,
 		});
 
+	// Failed terminal teardown remains fenced from normal runtime lookup while the
+	// exact runtime object retains authority for an explicit idempotent retry.
+	const cleanupRetries = new Map<string, SessionRuntime>();
 	const sessionStartPromises = new Map<string, Promise<SessionStartResult>>();
 	let activeRuntimeId: string | undefined;
 	let identityControlInFlight = false;
@@ -2341,13 +2348,15 @@ export function createNotificationsExtension(
 		reason: "session" | "notifications" = "session",
 		expectedRuntime?: SessionRuntime,
 	): Promise<boolean> {
-		const requestedRuntime = runtimes.get(id);
+		const retryRuntime = cleanupRetries.get(id);
+		const activeRuntime = runtimes.get(id);
+		const requestedRuntime = retryRuntime ?? activeRuntime;
 		if (expectedRuntime && requestedRuntime !== expectedRuntime) return false;
 		if (reason === "session" && requestedRuntime) requestedRuntime.stopping = true;
 		if (reason === "session" && requestedRuntime) {
 			// Fence the exact runtime before awaiting its startup promise: a late start
 			// must observe removal and clean itself up rather than becoming reachable.
-			runtimes.delete(id);
+			if (runtimes.get(id) === requestedRuntime) runtimes.delete(id);
 			if (activeRuntimeId === id) activeRuntimeId = undefined;
 		}
 		const pendingStart = sessionStartPromises.get(id);
@@ -2355,7 +2364,8 @@ export function createNotificationsExtension(
 			void pendingStart
 				.catch(() => {})
 				.then(() => {
-					if (runtimes.get(id) === requestedRuntime) void stopSession(id, reason, requestedRuntime);
+					if (runtimes.get(id) === requestedRuntime || cleanupRetries.get(id) === requestedRuntime)
+						void stopSession(id, reason, requestedRuntime);
 				});
 		const rt = requestedRuntime;
 
@@ -2378,6 +2388,9 @@ export function createNotificationsExtension(
 			rt.pendingInteractive.clear();
 			return true;
 		}
+		// Keep this exact object authoritative for the full terminal release, including
+		// the interval before a failed owner can be recorded for a later retry.
+		cleanupRetries.set(id, rt);
 
 		try {
 			rt.cancelPostmortemCleanup();
@@ -2405,16 +2418,24 @@ export function createNotificationsExtension(
 		try {
 			rt.disposeGateTerminalController();
 		} catch {}
-		let hostStopped = false;
-		let brokerRegistrationReleased = false;
+		let hostStopped = rt.hostStopped;
+		let brokerRegistrationReleased = rt.brokerRegistrationReleased;
+		const ownerReleaseFailures: unknown[] = [];
 
-		try {
-			const stopped = await rt.host.stop();
-			hostStopped = stopped === "stopped";
-			brokerRegistrationReleased = !rt.brokerRegistrationActive || stopped === "stopped";
-			if (rt.brokerRegistrationActive && stopped === "stopped") rt.brokerRegistrationActive = false;
-		} catch (e) {
-			logger.warn(`sdk host: stop failed: ${String(e)}`);
+		if (!hostStopped) {
+			try {
+				const stopped = await rt.host.stop();
+				hostStopped = stopped === "stopped";
+				brokerRegistrationReleased = !rt.brokerRegistrationActive || hostStopped;
+				if (rt.brokerRegistrationActive && hostStopped) rt.brokerRegistrationActive = false;
+				if (hostStopped) {
+					rt.hostStopped = true;
+					rt.brokerRegistrationReleased = brokerRegistrationReleased;
+				}
+			} catch (e) {
+				ownerReleaseFailures.push(e);
+				logger.warn(`sdk host: stop failed: ${String(e)}`);
+			}
 		}
 		rt.host.reverse.dispose();
 		// Resolve any still-pending interactive asks so the ask tool is not left hanging.
@@ -2424,6 +2445,7 @@ export function createNotificationsExtension(
 			rt.cursors.close();
 			await rt.revisions.close();
 		} catch (e) {
+			ownerReleaseFailures.push(e);
 			logger.warn(`sdk query snapshots: close failed: ${String(e)}`);
 		}
 		let closeFrameSent = false;
@@ -2434,18 +2456,27 @@ export function createNotificationsExtension(
 			logger.warn(`notifications: session_closed failed: ${String(e)}`);
 		}
 		if (closeFrameSent) await sleep(100);
-		let serverStopped = false;
-		try {
-			rt.server.stop();
-			serverStopped = true;
-		} catch (e) {
-			logger.warn(`notifications: stop failed: ${String(e)}`);
+		let serverStopped = rt.serverStopped;
+		if (!serverStopped) {
+			try {
+				await rt.server.stopAndWait();
+				serverStopped = true;
+				rt.serverStopped = true;
+			} catch (e) {
+				ownerReleaseFailures.push(e);
+				logger.warn(`notifications: stop failed: ${String(e)}`);
+			}
 		}
 		lifecycleStartupCapability?.rollback?.recordStop(rt.host.generation, {
 			runtimeRemoved: true,
-			hostStopped: hostStopped && serverStopped,
-			brokerRegistrationReleased,
+			hostStopped: rt.hostStopped && rt.serverStopped,
+			brokerRegistrationReleased: rt.brokerRegistrationReleased,
 		});
+		if (ownerReleaseFailures.length > 0) {
+			cleanupRetries.set(id, rt);
+			throw new AggregateError(ownerReleaseFailures, `SDK notification runtime ${id} owner release failed.`);
+		}
+		if (cleanupRetries.get(id) === rt) cleanupRetries.delete(id);
 		return true;
 	}
 
@@ -2484,6 +2515,8 @@ export function createNotificationsExtension(
 		if (lifecycleRequired && !isNotificationEligibleContext(ctx)) return failLifecycleStartup("ineligible");
 		const pendingStart = sessionStartPromises.get(id);
 		if (pendingStart) return pendingStart;
+		const retainedCleanup = cleanupRetries.get(id);
+		if (retainedCleanup) return failLifecycleStartup("failed", "SDK notification runtime cleanup is still pending.");
 		const existingRuntime = runtimes.get(id);
 		if (existingRuntime) {
 			activeRuntimeId = id;
@@ -2930,6 +2963,9 @@ export function createNotificationsExtension(
 			idleSeq: 0,
 			pendingInteractive,
 			brokerRegistrationActive: false,
+			hostStopped: false,
+			serverStopped: false,
+			brokerRegistrationReleased: false,
 			disposeAnswerSource: () => {},
 			disposeFileSink: () => {},
 			disposeGateListener: () => {},
@@ -2980,7 +3016,7 @@ export function createNotificationsExtension(
 		};
 		const cleanupAbandonedStartup = async (): Promise<void> => {
 			try {
-				server.stop();
+				await server.stopAndWait();
 			} catch {}
 			try {
 				await host.stop();

package/src/sdk/bus/native-runtime-compatibility.ts

@@ -1,4 +1,4 @@
-const REQUIRED_WORKFLOW_ARBITRATION_METHODS = ["registerArbitratedAsk", "retireIfUnclaimed"] as const;
+const REQUIRED_WORKFLOW_ARBITRATION_METHODS = ["registerArbitratedAsk", "retireIfUnclaimed", "stopAndWait"] as const;
 
 export class NativeRuntimeCompatibilityError extends Error {
 	readonly code = "native_runtime_incompatible";

package/src/sdk/bus/telegram-daemon.ts

@@ -941,23 +941,96 @@ type PairedChatPrivacy = "private" | "non-private" | "indeterminate";
 
 export type TelegramUpdateOutcome = "consumed" | "retry";
 
+export type TelegramPollResult =
+	| { kind: "success"; updateCount: number }
+	| { kind: "aborted" }
+	| { kind: "getUpdates_failed"; error: string }
+	| { kind: "api_failure"; errorCode?: number; description: string }
+	| { kind: "conflict"; description: string; backoffMs: number };
+
 export interface TelegramUpdatePollerOptions {
 	botApi: BotApi;
 	runtime: NotificationOperatorRuntime;
 	backoff: OperatorBackoffPolicy;
 	processUpdate: (update: unknown) => Promise<TelegramUpdateOutcome>;
+	health?: TelegramPollHealth;
+}
+
+type TelegramPollHealthStatus = "healthy" | "getUpdates_failed" | "api_failure" | "conflict";
+
+export class TelegramPollHealth {
+	#status: TelegramPollHealthStatus = "healthy";
+	#suppressedCount = 0;
+
+	record(result: TelegramPollResult): void {
+		if (result.kind === "aborted") return;
+		if (result.kind === "success") {
+			if (this.#status !== "healthy") {
+				logger.info("notifications daemon: Telegram getUpdates recovered", {
+					from: this.#status,
+					suppressedCount: this.#suppressedCount,
+					updateCount: result.updateCount,
+				});
+			}
+			this.#status = "healthy";
+			this.#suppressedCount = 0;
+			return;
+		}
+
+		const previousStatus = this.#status;
+		if (previousStatus === result.kind) {
+			this.#suppressedCount += 1;
+			return;
+		}
+
+		const suppressedCount = this.#suppressedCount;
+		this.#status = result.kind;
+		this.#suppressedCount = 0;
+		if (result.kind === "conflict") {
+			logger.error("notifications daemon: Telegram getUpdates 409 conflict", {
+				description: result.description,
+				backoffMs: result.backoffMs,
+				previousStatus,
+				suppressedCount,
+			});
+			return;
+		}
+		if (result.kind === "api_failure") {
+			logger.error("notifications daemon: Telegram getUpdates API failed", {
+				errorCode: result.errorCode,
+				description: result.description,
+				previousStatus,
+				suppressedCount,
+			});
+			return;
+		}
+
+		logger.error("notifications daemon: getUpdates failed", {
+			error: result.error,
+			previousStatus,
+			suppressedCount,
+		});
+	}
 }
 
 /** Owns getUpdates offset, conflict backoff, and per-update error isolation. */
 export class TelegramUpdatePoller {
 	#offset = 0;
 	#opts: TelegramUpdatePollerOptions;
+	#health: TelegramPollHealth;
 
 	constructor(opts: TelegramUpdatePollerOptions) {
 		this.#opts = opts;
+		this.#health = opts.health ?? new TelegramPollHealth();
 	}
 
 	async pollOnce(signal?: AbortSignal): Promise<number> {
+		const result = await this.pollOnceResult(signal);
+		this.#health.record(result);
+		return result.kind === "success" ? result.updateCount : 0;
+	}
+
+	async pollOnceResult(signal?: AbortSignal): Promise<TelegramPollResult> {
 		let body: {
 			ok?: boolean;
 			error_code?: number;
@@ -972,24 +1045,37 @@ export class TelegramUpdatePoller {
 			)) as typeof body;
 		} catch (err) {
 			// A cooperative stop aborts the in-flight long poll; treat as a clean wake.
-			if (isAbortError(err)) return 0;
+			if (isAbortError(err)) return { kind: "aborted" };
 			// A transient Telegram API failure must never crash the daemon.
-			logger.error("notifications daemon: getUpdates failed", { error: sanitizeDiagnostic(String(err)) });
 			await this.#opts.runtime.sleep(POLL_BACKOFF_MS, signal);
-			return 0;
+			return { kind: "getUpdates_failed", error: sanitizeDiagnostic(String(err)) };
 		}
 		// Telegram allows only one active getUpdates poller per bot. A 409 means
 		// another poller is live; back off boundedly instead of hot-looping.
 		if (body && body.ok === false && (body.error_code === 409 || /409|conflict/i.test(body.description ?? ""))) {
 			const backoffMs = this.#opts.backoff.next();
-			logger.error(
-				`notifications daemon: Telegram getUpdates 409 conflict (${body.description ?? "no description"}); backing off ${backoffMs}ms`,
-			);
 			await this.#opts.runtime.sleep(backoffMs, signal);
-			return 0;
+			return { kind: "conflict", description: sanitizeDiagnostic(body.description ?? "no description"), backoffMs };
+		}
+		if (body?.ok !== true || !Array.isArray(body.result)) {
+			await this.#opts.runtime.sleep(POLL_BACKOFF_MS, signal);
+			return {
+				kind: "api_failure",
+				errorCode: typeof body?.error_code === "number" ? body.error_code : undefined,
+				description: sanitizeDiagnostic(body?.description ?? "Malformed getUpdates response"),
+			};
 		}
 		this.#opts.backoff.reset();
-		for (const update of body.result ?? []) {
+		let malformedSeen = false;
+		for (const update of body.result) {
+			// A single malformed update_id must not wedge the poller. Skip the
+			// bad entry (surfaced below as an api_failure health signal) while
+			// still processing valid updates and advancing the offset past them,
+			// so one poisoned item cannot stall an otherwise-valid stream.
+			if (!Number.isSafeInteger(update?.update_id)) {
+				malformedSeen = true;
+				continue;
+			}
 			try {
 				const outcome = await this.#opts.processUpdate(update);
 				if (outcome === "retry") {
@@ -998,11 +1084,17 @@ export class TelegramUpdatePoller {
 				}
 				this.#offset = update.update_id + 1;
 			} catch (err) {
-				logger.error("notifications daemon: handleTelegramUpdate failed", { error: String(err) });
+				logger.error("notifications daemon: handleTelegramUpdate failed", {
+					error: sanitizeDiagnostic(String(err)),
+				});
 				this.#offset = update.update_id + 1;
 			}
 		}
-		return body.result?.length ?? 0;
+		if (malformedSeen) {
+			await this.#opts.runtime.sleep(POLL_BACKOFF_MS, signal);
+			return { kind: "api_failure", description: "Malformed getUpdates response" };
+		}
+		return { kind: "success", updateCount: body.result.length };
 	}
 }
 

package/src/session/agent-session.ts

@@ -57,6 +57,8 @@ import {
 	generateHandoff,
 	IMAGE_TOKEN_ESTIMATE,
 	prepareCompaction,
+	type RemoteCompactionFallbackHealthEvent,
+	type RemoteCompactionFallbackHealthHooks,
 	type SummaryOptions,
 	shouldCompact,
 } from "@gajae-code/agent-core/compaction";
@@ -641,6 +643,40 @@ interface TemporaryProviderSessionScopeRecord {
 	providerSessionState: Map<string, ProviderSessionState>;
 }
 
+class RemoteCompactionFallbackHealth implements RemoteCompactionFallbackHealthHooks {
+	#status: "healthy" | "fallback" = "healthy";
+	#suppressedCount = 0;
+
+	recordRemoteCompactionFallback(event: RemoteCompactionFallbackHealthEvent): void {
+		if (event.kind === "success") {
+			if (this.#status === "fallback") {
+				logger.info("OpenAI remote compaction recovered", {
+					model: event.model,
+					provider: event.provider,
+					suppressedCount: this.#suppressedCount,
+				});
+			}
+			this.#status = "healthy";
+			this.#suppressedCount = 0;
+			return;
+		}
+
+		if (this.#status === "fallback") {
+			this.#suppressedCount += 1;
+			return;
+		}
+
+		this.#status = "fallback";
+		this.#suppressedCount = 0;
+		logger.warn("OpenAI remote compaction failed, falling back to local summarization", {
+			error: event.error,
+			model: event.model,
+			provider: event.provider,
+			suppressedCount: 0,
+		});
+	}
+}
+
 /** Result from cycleRoleModels() */
 export interface RoleModelCycleResult {
 	model: Model;
@@ -1419,6 +1455,7 @@ export class AgentSession {
 	#providerCacheSessionId: string | undefined;
 	#isDisposed = false;
 	#disposePromise: Promise<void> | undefined;
+	#newSessionTransition: Promise<boolean> | undefined;
 	// Extension system
 	#extensionRunner: ExtensionRunner | undefined = undefined;
 
@@ -1544,6 +1581,7 @@ export class AgentSession {
 		}
 	>();
 
+	#remoteCompactionFallbackHealth = new RemoteCompactionFallbackHealth();
 	#streamingEditPrecheckedToolCallIds = new Set<string>();
 
 	#streamingEditFileCache = new StreamingEditFileCache();
@@ -7621,7 +7659,20 @@ export class AgentSession {
 	 * @param options - Optional initial messages and parent session path
 	 * @returns true if completed, false if cancelled by hook
 	 */
-	async newSession(options?: NewSessionOptions): Promise<boolean> {
+	newSession(options?: NewSessionOptions): Promise<boolean> {
+		if (this.#newSessionTransition) return this.#newSessionTransition;
+
+		const transition = this.#runNewSessionTransition(options);
+		this.#newSessionTransition = transition;
+		void transition
+			.finally(() => {
+				if (this.#newSessionTransition === transition) this.#newSessionTransition = undefined;
+			})
+			.catch(() => {});
+		return transition;
+	}
+
+	async #runNewSessionTransition(options?: NewSessionOptions): Promise<boolean> {
 		const previousSessionFile = this.sessionFile;
 		const previousWorkflowGateSessionId = this.sessionId;
 		const nextDiscoverySessionToolNames = this.#mcpDiscoveryEnabled
@@ -7643,32 +7694,132 @@ export class AgentSession {
 			}
 		}
 
-		this.#disconnectFromAgent();
-		await this.abort();
-		this.#cancelOwnAsyncJobs();
-		this.#closeAllProviderSessions("new session");
-		this.#rebindProviderSessionState(new Map());
-		this.agent.reset();
-		if (options?.drop && previousSessionFile) {
+		const manager = AsyncJobManager.instance();
+		const ownerId = this.#agentId;
+		const lease = manager && ownerId ? manager.beginOwnerSubagentShutdown(ownerId) : undefined;
+		if (manager && ownerId && !lease) {
+			this.emitNotice(
+				"error",
+				"Cannot start a new session while owned subagent cleanup is already in progress.",
+				"new-session-subagent-cleanup",
+			);
+			return false;
+		}
+
+		if (!lease) {
+			this.#disconnectFromAgent();
+			await this.abort();
+			if (this.isCompacting) {
+				this.abortCompaction();
+				while (this.isCompacting) {
+					await Bun.sleep(10);
+				}
+			}
+			this.#cancelOwnAsyncJobs();
+			this.#closeAllProviderSessions("new session");
+			this.#rebindProviderSessionState(new Map());
+			this.agent.reset();
+			if (!options?.drop) await this.sessionManager.flush();
+			await this.sessionManager.newSession(options);
+			this.setTodoPhases([]);
+			this.#syncAgentSessionId();
+			this.#bindWorkflowGateEmitter(previousWorkflowGateSessionId);
+			this.#rekeyHindsightMemoryForCurrentSessionId();
+			this.#resetHindsightConversationTrackingIfHindsight();
+			this.#steeringMessages = [];
+			this.#followUpMessages = [];
+			this.#pendingNextTurnMessages = [];
+			this.#scheduledHiddenNextTurnGeneration = undefined;
+			await this.#initializeNewSessionState(nextDiscoverySessionToolNames, previousSessionFile);
+			if (options?.drop && previousSessionFile) {
+				try {
+					await this.sessionManager.dropSession(previousSessionFile);
+				} catch (err) {
+					logger.error("Failed to delete session during /drop", { err });
+				}
+			}
+			return true;
+		}
+
+		if (!manager) throw new Error("Owner subagent shutdown manager became unavailable.");
+		if (!ownerId) throw new Error("Owner subagent shutdown owner became unavailable.");
+		const previousSessionIdentity = this.sessionManager.getSessionId();
+		try {
 			try {
-				await this.sessionManager.dropSession(previousSessionFile);
-			} catch (err) {
-				logger.error("Failed to delete session during /drop", { err });
+				manager.runOwnerProducerCleanupsStrict({ ownerId });
+				await this.abort();
+				if (this.isCompacting) {
+					this.abortCompaction();
+					while (this.isCompacting) {
+						await Bun.sleep(10);
+					}
+				}
+				const proof = await manager.cancelAndProveOwnerSubagents(lease);
+				if (!proof.confirmed) {
+					this.emitNotice(
+						"error",
+						"Unable to confirm owned subagent cleanup; session was not replaced. Wait for or inspect remaining subagents, then retry /new.",
+						"new-session-subagent-cleanup",
+					);
+					manager.finishOwnerSubagentShutdown(lease, "release");
+					return false;
+				}
+			} catch {
+				this.emitNotice(
+					"error",
+					"Unable to confirm owned subagent cleanup; session was not replaced. Wait for or inspect remaining subagents, then retry /new.",
+					"new-session-subagent-cleanup",
+				);
+				manager.finishOwnerSubagentShutdown(lease, "release");
+				return false;
 			}
-		} else {
-			await this.sessionManager.flush();
+
+			if (!(await manager.waitForOwnerInFlightDeliveries(ownerId))) {
+				throw new Error("Owned async deliveries did not settle before session replacement.");
+			}
+			if (!options?.drop) await this.sessionManager.flush();
+
+			if (!(await manager.cancelAndSettleOwnerJobs(ownerId))) {
+				throw new Error("Owned async jobs did not settle before session replacement.");
+			}
+
+			this.#disconnectFromAgent();
+			this.#closeAllProviderSessions("new session");
+			this.#rebindProviderSessionState(new Map());
+			this.agent.reset();
+			await this.sessionManager.newSession(options);
+			this.setTodoPhases([]);
+			this.#syncAgentSessionId();
+			this.#bindWorkflowGateEmitter(previousWorkflowGateSessionId);
+			this.#rekeyHindsightMemoryForCurrentSessionId();
+			this.#resetHindsightConversationTrackingIfHindsight();
+			this.#steeringMessages = [];
+			this.#followUpMessages = [];
+			this.#pendingNextTurnMessages = [];
+			this.#scheduledHiddenNextTurnGeneration = undefined;
+			await this.#initializeNewSessionState(nextDiscoverySessionToolNames, previousSessionFile);
+			if (options?.drop && previousSessionFile) {
+				try {
+					await this.sessionManager.dropSession(previousSessionFile);
+				} catch (err) {
+					logger.error("Failed to delete session during /drop", { err });
+				}
+			}
+			manager.finishOwnerSubagentShutdown(lease, "commit");
+			return true;
+		} catch (error) {
+			manager.finishOwnerSubagentShutdown(
+				lease,
+				this.sessionManager.getSessionId() !== previousSessionIdentity ? "commit" : "release",
+			);
+			throw error;
 		}
-		await this.sessionManager.newSession(options);
-		this.setTodoPhases([]);
-		this.#syncAgentSessionId();
-		this.#bindWorkflowGateEmitter(previousWorkflowGateSessionId);
-		this.#rekeyHindsightMemoryForCurrentSessionId();
-		this.#resetHindsightConversationTrackingIfHindsight();
-		this.#steeringMessages = [];
-		this.#followUpMessages = [];
-		this.#pendingNextTurnMessages = [];
-		this.#scheduledHiddenNextTurnGeneration = undefined;
+	}
 
+	async #initializeNewSessionState(
+		nextDiscoverySessionToolNames: string[] | undefined,
+		previousSessionFile: string | undefined,
+	): Promise<void> {
 		const inheritedThinkingLevel = resolveThinkingLevelForModel(this.model, this.#getInheritedThinkingLevel());
 		this.#thinkingLevel = inheritedThinkingLevel;
 		this.agent.setThinkingLevel(toReasoningEffort(inheritedThinkingLevel));
@@ -7687,15 +7838,11 @@ export class AgentSession {
 			this.sessionFile,
 			this.#getConfiguredDefaultSelectedMCPToolNames(),
 		);
-
 		this.#todoReminderCount = 0;
 		this.#planReferenceSent = false;
 		this.#planReferencePath = "local://PLAN.md";
 		this.#reconnectToAgent();
-
 		this.#resetIrcRosterDeliveryState();
-
-		// Emit session_switch event with reason "new" to hooks
 		if (this.#extensionRunner) {
 			await this.#extensionRunner.emit({
 				type: "session_switch",
@@ -7703,8 +7850,6 @@ export class AgentSession {
 				previousSessionFile,
 			});
 		}
-
-		return true;
 	}
 
 	/**
@@ -10291,11 +10436,13 @@ export class AgentSession {
 		sessionId: string | undefined;
 		providerSessionState: Map<string, ProviderSessionState>;
 		preferWebsockets: boolean | undefined;
+		remoteCompactionFallbackHealth: RemoteCompactionFallbackHealthHooks;
 	} {
 		return {
 			sessionId: this.agent.providerSessionId ?? this.agent.sessionId,
 			providerSessionState: this.#providerSessionState,
 			preferWebsockets: this.agent.preferWebsockets,
+			remoteCompactionFallbackHealth: this.#remoteCompactionFallbackHealth,
 		};
 	}
 

package/src/task/index.ts

@@ -19,7 +19,7 @@ import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae
 import type { Model, Usage } from "@gajae-code/ai";
 import { $env, prompt, Snowflake } from "@gajae-code/utils";
 import type { ToolSession } from "..";
-import { AsyncJobManager } from "../async";
+import { AsyncJobManager, OwnerSubagentShutdownError, type ResumeRunner } from "../async";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import type { Theme } from "../modes/theme/theme";
 import planModeSubagentPrompt from "../prompts/system/plan-mode-subagent.md" with { type: "text" };
@@ -547,8 +547,9 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		};
 
 		const maxConcurrency = this.session.settings.get("task.maxConcurrency");
+		let resumeRunner: ResumeRunner | undefined;
 		if (typeof manager.setResumeRunner === "function") {
-			manager.setResumeRunner((_subagentId, message, resumeDescriptor) => {
+			resumeRunner = (_subagentId, message, resumeDescriptor) => {
 				const descriptor = isTaskResumeDescriptor(resumeDescriptor?.data) ? resumeDescriptor.data : undefined;
 				if (!descriptor) return undefined;
 				const forkSeeds = descriptor.forkContextSeed
@@ -590,7 +591,8 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						},
 					},
 				);
-			});
+			};
+			manager.setResumeRunner(resumeRunner);
 		}
 		const semaphore = new Semaphore(maxConcurrency);
 		const buildForkContextSeedForTask = async (task: TaskItem): Promise<ForkContextSeed | undefined> => {
@@ -770,18 +772,21 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				);
 				startedJobs.push({ jobId, taskId: taskItem.id });
 				if (typeof manager.registerResumeDescriptor === "function") {
-					manager.registerResumeDescriptor({
-						subagentId: uniqueId,
-						ownerId: this.session.getAgentId?.() ?? undefined,
-						data: {
-							toolCallId: _toolCallId,
-							params,
-							task: { ...taskItem, id: uniqueId },
-							sessionFile: subtaskSessionFile,
-							forkContextSeed: frozenForkSeed,
-							agentSource: fallbackAgentSource,
-						} satisfies TaskResumeDescriptor,
-					});
+					manager.registerResumeDescriptor(
+						{
+							subagentId: uniqueId,
+							ownerId: this.session.getAgentId?.() ?? undefined,
+							data: {
+								toolCallId: _toolCallId,
+								params,
+								task: { ...taskItem, id: uniqueId },
+								sessionFile: subtaskSessionFile,
+								forkContextSeed: frozenForkSeed,
+								agentSource: fallbackAgentSource,
+							} satisfies TaskResumeDescriptor,
+						},
+						resumeRunner,
+					);
 				}
 				if (typeof manager.registerSubagentRecord === "function") {
 					manager.registerSubagentRecord({
@@ -795,7 +800,12 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 					});
 				}
 			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
+				const message =
+					error instanceof OwnerSubagentShutdownError
+						? error.message
+						: error instanceof Error
+							? error.message
+							: String(error);
 				failedSchedules.push(`${taskItem.id}: ${message}`);
 				const progress = progressByTaskId.get(taskItem.id);
 				if (progress) {