@gajae-code/coding-agent 0.17.6 → 0.17.7

package/src/modes/controllers/extension-ui-controller.ts

@@ -626,6 +626,10 @@ export class ExtensionUiController {
 			invokeSkill: (name, args, options) => this.ctx.session.invokeSkill(name, args, options),
 			setPlanMode: on => this.ctx.session.setSdkPlanMode(on),
 			operateGoal: (op, objective) => this.ctx.session.operateGoal(op, objective),
+			// Read the CURRENT session on every call: interactive contexts outlive a
+			// session rebind, and the snapshot must stay session-owned (owner-filtered)
+			// instead of reaching for the process-global manager (issue: jobs Q25).
+			getJobs: () => this.ctx.session.getAsyncJobSnapshot(),
 			getSkillState: () =>
 				this.ctx.session.skills.map(skill => ({ name: skill.name, description: skill.description })),
 			getConfigItems: () => this.ctx.session.getSdkConfigItems(),
@@ -854,6 +858,8 @@ export class ExtensionUiController {
 				}
 				return false;
 			},
+			// Same session-owned binding as the hooks/custom-tools context above.
+			getJobs: () => this.ctx.session.getAsyncJobSnapshot(),
 			getSkillState: () =>
 				this.ctx.session.skills.map(skill => ({ name: skill.name, description: skill.description })),
 			getConfigItems: () => this.ctx.session.getSdkConfigItems(),

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

@@ -29,12 +29,10 @@ import { CURATED_TIER_MAP } from "../../config/autorouting-tier-map";
 import type { AppKeybinding } from "../../config/keybindings";
 import {
 	activateModelProfile,
-	type MaterializeModelProfileForDeletionResult,
 	materializeActiveModelProfileAssignment,
 	materializeActiveModelProfileAssignments,
-	materializeModelProfileForDeletion,
-	restoreMaterializedModelProfileForDeletion,
 } from "../../config/model-profile-activation";
+import { ModelProfileReplacementRequiredError } from "../../config/model-profile-ownership";
 import { formatModelProfileDisplayLabel, recommendModelProfileForProvider } from "../../config/model-profiles";
 import { GJC_MODEL_ASSIGNMENT_TARGETS, type GjcModelAssignmentTargetId } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
@@ -1750,7 +1748,7 @@ export class SelectorController {
 		const profileLabel = profile ? formatModelProfileDisplayLabel(profile) : profileName;
 		const confirmed = await this.ctx.showHookConfirm(
 			`Delete custom model preset: ${profileLabel}`,
-			"This removes the preset entry after preserving current role model settings when this preset is active/default.",
+			"Saved sessions keep references to deleted presets and will fail closed until an explicit replacement is selected.",
 		);
 		if (!confirmed) {
 			this.ctx.showStatus("Preset delete cancelled.");
@@ -1759,8 +1757,6 @@ export class SelectorController {
 		}
 
 		const activeProfile = this.ctx.session.getActiveModelProfile?.();
-		const defaultProfile = this.ctx.settings.get("modelProfile.default");
-		let snapshot: MaterializeModelProfileForDeletionResult | undefined;
 		let deletedProfile: ModelProfileConfig | undefined;
 		const refreshSelectorState = (refreshedProfileName?: string): void => {
 			modelSelector.refreshRoleAssignments({
@@ -1772,14 +1768,7 @@ export class SelectorController {
 			modelSelector.refreshPresetProfiles(refreshedProfileName);
 		};
 		try {
-			if (activeProfile === profileName || defaultProfile === profileName) {
-				snapshot = await materializeModelProfileForDeletion({
-					session: this.ctx.session,
-					modelRegistry: this.ctx.session.modelRegistry,
-					settings: this.ctx.settings,
-					profileName,
-				});
-			}
+			if (activeProfile === profileName) throw new ModelProfileReplacementRequiredError(profileName);
 			deletedProfile = await this.ctx.session.modelRegistry.deleteCustomModelProfile(profileName);
 			await this.ctx.session.modelRegistry.refresh("offline", this.ctx.session.credentialSessionId);
 			await this.ctx.notifyConfigChanged?.();
@@ -1796,21 +1785,6 @@ export class SelectorController {
 					presetRestoreError = restoreErr;
 				}
 			}
-			if (snapshot) {
-				try {
-					await restoreMaterializedModelProfileForDeletion({
-						settings: this.ctx.settings,
-						session: this.ctx.session,
-						snapshot,
-					});
-				} catch (restoreErr) {
-					refreshSelectorState(deletedProfile ? profileName : undefined);
-					this.ctx.showError(
-						`Preset delete failed and settings rollback failed: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`,
-					);
-					return;
-				}
-			}
 			if (deletedProfile) refreshSelectorState(profileName);
 			if (presetRestoreError) {
 				this.ctx.showError(

package/src/sdk/broker/broker.ts

@@ -21,6 +21,11 @@ import {
 	listManagedSessionCandidates,
 	resolveManagedSessionScope,
 } from "../session-directory";
+import {
+	SESSION_LIST_SAVED_SESSION_OMISSION_DETAIL_CODES,
+	type SessionListSavedSessionOmission,
+	type SessionListSavedSessionOmissionDetailCode,
+} from "../session-list";
 import {
 	BROKER_HEARTBEAT_TTL_MS,
 	type BrokerDiscovery,
@@ -392,6 +397,7 @@ type SessionListCursor = {
 	limit: number;
 	offset: number;
 	expiresAt: number;
+	cwd?: string;
 	scope?: ResolvedScopeV1;
 	observedAt?: string;
 };
@@ -550,6 +556,10 @@ function sessionListLimit(input: Record<string, unknown>): number | BrokerRespon
 	return limit;
 }
 
+function savedSessionOmissionDetailCode(code: string): SessionListSavedSessionOmissionDetailCode | undefined {
+	return SESSION_LIST_SAVED_SESSION_OMISSION_DETAIL_CODES.find(candidate => candidate === code);
+}
+
 function isBrokerResponse(value: unknown): value is BrokerResponse {
 	return typeof value === "object" && value !== null && "ok" in value && typeof value.ok === "boolean";
 }
@@ -750,8 +760,15 @@ export function normalizeBrokerInput(operation: string, input: Record<string, un
 		const resolved = input.resolveSessionId;
 		if (resolved !== undefined && (typeof resolved !== "string" || !isCanonicalSessionId(resolved)))
 			return error("invalid_input", "resolveSessionId must be a canonical safe identifier");
+		const cwd = input.cwd;
+		if (cwd !== undefined && (typeof cwd !== "string" || cwd.length === 0))
+			return error("invalid_input", "cwd must be a non-empty string");
 		if (input.cursor !== undefined && (typeof input.cursor !== "string" || input.cursor.length === 0))
 			return error("invalid_input", "cursor must be a non-empty opaque string");
+		if (input.cursor !== undefined && resolved !== undefined)
+			return error("invalid_input", "cursor cannot be combined with resolveSessionId");
+		if (input.scope !== undefined && (cwd !== undefined || resolved !== undefined))
+			return error("invalid_input", "scope cannot be combined with cwd or resolveSessionId");
 		const limit = sessionListLimit(input);
 		if (isBrokerResponse(limit)) return limit;
 		if (input.scope !== undefined && !scopeRequestV1(input.scope) && input.cursor === undefined)
@@ -4469,6 +4486,8 @@ export class Broker {
 			if (typeof cursor === "string") this.#sessionListCursors.delete(cursor);
 			return error("invalid_input", "cursor is expired or invalid");
 		}
+		if (stored && input.cwd !== undefined && input.cwd !== stored.cwd)
+			return error("cwd_cursor_mismatch", "cwd must match the cursor snapshot");
 		if (stored && requestedLimit !== undefined && stored.limit !== requestedLimit)
 			return error("invalid_input", "limit must match the cursor page shape");
 		let scope: ResolvedScopeV1 | undefined;
@@ -4511,6 +4530,7 @@ export class Broker {
 			limit,
 			offset: 0,
 			expiresAt: Date.now() + SESSION_LIST_CURSOR_TTL_MS,
+			...(typeof input.cwd === "string" ? { cwd: input.cwd } : {}),
 			...(scope === undefined ? {} : { scope, observedAt: observedAt! }),
 		};
 		const sessions = snapshot.sessions.slice(snapshot.offset, snapshot.offset + snapshot.limit).map(session => {
@@ -4543,17 +4563,31 @@ export class Broker {
 		requestedOperation: string,
 		idempotencyKey: string | undefined,
 		requestedFingerprint: string,
+		legacyFingerprint?: string,
 	): Promise<BrokerResponse> {
 		if (!idempotencyKey) return error("invalid_input", "operation, idempotencyKey, and fingerprint are required");
 		if (requestedOperation === "session.spawn")
 			return error("invalid_input", "session.spawn does not support lifecycle lookup");
 		if (!LIFECYCLE_OPERATIONS.has(requestedOperation)) return error("not_found", "lifecycle operation was not found");
 		const identity = await deriveIdempotencyIdentity(this.settings.agentDir, requestedOperation, idempotencyKey);
-		const entry =
+		let entry =
 			this.ledger.get(identity) ??
 			this.ledger.findByOperationKey(`${requestedOperation}\0${idempotencyKey}`, requestedFingerprint);
+		let acceptedFingerprint = requestedFingerprint;
+		if (!entry && legacyFingerprint !== undefined) {
+			// Rows written before target-bound identities (v3) fingerprinted the raw,
+			// un-normalized request and are never expired, so they are matched only
+			// under their exact v3 identity and only against that raw fingerprint.
+			const legacy = this.ledger.get(
+				await deriveLegacyIdentity(this.settings.agentDir, requestedOperation, idempotencyKey),
+			);
+			if (legacy) {
+				entry = legacy;
+				if (legacy.fingerprint === legacyFingerprint) acceptedFingerprint = legacyFingerprint;
+			}
+		}
 		if (!entry) return error("not_found", "lifecycle operation was not found");
-		if (entry.fingerprint !== requestedFingerprint)
+		if (entry.fingerprint !== acceptedFingerprint)
 			return error("idempotency_conflict", "lifecycle request fingerprint differs");
 		if (entry.state === "terminal_uncertain")
 			return error("terminal_uncertain", "lifecycle outcome is still uncertain");
@@ -4606,9 +4640,14 @@ export class Broker {
 		if (operation === "session.lookup") {
 			const lookup = publicLifecycleLookupInput(input);
 			if (isBrokerResponse(lookup)) return lookup;
+			// The ledger fingerprint covers the normalized mutation input, so the
+			// lookup target must pass through the same normalization to match it.
+			const lookupTarget = normalizeBrokerInput(lookup.operation, lookup.target);
+			if (isBrokerResponse(lookupTarget)) return lookupTarget;
 			return await this.#lookupLifecycle(
 				lookup.operation,
 				idempotencyKey,
+				lifecycleFingerprint(lookup.operation, lookupTarget.input),
 				lifecycleFingerprint(lookup.operation, lookup.target),
 			);
 		}
@@ -4625,38 +4664,96 @@ export class Broker {
 			const cwd = typeof input.cwd === "string" ? input.cwd : undefined;
 			if (resolveSessionId && cwd) {
 				const scope = await resolveManagedSessionScope({ cwd, agentDir: this.settings.agentDir });
-				const listed =
+				let listed =
 					scope.kind === "resolved" ? await listManagedSessionCandidates({ scope: scope.scope }) : undefined;
+				if (
+					scope.kind === "resolved" &&
+					listed?.kind === "complete" &&
+					listed.invalid.some(
+						candidate => candidate.sessionId === resolveSessionId && candidate.code === "source_changed",
+					)
+				)
+					// A writer can finish after the preflight read but before the independent
+					// identity-bound inspection. Retry one complete scan, rerunning every
+					// scope, no-follow, uniqueness, and identity check against fresh state.
+					listed = await listManagedSessionCandidates({ scope: scope.scope });
+				const invalidCandidate =
+					listed?.kind === "complete"
+						? listed.invalid.find(candidate => candidate.sessionId === resolveSessionId)
+						: undefined;
 				const matches =
 					listed?.kind === "complete"
 						? listed.owned.filter(candidate => candidate.sessionId === resolveSessionId)
 						: [];
 				const match = matches.length === 1 ? matches[0] : undefined;
-				const savedSession =
-					match &&
-					match.sessionId === resolveSessionId &&
-					match.identity.nlink !== undefined &&
-					match.identity.ctimeNs !== undefined
-						? {
-								id: match.sessionId,
-								path: match.path,
-								identity: {
-									dev: match.identity.dev.toString(),
-									ino: match.identity.ino.toString(),
-									nlink: match.identity.nlink.toString(),
-									size: match.identity.size,
-									mtimeMs: match.identity.mtimeMs,
-									mtimeNs: match.identity.mtimeNs.toString(),
-									ctimeNs: match.identity.ctimeNs.toString(),
-									sha256: match.identity.sha256,
-								},
-							}
-						: undefined;
+				let savedSession: Record<string, unknown> | undefined;
+				let savedSessionOmission: SessionListSavedSessionOmission | undefined;
+				if (scope.kind !== "resolved") {
+					savedSessionOmission = {
+						sessionId: resolveSessionId,
+						reason: "scope_unavailable",
+						detailCode: scope.code,
+					};
+				} else if (listed?.kind !== "complete") {
+					savedSessionOmission = {
+						sessionId: resolveSessionId,
+						reason: "candidate_scan_failed",
+						...(listed === undefined ? {} : { detailCode: listed.code }),
+					};
+				} else if (invalidCandidate !== undefined) {
+					const detailCode = savedSessionOmissionDetailCode(invalidCandidate.code);
+					savedSessionOmission = {
+						sessionId: resolveSessionId,
+						reason: "candidate_invalid",
+						...(detailCode === undefined ? {} : { detailCode }),
+					};
+				} else if (matches.length === 0) {
+					savedSessionOmission = {
+						sessionId: resolveSessionId,
+						reason: "candidate_not_found",
+					};
+				} else if (matches.length > 1) {
+					savedSessionOmission = {
+						sessionId: resolveSessionId,
+						reason: "candidate_ambiguous",
+						candidateCount: matches.length,
+					};
+				} else if (match) {
+					const missingIdentityFields: ("nlink" | "ctimeNs")[] = [];
+					const { nlink, ctimeNs } = match.identity;
+					if (nlink === undefined) missingIdentityFields.push("nlink");
+					if (ctimeNs === undefined) missingIdentityFields.push("ctimeNs");
+					if (missingIdentityFields.length > 0) {
+						savedSessionOmission = {
+							sessionId: resolveSessionId,
+							reason: "identity_incomplete",
+							missingIdentityFields,
+						};
+					} else if (match.sessionId === resolveSessionId && nlink !== undefined && ctimeNs !== undefined) {
+						savedSession = {
+							id: match.sessionId,
+							path: match.path,
+							identity: {
+								dev: match.identity.dev.toString(),
+								ino: match.identity.ino.toString(),
+								nlink: nlink.toString(),
+								size: match.identity.size,
+								mtimeMs: match.identity.mtimeMs,
+								mtimeNs: match.identity.mtimeNs.toString(),
+								ctimeNs: ctimeNs.toString(),
+								sha256: match.identity.sha256,
+							},
+						};
+					}
+				} else {
+					savedSessionOmission = { sessionId: resolveSessionId, reason: "candidate_not_found" };
+				}
 				return {
 					...page,
 					result: {
 						...pageResult,
 						...(savedSession === undefined ? {} : { savedSession }),
+						...(savedSessionOmission === undefined ? {} : { savedSessionOmission }),
 					},
 				};
 			}

package/src/sdk/broker/lifecycle.ts

@@ -3,7 +3,7 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import path from "node:path";
-import type { NativeExactUnlinkResult } from "@gajae-code/natives";
+import type { NativeExactFileIdentity, NativeExactUnlinkResult } from "@gajae-code/natives";
 
 let nativeLifecycleBindings: typeof import("@gajae-code/natives") | undefined;
 
@@ -1758,29 +1758,105 @@ export async function writeEffectMarker(root: string, id: string, marker: Effect
 	}
 }
 
+export class LifecycleReadinessCleanupError extends Error {
+	constructor(cause: unknown) {
+		super("Lifecycle readiness marker cleanup could not be proven.", { cause });
+		this.name = "LifecycleReadinessCleanupError";
+	}
+}
+
+const LIFECYCLE_READY_REVOCATION_GRACE_MS = 100;
+
 /** The child writes this only after its endpoint and semantic ready event are both live. */
-export async function writeSessionLifecycleReady(root: string, id: string, effectMarker: string): Promise<void> {
+export async function writeSessionLifecycleReady(
+	root: string,
+	id: string,
+	effectMarker: string,
+	canPublish: () => boolean = () => true,
+	onPublishing?: (revoke: () => Promise<boolean>) => void,
+	onPublished?: () => void,
+): Promise<void> {
 	const incarnation = processIncarnation(process.pid);
 	if (!incarnation) throw new Error("Lifecycle child has no readable OS incarnation.");
+	const native = nativeLifecycle();
 	const directory = path.join(root, "sdk");
 	await fs.mkdir(directory, { recursive: true, mode: 0o700 });
 	const temporary = path.join(directory, `.${id}.lifecycle.ready.${randomUUID()}.tmp`);
-	const handle = await fs.open(
-		temporary,
-		fsSync.constants.O_CREAT | fsSync.constants.O_EXCL | fsSync.constants.O_WRONLY,
-		0o600,
-	);
+	const readyPath = lifecycleReadyPath(root, id);
+	let handle: fs.FileHandle | undefined;
+	let published = false;
+	let publicationIdentity: NativeExactFileIdentity | undefined;
+	let revocation: Promise<boolean> | undefined;
+	const readyMarkerIsAbsent = async (): Promise<boolean> => {
+		try {
+			await fs.lstat(readyPath);
+			return false;
+		} catch (error) {
+			return (error as NodeJS.ErrnoException).code === "ENOENT";
+		}
+	};
+	const revoke = (): Promise<boolean> => {
+		if (revocation) return revocation;
+		if (!publicationIdentity) return Promise.resolve(false);
+		let queued: boolean;
+		try {
+			queued = native.exactUnlinkDirectDetached(readyPath, publicationIdentity);
+		} catch {
+			queued = false;
+		}
+		if (!queued) {
+			revocation = readyMarkerIsAbsent();
+			return revocation;
+		}
+		revocation = (async () => {
+			const deadline = Date.now() + LIFECYCLE_READY_REVOCATION_GRACE_MS;
+			while (Date.now() < deadline) {
+				if (await readyMarkerIsAbsent()) return true;
+				await Bun.sleep(5);
+			}
+			return false;
+		})();
+		return revocation;
+	};
 	try {
-		await handle.writeFile(canonicalJson({ pid: process.pid, effectMarker, incarnation }));
+		handle = await fs.open(
+			temporary,
+			fsSync.constants.O_CREAT | fsSync.constants.O_EXCL | fsSync.constants.O_WRONLY,
+			0o600,
+		);
+		const contents = Buffer.from(canonicalJson({ pid: process.pid, effectMarker, incarnation }), "utf8");
+		await handle.writeFile(contents);
 		await handle.sync();
-	} finally {
+		const stat = await handle.stat({ bigint: true });
+		const parent = await fs.lstat(directory, { bigint: true });
+		if (!stat.isFile() || stat.nlink !== 1n || stat.size !== BigInt(contents.byteLength) || !parent.isDirectory())
+			throw new Error("Lifecycle readiness publication identity is invalid.");
+		publicationIdentity = {
+			dev: stat.dev,
+			ino: stat.ino,
+			nlink: stat.nlink,
+			parentDev: parent.dev,
+			parentIno: parent.ino,
+			size: stat.size,
+			mtimeNs: stat.mtimeNs,
+			sha256: createHash("sha256").update(contents).digest("hex"),
+			quarantineName: `.gjc-reap-${randomUUID()}-${path.basename(readyPath)}`,
+		};
 		await handle.close();
-	}
-	try {
-		await fs.rename(temporary, lifecycleReadyPath(root, id));
+		handle = undefined;
+		if (!canPublish()) throw new Error("Lifecycle readiness cutoff passed before publication.");
+		await fs.rename(temporary, readyPath);
+		published = true;
+		onPublishing?.(revoke);
 		await syncDirectory(directory);
+		if (!canPublish()) throw new Error("Lifecycle readiness cutoff passed during publication.");
+		onPublished?.();
+	} catch (error) {
+		if (published && !(await revoke())) throw new LifecycleReadinessCleanupError(error);
+		throw error;
 	} finally {
-		await fs.rm(temporary, { force: true });
+		if (handle) await handle.close().catch(() => {});
+		if (!published) await fs.rm(temporary, { force: true });
 	}
 }
 

package/src/sdk/cli/session-cli.ts

@@ -4,7 +4,13 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { replaceTabs, truncateToWidth } from "@gajae-code/tui";
 import { getAgentDir, logger, sanitizeDisplayLine } from "@gajae-code/utils";
-import { PublicCommandFailure, type PublicEffectProof, type PublicFailureKind } from "../../cli/public-command-errors";
+import {
+	PUBLIC_COMMAND_DIAGNOSTICS,
+	type PublicCommandDiagnosticCode,
+	PublicCommandFailure,
+	type PublicEffectProof,
+	type PublicFailureKind,
+} from "../../cli/public-command-errors";
 import type { EvidenceReference } from "../../cli/public-command-evidence";
 import { repo as resolveGitRepository } from "../../utils/git";
 import { ensureBroker } from "../broker/ensure";
@@ -20,6 +26,7 @@ import { lifecycleRequestTimeoutMs } from "../broker/startup-budget";
 import { readSdkBrokerDiscovery, SdkClient, SdkClientError } from "../client";
 import { createBrokerSessionLifecycleService } from "../lifecycle/broker-client";
 import type {
+	SessionLifecycleLookupOutcome,
 	SessionLifecycleMutationRequest,
 	SessionLifecycleOperation,
 	SessionLifecycleResult,
@@ -194,6 +201,10 @@ export function sdkPublicFailure(code: string, details?: unknown, proof?: Public
 		kind: Object.hasOwn(kinds, code) ? kinds[code]! : "operation_failed",
 		proof: code === "wait_timeout" ? "accepted" : proof,
 		references,
+		// A typed `resource_gone` keeps its public classification; the fixed
+		// diagnostic only separates absent resource state from an empty result.
+		// It asserts no cause and echoes no host-supplied text.
+		...(code === "resource_gone" ? { diagnostics: ["sdk_resource_gone" as const] } : {}),
 	});
 }
 
@@ -242,8 +253,15 @@ export function lifecyclePublicFailure(outcome: Extract<SessionLifecycleResult,
 	// The service emits retryable protocol_error only when requestSent is explicitly false.
 	const proof: PublicEffectProof =
 		outcome.certainty === "retryable" && outcome.error.code === "protocol_error" ? "pre-send" : "unknown";
+	// `operation_failed` cannot distinguish a conflict from any other failed operation, so
+	// the conflict survives as one fixed diagnostic. The broker message itself is never
+	// rendered: it may carry request keys, paths, or credentials, and its cause is not
+	// decidable from the code alone.
+	const diagnostics: readonly PublicCommandDiagnosticCode[] | undefined =
+		outcome.error.code === "idempotency_conflict" ? ["lifecycle_idempotency_conflict"] : undefined;
 	return new PublicCommandFailure({
 		...failure.input,
+		...(diagnostics === undefined ? {} : { diagnostics }),
 		// Generic lifecycle codes cannot override the authoritative, conservative proof.
 		kind:
 			failure.input.kind === "usage" || failure.input.kind === "invalid_json"
@@ -2274,6 +2292,22 @@ function sessionCloseRequestKey(
 	return `${SDK_SESSION_CLI_LIFECYCLE_ACTOR.namespace}:session.close:${sessionId}:${authority.endpointGeneration}:${authority.endpointIncarnation}`;
 }
 
+/**
+ * The lookup route returns its structured outcome directly: it never passes through the
+ * public error envelope (nor its 8192-byte budget), and `stripSecretFields` only drops
+ * secret-shaped field *names*, not a broker-controlled `message` body. A conflict message
+ * can carry request keys, paths, or credentials, so exactly that code carries the same
+ * fixed, cause-neutral text as the public diagnostic. Every other code — including unknown,
+ * near-miss, and prototype-shaped ones — is left undiagnosed and unchanged.
+ */
+function sanitizedLookupOutcome(outcome: SessionLifecycleLookupOutcome): SessionLifecycleLookupOutcome {
+	if (outcome.ok || outcome.error.code !== "idempotency_conflict") return outcome;
+	return {
+		...outcome,
+		error: { ...outcome.error, message: PUBLIC_COMMAND_DIAGNOSTICS.lifecycle_idempotency_conflict },
+	};
+}
+
 async function runRawGlobal(
 	agentDir: string,
 	operation: string,
@@ -2307,13 +2341,15 @@ async function runRawGlobal(
 		if (!args.idempotencyKey)
 			throw new SdkSessionCliError("invalid_input", "--idempotency-key is required for session lookup.", 2);
 		const lifecycle = lifecycleOverride ?? createBrokerSessionLifecycleService(agentDir);
-		return await lifecycle.lookup({
-			actor: SDK_SESSION_CLI_LIFECYCLE_ACTOR,
-			capability: "session.lookup",
-			operation: "session.create",
-			requestKey: args.idempotencyKey,
-			target: input,
-		});
+		return sanitizedLookupOutcome(
+			await lifecycle.lookup({
+				actor: SDK_SESSION_CLI_LIFECYCLE_ACTOR,
+				capability: "session.lookup",
+				operation: "session.create",
+				requestKey: args.idempotencyKey,
+				target: input,
+			}),
+		);
 	}
 	if (!isLifecycleOperation(operation))
 		throw new SdkSessionCliError("unknown_operation", `Unknown global operation: ${operation}`, 1);
@@ -2510,7 +2546,7 @@ export async function runSdkSessionCli(
 		const secretError = validateAdapterSecretFields(operation, input);
 		if (secretError) throw new SdkSessionCliError(secretError.code, secretError.message, 2);
 		if (kind === "global") {
-			const result = await runRawGlobal(agentDir, operation, input, args);
+			const result = await runRawGlobal(agentDir, operation, input, args, deps.lifecycleService);
 			writeOutput(stripSecretFields(result));
 			if (isRecord(result) && result.ok === false) setExitCode(1);
 			return;

package/src/sdk/host/control/dispatch.ts

@@ -3,6 +3,7 @@ import {
 	DEFAULT_MODEL_SELECTION_RECOVERY_MESSAGE,
 	parseDefaultModelSelectionRecovery,
 } from "../../../session/default-model-selection";
+import { MODEL_NOT_SELECTED_CODE, MODEL_NOT_SELECTED_PUBLIC_MESSAGE } from "../../../setup/model-onboarding-guidance";
 import { validateRequiredPromptText } from "../../protocol/adapter-validation";
 import { OPERATIONS, type Operation } from "../../protocol/operation-registry";
 import type { ControlInput, ControlSurface, ControlValue } from "./operations";
@@ -370,6 +371,11 @@ function errorResponse(id: string, row: Operation, error: unknown): ControlRespo
 		};
 		return failure(id, code, DEFAULT_MODEL_SELECTION_RECOVERY_MESSAGE, undefined, recovery);
 	}
+	// The missing-model preflight message carries local onboarding guidance
+	// (providers, commands, env vars, setup paths); publish the fixed safe text
+	// instead so the client still learns the actual, actionable state.
+	if (code === MODEL_NOT_SELECTED_CODE && row.errorCodes.includes(code))
+		return failure(id, code, MODEL_NOT_SELECTED_PUBLIC_MESSAGE);
 	if (code && (row.errorCodes.includes(code) || SHARED_ERROR_CODES.has(code)))
 		return failure(id, code, message, undefined, details);
 	if (code === "resource_gone" || /not found|gone/i.test(message)) return failure(id, "resource_gone", message);