@gajae-code/coding-agent 0.18.0 → 0.18.5

package/src/sdk/client/client.ts

@@ -14,6 +14,8 @@ export type SdkErrorCode =
 export class SdkClientError extends Error {
 	readonly code: SdkErrorCode;
 	readonly details: unknown;
+	/** True only when the SDK client itself reported a transport failure, never for a server error frame. */
+	readonly transport: boolean;
 	/**
 	 * Reconnect-cycle diagnostics, separate from `details` because `details` is an
 	 * established contract: callers read the terminating transport error straight off
@@ -22,19 +24,35 @@ export class SdkClientError extends Error {
 	 * break every such reader, so the new attribution rides alongside it instead.
 	 */
 	readonly reconnect?: SdkReconnectExhaustedDetails;
-	constructor(code: SdkErrorCode, message: string, details?: unknown, reconnect?: SdkReconnectExhaustedDetails) {
+	constructor(
+		code: SdkErrorCode,
+		message: string,
+		details?: unknown,
+		reconnect?: SdkReconnectExhaustedDetails,
+		options: { transport?: boolean } = {},
+	) {
 		super(message);
 		this.name = "SdkClientError";
 		this.code = code;
 		this.details = details;
+		this.transport = options.transport === true;
 		if (reconnect) this.reconnect = reconnect;
 	}
 }
 
+function transportError(
+	code: SdkErrorCode,
+	message: string,
+	details?: unknown,
+	reconnect?: SdkReconnectExhaustedDetails,
+): SdkClientError {
+	return new SdkClientError(code, message, details, reconnect, { transport: true });
+}
+
 /** A prepared transport operation failed before any wire handoff. */
 export class SdkPreparedDispatchError extends SdkClientError {
 	constructor(error: SdkClientError) {
-		super(error.code, error.message, error.details, error.reconnect);
+		super(error.code, error.message, error.details, error.reconnect, { transport: error.transport });
 		this.name = "SdkPreparedDispatchError";
 	}
 }
@@ -350,18 +368,18 @@ export class SdkClient {
 	}
 
 	send(frame: SdkFrame): void {
-		if (this.#closed) throw new SdkClientError("connection_closed", "SDK client closed");
+		if (this.#closed) throw transportError("connection_closed", "SDK client closed");
 		this.#throwIfDeadlineElapsed();
 		const current = this.#currentSocketRecord ?? this.#opening?.candidate;
 		const authoritative =
 			this.#isActive(current ?? null) ||
 			(!!current && current.phase === "hello" && this.#isCandidate(current.cycle, current));
 		if (!current || !authoritative || current.socket.readyState !== WebSocket.OPEN)
-			throw new SdkClientError("connection_closed", "SDK WebSocket is not connected");
+			throw transportError("connection_closed", "SDK WebSocket is not connected");
 		try {
 			current.socket.send(JSON.stringify(frame));
 		} catch (error) {
-			throw new SdkClientError("unavailable", "SDK WebSocket send failed", error);
+			throw transportError("unavailable", "SDK WebSocket send failed", error);
 		}
 	}
 
@@ -383,19 +401,19 @@ export class SdkClient {
 			if (cycle.backoffTimer) clearTimeout(cycle.backoffTimer);
 			if (cycle.candidate) {
 				transports.add(cycle.candidate);
-				this.#retire(cycle.candidate, new SdkClientError("connection_closed", "SDK client closed"), false);
+				this.#retire(cycle.candidate, transportError("connection_closed", "SDK client closed"), false);
 			}
-			cycle.rejectBackoff?.(new SdkClientError("connection_closed", "SDK client closed"));
+			cycle.rejectBackoff?.(transportError("connection_closed", "SDK client closed"));
 			cycle.rejectBackoff = undefined;
 			if (this.#opening === cycle) this.#opening = null;
 		}
 		const current = this.#currentSocketRecord;
 		if (current) {
 			transports.add(current);
-			this.#retire(current, new SdkClientError("connection_closed", "SDK client closed"), false, true);
+			this.#retire(current, transportError("connection_closed", "SDK client closed"), false, true);
 		}
 		for (const [id, pending] of this.#pending)
-			this.#settlePending(id, pending, new SdkClientError("connection_closed", "SDK client closed"), true);
+			this.#settlePending(id, pending, transportError("connection_closed", "SDK client closed"), true);
 		try {
 			await Promise.all([...transports].map(incarnation => this.#closeTransport(incarnation)));
 		} finally {
@@ -469,7 +487,7 @@ export class SdkClient {
 
 	async #request(frame: Frame, options: SdkRequestOptions, onResponse?: () => void): Promise<unknown> {
 		if (this.#closed) {
-			const error = new SdkClientError("connection_closed", "SDK client closed");
+			const error = transportError("connection_closed", "SDK client closed");
 			throw options.connectedOnly ? new SdkPreparedDispatchError(error) : error;
 		}
 		try {
@@ -526,7 +544,7 @@ export class SdkClient {
 					this.#settlePending(
 						id,
 						pending,
-						new SdkClientError("timeout", `SDK request timed out after ${timeoutMs}ms`, {
+						transportError("timeout", `SDK request timed out after ${timeoutMs}ms`, {
 							requestId: id,
 							requestSent: pending.sent,
 						} satisfies SdkRequestTimeoutDetails),
@@ -537,7 +555,7 @@ export class SdkClient {
 		};
 		this.#pending.set(id, pending);
 		if (!this.#isActive(incarnation) || incarnation.socket.readyState !== WebSocket.OPEN) {
-			const error = new SdkClientError("unavailable", "SDK WebSocket is not connected");
+			const error = transportError("unavailable", "SDK WebSocket is not connected");
 			this.#settlePending(id, pending, options.connectedOnly ? new SdkPreparedDispatchError(error) : error);
 			return await deferred.promise;
 		}
@@ -591,9 +609,9 @@ export class SdkClient {
 					pending,
 					options.connectedOnly
 						? new SdkPreparedDispatchError(
-								new SdkClientError("connection_closed", "SDK client closed during dispatch"),
+								transportError("connection_closed", "SDK client closed during dispatch"),
 							)
-						: new SdkClientError("connection_closed", "SDK client closed during dispatch"),
+						: transportError("connection_closed", "SDK client closed during dispatch"),
 				);
 			return await deferred.promise;
 		}
@@ -603,7 +621,7 @@ export class SdkClient {
 			return await deferred.promise;
 		}
 		if (incarnation.socket.readyState !== WebSocket.OPEN) {
-			const error = new SdkClientError("unavailable", "SDK WebSocket is not connected");
+			const error = transportError("unavailable", "SDK WebSocket is not connected");
 			this.#settlePending(id, pending, options.connectedOnly ? new SdkPreparedDispatchError(error) : error);
 			return await deferred.promise;
 		}
@@ -638,7 +656,7 @@ export class SdkClient {
 				const sendError =
 					error instanceof SdkClientError
 						? error
-						: new SdkClientError("unavailable", "SDK WebSocket send failed", error);
+						: transportError("unavailable", "SDK WebSocket send failed", error);
 				this.#settlePending(
 					id,
 					pending,
@@ -665,7 +683,7 @@ export class SdkClient {
 	}
 
 	#deadlineError(reconnect?: SdkReconnectExhaustedDetails): SdkClientError {
-		return new SdkClientError("timeout", "SDK client deadline elapsed.", undefined, reconnect);
+		return transportError("timeout", "SDK client deadline elapsed.", undefined, reconnect);
 	}
 
 	#remainingTimeout(limit = this.#timeoutMs): number {
@@ -682,7 +700,7 @@ export class SdkClient {
 		const current = this.#currentSocketRecord;
 		if (current && this.#isActive(current) && current.socket.readyState === WebSocket.OPEN) return current;
 		if (current)
-			this.#retire(current, new SdkClientError("connection_closed", "SDK WebSocket connection closed"), true, true);
+			this.#retire(current, transportError("connection_closed", "SDK WebSocket connection closed"), true, true);
 
 		let cycle = this.#opening;
 		if (!cycle) {
@@ -696,7 +714,7 @@ export class SdkClient {
 	#requireConnectedIncarnation(): Incarnation {
 		const current = this.#currentSocketRecord;
 		if (!current || !this.#isActive(current) || current.socket.readyState !== WebSocket.OPEN)
-			throw new SdkClientError("connection_closed", "SDK WebSocket disconnected before prepared dispatch.");
+			throw transportError("connection_closed", "SDK WebSocket disconnected before prepared dispatch.");
 		return current;
 	}
 
@@ -711,7 +729,7 @@ export class SdkClient {
 			reason,
 		});
 		const cancelled = (): SdkClientError =>
-			new SdkClientError("connection_closed", "SDK client closed", lastError, diagnostics("cancelled"));
+			transportError("connection_closed", "SDK client closed", lastError, diagnostics("cancelled"));
 		/**
 		 * A deadline and retry budget measure different failure axes. One-shot clients
 		 * need the deadline to fast-fail their operation, while long-lived ACP sessions
@@ -730,10 +748,10 @@ export class SdkClient {
 			try {
 				const incarnation = await this.#open(cycle);
 				if (!this.#isActive(incarnation) && (!this.#isOpening(cycle) || cycle.candidate !== incarnation))
-					throw new SdkClientError("connection_closed", "SDK WebSocket is not connected");
+					throw transportError("connection_closed", "SDK WebSocket is not connected");
 				await this.#waitForHello(incarnation);
 				if (this.#isActive(incarnation)) return incarnation;
-				throw new SdkClientError("connection_closed", "SDK WebSocket is not connected");
+				throw transportError("connection_closed", "SDK WebSocket is not connected");
 			} catch (error) {
 				lastError = error;
 				if (!this.#isOpening(cycle)) throw cancelled();
@@ -743,7 +761,7 @@ export class SdkClient {
 						candidate,
 						error instanceof SdkClientError
 							? error
-							: new SdkClientError("unavailable", "SDK WebSocket connection failed", error),
+							: transportError("unavailable", "SDK WebSocket connection failed", error),
 						true,
 					);
 				if (attempt < this.#reconnectAttempts) {
@@ -780,7 +798,7 @@ export class SdkClient {
 		}
 		cycle.phase = "complete";
 		if (this.#opening === cycle) this.#opening = null;
-		const error = new SdkClientError(
+		const error = transportError(
 			"reconnect_exhausted",
 			"SDK WebSocket reconnect attempts exhausted",
 			lastError,
@@ -891,7 +909,7 @@ export class SdkClient {
 		if (incarnation.failure) return Promise.reject(incarnation.failure);
 		if (this.#isActive(incarnation)) return Promise.resolve();
 		if (!this.#isCandidate(incarnation.cycle, incarnation) || incarnation.phase !== "hello")
-			return Promise.reject(new SdkClientError("connection_closed", "SDK WebSocket is not connected"));
+			return Promise.reject(transportError("connection_closed", "SDK WebSocket is not connected"));
 		const deferred = Promise.withResolvers<void>();
 		incarnation.resolveHello = deferred.resolve;
 		incarnation.rejectHello = deferred.reject;
@@ -903,7 +921,7 @@ export class SdkClient {
 		const error =
 			this.#deadline !== undefined && Date.now() >= this.#deadline
 				? this.#deadlineError()
-				: new SdkClientError("timeout", `SDK WebSocket connection timed out after ${timeoutMs}ms`);
+				: transportError("timeout", `SDK WebSocket connection timed out after ${timeoutMs}ms`);
 		incarnation.rejectOpen?.(error);
 		this.#retire(incarnation, error, true);
 	}
@@ -911,20 +929,20 @@ export class SdkClient {
 	#onSocketFailure(incarnation: Incarnation, event?: Event): void {
 		if (!this.#isCandidate(incarnation.cycle, incarnation) && !this.#isActive(incarnation)) return;
 		const detail = event as (Event & { error?: unknown; message?: unknown }) | undefined;
+		let failureMessage = "SDK WebSocket connection closed";
+		if (detail?.error instanceof Error) failureMessage = detail.error.message;
+		else if (typeof detail?.message === "string") failureMessage = detail.message;
 		const error =
-			detail?.error instanceof Error
+			detail?.error instanceof SdkClientError && detail.error.transport
 				? detail.error
-				: new SdkClientError(
-						"connection_closed",
-						typeof detail?.message === "string" ? detail.message : "SDK WebSocket connection closed",
-					);
+				: transportError("connection_closed", failureMessage);
 		if (incarnation.phase === "opening") incarnation.rejectOpen?.(error);
 		if (incarnation.phase === "hello") incarnation.rejectHello?.(error);
 		this.#retire(
 			incarnation,
 			error instanceof SdkClientError
 				? error
-				: new SdkClientError("unavailable", "SDK WebSocket connection failed", error),
+				: transportError("unavailable", "SDK WebSocket connection failed", error),
 			true,
 			true,
 		);
@@ -1115,7 +1133,7 @@ export class SdkClient {
 		const onClose = (): void => resolve();
 		socket.addEventListener("close", onClose, { once: true });
 		const timer = setTimeout(
-			() => reject(new SdkClientError("timeout", `SDK WebSocket close timed out after ${timeoutMs}ms`)),
+			() => reject(transportError("timeout", `SDK WebSocket close timed out after ${timeoutMs}ms`)),
 			timeoutMs,
 		);
 		timer.unref?.();
@@ -1124,9 +1142,9 @@ export class SdkClient {
 			if (Number(socket.readyState) === WebSocket.CLOSED) resolve();
 			await promise;
 		} catch (error) {
-			if (error instanceof SdkClientError) throw error;
+			if (error instanceof SdkClientError && error.transport) throw error;
 			if (Number(socket.readyState) !== WebSocket.CLOSED)
-				throw new SdkClientError("connection_closed", "SDK WebSocket close failed", error);
+				throw transportError("connection_closed", "SDK WebSocket close failed", error);
 		} finally {
 			clearTimeout(timer);
 			socket.removeEventListener("close", onClose);

package/src/sdk/host/session-runtime.ts

@@ -50,6 +50,12 @@ import { parseThinkingLevel } from "../../thinking";
 import { readEndpointFile } from "../broker/endpoint-authority";
 import { ensureBroker } from "../broker/ensure";
 import { processIncarnation } from "../broker/process-incarnation";
+import { RecoveryBackoffTracker } from "../broker/recovery-backoff";
+import {
+	captureRuntimeImageIdentity,
+	isSdkInternalRuntimeImageReplaced,
+	sdkInternalRuntimeImage,
+} from "../broker/runtime";
 import {
 	type MasterRoleAttestationV2,
 	resolveSessionLocator,
@@ -716,6 +722,15 @@ export interface CreateSdkSessionRuntimeOptions {
 	onFailureDiagnosticKeyCountForTests?: (count: number) => void;
 	/** Test-only observation after a resolved invocation completion is reconciled. */
 	onInvocationCompletionReconciledForTests?: (kind: InvocationKind, correlation: InvocationCorrelation) => void;
+	/** Test hook: provides a function to inject a controlled clock for broker recovery backoff assertions. */
+	setRecoveryBackoffClockForTest?: (inject: (clock: { now(): number }) => void) => void;
+	/** Test hook: inject mock runtime image identity and replacement detection for broker recovery tests. */
+	setRuntimeImageIdentityForTest?: (
+		register: (
+			captureFn: () => Awaited<ReturnType<typeof captureRuntimeImageIdentity>> | undefined,
+			isReplacedFn: () => Promise<boolean>,
+		) => void,
+	) => void;
 }
 
 function unavailable(operation: string): () => never {
@@ -7013,6 +7028,43 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		let brokerRegistered = false;
 		let brokerRegistrationInFlight: Promise<void> | undefined;
 		let brokerRecoveryStopped = false;
+		let brokerRecoveryRestartRequired = false;
+		const brokerRecoveryBackoff = new RecoveryBackoffTracker();
+		if (options.setRecoveryBackoffClockForTest) {
+			options.setRecoveryBackoffClockForTest((clock: { now(): number }) =>
+				brokerRecoveryBackoff.setClockForTest(clock),
+			);
+		}
+		// Capture runtime image identity at startup to detect replacements
+		let startupRuntimeImageIdentity: Awaited<ReturnType<typeof captureRuntimeImageIdentity>> | undefined;
+		let captureStartupRuntimeImageForTest:
+			| (() => Awaited<ReturnType<typeof captureRuntimeImageIdentity>> | undefined)
+			| undefined;
+		let isRuntimeImageReplacedForTest: (() => Promise<boolean>) | undefined;
+		if (options.setRuntimeImageIdentityForTest) {
+			options.setRuntimeImageIdentityForTest(
+				(
+					captureFn: () => Awaited<ReturnType<typeof captureRuntimeImageIdentity>> | undefined,
+					isReplacedFn: () => Promise<boolean>,
+				) => {
+					captureStartupRuntimeImageForTest = captureFn;
+					isRuntimeImageReplacedForTest = isReplacedFn;
+				},
+			);
+		}
+		const captureStartupRuntimeImage = async (): Promise<void> => {
+			if (options.setRuntimeImageIdentityForTest) {
+				// Test mode: use injected identity
+				startupRuntimeImageIdentity = captureStartupRuntimeImageForTest?.();
+			} else {
+				// Production mode: capture real runtime image
+				const runtimeImage = sdkInternalRuntimeImage();
+				if (runtimeImage) {
+					startupRuntimeImageIdentity = await captureRuntimeImageIdentity(runtimeImage);
+				}
+			}
+		};
+		const startupImageCapture = captureStartupRuntimeImage();
 		const registerBroker = async (): Promise<void> => {
 			if (brokerRegistered) return;
 			if (brokerRegistrationInFlight !== undefined) {
@@ -7143,17 +7195,58 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		let brokerRecoveryTimer: NodeJS.Timeout | undefined;
 		let brokerRecoveryInFlight: Promise<void> | undefined;
 		const runBrokerRecovery = async (): Promise<void> => {
-			if (brokerRecoveryStopped || brokerRecoveryInFlight !== undefined) return;
+			if (brokerRecoveryStopped || brokerRecoveryInFlight !== undefined || brokerRecoveryRestartRequired) return;
+			// Checked synchronously so an interval tick cannot start an attempt the backoff forbids.
+			if (!brokerRecoveryBackoff.canAttemptRecovery(options.agentDir)) return;
+
+			// The single-flight slot is claimed before the first await: the interval does not wait
+			// for prior callbacks, so a slow runtime-image probe must not let a second tick through
+			// to ensure the broker and record the same failure twice.
 			const recovery = (async (): Promise<void> => {
+				// A replaced runtime image cannot launch a broker; restarting the session is the only fix.
+				const imageReplaced = await (isRuntimeImageReplacedForTest
+					? isRuntimeImageReplacedForTest()
+					: isSdkInternalRuntimeImageReplaced(startupRuntimeImageIdentity).catch(() => false));
+				if (imageReplaced) {
+					brokerRecoveryRestartRequired = true;
+					stopBrokerRecovery();
+					logger.warn("sdk broker recovery requires session restart", {
+						reason: "runtime_image_replaced",
+					});
+					return;
+				}
 				if (brokerRecoveryStopped) return;
 				if (brokerRegistered) await (options.ensureBrokerImpl ?? ensureBroker)({ agentDir: options.agentDir });
-				else await registerBroker();
+				else {
+					// Optional registration logs and resolves on failure; recovery must still count it
+					// as a failed attempt so the backoff holds instead of resetting every tick.
+					await registerBroker();
+					if (!brokerRegistered && !brokerRecoveryStopped)
+						throw Object.assign(new Error("SDK broker registration did not complete."), {
+							code: "registration_incomplete",
+						});
+				}
 			})();
 			brokerRecoveryInFlight = recovery;
 			try {
 				await recovery;
+				if (brokerRecoveryRestartRequired || brokerRecoveryStopped) return;
+				brokerRecoveryBackoff.recordSuccess(options.agentDir);
 			} catch (error) {
-				logger.warn("sdk broker recovery unavailable", { code: brokerDiagnosticCode(error) });
+				const shouldContinue = brokerRecoveryBackoff.recordFailure(options.agentDir);
+				if (!shouldContinue) {
+					// Max recovery attempts reached; mark that restart is required.
+					brokerRecoveryRestartRequired = true;
+					stopBrokerRecovery();
+					logger.warn("sdk broker recovery max attempts exceeded", {
+						code: brokerDiagnosticCode(error),
+					});
+				} else {
+					logger.warn("sdk broker recovery unavailable", {
+						code: brokerDiagnosticCode(error),
+						backoffWaitMs: brokerRecoveryBackoff.getBackoffWaitMs(options.agentDir),
+					});
+				}
 			} finally {
 				if (brokerRecoveryInFlight === recovery) brokerRecoveryInFlight = undefined;
 			}
@@ -7210,6 +7303,9 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		try {
 			publishedEndpointUrl = (await runtime.start()).url;
 			await registerBroker();
+			// Await the startup runtime image capture before arming recovery.
+			// This ensures replacement detection works correctly on the first recovery check.
+			await startupImageCapture;
 			if (!brokerRecoveryStopped) startBrokerRecovery();
 		} catch (error) {
 			active = undefined;

package/src/sdk/prompt-watchdog.ts

@@ -97,8 +97,13 @@ export class PromptActivity {
 	#awaitingModel = false;
 
 	/** Folds one inbound frame's lifecycle event into the in-flight tool and model state. */
-	observe(eventType: string | undefined, toolCallId: string | undefined, messageRole: string | undefined): void {
-		this.#observeInference(eventType, messageRole);
+	observe(
+		eventType: string | undefined,
+		toolCallId: string | undefined,
+		messageRole: string | undefined,
+		messageHasToolCall = false,
+	): void {
+		this.#observeInference(eventType, messageRole, messageHasToolCall);
 		if (toolCallId === undefined) return;
 		if (eventType === "tool_execution_start" || eventType === "tool_execution_update") this.#running.add(toolCallId);
 		else if (eventType === "tool_execution_end") this.#running.delete(toolCallId);
@@ -110,7 +115,11 @@ export class PromptActivity {
 	 * re-invocation that carries a tool result back — until the first frame of that
 	 * response proves the model answered.
 	 */
-	#observeInference(eventType: string | undefined, messageRole: string | undefined): void {
+	#observeInference(
+		eventType: string | undefined,
+		messageRole: string | undefined,
+		messageHasToolCall: boolean,
+	): void {
 		if (eventType === "agent_start" || eventType === "tool_execution_end") {
 			this.#awaitingModel = true;
 			return;
@@ -132,7 +141,11 @@ export class PromptActivity {
 		// Providers that do not stream emit no `message_update`, so the assistant message
 		// itself is the first proof. `message_start`/`message_end` also carry the user and
 		// tool-result messages the host echoes back, which prove nothing about the model.
-		if ((eventType === "message_start" || eventType === "message_end") && messageRole === "assistant")
+		if (
+			(eventType === "message_start" || eventType === "message_end") &&
+			messageRole === "assistant" &&
+			!messageHasToolCall
+		)
 			this.#awaitingModel = false;
 	}
 

package/src/sdk/protocol/operation-inventory.generated.json

@@ -5506,6 +5506,17 @@
 			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
 		]
 	},
+	{
+		"sourceId": "agent_session:getAutoCompactionThresholdTokens",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal compaction-threshold accessor feeding the /context breakdown; exposed through context.get, not an independent SDK operation",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:getContextUsage",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",

package/src/session/agent-session.ts

@@ -58,23 +58,28 @@ import {
 	CompactionCancelledError,
 	type CompactionPreparation,
 	type CompactionResult,
+	type CompactionSettings,
 	calculateContextTokens,
 	calculatePromptTokens,
 	collectEntriesForBranchSummary,
 	compact,
 	type EmergencyCompactionSample,
+	effectiveReserveTokens,
 	emergencyCompactionReason,
 	estimateMessageTokensHeuristic,
 	estimateTextTokensHeuristic,
 	generateBranchSummary,
 	generateHandoff,
 	IMAGE_TOKEN_ESTIMATE,
+	isDefaultAutoThresholdCeilingApplied,
 	prepareCompaction,
 	type RemoteCompactionFallbackHealthEvent,
 	type RemoteCompactionFallbackHealthHooks,
+	resolveThresholdTokens,
 	type SummaryOptions,
 	shouldCompact,
 } from "@gajae-code/agent-core/compaction";
+
 import {
 	commitToolOutputPrune,
 	createPrunedNotice,
@@ -19954,10 +19959,15 @@ export class AgentSession {
 				const compactionSettings = this.settings.getGroup("compaction");
 				const pathEntries = this.#withoutEphemeralCustomMessageEntries(this.sessionManager.getBranch());
 
-				const preparation = prepareCompaction(pathEntries, compactionSettings, {
-					contextWindow: this.model.contextWindow,
-					tokenCorrectionRatio: this.#computeCompactionTokenCorrectionRatio(),
-				});
+				const preparation = prepareCompaction(
+					pathEntries,
+					this.#compactionSettingsForContextPromotion(compactionSettings),
+					{
+						contextWindow: this.model.contextWindow,
+						tokenCorrectionRatio: this.#computeCompactionTokenCorrectionRatio(),
+					},
+				);
+
 				if (!preparation) {
 					// Check why we can't compact
 					const lastEntry = pathEntries[pathEntries.length - 1];
@@ -20974,12 +20984,12 @@ export class AgentSession {
 		}
 	}
 
-	#recordAdaptiveCompactionCall<T extends { adaptive?: { enabled: boolean; turnWindow: number } }>(
+	#recordAdaptiveCompactionCall(
 		contextTokens: number,
-		settings: T,
+		settings: CompactionSettings,
 		assistantMessage: AssistantMessage,
-	): T {
-		if (!settings.adaptive?.enabled) return settings;
+	): CompactionSettings {
+		if (!settings.adaptive?.enabled) return this.#compactionSettingsWithAdaptiveState(settings);
 		this.#adaptiveCompactionTracker.setWindowMs(settings.adaptive.turnWindow * 60_000);
 		const messageKey = this.#adaptiveCompactionMessageKey(assistantMessage);
 		if (this.#adaptiveCompactionRecordedMessageKey === messageKey) {
@@ -20994,11 +21004,31 @@ export class AgentSession {
 		return `${message.provider}\u0000${message.model}\u0000${message.timestamp}\u0000${message.usage?.totalTokens ?? ""}`;
 	}
 
-	#compactionSettingsWithAdaptiveState<T extends { adaptive?: { enabled: boolean } }>(settings: T): T {
-		if (!settings.adaptive?.enabled) return settings;
+	#compactionSettingsWithAdaptiveState(settings: CompactionSettings): CompactionSettings {
+		const adaptiveSettings = settings.adaptive?.enabled
+			? { ...settings, adaptiveState: this.#adaptiveCompactionTracker.decisionState() }
+			: settings;
+		return this.#compactionSettingsForContextPromotion(adaptiveSettings);
+	}
+
+	#compactionSettingsForContextPromotion(settings: CompactionSettings): CompactionSettings {
+		const contextWindow = this.model?.contextWindow ?? 0;
+		const isContextPromoted = this.#temporaryProviderSessionScopes.some(
+			scope => scope.token.reason === "context-promotion",
+		);
+		if (
+			!isContextPromoted ||
+			!isDefaultAutoThresholdCeilingApplied(contextWindow, settings)
+		) {
+			return settings;
+		}
+
+		// Context promotion is opt-in and exists to use the larger model's headroom.
+		// Keep the reserve-based default on the promoted model instead of immediately
+		// compacting at the same 300K ceiling that triggered promotion.
 		return {
 			...settings,
-			adaptiveState: this.#adaptiveCompactionTracker.decisionState(),
+			thresholdTokens: contextWindow - effectiveReserveTokens(contextWindow, settings),
 		};
 	}
 
@@ -22304,10 +22334,15 @@ export class AgentSession {
 			// correction only when it SHRINKS the keep window (ratio >= 1), never when
 			// it would grow it, so recovery cannot re-overflow the provider window.
 			const overflowRatio = this.#computeCompactionTokenCorrectionRatio();
-			const preparation = prepareCompaction(pathEntries, compactionSettings, {
-				contextWindow: this.model?.contextWindow,
-				tokenCorrectionRatio: overflowRatio !== undefined ? Math.max(1, overflowRatio) : undefined,
-			});
+			const preparation = prepareCompaction(
+				pathEntries,
+				this.#compactionSettingsForContextPromotion(compactionSettings),
+				{
+					contextWindow: this.model?.contextWindow,
+					tokenCorrectionRatio: overflowRatio !== undefined ? Math.max(1, overflowRatio) : undefined,
+				},
+			);
+
 			if (autoCompactionSignal.aborted) return await emitAborted();
 
 			if (!preparation) {
@@ -24390,8 +24425,15 @@ export class AgentSession {
 		if (!managedFallback && assistantMessageHasVisibleOrToolContent(message)) {
 			return false;
 		}
+		const canReplayUnexpectedSocketClose =
+			classification === "transient" &&
+			isUnexpectedSocketCloseMessage(message.errorMessage ?? "") &&
+			!hasBareDefaultRetryDisqualifyingFacts(message) &&
+			this.#hasCleanRetryReplaySafety;
 		// Bare defaults retain their narrow watchdog and provider capacity-overload
-		// admissions. A first-event timeout adds the typed, content-free,
+		// admissions. A content-free unexpected socket close is replay-safe when
+		// the attempt has no conflicting facts and the retry scope is clean. A
+		// first-event timeout adds the typed, content-free,
 		// current-clean-scope requirement above; other transient watchdogs preserve
 		// legacy behavior. A provider overload is admitted only from that provider's
 		// own typed overload code on a content-free attempt carrying no conflicting
@@ -24400,12 +24442,16 @@ export class AgentSession {
 		if (!managedFallback && !legacyRetryConfigured && !canReplayRotatedCredential && !canReplayEmptyResponse) {
 			if (
 				(!canReplayProviderOverload &&
+					!canReplayUnexpectedSocketClose &&
 					!this.#isTypedFirstEventTimeout(message) &&
 					!messageOnlyWatchdogTimeout &&
 					(hasBareDefaultRetryDisqualifyingFacts(message) ||
 						(classification !== "transient" && classification !== "first_event_timeout") ||
 						!BARE_DEFAULT_WATCHDOG_ERROR.test(message.errorMessage ?? ""))) ||
-				(!firstEventTimeout && !messageOnlyWatchdogTimeout && !this.#hasCleanRetryReplaySafety)
+				(!firstEventTimeout &&
+					!messageOnlyWatchdogTimeout &&
+					!canReplayUnexpectedSocketClose &&
+					!this.#hasCleanRetryReplaySafety)
 			) {
 				return false;
 			}
@@ -24414,6 +24460,7 @@ export class AgentSession {
 			!managedFallback &&
 			classification === "transient" &&
 			!canReplayProviderOverload &&
+			!canReplayUnexpectedSocketClose &&
 			!this.#isIdleStreamStallErrorMessage(message.errorMessage ?? "");
 
 		const failedSelector = managedFallback ? controller.currentSelector() : undefined;
@@ -27184,6 +27231,21 @@ export class AgentSession {
 		};
 	}
 
+	/** Current auto-compaction threshold, including active model-promotion policy. */
+	getAutoCompactionThresholdTokens(contextTokens?: number): number {
+		const model = this.model;
+		if (!model) return 0;
+		const contextWindow = model.contextWindow ?? 0;
+		if (contextWindow <= 0) return 0;
+		const settings = this.settings.getGroup("compaction") as CompactionSettings;
+		return resolveThresholdTokens(
+			contextWindow,
+			this.#compactionSettingsWithAdaptiveState(settings),
+			0,
+			contextTokens,
+		);
+	}
+
 	/**
 	 * Get current context usage statistics.
 	 * Uses the last assistant message's usage data when available,