@gajae-code/coding-agent 0.15.5 → 0.15.6

package/src/modes/controllers/input-controller.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { type AgentMessage, ThinkingLevel } from "@gajae-code/agent-core";
-import { type AutocompleteProvider, matchesKey, type SlashCommand } from "@gajae-code/tui";
+import { type AutocompleteProvider, getKeybindings, matchesKey, type SlashCommand } from "@gajae-code/tui";
 import { $pickenv, logger, sanitizeText } from "@gajae-code/utils";
 import { type AppKeybinding, KEYBINDINGS } from "../../config/keybindings";
 import { isSettingsInitialized, settings } from "../../config/settings";
@@ -1855,19 +1855,36 @@ export class InputController {
 		const now = Date.now();
 		if (now - this.#lastBackgroundFoldKeyTime > BACKGROUND_FOLD_DOUBLE_PRESS_MS) {
 			this.#lastBackgroundFoldKeyTime = now;
-			this.ctx.showStatus("Press Ctrl+B again to fold supported foreground bash into a background job");
+			const foldKeys = getKeybindings().getKeys("app.tool.backgroundFold");
+			this.ctx.showStatus(
+				`Press ${foldKeys.join(" / ")} again to fold supported foreground bash into a background job`,
+			);
 			return true;
 		}
 		this.#lastBackgroundFoldKeyTime = 0;
 
-		if (!this.ctx.session.requestForegroundBashBackground?.()) {
+		try {
+			const request = this.ctx.session.requestForegroundBashBackground?.() ?? Promise.resolve(false);
+			void request
+				.then(backgrounded => {
+					if (backgrounded) {
+						this.ctx.showStatus("Folding foreground bash into a quiet background job…");
+						return;
+					}
+					this.ctx.showWarning(
+						"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
+					);
+				})
+				.catch(() => {
+					this.ctx.showWarning(
+						"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
+					);
+				});
+		} catch {
 			this.ctx.showWarning(
 				"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
 			);
-			return true;
 		}
-
-		this.ctx.showStatus("Folding foreground bash into a quiet background job…");
 		return true;
 	}
 

package/src/modes/interactive-mode.ts

@@ -426,6 +426,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	lastComposerClearEscapeTime = 0;
 	shutdownRequested = false;
 	#isShuttingDown = false;
+	#shutdownEscalated = false;
 	hookSelector: HookSelectorComponent | undefined = undefined;
 	hookInput: HookInputComponent | undefined = undefined;
 	hookEditor: HookEditorComponent | undefined = undefined;
@@ -1682,7 +1683,19 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	async shutdown(): Promise<void> {
-		if (this.#isShuttingDown) return;
+		if (this.#isShuttingDown) {
+			// A second explicit exit is an escalation, not another silent no-op. The
+			// graceful path may be waiting on a lock-hostile filesystem; postmortem.quit
+			// has its own bounded cleanup deadline and will force the process out even
+			// when the first shutdown cannot finish.
+			if (!this.#shutdownEscalated) {
+				this.#shutdownEscalated = true;
+				logger.warn("Escalating repeated interactive shutdown request");
+				this.session.abort();
+				void postmortem.quit(1);
+			}
+			return;
+		}
 		this.#isShuttingDown = true;
 
 		// `/btw` owns the shared composer while its panel is open. Never persist a

package/src/modes/jobs-observer.ts

@@ -16,12 +16,48 @@ import type { AsyncJob, AsyncJobManager } from "../async";
 import { deleteCronJobById, listCronSnapshots, onCronChange } from "../tools/cron";
 
 export type JobsWorstState = "none" | "running" | "failed";
+export type JobDeliveryState = "pending" | "delivered" | "failed-visible";
+
+/** The manager-owned, one-pass job projection consumed by this observer. */
+export interface AsyncJobSnapshotEntry {
+	id: string;
+	kind: string;
+	label: string;
+	status: AsyncJob["status"];
+	generation: string;
+	backgrounded: boolean;
+	deliveryState: JobDeliveryState;
+}
+
+/** Scalar delivery failure evidence that may outlive the AsyncJob record. */
+export interface DeadLetteredJobSnapshotEntry {
+	jobId: string;
+	generation: string;
+	ownerId?: string;
+	backgrounded?: boolean;
+	attempt: number;
+	lastError?: string;
+	recordedAt: number;
+}
+
+export interface AsyncJobsSnapshot {
+	jobs: AsyncJobSnapshotEntry[];
+	deadLettered: DeadLetteredJobSnapshotEntry[];
+}
 
 export interface MonitorJobView {
 	id: string;
 	label: string;
 	status: AsyncJob["status"];
 	startTime: number;
+	generation?: string;
+	backgrounded?: boolean;
+	deliveryState?: JobDeliveryState;
+}
+
+export interface FoldedJobView extends AsyncJobSnapshotEntry {
+	/** Safe diagnostic retained for a dead-lettered delivery, when available. */
+	errorText?: string;
 }
 
 export interface CronJobView {
@@ -39,6 +75,10 @@ export interface CronJobView {
 export interface JobsSnapshot {
 	monitors: MonitorJobView[];
 	crons: CronJobView[];
+	/** Backgrounded work and undeliverable terminal work that must stay visible. */
+	foldedJobs?: FoldedJobView[];
+	/** Scalar dead-letter evidence retained for diagnostics and red-drill-in. */
+	deadLettered?: DeadLetteredJobSnapshotEntry[];
 	activeMonitorCount: number;
 	activeCronCount: number;
 	worstState: JobsWorstState;
@@ -48,12 +88,22 @@ export interface JobsSnapshot {
 export const EMPTY_JOBS_SNAPSHOT: JobsSnapshot = {
 	monitors: [],
 	crons: [],
+	foldedJobs: [],
+	deadLettered: [],
 	activeMonitorCount: 0,
 	activeCronCount: 0,
 	worstState: "none",
 	failedUnacknowledged: false,
 };
 
+function jobKey(id: string, generation: string): string {
+	return `${id}\u0000${generation}`;
+}
+
+interface AsyncJobSnapshotSource {
+	getJobsSnapshot?: (filter?: { ownerId?: string }) => AsyncJobsSnapshot;
+}
+
 export class JobsObserver {
 	readonly #manager: AsyncJobManager;
 	readonly #ownerId: string | undefined;
@@ -103,7 +153,14 @@ export class JobsObserver {
 		}
 	}
 
+	#readAsyncJobsSnapshot(): AsyncJobsSnapshot {
+		const source = this.#manager as AsyncJobSnapshotSource;
+		if (typeof source.getJobsSnapshot !== "function") return { jobs: [], deadLettered: [] };
+		return source.getJobsSnapshot(this.#ownerId ? { ownerId: this.#ownerId } : undefined);
+	}
+
 	#listMonitorJobs(): AsyncJob[] {
+		if (typeof this.#manager.getAllJobs !== "function") return [];
 		const filter = this.#ownerId ? { ownerId: this.#ownerId } : undefined;
 		return this.#manager.getAllJobs(filter).filter(job => job.type === "bash" && job.metadata?.monitor === true);
 	}
@@ -114,25 +171,92 @@ export class JobsObserver {
 	 * snapshot (never scans the manager/cron stores).
 	 */
 	#recompute(): void {
+		const asyncSnapshot = this.#readAsyncJobsSnapshot();
+		const snapshotEntries = new Map<string, AsyncJobSnapshotEntry>();
+		for (const entry of asyncSnapshot.jobs) snapshotEntries.set(jobKey(entry.id, entry.generation), entry);
+
 		const monitorJobs = this.#listMonitorJobs();
-		const presentIds = new Set(monitorJobs.map(job => job.id));
-		// Prune acknowledged ids whose jobs have been evicted.
-		for (const id of this.#acknowledgedFailedIds) {
-			if (!presentIds.has(id)) this.#acknowledgedFailedIds.delete(id);
+		const monitorKeys = new Set(monitorJobs.map(job => jobKey(job.id, job.generation)));
+		const presentKeys = new Set<string>([
+			...asyncSnapshot.jobs.map(entry => jobKey(entry.id, entry.generation)),
+			...asyncSnapshot.deadLettered.map(entry => jobKey(entry.jobId, entry.generation)),
+		]);
+		// Prune acknowledged keys whose jobs and scalar dead letters have been evicted.
+		for (const key of this.#acknowledgedFailedIds) {
+			if (!presentKeys.has(key)) this.#acknowledgedFailedIds.delete(key);
 		}
-		// Sticky failure latch: set when an unacknowledged failed monitor is seen
-		// (including at construction); stays set even after the failed job evicts,
-		// until acknowledgeFailures() clears it.
-		const hasUnacknowledgedFailure = monitorJobs.some(
-			job => job.status === "failed" && !this.#acknowledgedFailedIds.has(job.id),
-		);
+
+		// Sticky failure latch: the manager's terminal status and delivery
+		// classification are authoritative; neither is reconstructed from getters.
+		const hasUnacknowledgedFailure =
+			asyncSnapshot.jobs.some(
+				entry =>
+					(entry.deliveryState === "failed-visible" ||
+						(entry.status === "failed" &&
+							(entry.backgrounded || monitorKeys.has(jobKey(entry.id, entry.generation))))) &&
+					!this.#acknowledgedFailedIds.has(jobKey(entry.id, entry.generation)),
+			) ||
+			asyncSnapshot.deadLettered.some(
+				entry => !this.#acknowledgedFailedIds.has(jobKey(entry.jobId, entry.generation)),
+			);
 		if (hasUnacknowledgedFailure) this.#failedUnacknowledged = true;
 
-		const activeMonitors = monitorJobs.filter(job => job.status === "running");
-		const cronSnapshots = listCronSnapshots(this.#ownerId);
 		const monitors: MonitorJobView[] = monitorJobs
-			.map(job => ({ id: job.id, label: job.label, status: job.status, startTime: job.startTime }))
+			.flatMap(job => {
+				const entry = snapshotEntries.get(jobKey(job.id, job.generation));
+				if (!entry) return [];
+				return [
+					{
+						id: entry.id,
+						label: entry.label,
+						status: entry.status,
+						startTime: job.startTime,
+						generation: entry.generation,
+						backgrounded: entry.backgrounded,
+						deliveryState: entry.deliveryState,
+					},
+				];
+			})
 			.sort((a, b) => b.startTime - a.startTime);
+
+		// Keep every backgrounded job visible. A non-delivered terminal entry is
+		// also retained here so pending/failed delivery can never disappear merely
+		// because it was not marked backgrounded by its producer.
+		const deadLettersByKey = new Map(
+			asyncSnapshot.deadLettered.map(entry => [jobKey(entry.jobId, entry.generation), entry] as const),
+		);
+		const foldedJobs: FoldedJobView[] = asyncSnapshot.jobs
+			.filter(
+				entry =>
+					entry.backgrounded ||
+					(entry.status !== "running" &&
+						(entry.deliveryState === "failed-visible" ||
+							(entry.status === "failed" && entry.backgrounded) ||
+							entry.deliveryState !== "delivered")),
+			)
+			.map(entry => {
+				const lastError = deadLettersByKey.get(jobKey(entry.id, entry.generation))?.lastError;
+				return lastError === undefined ? { ...entry } : { ...entry, errorText: lastError };
+			});
+		const foldedKeys = new Set(foldedJobs.map(entry => jobKey(entry.id, entry.generation)));
+		for (const entry of asyncSnapshot.deadLettered) {
+			const key = jobKey(entry.jobId, entry.generation);
+			if (foldedKeys.has(key)) continue;
+			foldedKeys.add(key);
+			foldedJobs.push({
+				id: entry.jobId,
+				kind: "dead-letter",
+				label: entry.jobId,
+				status: "failed",
+				generation: entry.generation,
+				backgrounded: entry.backgrounded === true,
+				deliveryState: "failed-visible",
+				errorText: entry.lastError,
+			});
+		}
+
+		const activeMonitors = monitors.filter(monitor => monitor.status === "running" && !monitor.backgrounded);
+		const cronSnapshots = listCronSnapshots(this.#ownerId);
 		const crons: CronJobView[] = cronSnapshots
 			.map(snapshot => ({
 				id: snapshot.id,
@@ -145,14 +269,17 @@ export class JobsObserver {
 				firing: snapshot.firing,
 			}))
 			.sort((a, b) => b.createdAt - a.createdAt);
+		const hasRunningFoldedJob = foldedJobs.some(job => job.status === "running");
 		const worstState: JobsWorstState = this.#failedUnacknowledged
 			? "failed"
-			: activeMonitors.length > 0 || crons.length > 0
+			: activeMonitors.length > 0 || crons.length > 0 || hasRunningFoldedJob
 				? "running"
 				: "none";
 		this.#snapshot = {
 			monitors,
 			crons,
+			foldedJobs,
+			deadLettered: asyncSnapshot.deadLettered.map(entry => ({ ...entry })),
 			activeMonitorCount: activeMonitors.length,
 			activeCronCount: crons.length,
 			worstState,
@@ -167,8 +294,14 @@ export class JobsObserver {
 
 	/** Clear the failure latch (called when the user opens the jobs overlay). */
 	acknowledgeFailures(): void {
-		for (const job of this.#listMonitorJobs()) {
-			if (job.status === "failed") this.#acknowledgedFailedIds.add(job.id);
+		const asyncSnapshot = this.#readAsyncJobsSnapshot();
+		for (const entry of asyncSnapshot.jobs) {
+			if (entry.status === "failed" || entry.deliveryState === "failed-visible") {
+				this.#acknowledgedFailedIds.add(jobKey(entry.id, entry.generation));
+			}
+		}
+		for (const entry of asyncSnapshot.deadLettered) {
+			this.#acknowledgedFailedIds.add(jobKey(entry.jobId, entry.generation));
 		}
 		if (!this.#failedUnacknowledged) return;
 		this.#failedUnacknowledged = false;

package/src/modes/runtime-init.ts

@@ -343,7 +343,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 						return { retried: true, immediate: true };
 					}
 					case "bash.background": {
-						if (!session.requestForegroundBashBackground())
+						if (!(await session.requestForegroundBashBackground()))
 							throw Object.assign(
 								new Error("The active bash command cannot be moved to a managed background job."),
 								{ code: "not_foldable" },

package/src/modes/utils/injected-user-submission.ts

@@ -17,7 +17,11 @@ import type { InteractiveModeContext } from "../types";
  * (unhandled rejection → resident crash).
  */
 export function extensionUserMessageContentError(content: string | (TextContent | ImageContent)[]): Error | undefined {
-	if (typeof content === "string") return undefined;
+	if (typeof content === "string") {
+		if (content.trim().length === 0)
+			return Object.assign(new Error("Prompt must not be empty."), { code: "invalid_input" });
+		return undefined;
+	}
 	if (!Array.isArray(content)) {
 		return Object.assign(new Error("sendUserMessage requires string or content-array content."), {
 			code: "invalid_input",
@@ -30,6 +34,16 @@ export function extensionUserMessageContentError(content: string | (TextContent
 			});
 		}
 	}
+	const text = content
+		.filter((part): part is TextContent => part.type === "text")
+		.map(part => part.text)
+		.join("\n");
+	const hasUsableImage = content.some(
+		(part): part is ImageContent =>
+			part.type === "image" && typeof part.data === "string" && part.data.trim().length > 0,
+	);
+	if (text.trim().length === 0 && !hasUsableImage)
+		return Object.assign(new Error("Prompt must not be empty."), { code: "invalid_input" });
 	return undefined;
 }
 export function normalizeInjectedUserContent(content: string | (TextContent | ImageContent)[]): {

package/src/prompts/tools/bash.md

@@ -16,8 +16,8 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 {{#if asyncEnabled}}
 - Use `async: true` for long-running commands when you don't need immediate output; the call returns a background job ID and the result is delivered automatically as a follow-up.
 {{/if}}
-{{#if autoBackgroundEnabled}}
-- In the interactive TUI, the user can press `Ctrl+B` twice while a supported managed foreground bash command is still running to fold it into a quiet background job. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
+{{#if foregroundFoldEnabled}}
+- In the interactive TUI, the user can press the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via the `app.tool.backgroundFold` keybinding) while a foreground command is still running to fold it into a background job. All three command surfaces fold: managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded command keeps its original timeout and is never killed or restarted by folding; a folded PTY continues output-only, so it stops accepting input. The turn then ends cleanly and a later turn resumes automatically with the command's result, so the interrupted task is finished rather than abandoned. `task`/`subagent` waits are deliberately NOT foldable. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
 {{/if}}
 </instruction>
 {{#if restrictedAllowedPrefixes}}

package/src/prompts/tools/fold-receipt.md

@@ -0,0 +1,3 @@
+This result came from a folded {{kind}} wait (job {{jobId}}).
+Output reference: {{outputInstruction}}
+{{cwdNotice}}{{intentNotice}}

package/src/prompts/tools/job.md

@@ -2,7 +2,7 @@ Inspects, waits, or cancels async jobs.
 
 Background job results are delivered automatically when complete. Jobs that back task subagents should be controlled via the `subagent` tool when it is available; use `job` for non-subagent jobs (async bash, monitors) and as a compatibility fallback. Running job output stays quiet by default to avoid flooding the conversation; use `tail` when you explicitly want to show/reopen retained output. Reach for this tool only when you need to inspect or intervene.
 
-In the interactive TUI, supported managed foreground bash can be folded into a background job by pressing `Ctrl+B` twice while it is running. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
+In the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
 
 # Operations
 

package/src/sdk/acp/adapter.ts

@@ -9,7 +9,11 @@ import {
 	type SessionReconcileUncertainTarget,
 	validateSessionReconcileUncertainTarget,
 } from "../lifecycle/service";
-import { validateAdapterControl, validateAdapterSecretFields } from "../protocol/adapter-validation";
+import {
+	validateAdapterControl,
+	validateAdapterSecretFields,
+	validateRequiredPromptText,
+} from "../protocol/adapter-validation";
 import { OPERATIONS } from "../protocol/operation-registry";
 import { type SessionAttachment, type SessionRouter, SessionRouterError } from "../router";
 import { ACP_SESSION_RECONNECT, SESSION_ABORT_TIMEOUT_MS } from "../session-reconnect";
@@ -343,7 +347,18 @@ export class AcpSdkAdapter {
 	}
 
 	async prompt(params: JsonObject | string): Promise<unknown> {
-		const text = typeof params === "string" ? params : String(params.prompt ?? params.text ?? "");
+		const rawText =
+			typeof params === "string"
+				? params
+				: params !== null && typeof params === "object"
+					? (params.prompt ?? params.text)
+					: undefined;
+		const text = typeof rawText === "string" ? rawText : "";
+		const invalid = validateRequiredPromptText("turn.prompt", {
+			text,
+			...(typeof params === "object" && Array.isArray(params.images) ? { images: params.images } : {}),
+		});
+		if (invalid) throw new AcpSdkAdapterError(invalid.code, invalid.message);
 		return await this.#requestSession({
 			type: "control_request",
 			operation: "turn.prompt",

package/src/sdk/broker/broker.ts

@@ -46,6 +46,8 @@ export interface BrokerSettings {
 	heartbeatTtlMs?: number;
 	/** Broker-owned migration policy. Client lifecycle frames cannot select it. */
 	resolveDirectoryMigration?: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
+	/** Host model resolver override for lifecycle tests and embedders. */
+	resolveModelPin?: SdkHostModelResolver;
 }
 
 type ResolvedBrokerSettings = {
@@ -863,7 +865,8 @@ export class Broker {
 	#completion!: Promise<void>;
 	#resolveCompletion!: () => void;
 	#rejectCompletion!: (error: unknown) => void;
-	readonly #resolveModelPin: SdkHostModelResolver;
+	#resolveModelPin: SdkHostModelResolver;
+	#ownsResolveModelPin: boolean;
 	constructor(settings: BrokerSettings) {
 		this.settings = {
 			agentDir: settings.agentDir,
@@ -874,7 +877,8 @@ export class Broker {
 		};
 		this.index = new SessionIndex(settings.agentDir);
 		this.ledger = new LifecycleLedger(settings.agentDir);
-		this.#resolveModelPin = createDefaultSdkHostModelResolver(this.settings.agentDir);
+		this.#ownsResolveModelPin = settings.resolveModelPin === undefined;
+		this.#resolveModelPin = settings.resolveModelPin ?? createDefaultSdkHostModelResolver(this.settings.agentDir);
 		this.#lock = path.join(settings.agentDir, "sdk", "broker.lock");
 		const completion = Promise.withResolvers<void>();
 		this.#completion = completion.promise;
@@ -1023,6 +1027,8 @@ export class Broker {
 			this.#resolveCompletion = completion.resolve;
 			this.#rejectCompletion = completion.reject;
 			this.#completionTask = null;
+			if (this.#ownsResolveModelPin)
+				this.#resolveModelPin = createDefaultSdkHostModelResolver(this.settings.agentDir);
 			// A drained queue refuses every later startup by design, so a restarted broker
 			// needs a new one or it would admit nothing for the rest of the process.
 			this.#startupAdmissions = new StartupAdmissionQueue(sdkHostStartupConcurrency());
@@ -1285,25 +1291,35 @@ export class Broker {
 		if (this.#heartbeatTimer) clearInterval(this.#heartbeatTimer);
 		this.#heartbeatTimer = null;
 		this.#completionTask = (async () => {
-			await this.#transport?.stop();
-			this.#transport = null;
-			if (mode === "lost-root")
-				await Promise.race([Promise.allSettled(this.#admitted), Bun.sleep(BROKER_SETTLEMENT_MS)]);
-			else await Promise.allSettled(this.#admitted);
-			this.#publication?.close();
-			this.#publication = null;
-			if (mode === "owned-root" && this.discovery?.ownerId === this.#owner) {
-				try {
-					const disk = JSON.parse(await fs.readFile(brokerDiscoveryPath(this.settings.agentDir), "utf8")) as {
-						ownerId?: string;
-					};
-					if (disk.ownerId === this.#owner) await fs.unlink(brokerDiscoveryPath(this.settings.agentDir));
-				} catch (e) {
-					if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e;
+			try {
+				await this.#transport?.stop();
+				this.#transport = null;
+				if (mode === "lost-root")
+					await Promise.race([Promise.allSettled(this.#admitted), Bun.sleep(BROKER_SETTLEMENT_MS)]);
+				else await Promise.allSettled(this.#admitted);
+				this.#publication?.close();
+				this.#publication = null;
+				if (mode === "owned-root" && this.discovery?.ownerId === this.#owner) {
+					try {
+						const disk = JSON.parse(await fs.readFile(brokerDiscoveryPath(this.settings.agentDir), "utf8")) as {
+							ownerId?: string;
+						};
+						if (disk.ownerId === this.#owner) await fs.unlink(brokerDiscoveryPath(this.settings.agentDir));
+					} catch (e) {
+						if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e;
+					}
+					await this.#releaseOwnedLock();
+				}
+			} finally {
+				const disposeModelPin = this.#ownsResolveModelPin ? this.#resolveModelPin.dispose?.() : undefined;
+				if (mode === "lost-root" && disposeModelPin !== undefined) {
+					void disposeModelPin.catch(() => undefined);
+					await Promise.race([disposeModelPin, Bun.sleep(BROKER_SETTLEMENT_MS)]);
+				} else {
+					await disposeModelPin;
 				}
-				await this.#releaseOwnedLock();
+				this.discovery = null;
 			}
-			this.discovery = null;
 		})();
 		void this.#completionTask.then(this.#resolveCompletion, this.#rejectCompletion);
 		return this.#completionTask;
@@ -1417,14 +1433,25 @@ export class Broker {
 
 		try {
 			const endpointPath = path.join(record.locator.stateRoot, "sdk", `${record.sessionId}.json`);
-			const [source, metadata] = await Promise.all([fs.readFile(endpointPath, "utf8"), fs.stat(endpointPath)]);
+			const before = await fs.lstat(endpointPath, { bigint: true });
+			if (!before.isFile()) return error("endpoint_stale", "session endpoint is not a regular file");
+			const source = await fs.readFile(endpointPath, "utf8");
+			const metadata = await fs.lstat(endpointPath, { bigint: true });
+			if (
+				before.dev !== metadata.dev ||
+				before.ino !== metadata.ino ||
+				before.size !== metadata.size ||
+				before.mtimeNs !== metadata.mtimeNs ||
+				before.ctimeNs !== metadata.ctimeNs
+			)
+				return error("endpoint_stale", "session endpoint changed during read");
 			const endpoint = JSON.parse(source) as Record<string, unknown>;
 			if (
 				endpoint.sessionId !== record.sessionId ||
 				endpoint.pid !== record.pid ||
 				endpoint.stale === true ||
 				record.endpointMtimeMs === undefined ||
-				Math.abs(metadata.mtimeMs - record.endpointMtimeMs) > 0.001
+				Math.abs(Number(metadata.mtimeNs) / 1_000_000 - record.endpointMtimeMs) > 0.001
 			)
 				return error("endpoint_stale", "session endpoint is stale");
 			await this.index.refresh();

package/src/sdk/broker/lifecycle.ts

@@ -14,7 +14,10 @@ function nativeLifecycle(): typeof import("@gajae-code/natives") {
 }
 
 import { $credentialEnv, logger, resolveEquivalentPath } from "@gajae-code/utils";
-
+import {
+	loadAcceptedModelPresetRegistry,
+	loadAcceptedModelPresetRegistryAsync,
+} from "../../config/model-preset-registry";
 import {
 	isModelProfileError,
 	type ModelProfileErrorDetails,
@@ -609,13 +612,36 @@ function text(value: unknown): string | undefined {
 	return typeof value === "string" && value ? value : undefined;
 }
 
-function validateBrokerModelPreset(agentDir: string, requestedProfile: string): string | BrokerResponse {
+function validateBrokerModelPresetSync(agentDir: string, requestedProfile: string): string | BrokerResponse {
+	const modelsConfigFile = ModelsConfigFile.relocate(path.join(agentDir, "models.yml"));
+	modelsConfigFile.invalidate();
+	const loaded = modelsConfigFile.tryLoad();
+	const accepted = loadAcceptedModelPresetRegistry(agentDir);
+	const profiles = mergeModelProfiles(loaded.status === "ok" ? loaded.value.profiles : undefined, accepted.profiles);
+	try {
+		return validateModelProfileName(
+			requestedProfile,
+			profiles,
+			accepted.error ?? (loaded.status === "error" ? loaded.error : undefined),
+		);
+	} catch (error) {
+		if (isModelProfileError(error)) return fail(error.code, error.message, undefined, error.details);
+		throw error;
+	}
+}
+
+async function validateBrokerModelPreset(agentDir: string, requestedProfile: string): Promise<string | BrokerResponse> {
 	const modelsConfigFile = ModelsConfigFile.relocate(path.join(agentDir, "models.yml"));
 	modelsConfigFile.invalidate();
 	const loaded = modelsConfigFile.tryLoad();
-	const profiles = mergeModelProfiles(loaded.status === "ok" ? loaded.value.profiles : undefined);
+	const accepted = await loadAcceptedModelPresetRegistryAsync(agentDir);
+	const profiles = mergeModelProfiles(loaded.status === "ok" ? loaded.value.profiles : undefined, accepted.profiles);
 	try {
-		return validateModelProfileName(requestedProfile, profiles, loaded.status === "error" ? loaded.error : undefined);
+		return validateModelProfileName(
+			requestedProfile,
+			profiles,
+			accepted.error ?? (loaded.status === "error" ? loaded.error : undefined),
+		);
 	} catch (error) {
 		if (isModelProfileError(error)) return fail(error.code, error.message, undefined, error.details);
 		throw error;
@@ -623,7 +649,7 @@ function validateBrokerModelPreset(agentDir: string, requestedProfile: string):
 }
 
 export function validateBrokerModelPresetForTest(agentDir: string, requestedProfile: string): string | BrokerResponse {
-	return validateBrokerModelPreset(agentDir, requestedProfile);
+	return validateBrokerModelPresetSync(agentDir, requestedProfile);
 }
 
 function readinessTimeout(input: Input): number | BrokerResponse {
@@ -4030,7 +4056,7 @@ async function launchInput(
 	if (input.modelPreset !== undefined && (typeof input.modelPreset !== "string" || input.modelPreset.length === 0))
 		return fail("invalid_input", "modelPreset must be a non-empty exact profile ID.");
 	if (modelPreset !== undefined) {
-		const validatedModelPreset = validateBrokerModelPreset(broker.settings.agentDir, modelPreset);
+		const validatedModelPreset = await validateBrokerModelPreset(broker.settings.agentDir, modelPreset);
 		if (typeof validatedModelPreset !== "string") return validatedModelPreset;
 		modelPreset = validatedModelPreset;
 	}

package/src/sdk/bus/chat-daemon-control.ts

@@ -132,8 +132,8 @@ export type ChatDaemonAction = "stop" | "reload";
  * would retain the old hot polling loop, so replacement is required.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 70,
-	slack: 73,
+	discord: 71,
+	slack: 74,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {

package/src/sdk/bus/chat-daemon-runtime.ts

@@ -114,6 +114,10 @@ function readGeneration(value: unknown): number | undefined {
 	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
 }
 
+function readSequence(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
 /**
  * What one representation of a frame states about an identity it owns.
  *
@@ -138,7 +142,7 @@ const ABSENT_IDENTITY: IdentityClaim<never> = { state: "absent" };
  */
 function identityClaim<T>(
 	frame: Record<string, unknown> | undefined,
-	key: "sessionId" | "generation" | "name" | "kind",
+	key: "sessionId" | "generation" | "name" | "kind" | "seq",
 	read: (value: unknown) => T | undefined,
 ): IdentityClaim<T> {
 	if (!frame || !Object.hasOwn(frame, key)) return ABSENT_IDENTITY;
@@ -232,11 +236,17 @@ function correlateFrame(frame: Record<string, unknown>): CorrelatedFrame | undef
 		identityClaim(payload, "generation", readGeneration),
 	);
 	if (!generation.ok) return undefined;
+	const seq = reconcileIdentity(
+		identityClaim(frame, "seq", readSequence),
+		identityClaim(payload, "seq", readSequence),
+	);
+	if (!seq.ok) return undefined;
 	return {
 		body,
 		name: envelopeName.value ?? bodyName,
 		sessionId: sessionId.value,
 		generation: generation.value,
+		seq: seq.value,
 	};
 }