@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/lsp/index.ts

@@ -6,6 +6,7 @@ import type { BunFile } from "bun";
 import { type Theme, theme } from "../modes/theme/theme";
 import lspDescription from "../prompts/tools/lsp.md" with { type: "text" };
 import type { ToolSession } from "../tools";
+import { FileWriteNotPublishedError, writeFileAtomically } from "../tools/atomic-file-write";
 import { formatPathRelativeToCwd, resolveToCwd } from "../tools/path-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "../tools/tool-errors";
 import { clampTimeout } from "../tools/tool-timeouts";
@@ -745,11 +746,11 @@ export async function writethroughNoop(
 	_batch?: LspWritethroughBatchRequest,
 	_getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined,
 ): Promise<FileDiagnosticsResult | undefined> {
-	if (file) {
+	if (file !== undefined) {
 		await file.write(content);
-	} else {
-		await Bun.write(dst, content);
+		return undefined;
 	}
+	await writeFileAtomically(dst, content);
 	return undefined;
 }
 
@@ -921,7 +922,25 @@ async function runLspWritethrough(
 	const { lspServers, customLinterServers } = splitServers(servers);
 
 	let finalContent = content;
-	const writeContent = async (value: string) => (file ? file.write(value) : Bun.write(dst, value));
+	let publishedContent = false;
+	const writeContent = async (value: string) => {
+		try {
+			if (file !== undefined) await file.write(value);
+			else await writeFileAtomically(dst, value);
+			publishedContent = true;
+		} catch (error) {
+			if (error instanceof FileWriteNotPublishedError) {
+				if (publishedContent) {
+					throw new FileWriteNotPublishedError(dst, error.cause, {
+						destUnchanged: false,
+						publicationState: "published",
+					});
+				}
+				throw error;
+			}
+			throw error;
+		}
+	};
 	const getWritePromise = once(() => writeContent(finalContent));
 	const useCustomFormatter = enableFormat && customLinterServers.length > 0;
 
@@ -986,7 +1005,8 @@ async function runLspWritethrough(
 				});
 			}
 		});
-	} catch {
+	} catch (error) {
+		if (error instanceof FileWriteNotPublishedError) throw error;
 		if (timedOut) {
 			formatter = undefined;
 			diagnostics = undefined;

package/src/main.ts

@@ -173,6 +173,8 @@ const ACP_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"task.maxRecursionDepth",
 	"task.disabledAgents",
 	"task.agentModelOverrides",
+	"task.autorouting.enabled",
+	"task.autorouting.tiers",
 	// Memory subsystems are off-by-default for embedded (ACP) hosts; embedders
 	// that want memory should opt in explicitly through their own settings layer.
 	"memory.backend",
@@ -1234,16 +1236,6 @@ async function buildSessionOptions(
 	return { options };
 }
 
-/**
- * Research-mode (RLM) preset hook. Lets `gjc rlm` augment the session options
- * (system prompt, restricted toolset, custom python tool) and assert the tool
- * boundary once the session's tool registry is fully assembled.
- */
-export interface RlmPreset {
-	applyOptions: (options: CreateAgentSessionOptions, settings: Settings) => void;
-	onSessionCreated?: (session: AgentSession) => void | Promise<void>;
-}
-
 type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promise<void>;
 
 export interface RunRootCommandDependencies {
@@ -1252,7 +1244,6 @@ export interface RunRootCommandDependencies {
 	discoverAuthStorage?: typeof discoverAuthStorage;
 	runAcpMode?: (options?: { agentDir?: string }) => Promise<void>;
 	settings?: Settings;
-	rlmPreset?: RlmPreset;
 	suppressProcessExit?: boolean;
 	startupUpdate?: { check: () => Promise<string | undefined> };
 	initTheme?: typeof initTheme;
@@ -1685,8 +1676,6 @@ export async function runRootCommand(
 	const deferMemoryBackendStartup = hasRootStartupProfile && !(parsedArgs.authBootstrap === true && isInteractive);
 	sessionOptions.deferMemoryBackendStartup = deferMemoryBackendStartup;
 
-	// Research-mode (RLM) preset: augment session options before session creation.
-	deps.rlmPreset?.applyOptions(sessionOptions, settingsInstance);
 	const acpStartupOptions = mode === "acp" ? resolveAcpStartupOptions(parsedArgs, sessionOptions) : undefined;
 
 	// Handle CLI credential selection and --api-key as runtime overrides (not persisted).
@@ -1822,20 +1811,6 @@ export async function runRootCommand(
 		// Herdr integration: report gjc lifecycle state when running in a Herdr pane.
 		installHerdrReporter(listener => session.subscribe(listener));
 
-		// Research-mode (RLM) preset: hard tool-boundary assertion after the registry is assembled.
-		if (deps.rlmPreset?.onSessionCreated) {
-			try {
-				await deps.rlmPreset.onSessionCreated(session);
-			} catch (error) {
-				try {
-					await session.dispose();
-				} catch {
-					logger.warn("Failed to dispose session after RLM post-create error");
-				}
-				throw error;
-			}
-		}
-
 		let startDeferredModelProfiles: DeferredModelProfileStartup | undefined;
 		if (!(parsedArgs.authBootstrap === true && isInteractive)) {
 			const profileArgs = {

package/src/modes/acp/acp-agent.ts

@@ -165,6 +165,8 @@ type SessionRecord = {
 	/** Bounded set of correlations already settled; they stay closed for publication. */
 	settledPromptCorrelations: PromptCorrelation[];
 	authFailure?: string;
+	/** Replayable startup notice captured before ACP bootstrap; emitted once after the session id is known. */
+	routingInactiveNotice?: string;
 	activePrompt?: PromptWaiter;
 	/** Set by `session/cancel` so an in-flight prompt settles as `cancelled`, never as an error. */
 	cancelRequested?: boolean;
@@ -830,23 +832,43 @@ export async function collectActiveProviderIds(
 const MAX_MODEL_CATALOG_PAGES = 100;
 
 /**
- * Collect every page of `models.list/current` (Q10) into one catalog so the
- * active-provider filter never drops models that only appear on later pages.
- * The SDK pages Q10 at a fixed byte target (256 KiB), which a fully
- * configured catalog can exceed. Returns the same
- * `{ result: { page: { items } } }` envelope `pageItems` consumes.
+ * Validate one `models.list/current` response and return its page. The SDK pages
+ * Q10 at a fixed byte target (256 KiB), which a fully configured catalog can
+ * exceed, so every page shape failure fails closed instead of silently dropping
+ * models the active-provider filter would need.
  */
-export async function collectModelCatalog(adapter: Pick<AcpSdkAdapter, "query">): Promise<unknown> {
+interface ModelCatalogPage {
+	items: unknown[];
+	complete?: unknown;
+	continuationCursor?: unknown;
+}
+
+function requireCatalogPage(response: unknown): ModelCatalogPage {
+	const page = queryPage(response);
+	if (!page) throw new AcpSdkAdapterError("protocol_error", "models.list/current returned no page.");
+	if (!Array.isArray(page.items))
+		throw new AcpSdkAdapterError("protocol_error", "models.list/current returned a malformed page.");
+	return page as ModelCatalogPage;
+}
+
+async function collectModelCatalogContinuation(
+	adapter: Pick<AcpSdkAdapter, "query">,
+	firstPage: ModelCatalogPage,
+): Promise<unknown[]> {
+	if (firstPage.complete === true) return [];
+	if (typeof firstPage.continuationCursor !== "string")
+		throw new AcpSdkAdapterError(
+			"protocol_error",
+			"models.list/current page is incomplete without a continuation cursor.",
+		);
+	let cursor: string | undefined = firstPage.continuationCursor;
 	const items: unknown[] = [];
-	let cursor: string | undefined;
-	for (let pageCount = 0; pageCount < MAX_MODEL_CATALOG_PAGES; pageCount++) {
+	// Page 1 was already consumed by the caller, so the remaining budget is one shorter.
+	for (let pageCount = 1; pageCount < MAX_MODEL_CATALOG_PAGES; pageCount++) {
 		const response = await adapter.query("models.list/current", {}, cursor);
-		const page = queryPage(response);
-		if (!page) throw new AcpSdkAdapterError("protocol_error", "models.list/current returned no page.");
-		if (!Array.isArray(page.items))
-			throw new AcpSdkAdapterError("protocol_error", "models.list/current returned a malformed page.");
+		const page = requireCatalogPage(response);
 		items.push(...page.items);
-		if (page.complete === true) return { result: { page: { items } } };
+		if (page.complete === true) return items;
 		if (typeof page.continuationCursor !== "string")
 			throw new AcpSdkAdapterError(
 				"protocol_error",
@@ -857,6 +879,32 @@ export async function collectModelCatalog(adapter: Pick<AcpSdkAdapter, "query">)
 	throw new AcpSdkAdapterError("protocol_error", "models.list/current exceeded the page budget.");
 }
 
+/**
+ * Collect the model catalog (Q10) and the active-provider set (Q29) under one
+ * credential ordering. Assembling the first Q10 page is what finalizes host-side
+ * credential state — expired or invalid OAuth credentials are refreshed or
+ * disabled while that snapshot is built, and continuation pages replay the
+ * frozen revision without further side effects — so Q29 must not start until
+ * page 1 has resolved. Starting both together would let Q29 snapshot pre-refresh
+ * credential state and mix catalog rows and provider availability from different
+ * credential states. After page 1, the provider walk overlaps the remaining
+ * catalog pages instead of adding its latency after them.
+ */
+export async function collectModelCatalogAndActiveProviders(
+	adapter: Pick<AcpSdkAdapter, "query">,
+): Promise<{ modelCatalog: unknown; activeProviders: ReadonlySet<string> | undefined }> {
+	const firstResponse = await adapter.query("models.list/current");
+	const firstPage = requireCatalogPage(firstResponse);
+	const [remaining, activeProviders] = await Promise.all([
+		collectModelCatalogContinuation(adapter, firstPage),
+		collectActiveProviderIds(adapter),
+	]);
+	return {
+		modelCatalog: { result: { page: { items: [...firstPage.items, ...remaining] } } },
+		activeProviders,
+	};
+}
+
 const THINKING_CONFIG_OPTIONS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"].map(value => ({
 	value,
 	name: value,
@@ -1133,13 +1181,23 @@ export class AcpAgent implements Agent {
 	readonly #attaching = new Map<string, PendingAttachment>();
 	readonly #resolvingExisting = new Map<string, PendingAttachment>();
 	readonly #knownSessionCwds = new Map<string, string>();
+	/**
+	 * Sessions this connection actually owns, i.e. ones it created or attached to.
+	 * Destructive lifecycle control gates on this set, never on `#knownSessionCwds`.
+	 *
+	 * `session/list` legitimately populates `#knownSessionCwds` for every session a
+	 * shared broker reports, so treating that map as ownership let a second ACP
+	 * connection enumerate another connection's sessions and then close or delete
+	 * them. Knowing a session's cwd is not authority over its lifecycle.
+	 */
+	readonly #ownedSessionIds = new Set<string>();
 	readonly #knownSessionMcpServers = new Map<string, SessionLifecycleMcpServer[]>();
 	readonly #knownSessionMetadata = new Map<string, { title?: string; updatedAt?: string }>();
 	readonly #pendingDeleteLocators = new Map<string, { cwd: string; path: string }>();
 	readonly #pendingCloseIdempotencyKeys = new Map<string, string>();
 	readonly #sessionEpochs = new Map<string, number>();
 	readonly #tearingDown = new Map<string, number>();
-	readonly #closing = new Map<string, Promise<CloseSessionResponse>>();
+	readonly #lifecycleOperations = new Map<string, Promise<void>>();
 	#clientCapabilities: ClientCapabilities | undefined;
 	#broker: Promise<BrokerConnection> | undefined;
 	readonly #startupOptions: AcpStartupOptions | undefined;
@@ -1276,6 +1334,7 @@ export class AcpAgent implements Agent {
 		);
 		const id = sessionId(result);
 		this.#knownSessionCwds.set(id, params.cwd);
+		this.#ownedSessionIds.add(id);
 		this.#knownSessionMcpServers.set(id, mcpServers);
 		try {
 			await this.#attach(id, params.cwd, undefined, result);
@@ -1331,6 +1390,7 @@ export class AcpAgent implements Agent {
 		);
 		const id = sessionId(result);
 		this.#knownSessionCwds.set(id, params.cwd);
+		this.#ownedSessionIds.add(id);
 		this.#knownSessionMcpServers.set(id, mcpServers);
 		try {
 			await this.#attach(id, params.cwd, undefined, result);
@@ -1381,70 +1441,83 @@ export class AcpAgent implements Agent {
 
 	closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse> {
 		const record = this.#sessions.get(params.sessionId);
-		const cwd = record?.cwd ?? this.#knownSessionCwds.get(params.sessionId);
 		// ACP close has no cwd. Only connection-owned sessions may reach broker lifecycle control.
+		if (!this.#ownedSessionIds.has(params.sessionId)) return Promise.resolve({});
+		const cwd = record?.cwd ?? this.#knownSessionCwds.get(params.sessionId);
 		if (!cwd) return Promise.resolve({});
-		const existing = this.#closing.get(params.sessionId);
-		if (existing) return existing;
-		const deferred = Promise.withResolvers<CloseSessionResponse>();
-		this.#closing.set(params.sessionId, deferred.promise);
-		void this.#closeOwnedSession(params.sessionId).then(deferred.resolve, deferred.reject);
-		const cleanup = deferred.promise.finally(() => {
-			if (this.#closing.get(params.sessionId) === deferred.promise) this.#closing.delete(params.sessionId);
+		return this.#enqueueLifecycleOperation(params.sessionId, async () => {
+			// A preceding delete in the same lifecycle chain already completed the terminal operation.
+			if (!this.#ownedSessionIds.has(params.sessionId) && !this.#sessions.has(params.sessionId)) return {};
+			return this.#closeOwnedSession(params.sessionId);
 		});
-		void cleanup.catch(() => undefined);
-		return deferred.promise;
 	}
 
 	async deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse> {
 		const record = this.#sessions.get(params.sessionId);
 		const pendingLocator = this.#pendingDeleteLocators.get(params.sessionId);
+		// Capture authority before joining the lifecycle chain: an admitted delete must
+		// remain authorized when a preceding close retires connection ownership.
+		if (!this.#ownedSessionIds.has(params.sessionId) && pendingLocator === undefined) return {};
 		const cwd = record?.cwd ?? this.#knownSessionCwds.get(params.sessionId) ?? pendingLocator?.cwd;
-		// ACP's delete request has no cwd. Unknown ids remain the protocol no-op,
-		// while the broker can reconstruct an authenticated pending locator from its durable ledger.
-		if (!cwd) {
-			await (await this.#brokerAdapter()).global(
-				"session.delete",
-				{ sessionId: params.sessionId },
-				this.#lifecycleIdempotencyKey(params.sessionId, "session.delete"),
-			);
-			return {};
-		}
-		this.#beginTeardown(params.sessionId);
-		try {
-			// A retained delete locator proves the prior attempt already completed
-			// connection/process teardown and reached durable artifact cleanup. Re-closing
-			// that terminal session can only replace the authoritative cleanup_pending
-			// result with unrelated close uncertainty, so retries resume deletion directly.
-			await this.#teardownSession(params.sessionId, "deleted", pendingLocator === undefined || record !== undefined);
-			let saved = pendingLocator?.cwd === cwd ? pendingLocator.path : undefined;
-			if (!saved) {
-				try {
-					saved = await this.#resolveSavedSession(params.sessionId, cwd);
-				} catch (error) {
-					if (error instanceof AcpSdkAdapterError && error.code === "not_found") {
-						this.#knownSessionCwds.delete(params.sessionId);
-						this.#knownSessionMcpServers.delete(params.sessionId);
-						this.#knownSessionMetadata.delete(params.sessionId);
-						return {};
+		return this.#enqueueLifecycleOperation(params.sessionId, async () => {
+			// ACP's delete request has no cwd. Unknown ids remain the protocol no-op,
+			// while the broker can reconstruct an authenticated pending locator from its durable ledger.
+			if (!cwd) {
+				await (await this.#brokerAdapter()).global(
+					"session.delete",
+					{ sessionId: params.sessionId },
+					this.#lifecycleIdempotencyKey(params.sessionId, "session.delete"),
+				);
+				return {};
+			}
+			this.#beginTeardown(params.sessionId);
+			try {
+				// A preceding close in the lifecycle chain already completed process teardown.
+				// Continue with durable deletion instead of re-closing an already-dead process.
+				const teardownCompleted =
+					!this.#ownedSessionIds.has(params.sessionId) && !this.#sessions.has(params.sessionId);
+				if (!teardownCompleted) {
+					// A retained delete locator proves the prior attempt already completed
+					// connection/process teardown and reached durable artifact cleanup. Re-closing
+					// that terminal session can only replace the authoritative cleanup_pending
+					// result with unrelated close uncertainty, so retries resume deletion directly.
+					await this.#teardownSession(
+						params.sessionId,
+						"deleted",
+						pendingLocator === undefined || record !== undefined,
+					);
+				}
+				let saved = pendingLocator?.cwd === cwd ? pendingLocator.path : undefined;
+				if (!saved) {
+					try {
+						saved = await this.#resolveSavedSession(params.sessionId, cwd);
+					} catch (error) {
+						if (error instanceof AcpSdkAdapterError && error.code === "not_found") {
+							this.#knownSessionCwds.delete(params.sessionId);
+							this.#ownedSessionIds.delete(params.sessionId);
+							this.#knownSessionMcpServers.delete(params.sessionId);
+							this.#knownSessionMetadata.delete(params.sessionId);
+							return {};
+						}
+						throw error;
 					}
-					throw error;
 				}
+				this.#pendingDeleteLocators.set(params.sessionId, { cwd, path: saved });
+				await (await this.#brokerAdapter()).global(
+					"session.delete",
+					{ sessionId: params.sessionId, sessionPath: saved, cwd, target: { path: cwd } },
+					this.#lifecycleIdempotencyKey(params.sessionId, "session.delete"),
+				);
+				this.#knownSessionCwds.delete(params.sessionId);
+				this.#ownedSessionIds.delete(params.sessionId);
+				this.#knownSessionMcpServers.delete(params.sessionId);
+				this.#knownSessionMetadata.delete(params.sessionId);
+				this.#pendingDeleteLocators.delete(params.sessionId);
+				return {};
+			} finally {
+				this.#finishTeardown(params.sessionId);
 			}
-			this.#pendingDeleteLocators.set(params.sessionId, { cwd, path: saved });
-			await (await this.#brokerAdapter()).global(
-				"session.delete",
-				{ sessionId: params.sessionId, sessionPath: saved, cwd, target: { path: cwd } },
-				this.#lifecycleIdempotencyKey(params.sessionId, "session.delete"),
-			);
-			this.#knownSessionCwds.delete(params.sessionId);
-			this.#knownSessionMcpServers.delete(params.sessionId);
-			this.#knownSessionMetadata.delete(params.sessionId);
-			this.#pendingDeleteLocators.delete(params.sessionId);
-			return {};
-		} finally {
-			this.#finishTeardown(params.sessionId);
-		}
+		});
 	}
 
 	async setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse> {
@@ -1911,6 +1984,20 @@ export class AcpAgent implements Agent {
 		else this.#tearingDown.delete(id);
 	}
 
+	#enqueueLifecycleOperation<T>(id: string, operation: () => Promise<T>): Promise<T> {
+		const previous = this.#lifecycleOperations.get(id) ?? Promise.resolve();
+		const result = previous.catch(() => undefined).then(operation);
+		const settled = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		this.#lifecycleOperations.set(id, settled);
+		void settled.finally(() => {
+			if (this.#lifecycleOperations.get(id) === settled) this.#lifecycleOperations.delete(id);
+		});
+		return result;
+	}
+
 	#lifecycleIdempotencyKey(id: string, operation: "session.close" | "session.delete"): string {
 		return `acp:${operation}:${id}`;
 	}
@@ -2135,6 +2222,7 @@ export class AcpAgent implements Agent {
 			this.#pendingRouterAdapters.delete(id);
 			this.#pendingRouterFrames.delete(id);
 			this.#knownSessionCwds.set(id, cwd);
+			this.#ownedSessionIds.add(id);
 			await applyAcpPermissionMode(adapter, this.#clientCapabilities);
 			this.#assertSessionEpoch(id, epoch);
 			// A successful attachment establishes a new live-owner epoch. Any locator
@@ -2151,6 +2239,7 @@ export class AcpAgent implements Agent {
 					await this.#teardownSession(id, "attachment failed", false);
 				} finally {
 					this.#knownSessionCwds.delete(id);
+					this.#ownedSessionIds.delete(id);
 					this.#knownSessionMcpServers.delete(id);
 				}
 			} else if (adapter) {
@@ -2216,6 +2305,7 @@ export class AcpAgent implements Agent {
 	async #discardNewSession(id: string): Promise<void> {
 		await this.#teardownSession(id, "discarded", true);
 		this.#knownSessionCwds.delete(id);
+		this.#ownedSessionIds.delete(id);
 		this.#knownSessionMcpServers.delete(id);
 		this.#knownSessionMetadata.delete(id);
 	}
@@ -2229,6 +2319,7 @@ export class AcpAgent implements Agent {
 			if (attaching) await Promise.allSettled([attaching.task]);
 			await this.#teardownSession(id, "closed", true);
 			this.#knownSessionCwds.delete(id);
+			this.#ownedSessionIds.delete(id);
 			this.#knownSessionMcpServers.delete(id);
 			this.#knownSessionMetadata.delete(id);
 			return {};
@@ -2244,7 +2335,7 @@ export class AcpAgent implements Agent {
 	 */
 	async #teardownSession(id: string, reason: string, closeRemote: boolean): Promise<void> {
 		const record = this.#sessions.get(id);
-		const ownershipBound = record !== undefined || this.#knownSessionCwds.has(id);
+		const ownershipBound = record !== undefined || this.#ownedSessionIds.has(id);
 		this.#beginTeardown(id);
 		try {
 			this.#advanceSessionEpoch(id);
@@ -2537,6 +2628,10 @@ export class AcpAgent implements Agent {
 		if (!received) return;
 		const { event, wirePayload } = received;
 		const isTerminal = event.type === "agent_end" || event.type === "agent_failed";
+		if (event.type === "notice" && event.source === "autorouting" && typeof event.message === "string") {
+			record.routingInactiveNotice = event.message;
+			return;
+		}
 		const derivedCorrelation = sdkFrameCorrelation(frame, event);
 		const correlation = derivedCorrelation ?? {};
 		const activePrompt = record.activePrompt;
@@ -2848,15 +2943,26 @@ export class AcpAgent implements Agent {
 		const record = this.#sessions.get(id);
 		if (!record) throw new AcpSdkAdapterError("not_found", `Unknown session, not found: ${id}`);
 		const modelPreset = this.#startupOptions?.modelPreset;
-		const [config, modelCatalog] = await Promise.all([
+		const [config, sessionCatalog] = await Promise.all([
 			record.adapter.query("config.list/get"),
-			modelPreset === undefined ? collectModelCatalog(record.adapter) : record.adapter.query("models.profiles.list"),
+			modelPreset === undefined
+				? collectModelCatalogAndActiveProviders(record.adapter)
+				: record.adapter
+						.query("models.profiles.list")
+						.then((profiles): { modelCatalog: unknown; activeProviders: undefined } => ({
+							modelCatalog: profiles,
+							activeProviders: undefined,
+						})),
 		]);
-		// Resolve usable providers in parallel. Only an older session host that
-		// rejects `providers.list/active` with `operation_not_session_owned`
-		// falls back to the full catalog; operational failures fail closed so
-		// the active-provider contract is not silently widened.
-		const activeProviders = modelPreset === undefined ? await collectActiveProviderIds(record.adapter) : undefined;
+		// The active-provider walk overlaps the catalog inside the batch above, but
+		// only after the first models.list/current page has finalized host-side
+		// credential state, so catalog rows and provider availability never mix
+		// pre- and post-refresh credential snapshots. Only an older session host
+		// that rejects `providers.list/active` with `operation_not_session_owned`
+		// falls back to the full catalog; operational failures fail closed so the
+		// active-provider contract is not silently widened.
+		const modelCatalog = sessionCatalog.modelCatalog;
+		const activeProviders = sessionCatalog.activeProviders;
 		record.authFailure = undefined;
 		if (modelPreset !== undefined) {
 			const activePreset = configValues(config).get(MODEL_PRESET_CONFIG_KEY);
@@ -3341,6 +3447,24 @@ export class AcpAgent implements Agent {
 						record.adapter,
 					);
 				}
+				// Not consumed on publish: this mirrors authFailure's lifecycle, where a
+				// later load/resume legitimately re-announces the condition. Clearing here
+				// would also lose the warning outright if the publish below rejected, since
+				// the enclosing bootstrap task swallows failures.
+				if (record.routingInactiveNotice) {
+					const message = record.routingInactiveNotice;
+					await this.#publishSessionUpdate(
+						id,
+						{
+							sessionId: id,
+							update: {
+								sessionUpdate: "agent_thought_chunk",
+								content: { type: "text", text: `[warning:autorouting] ${message}\n` },
+							},
+						},
+						record.adapter,
+					);
+				}
 				await this.#publishSessionUpdate(
 					id,
 					{
@@ -3507,11 +3631,12 @@ export class AcpAgent implements Agent {
 		this.#attaching.clear();
 		this.#resolvingExisting.clear();
 		this.#knownSessionCwds.clear();
+		this.#ownedSessionIds.clear();
 		this.#knownSessionMcpServers.clear();
 		this.#knownSessionMetadata.clear();
 		this.#pendingDeleteLocators.clear();
 		this.#pendingCloseIdempotencyKeys.clear();
-		if (this.#closing.size === 0) this.#closing.clear();
+		if (this.#lifecycleOperations.size === 0) this.#lifecycleOperations.clear();
 		this.#tearingDown.clear();
 		if (this.#broker) {
 			const broker = this.#broker;