@gajae-code/coding-agent 0.15.5 → 0.16.0

package/src/session/session-manager.ts

@@ -7299,8 +7299,49 @@ export class SessionManager {
 	/** Serializes model, SDK, and ACP cwd transitions; dispose joins this tail. */
 	#cwdTransitionTail: Promise<void> = Promise.resolve();
 	#cwdTransitionOwner: symbol | undefined;
+	#cwdMoveAdmissionClosed = false;
 	#cwdReadLeaseOwner = Symbol("cwd-read-lease-owner");
 	#cwdGeneration = 0;
+	/**
+	 * Listeners invoked after every committed `moveTo`, for every move surface
+	 * (`move_session`, TUI `/move`, SDK/ACP `session.cwd.move`). They receive the previous
+	 * and new cwd and the previous session file, and run best-effort: a listener throw is
+	 * logged and never turns an already-durable move into a rejection.
+	 */
+	#afterMoveListeners = new Set<
+		(move: { previousCwd: string; newCwd: string; previousSessionFile: string | undefined }) => void | Promise<void>
+	>();
+	#beforeMoveListeners = new Set<
+		(move: {
+			previousCwd: string;
+			newCwd: string;
+			previousSessionFile: string | undefined;
+			newSessionFile: string | undefined;
+			previousCwdIdentity: { dev: bigint; ino: bigint };
+			newCwdIdentity: { dev: bigint; ino: bigint };
+		}) => void | Promise<void>
+	>();
+	#moveAbortListeners = new Set<
+		(move: {
+			previousCwd: string;
+			newCwd: string;
+			previousSessionFile: string | undefined;
+			newSessionFile: string | undefined;
+			previousCwdIdentity: { dev: bigint; ino: bigint };
+			newCwdIdentity: { dev: bigint; ino: bigint };
+			preserveRecoveryJournal?: boolean;
+		}) => void | Promise<void>
+	>();
+	#movePublicationListeners = new Set<
+		(move: {
+			previousCwd: string;
+			newCwd: string;
+			previousSessionFile: string | undefined;
+			newSessionFile: string | undefined;
+			previousCwdIdentity: { dev: bigint; ino: bigint };
+			newCwdIdentity: { dev: bigint; ino: bigint };
+		}) => void | Promise<void>
+	>();
 	/** Number of tool executions currently holding a shared read lease on `cwd`. */
 	#cwdReaderCount = 0;
 	/** Resolved when the last outstanding read lease is released. */
@@ -8385,13 +8426,13 @@ export class SessionManager {
 			this.#usageStatistics = commit.usageStatistics;
 			this.#flushed = true;
 			this.#ensuredOnDisk = true;
-			this.#managedPersistExpectedIdentity = this.#captureManagedPersistIdentity(sessionFile);
+			this.#managedPersistExpectedIdentity =
+				this.destination.kind === "managed" ? this.#captureManagedPersistIdentity(sessionFile) : undefined;
 			this.#lazyReopenSucceeded = true;
 			this.#lazyReopenFallbackReason = undefined;
 			initialized = true;
 			return true;
-		} catch (error) {
-			SessionManagerTestHooks.lastSidecarInitError = toError(error).message;
+		} catch {
 			return false;
 		} finally {
 			if (!initialized) {
@@ -8572,7 +8613,8 @@ export class SessionManager {
 				this.#lazyReopenFallbackReason = "bounded_first_open_descriptor_changed";
 				return false;
 			}
-			this.#managedPersistExpectedIdentity = this.#captureManagedPersistIdentity(sessionFile);
+			this.#managedPersistExpectedIdentity =
+				this.destination.kind === "managed" ? this.#captureManagedPersistIdentity(sessionFile) : undefined;
 			this.#sessionId = discovery.header.id;
 			this.#sessionName = discovery.header.title;
 			this.#titleSource = discovery.header.titleSource;
@@ -10727,10 +10769,139 @@ export class SessionManager {
 	async joinCwdTransition(): Promise<void> {
 		await this.#cwdTransitionTail;
 	}
+
+	async closeCwdMoveAdmission(): Promise<void> {
+		await this.runExclusiveCwdTransition(async () => {
+			this.#cwdMoveAdmissionClosed = true;
+		});
+	}
 	getCwdGeneration(): number {
 		return this.#cwdGeneration;
 	}
 
+	/**
+	 * Register a listener invoked after every committed `moveTo`. Returns an idempotent
+	 * unregister handle. Every move surface funnels through `moveTo`, so a single
+	 * registration covers `move_session`, `/move`, and SDK/ACP `session.cwd.move`.
+	 */
+	registerAfterMoveListener(
+		listener: (move: {
+			previousCwd: string;
+			newCwd: string;
+			previousSessionFile: string | undefined;
+		}) => void | Promise<void>,
+	): () => void {
+		this.#afterMoveListeners.add(listener);
+		return () => {
+			this.#afterMoveListeners.delete(listener);
+		};
+	}
+
+	registerBeforeMoveListener(
+		listener: (move: {
+			previousCwd: string;
+			newCwd: string;
+			previousSessionFile: string | undefined;
+			newSessionFile: string | undefined;
+			previousCwdIdentity: { dev: bigint; ino: bigint };
+			newCwdIdentity: { dev: bigint; ino: bigint };
+			preserveRecoveryJournal?: boolean;
+		}) => void | Promise<void>,
+	): () => void {
+		this.#beforeMoveListeners.add(listener);
+		return () => {
+			this.#beforeMoveListeners.delete(listener);
+		};
+	}
+
+	async #runBeforeMoveListeners(move: {
+		previousCwd: string;
+		newCwd: string;
+		previousSessionFile: string | undefined;
+		newSessionFile: string | undefined;
+		previousCwdIdentity: { dev: bigint; ino: bigint };
+		newCwdIdentity: { dev: bigint; ino: bigint };
+	}): Promise<void> {
+		for (const listener of [...this.#beforeMoveListeners]) await listener(move);
+	}
+
+	registerMovePublicationListener(
+		listener: (move: {
+			previousCwd: string;
+			newCwd: string;
+			previousSessionFile: string | undefined;
+			newSessionFile: string | undefined;
+			previousCwdIdentity: { dev: bigint; ino: bigint };
+			newCwdIdentity: { dev: bigint; ino: bigint };
+			preserveRecoveryJournal?: boolean;
+		}) => void | Promise<void>,
+	): () => void {
+		this.#movePublicationListeners.add(listener);
+		return () => {
+			this.#movePublicationListeners.delete(listener);
+		};
+	}
+
+	async #runMovePublicationListeners(move: {
+		previousCwd: string;
+		newCwd: string;
+		previousSessionFile: string | undefined;
+		newSessionFile: string | undefined;
+		previousCwdIdentity: { dev: bigint; ino: bigint };
+		newCwdIdentity: { dev: bigint; ino: bigint };
+	}): Promise<void> {
+		for (const listener of [...this.#movePublicationListeners]) await listener(move);
+	}
+
+	registerMoveAbortListener(
+		listener: (move: {
+			previousCwd: string;
+			newCwd: string;
+			previousSessionFile: string | undefined;
+			newSessionFile: string | undefined;
+			previousCwdIdentity: { dev: bigint; ino: bigint };
+			newCwdIdentity: { dev: bigint; ino: bigint };
+			preserveRecoveryJournal?: boolean;
+		}) => void | Promise<void>,
+	): () => void {
+		this.#moveAbortListeners.add(listener);
+		return () => {
+			this.#moveAbortListeners.delete(listener);
+		};
+	}
+
+	async #runMoveAbortListeners(move: {
+		previousCwd: string;
+		newCwd: string;
+		previousSessionFile: string | undefined;
+		newSessionFile: string | undefined;
+		previousCwdIdentity: { dev: bigint; ino: bigint };
+		newCwdIdentity: { dev: bigint; ino: bigint };
+		preserveRecoveryJournal?: boolean;
+	}): Promise<void> {
+		for (const listener of [...this.#moveAbortListeners]) {
+			try {
+				await listener(move);
+			} catch (error) {
+				logger.warn("move-abort listener failed", { error: String(error), cwd: move.newCwd });
+			}
+		}
+	}
+
+	async #runAfterMoveListeners(move: {
+		previousCwd: string;
+		newCwd: string;
+		previousSessionFile: string | undefined;
+	}): Promise<void> {
+		for (const listener of [...this.#afterMoveListeners]) {
+			try {
+				await listener(move);
+			} catch (error) {
+				logger.warn("after-move listener failed", { error: String(error), cwd: move.newCwd });
+			}
+		}
+	}
+
 	#ownsCwdTransition(): boolean {
 		const owner = this.#cwdTransitionOwner;
 		return owner !== undefined && cwdTransitionAls.getStore() === owner;
@@ -10801,15 +10972,73 @@ export class SessionManager {
 		options?: {
 			expectedIdentity?: { dev: bigint; ino: bigint };
 			targetHandle?: { stat: (opts: { bigint: true }) => Promise<fs.BigIntStats> };
+			expectedSourceIdentity?: { dev: bigint; ino: bigint };
+			sourceHandle?: { stat: (opts: { bigint: true }) => Promise<fs.BigIntStats> };
 		},
 	): Promise<void> {
 		if (!this.#ownsCwdTransition()) {
 			return this.runExclusiveCwdTransition(() => this.moveTo(newCwd, options));
 		}
-		const resolvedCwd = path.resolve(newCwd);
+		if (this.#cwdMoveAdmissionClosed) throw new Error("Session cwd move admission is closed.");
+		if (!options?.sourceHandle) {
+			const sourceHandle = await SessionManager.openNoFollowDirectory(this.cwd);
+			try {
+				const sourceIdentity = await sourceHandle.stat({ bigint: true });
+				if (!sourceIdentity.isDirectory()) throw new Error(`Current cwd is not a directory: ${this.cwd}`);
+				return await this.moveTo(newCwd, {
+					...options,
+					expectedSourceIdentity: options?.expectedSourceIdentity ?? {
+						dev: sourceIdentity.dev,
+						ino: sourceIdentity.ino,
+					},
+					sourceHandle,
+				});
+			} finally {
+				await sourceHandle.close();
+			}
+		}
+		const resolvedCwd = await fs.promises.realpath(path.resolve(newCwd));
+		const resolvedIdentity = await fs.promises.lstat(resolvedCwd, { bigint: true });
+		if (!resolvedIdentity.isDirectory() || resolvedIdentity.isSymbolicLink()) {
+			throw new Error(`Refusing to rescope: target is not a directory: ${resolvedCwd}`);
+		}
+		if (!options?.targetHandle) {
+			const targetHandle = await SessionManager.openNoFollowDirectory(resolvedCwd);
+			try {
+				const targetIdentity = await targetHandle.stat({ bigint: true });
+				const revalidatedCwd = await fs.promises.realpath(path.resolve(newCwd));
+				const namedIdentity = await fs.promises.lstat(revalidatedCwd, { bigint: true });
+				if (
+					revalidatedCwd !== resolvedCwd ||
+					!namedIdentity.isDirectory() ||
+					namedIdentity.isSymbolicLink() ||
+					namedIdentity.dev !== resolvedIdentity.dev ||
+					namedIdentity.ino !== resolvedIdentity.ino ||
+					targetIdentity.dev !== resolvedIdentity.dev ||
+					targetIdentity.ino !== resolvedIdentity.ino
+				)
+					throw new Error(`Refusing to rescope: target identity changed: ${resolvedCwd}`);
+				return await this.moveTo(resolvedCwd, {
+					...options,
+					expectedIdentity: options?.expectedIdentity ?? {
+						dev: targetIdentity.dev,
+						ino: targetIdentity.ino,
+					},
+					targetHandle,
+				});
+			} finally {
+				await targetHandle.close();
+			}
+		}
 		if (options?.expectedIdentity || options?.targetHandle) {
 			await this.#assertCwdTargetIdentity(resolvedCwd, options);
 		}
+		if (options?.expectedSourceIdentity || options?.sourceHandle) {
+			await this.#assertCwdTargetIdentity(this.cwd, {
+				expectedIdentity: options.expectedSourceIdentity,
+				targetHandle: options.sourceHandle,
+			});
+		}
 		if (resolvedCwd === this.cwd) return;
 		const previousCwd = this.cwd;
 		const previousSessionDir = this.sessionDir;
@@ -10825,6 +11054,19 @@ export class SessionManager {
 					)
 				: this.destination;
 		const newSessionDir = nextDestination.directory;
+		const nextSessionFile = this.#sessionFile
+			? path.join(newSessionDir, path.basename(this.#sessionFile))
+			: undefined;
+		const pinnedSourceIdentity = await options.sourceHandle.stat({ bigint: true });
+		const pinnedTargetIdentity = await options.targetHandle.stat({ bigint: true });
+		const moveDetails = {
+			previousCwd,
+			newCwd: resolvedCwd,
+			previousSessionFile,
+			newSessionFile: nextSessionFile,
+			previousCwdIdentity: { dev: pinnedSourceIdentity.dev, ino: pinnedSourceIdentity.ino },
+			newCwdIdentity: { dev: pinnedTargetIdentity.dev, ino: pinnedTargetIdentity.ino },
+		};
 		let hadSessionFile = false;
 		const managedMove = this.destination.kind === "managed" && nextDestination.kind === "managed";
 		let managedSourceStore: ManagedSessionDescendantStore | undefined;
@@ -10832,16 +11074,29 @@ export class SessionManager {
 		let rollbackManagedMove: (() => Promise<void>) | undefined;
 		let residentTransition: PreparedResidentStoreTransition | undefined;
 		const hadPersistedSession = this.#ensuredOnDisk;
+		try {
+			await this.#runBeforeMoveListeners(moveDetails);
+		} catch (error) {
+			await this.#runMoveAbortListeners(moveDetails);
+			throw error;
+		}
 
+		let targetIdentityRevalidated = false;
+		let publicationStarted = false;
 		if (this.persist && this.#sessionFile) {
 			// Close the persist writer before moving files
-			await this.#closePersistWriter();
+			try {
+				await this.#closePersistWriter();
+			} catch (error) {
+				await this.#runMoveAbortListeners(moveDetails);
+				throw error;
+			}
 			this.#persistChain = Promise.resolve();
 			this.#persistError = undefined;
 			this.#persistErrorReported = false;
 
 			const oldSessionFile = this.#sessionFile;
-			const newSessionFile = path.join(newSessionDir, path.basename(oldSessionFile));
+			const newSessionFile = nextSessionFile!;
 			const oldArtifactDir = oldSessionFile.slice(0, -6); // strip .jsonl
 			const newArtifactDir = newSessionFile.slice(0, -6);
 			let managedTranscript!: ReturnType<ManagedSessionDescendantStore["readExpected"]>;
@@ -10851,24 +11106,30 @@ export class SessionManager {
 			hadSessionFile = managedMove ? false : this.#storage.existsSync(oldSessionFile);
 			let movedSessionFile = false;
 			let movedArtifactDir = false;
-			const materializedEntries = materializeResidentEntriesForReadSync(
-				this.#fileEntries,
-				this.#residentBlobStores(),
-			);
-			const transitionEntries: FileEntry[] = materializedEntries.map(entry =>
-				entry.type === "session" ? { ...entry, cwd: resolvedCwd } : entry,
-			);
-			residentTransition = this.#prepareResidentTextStoreTransition(
-				{
-					target: { sessionId: this.#sessionId, sessionFile: newSessionFile },
-					primary: {
-						mode: "materialize",
-						sourceEntries: transitionEntries,
-						sourceStores: { textStore: null, imageStore: this.#residentImageBlobStore },
+			try {
+				const materializedEntries = materializeResidentEntriesForReadSync(
+					this.#fileEntries,
+					this.#residentBlobStores(),
+				);
+				const transitionEntries: FileEntry[] = materializedEntries.map(entry =>
+					entry.type === "session" ? { ...entry, cwd: resolvedCwd } : entry,
+				);
+				residentTransition = this.#prepareResidentTextStoreTransition(
+					{
+						target: { sessionId: this.#sessionId, sessionFile: newSessionFile },
+						primary: {
+							mode: "materialize",
+							sourceEntries: transitionEntries,
+							sourceStores: { textStore: null, imageStore: this.#residentImageBlobStore },
+						},
 					},
-				},
-				"retain-and-throw",
-			);
+					"retain-and-throw",
+				);
+			} catch (error) {
+				residentTransition?.dispose();
+				await this.#runMoveAbortListeners(moveDetails);
+				throw error;
+			}
 			const discardResidentTransitionAndThrow = (error: unknown): never => {
 				residentTransition?.dispose();
 				throw error;
@@ -10911,6 +11172,14 @@ export class SessionManager {
 					throw new Error("artifact_destination_mismatch");
 				destination.fsyncTree();
 			};
+			try {
+				await this.#runMovePublicationListeners(moveDetails);
+				publicationStarted = true;
+			} catch (error) {
+				residentTransition?.dispose();
+				await this.#runMoveAbortListeners(moveDetails);
+				throw error;
+			}
 			try {
 				if (managedMove) {
 					if (previousDestination.kind !== "managed" || nextDestination.kind !== "managed")
@@ -10996,6 +11265,16 @@ export class SessionManager {
 						if (!isEnoent(err)) throw err;
 					}
 				}
+				if (options?.expectedIdentity || options?.targetHandle) {
+					if (options.expectedSourceIdentity || options.sourceHandle) {
+						await this.#assertCwdTargetIdentity(previousCwd, {
+							expectedIdentity: options.expectedSourceIdentity,
+							targetHandle: options.sourceHandle,
+						});
+					}
+					await this.#assertCwdTargetIdentity(resolvedCwd, options);
+					targetIdentityRevalidated = true;
+				}
 			} catch (err) {
 				if (managedMove && managedDestinationStore) {
 					try {
@@ -11037,6 +11316,7 @@ export class SessionManager {
 						)
 							await managedSourceStore.publishNoReplace(path.basename(oldSessionFile), managedTranscript.bytes);
 					} catch (rollbackErr) {
+						await this.#runMoveAbortListeners({ ...moveDetails, preserveRecoveryJournal: true });
 						discardResidentTransitionAndThrow(
 							new Error(`Failed to rollback managed move: ${toError(rollbackErr).message}`, {
 								cause: toError(err),
@@ -11044,18 +11324,46 @@ export class SessionManager {
 						);
 					}
 				} else {
-					if (movedArtifactDir) await movePathAcrossDevicesSafe(newArtifactDir, oldArtifactDir);
-					if (movedSessionFile) await movePathAcrossDevicesSafe(newSessionFile, oldSessionFile);
+					try {
+						if (movedArtifactDir) await movePathAcrossDevicesSafe(newArtifactDir, oldArtifactDir);
+						if (movedSessionFile) await movePathAcrossDevicesSafe(newSessionFile, oldSessionFile);
+					} catch (rollbackError) {
+						await this.#runMoveAbortListeners({ ...moveDetails, preserveRecoveryJournal: true });
+						discardResidentTransitionAndThrow(
+							new Error(`Failed to rollback move: ${toError(rollbackError).message}`, { cause: toError(err) }),
+						);
+					}
 				}
+				await this.#runMoveAbortListeners(moveDetails);
 				discardResidentTransitionAndThrow(err);
 			}
 			this.#sessionFile = newSessionFile;
 		}
+		if (!publicationStarted) {
+			try {
+				await this.#runMovePublicationListeners(moveDetails);
+				publicationStarted = true;
+			} catch (error) {
+				await this.#runMoveAbortListeners(moveDetails);
+				throw error;
+			}
+		}
 
 		// Update cwd and sessionDir after physical publication succeeds. Metadata failures restore the source
 		// authority but deliberately retain any destination publication evidence rather than deleting it.
-		if (options?.expectedIdentity || options?.targetHandle) {
-			await this.#assertCwdTargetIdentity(resolvedCwd, options);
+		if (!targetIdentityRevalidated && (options?.expectedIdentity || options?.targetHandle)) {
+			try {
+				if (options.expectedSourceIdentity || options.sourceHandle) {
+					await this.#assertCwdTargetIdentity(previousCwd, {
+						expectedIdentity: options.expectedSourceIdentity,
+						targetHandle: options.sourceHandle,
+					});
+				}
+				await this.#assertCwdTargetIdentity(resolvedCwd, options);
+			} catch (error) {
+				await this.#runMoveAbortListeners(moveDetails);
+				throw error;
+			}
 		}
 		this.#cwdGeneration += 1;
 		this.cwd = resolvedCwd;
@@ -11095,6 +11403,7 @@ export class SessionManager {
 					await rollbackManagedMove();
 				} catch (rollbackError) {
 					if (toError(rollbackError).message !== "cleanup_pending") {
+						await this.#runMoveAbortListeners({ ...moveDetails, preserveRecoveryJournal: true });
 						throw new Error(`Failed to rollback managed move: ${toError(rollbackError).message}`, {
 							cause: toError(error),
 						});
@@ -11115,12 +11424,14 @@ export class SessionManager {
 				const header = this.#fileEntries.find(entry => entry.type === "session") as SessionHeader | undefined;
 				if (header) applyHeaderPatch(header, { cwd: previousCwd });
 				this.#headerExportRevision++;
+				await this.#runMoveAbortListeners(moveDetails);
 				throw error;
 			}
 			// The destination has already been published. Retain it rather than moving it
 			// back over the source after a metadata failure.
 			this.#managedTranscriptStoreCache = null;
 			this.#headerExportRevision++;
+			await this.#runAfterMoveListeners(moveDetails);
 			throw error;
 		}
 		if (residentTransition) this.#commitResidentTextStoreTransition(residentTransition);
@@ -11129,6 +11440,9 @@ export class SessionManager {
 		if (this.#sessionFile) {
 			writeTerminalBreadcrumb(resolvedCwd, this.#sessionFile);
 		}
+		// The move is fully committed here; notify every surface's after-move listeners
+		// (coordinator runtime-state relocation, postmortem finalizer rebinding, ...).
+		await this.#runAfterMoveListeners(moveDetails);
 	}
 
 	/** Sync version for initial creation (no existing writer to close). */

package/src/session/yield-queue.ts

@@ -18,8 +18,9 @@ export interface YieldDispatcher<P> {
 export interface YieldQueueOptions {
 	isStreaming: () => boolean;
 	injectStreaming(msg: AgentMessage): void;
-	injectIdle(messages: AgentMessage[]): Promise<void>;
-	scheduleIdleFlush(run: () => Promise<void>): void;
+	injectIdle(messages: AgentMessage[], signal?: AbortSignal): Promise<void>;
+	scheduleIdleFlush(run: (signal?: AbortSignal) => Promise<void>, onSkip: () => void): void;
+	getIdleFlushSignal?(): AbortSignal | undefined;
 }
 
 type YieldFlushMode = "streaming" | "idle";
@@ -39,6 +40,7 @@ export class YieldQueue {
 	readonly #dispatchers = new Map<string, StoredDispatcher>();
 	readonly #entries = new Map<string, unknown[]>();
 	#idleFlushPending = false;
+	#idleFlushPendingOwner: symbol | undefined;
 
 	constructor(options: YieldQueueOptions) {
 		this.#options = options;
@@ -82,9 +84,10 @@ export class YieldQueue {
 		return false;
 	}
 
-	async flush(mode: YieldFlushMode): Promise<void> {
+	async flush(mode: YieldFlushMode, signal?: AbortSignal): Promise<void> {
 		if (mode === "idle") {
 			this.#idleFlushPending = false;
+			this.#idleFlushPendingOwner = undefined;
 		}
 		const idleMessages: AgentMessage[] = [];
 		for (const [kind, dispatcher] of this.#dispatchers) {
@@ -105,16 +108,20 @@ export class YieldQueue {
 		}
 		if (mode === "idle" && idleMessages.length > 0) {
 			try {
-				await this.#options.injectIdle(idleMessages);
+				await this.#options.injectIdle(idleMessages, signal ?? this.#options.getIdleFlushSignal?.());
 			} catch (error) {
 				logger.warn("Yield queue idle dispatch failed", { error: formatError(error) });
 			}
 		}
 	}
 
-	clear(): void {
+	clear(onDrop?: (kind: string, entries: readonly unknown[]) => void): void {
+		if (onDrop) {
+			for (const [kind, entries] of this.#entries) onDrop(kind, entries);
+		}
 		this.#entries.clear();
 		this.#idleFlushPending = false;
+		this.#idleFlushPendingOwner = undefined;
 	}
 
 	/** Drop only the queued entries of a single kind, leaving other kinds intact. */
@@ -140,14 +147,21 @@ export class YieldQueue {
 	#scheduleIdleFlush(): void {
 		if (this.#idleFlushPending) return;
 		this.#idleFlushPending = true;
+		const owner = Symbol("idle-flush");
+		this.#idleFlushPendingOwner = owner;
+		const releaseOwner = () => {
+			if (this.#idleFlushPendingOwner !== owner) return;
+			this.#idleFlushPendingOwner = undefined;
+			this.#idleFlushPending = false;
+		};
 		try {
-			this.#options.scheduleIdleFlush(async () => {
-				this.#idleFlushPending = false;
+			this.#options.scheduleIdleFlush(async signal => {
+				releaseOwner();
 				if (this.#options.isStreaming()) return;
-				await this.flush("idle");
-			});
+				await this.flush("idle", signal);
+			}, releaseOwner);
 		} catch (error) {
-			this.#idleFlushPending = false;
+			releaseOwner();
 			logger.warn("Yield queue idle flush scheduling failed", { error: formatError(error) });
 		}
 	}

package/src/setup/frictionless-onboarding.ts

@@ -748,6 +748,7 @@ export function shouldOfferOnboarding(state: FrictionlessOnboardingState): boole
 
 export interface AutomaticOnboardingInput {
 	normalInteractive: boolean;
+	automation?: boolean;
 	initialMessage?: string;
 	initialMessages: readonly string[];
 	initialImages?: readonly unknown[];
@@ -757,6 +758,7 @@ export interface AutomaticOnboardingInput {
 export function shouldOfferAutomaticOnboarding(input: AutomaticOnboardingInput): boolean {
 	return (
 		input.normalInteractive &&
+		!input.automation &&
 		!input.initialMessage &&
 		input.initialMessages.length === 0 &&
 		(input.initialImages?.length ?? 0) === 0 &&

package/src/setup/provider-presets.json

@@ -4,7 +4,7 @@
   {"id":"glm","aliases":["zai","z-ai","bigmodel"],"name":"GLM / zAI","description":"OpenAI-compatible GLM endpoint from zAI/BigModel","compatibility":"openai","api":"openai-completions","providerId":"glm-proxy","baseUrl":"https://api.z.ai/api/paas/v4","apiKeyEnv":"ZAI_API_KEY","models":["glm-4.6"],"compat":{"supportsDeveloperRole":false,"supportsReasoningEffort":false,"thinkingFormat":"zai","reasoningContentField":"reasoning_content"}},
   {"id":"alibaba-token-plan","aliases":["alibaba","token-plan"],"name":"Alibaba Token Plan","description":"OpenAI-compatible Alibaba Token Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"alibaba-token-plan","baseUrl":"https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1","apiKeyEnv":"ALIBABA_TOKEN_PLAN_API_KEY","models":["qwen3.8-max-preview","qwen3.8-max","glm-5.2","deepseek-v4-pro"],"modelApi":{"qwen3.8-max-preview":"openai-responses","qwen3.8-max":"openai-responses","glm-5.2":"openai-completions","deepseek-v4-pro":"openai-completions"},"compat":{"supportsDeveloperRole":false}},
   {"id":"cline-pass","aliases":["clinepass","cline"],"name":"ClinePass","description":"ClinePass subscription models discovered from Cline's upstream models.dev catalog","compatibility":"openai","api":"openai-completions","providerId":"cline-pass","baseUrl":"https://api.cline.bot/api/v1","apiKeyEnv":"CLINE_API_KEY","discovery":{"type":"models-dev","modelsDevProvider":"cline-pass"},"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning"}},
-  {"id":"commandcode-goat","aliases":["commandcode","command-code","goat"],"name":"Command Code GOAT","description":"Command Code GOAT coding-plan models discovered from its OpenAI-compatible Provider API","compatibility":"openai","api":"openai-completions","providerId":"commandcode-goat","baseUrl":"https://api.commandcode.ai/provider/v1","apiKeyEnv":"CMD_API_KEY","discovery":{"type":"openai-models-list","apiByModelPrefix":{"claude-":"anthropic-messages"}},"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
+  {"id":"commandcode-goat","aliases":["commandcode","command-code","goat"],"name":"Command Code GOAT","description":"Command Code GOAT coding-plan models discovered from its OpenAI-compatible Provider API","compatibility":"openai","api":"openai-completions","providerId":"commandcode-goat","baseUrl":"https://api.commandcode.ai/provider/v1","apiKeyEnv":"CMD_API_KEY","discovery":{"type":"openai-models-list","apiByModelPrefix":{"claude":"anthropic-messages","anthropic/claude":"anthropic-messages"}},"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","reasoningContentField":"reasoning_content"}},
   {"id":"litellm","aliases":["litellm-proxy"],"name":"LiteLLM Proxy","description":"OpenAI-compatible LiteLLM proxy endpoint (user-supplied base URL) with live model discovery","compatibility":"openai","api":"openai-completions","providerId":"litellm","parameterized":true,"apiKeyEnv":"LITELLM_API_KEY","discovery":{"type":"openai-models-list"}},
   {"id":"openai-compatible-proxy","aliases":["openai-proxy","compatible-proxy","custom-proxy"],"name":"OpenAI-Compatible Proxy","description":"Generic OpenAI-compatible gateway (OpenRouter, OpenCode Go, custom) with live model discovery","compatibility":"openai","api":"openai-completions","providerId":"openai-compatible-proxy","parameterized":true,"apiKeyEnv":"OPENAI_COMPATIBLE_API_KEY","discovery":{"type":"openai-models-list"}}
 ]

package/src/slash-commands/helpers/credential-switch.ts

@@ -131,7 +131,12 @@ export async function switchSessionCredentialCommand(runtime: SlashCommandRuntim
 	}
 
 	try {
-		authStorage.switchSessionCredential(provider, runtime.session.credentialSessionId, parsed.selector);
+		authStorage.switchSessionCredential(
+			provider,
+			runtime.session.credentialSessionId,
+			parsed.selector,
+			runtime.session.modelRegistry.getAuthStorageOwner?.(),
+		);
 	} catch (error) {
 		return error instanceof Error ? error.message : String(error);
 	}

package/src/task/executor.ts

@@ -1121,6 +1121,8 @@ export async function runSubprocessOnce(options: ExecutorOptions): Promise<Singl
 	const abortController = new AbortController();
 	const abortSignal = abortController.signal;
 	let activeSession: AgentSession | null = null;
+	let ownedModelRegistry: ModelRegistry | undefined;
+	let ownedAuthStorage: AuthStorage | undefined;
 	let unsubscribe: (() => void) | null = null;
 	let yieldCalled = false;
 	let pauseRequested = false;
@@ -1703,9 +1705,19 @@ export async function runSubprocessOnce(options: ExecutorOptions): Promise<Singl
 			checkAbort();
 			// Pin authStorage to modelRegistry.authStorage — mirrors the createAgentSession invariant.
 			const registryFromParent = options.modelRegistry !== undefined;
-			const modelRegistry =
-				options.modelRegistry ??
-				new ModelRegistry(options.authStorage ?? (await awaitAbortable(discoverAuthStorage())));
+			const registryAuthStorage =
+				options.authStorage ??
+				options.modelRegistry?.authStorage ??
+				(await awaitAbortable(discoverAuthStorage(settings.getAgentDir())));
+			if (options.modelRegistry === undefined && options.authStorage === undefined)
+				ownedAuthStorage = registryAuthStorage;
+			ownedModelRegistry = options.modelRegistry
+				? undefined
+				: new ModelRegistry(registryAuthStorage, path.join(settings.getAgentDir(), "models.yml"), settings, {
+						agentDir: settings.getAgentDir(),
+						automaticRefresh: false,
+					});
+			const modelRegistry = options.modelRegistry ?? ownedModelRegistry!;
 			const authStorage = modelRegistry.authStorage;
 			if (options.authStorage && options.authStorage !== authStorage) {
 				throw new Error(
@@ -2500,6 +2512,10 @@ export async function runSubprocessOnce(options: ExecutorOptions): Promise<Singl
 					// Ignore cleanup errors
 				}
 			}
+			ownedModelRegistry?.dispose();
+			ownedModelRegistry = undefined;
+			ownedAuthStorage?.close();
+			ownedAuthStorage = undefined;
 		}
 
 		return {