@gajae-code/coding-agent 0.11.6 → 0.11.8

package/src/sdk/client/discovery.ts

@@ -6,6 +6,8 @@ export interface SdkSessionEndpoint {
 	sessionId: string;
 	url: string;
 	token: string;
+	pid?: number;
+	stale?: boolean;
 	path: string;
 }
 
@@ -38,12 +40,26 @@ function endpointDirectory(repo: string): string {
 function parseEndpoint(sessionId: string, file: string, value: unknown): SdkSessionEndpoint {
 	if (!value || typeof value !== "object")
 		throw new SdkDiscoveryError(file, "SDK endpoint discovery record must be an object.");
-	const endpoint = value as { version?: unknown; url?: unknown; token?: unknown };
+	const endpoint = value as { version?: unknown; url?: unknown; token?: unknown; pid?: unknown; stale?: unknown };
 	if (typeof endpoint.version === "number" && endpoint.version > 1)
 		throw new SdkDiscoveryError(file, "Unsupported SDK endpoint discovery state version.");
-	if (typeof endpoint.url !== "string" || typeof endpoint.token !== "string" || !endpoint.url || !endpoint.token)
+	if (typeof endpoint.url !== "string" || !endpoint.url)
 		throw new SdkDiscoveryError(file, "SDK endpoint discovery record is invalid.");
-	return { sessionId, url: endpoint.url, token: endpoint.token, path: file };
+	const stale = typeof endpoint.stale === "boolean" ? endpoint.stale : undefined;
+	const pid =
+		typeof endpoint.pid === "number" && Number.isInteger(endpoint.pid) && endpoint.pid > 0 ? endpoint.pid : undefined;
+	if (endpoint.token !== undefined && typeof endpoint.token !== "string")
+		throw new SdkDiscoveryError(file, "SDK endpoint discovery record is invalid.");
+	const token = endpoint.token ?? "";
+	if (!token && stale !== true) throw new SdkDiscoveryError(file, "SDK endpoint discovery record is invalid.");
+	return {
+		sessionId,
+		url: endpoint.url,
+		token,
+		...(pid === undefined ? {} : { pid }),
+		...(stale === undefined ? {} : { stale }),
+		path: file,
+	};
 }
 
 function discoveryError(file: string, error: unknown): SdkDiscoveryError {

package/src/sdk/client/liveness.ts

@@ -0,0 +1,49 @@
+import type { SdkSessionEndpoint } from "./discovery";
+
+export type SdkEndpointLiveness = "live" | "stale" | "dead" | "unknown";
+
+export interface SdkEndpointSelectionError {
+	code:
+		| "endpoint_stale"
+		| "endpoint_dead"
+		| "endpoint_unknown"
+		| "no_live_endpoint"
+		| "multiple_live_endpoints"
+		| "not_found";
+}
+
+export function classifyEndpoint(endpoint: SdkSessionEndpoint): SdkEndpointLiveness {
+	if (endpoint.stale === true) return "stale";
+	if (!Number.isInteger(endpoint.pid) || endpoint.pid === undefined || endpoint.pid <= 0) return "unknown";
+	try {
+		process.kill(endpoint.pid, 0);
+		return "live";
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ESRCH") return "dead";
+		return code === "EPERM" ? "live" : "unknown";
+	}
+}
+
+export function selectLiveEndpoint(
+	records: readonly SdkSessionEndpoint[],
+	explicitSessionId?: string,
+): SdkSessionEndpoint | SdkEndpointSelectionError {
+	if (explicitSessionId !== undefined) {
+		const endpoint = records.find(record => record.sessionId === explicitSessionId);
+		if (!endpoint) return { code: "not_found" };
+		switch (classifyEndpoint(endpoint)) {
+			case "live":
+				return endpoint;
+			case "stale":
+				return { code: "endpoint_stale" };
+			case "dead":
+				return { code: "endpoint_dead" };
+			case "unknown":
+				return { code: "endpoint_unknown" };
+		}
+	}
+	const live = records.filter(record => classifyEndpoint(record) === "live");
+	if (live.length === 1) return live[0]!;
+	return { code: live.length === 0 ? "no_live_endpoint" : "multiple_live_endpoints" };
+}

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

@@ -137,7 +137,7 @@ function invoke(
 ): Promise<ControlValue> | ControlValue {
 	switch (operation) {
 		case "turn.prompt":
-			return surface.prompt(text(input), input.images);
+			return surface.prompt(text(input), input.images, input.clientRef as string | undefined);
 		case "turn.steer":
 			return surface.steer(text(input));
 		case "turn.follow_up":

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

@@ -6,7 +6,7 @@ export type ControlInput = Record<string, unknown>;
  * AgentSession and its controllers without exposing those concrete types here.
  */
 export interface ControlSurface {
-	prompt(text: string, images?: ControlValue): Promise<ControlValue> | ControlValue;
+	prompt(text: string, images?: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
 	steer(text: string): Promise<ControlValue> | ControlValue;
 	followUp(text: string): Promise<ControlValue> | ControlValue;
 	abort(): Promise<ControlValue> | ControlValue;

package/src/sdk/host/host.ts

@@ -15,7 +15,7 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	onProviderDefinitionsRemoved?: (capability: string) => void;
 	onReverseCancel?: (requestId: string, reason: "provider_disconnected" | "lease_released") => void;
 	/** Best-effort capabilities mirrored from the native transport for out-of-band consumers. */
-	connectionCapabilities?: (connectionId: string) => ReadonlySet<string>;
+	connectionCapabilities?: (connectionId: string) => ReadonlySet<string> | undefined;
 }
 
 const TOOL_ACTIVITY_V1 = "tool_activity_v1";
@@ -231,11 +231,7 @@ export class SessionSdkHost {
 					const sinceGeneration = rawGeneration;
 					const sinceSeq = rawSeq;
 					const replay = this.events.replay(sinceSeq, sinceGeneration);
-					const capabilities = Array.isArray(frame.capabilities)
-						? new Set(
-								frame.capabilities.filter((capability): capability is string => typeof capability === "string"),
-							)
-						: (this.#options.connectionCapabilities?.(connectionId) ?? EMPTY_CAPABILITIES);
+					const capabilities = this.#options.connectionCapabilities?.(connectionId) ?? EMPTY_CAPABILITIES;
 					const events = replay.events.filter(
 						event => !CAP_GATED_FRAME_KINDS.has(String(event.kind)) || capabilities.has(TOOL_ACTIVITY_V1),
 					);

package/src/sdk/host/query/handlers.ts

@@ -1,3 +1,4 @@
+import { PROMPT_CLIENT_REF_MAX_LENGTH } from "../../prompt-status.js";
 import {
 	assertCursorSelector,
 	type CursorEnvelope,
@@ -43,6 +44,10 @@ export interface SessionSurface {
 		| Promise<{ bytes: Uint8Array; totalBytes: number } | undefined>;
 
 	getJobs(): unknown | Promise<unknown>;
+	/** Q26 keyed lookup of a submitted prompt's authoritative reconciliation status. */
+	getPromptStatus?(selector: { commandId?: string; turnId?: string; clientRef?: string }): unknown | Promise<unknown>;
+	/** Q27 effective model-profile catalog from the live session registry. */
+	getModelProfiles?(): unknown[] | Promise<unknown[]>;
 	/** Query rows backed by the session's installed binding map. */
 	installedQueries?: ReadonlySet<string>;
 }
@@ -66,7 +71,7 @@ export interface QueryResponse {
 	ok: boolean;
 	page?: QueryPage;
 	result?: unknown;
-	error?: { code: string; message: string; restartQuery?: boolean };
+	error?: { code: string; message: string; restartQuery?: boolean; details?: unknown };
 }
 
 const sources: Record<string, { resource: string; method: keyof SessionSurface; mvcc: boolean }> = {
@@ -92,6 +97,7 @@ const sources: Record<string, { resource: string; method: keyof SessionSurface;
 	Q21: { resource: "queue", method: "getQueueMessages", mvcc: true },
 	Q22: { resource: "extensions", method: "getExtensions", mvcc: true },
 	Q25: { resource: "jobs", method: "getJobs", mvcc: false },
+	Q27: { resource: "modelProfiles", method: "getModelProfiles", mvcc: true },
 };
 const names = [
 	"transcript.list",
@@ -119,6 +125,8 @@ const names = [
 	"resource.body",
 	"artifact.read",
 	"runtime.jobs.list",
+	"turn.prompt_status",
+	"models.profiles.list",
 ];
 
 export class QueryHandlers {
@@ -147,13 +155,18 @@ export class QueryHandlers {
 				);
 			if (query === "Q02") return await this.#transcriptBody(request);
 			if (query === "Q23") return await this.#resourceBody(request);
+			if (query === "Q26") return await this.#promptStatus(request);
 			if (query === "Q24") return await this.#artifact(request);
+			if (query === "Q27" && request.input && Object.keys(request.input).length > 0)
+				return this.#error(request, "invalid_request", false, "models.profiles.list does not accept input fields.");
+			if (query === "Q27" && typeof this.surface.getModelProfiles !== "function")
+				return this.#error(request, "unavailable", false, "models.profiles.list is unavailable for this session.");
 			const source = sources[query];
 			if (!source) return this.#error(request, "invalid_request");
 			return await this.#pageSource(request, query, source);
 		} catch (error) {
 			if (error instanceof CursorError) return this.#error(request, error.code, error.restartQuery, error.message);
-			if (isTypedError(error)) return this.#error(request, error.code, false, error.message);
+			if (isTypedError(error)) return this.#error(request, error.code, false, error.message, error.details);
 			return this.#error(request, "internal", false, error instanceof Error ? error.message : String(error));
 		}
 	}
@@ -504,8 +517,60 @@ export class QueryHandlers {
 		return { id: request.id, ok: true, page };
 	}
 
-	#error(request: QueryRequest, code: string, restartQuery = false, message = code): QueryResponse {
-		return { id: request.id, ok: false, error: { code, message, ...(restartQuery ? { restartQuery: true } : {}) } };
+	async #promptStatus(request: QueryRequest): Promise<QueryResponse> {
+		if (request.cursor)
+			return this.#error(request, "invalid_request", false, "turn.prompt_status does not support cursors.");
+		const input = request.input ?? {};
+		for (const key of Object.keys(input))
+			if (key !== "commandId" && key !== "turnId" && key !== "clientRef")
+				return this.#error(
+					request,
+					"invalid_request",
+					false,
+					`turn.prompt_status does not accept selector field "${key}".`,
+				);
+		const commandId = typeof input.commandId === "string" && input.commandId ? input.commandId : undefined;
+		const turnId = typeof input.turnId === "string" && input.turnId ? input.turnId : undefined;
+		const rawClientRef = typeof input.clientRef === "string" ? input.clientRef : undefined;
+		const trimmedClientRef = rawClientRef?.trim();
+		if (rawClientRef !== undefined && (!trimmedClientRef || trimmedClientRef.length > PROMPT_CLIENT_REF_MAX_LENGTH))
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"clientRef must be a non-empty string of at most 128 characters.",
+			);
+		const clientRef = trimmedClientRef || undefined;
+		if ((commandId === undefined) !== (turnId === undefined))
+			return this.#error(request, "invalid_request", false, "commandId and turnId must be provided together.");
+		if (commandId !== undefined && clientRef !== undefined)
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"Provide exactly one selector: a commandId/turnId pair or a clientRef.",
+			);
+		if (commandId === undefined && clientRef === undefined)
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"turn.prompt_status requires a commandId/turnId pair or a clientRef.",
+			);
+		if (typeof this.surface.getPromptStatus !== "function")
+			return this.#error(request, "unavailable", false, "turn.prompt_status is unavailable for this session.");
+		const result = await this.surface.getPromptStatus(
+			clientRef !== undefined ? { clientRef } : { commandId: commandId!, turnId: turnId! },
+		);
+		return { id: request.id, ok: true, result };
+	}
+
+	#error(request: QueryRequest, code: string, restartQuery = false, message = code, details?: unknown): QueryResponse {
+		return {
+			id: request.id,
+			ok: false,
+			error: { code, message, ...(restartQuery ? { restartQuery: true } : {}), ...(details ? { details } : {}) },
+		};
 	}
 }
 function selectorFor(queryId: string, input: Record<string, unknown> | undefined): CursorSelector {
@@ -521,7 +586,7 @@ function idOf(value: unknown): string | undefined {
 function lastId(value: unknown): string | undefined {
 	return Array.isArray(value) ? idOf(value.at(-1)) : undefined;
 }
-function isTypedError(error: unknown): error is { code: string; message: string } {
+function isTypedError(error: unknown): error is { code: string; message: string; details?: unknown } {
 	return Boolean(
 		error &&
 			typeof error === "object" &&

package/src/sdk/index.ts

@@ -1,3 +1,14 @@
+export {
+	MODEL_PROFILE_DISCOVERY_QUERY,
+	MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES,
+	type ModelProfileCatalogItem,
+	type ModelProfileErrorCode,
+	type ModelProfileErrorDetails,
+	ModelProfileRegistryError,
+	type ModelProfileRegistryErrorDetails,
+	type UnknownModelProfileDetails,
+	UnknownModelProfileError,
+} from "../config/model-profile-contract";
 export * as bus from "./bus";
 export * from "./client";
 export * as host from "./host";
@@ -10,5 +21,6 @@ export type {
 	Q10ThinkingEffort,
 	Q10ThinkingMode,
 } from "./models";
+export * from "./prompt-status";
 export * from "./session";
 export * from "./session-directory";

package/src/sdk/prompt-status.ts

@@ -0,0 +1,97 @@
+/**
+ * Public DTO contract for Q26 `turn.prompt_status` and the `clientRef`
+ * correlation field on `turn.prompt`.
+ *
+ * Semantics:
+ * - `turn.prompt` remains ordered and non-idempotent. An envelope
+ *   `idempotencyKey` is ignored for replay/conflict purposes on ordered
+ *   operations (no replay cache, no `idempotency_conflict`).
+ * - `clientRef` is a caller-chosen correlation key (trimmed, non-empty,
+ *   1..PROMPT_CLIENT_REF_MAX_LENGTH chars; one fresh value per logical prompt)
+ *   mapped to the generated commandId/turnId at preflight acceptance so a
+ *   caller can reconcile after a lost acknowledgement frame.
+ * - The clientRef index is scoped to one live session runtime: identical refs
+ *   may coexist in different sessions, lookups never cross sessions, a ref
+ *   conflicts only while its record is retained (`client_ref_conflict`), and
+ *   after terminal TTL/capacity eviction a ref may be admitted again with the
+ *   prior outcome unknown — callers MUST NOT reuse a clientRef as a retry
+ *   mechanism and MUST treat `unknown` as uncertainty, not proof of
+ *   non-execution.
+ * - The durability floor is the live session process: after restart or
+ *   retained-record eviction, a lookup honestly reports `unknown`.
+ * - Q26 tracks prompts accepted through the SDK control surface (which always
+ *   carries a requesting connection); submissions without a delivery owner are
+ *   outside the reconciliation contract and hold no reservation.
+ */
+
+export const PROMPT_CLIENT_REF_MAX_LENGTH = 128;
+
+export interface TurnPromptImageInput {
+	data: string;
+	mimeType?: string;
+}
+
+/** Public input contract for ordered `turn.prompt`. */
+export interface TurnPromptInput {
+	text: string;
+	images?: TurnPromptImageInput[];
+	clientRef?: string;
+}
+
+/** Terminal outcome is preserved exactly; active records never age into terminal. */
+export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
+
+/** Exactly one selector per lookup. */
+export type TurnPromptStatusSelector = { clientRef: string } | { commandId: string; turnId: string };
+
+interface TurnPromptReconciliationIdentity {
+	commandId: string;
+	turnId: string;
+	clientRef?: string;
+	/** Epoch milliseconds of preflight acceptance. */
+	acceptedAt: number;
+}
+
+export interface TurnPromptReconciliationAccepted extends TurnPromptReconciliationIdentity {
+	status: "accepted";
+}
+
+export interface TurnPromptReconciliationInFlight extends TurnPromptReconciliationIdentity {
+	status: "in_flight";
+	/** Epoch milliseconds of the agent_start transition. */
+	startedAt: number;
+}
+
+export interface TurnPromptReconciliationTerminalOk extends TurnPromptReconciliationIdentity {
+	status: "terminal_ok";
+	startedAt?: number;
+	/** Epoch milliseconds of the terminal transition. */
+	terminalAt: number;
+}
+
+export interface TurnPromptReconciliationFailed extends TurnPromptReconciliationIdentity {
+	status: "failed";
+	startedAt?: number;
+	terminalAt: number;
+	/** Bounded, sanitized failure detail (code safe-token ≤64, message ≤512). */
+	error: { code: string; message: string };
+}
+
+export interface TurnPromptReconciliationUnknown {
+	status: "unknown";
+}
+
+export type TurnPromptReconciliation =
+	| TurnPromptReconciliationAccepted
+	| TurnPromptReconciliationInFlight
+	| TurnPromptReconciliationTerminalOk
+	| TurnPromptReconciliationFailed
+	| TurnPromptReconciliationUnknown;
+
+/** Result of a successful `turn.prompt` preflight acknowledgement. */
+export interface TurnPromptAcceptedResult {
+	commandId: string;
+	turnId: string;
+	accepted: true;
+	clientRef?: string;
+}

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

@@ -1511,6 +1511,42 @@
 			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
 		]
 	},
+	{
+		"sourceId": "registry:Q26",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "turn.prompt_status",
+		"adapterMappings": {
+			"telegram": "prohibited",
+			"discord": "prohibited",
+			"slack": "prohibited",
+			"mcp": "generic_safe",
+			"acp": "generic_safe",
+			"daemonCli": "generic_safe"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
+	{
+		"sourceId": "registry:Q27",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "models.profiles.list",
+		"adapterMappings": {
+			"telegram": "prohibited",
+			"discord": "prohibited",
+			"slack": "prohibited",
+			"mcp": "generic_safe",
+			"acp": "generic_safe",
+			"daemonCli": "generic_safe"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
 	{
 		"sourceId": "registry:R01",
 		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
@@ -2294,6 +2330,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:getDeepInterviewAskStage",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal AskTool schema-selection accessor, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:peekQueueInvoker",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -4430,6 +4477,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:createBtwConversationScope",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal privacy-scoped side-chat snapshot factory, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:runEphemeralTurn",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",

package/src/sdk/protocol/operation-registry.ts

@@ -154,6 +154,11 @@ const queries = [
 	["resource.body", "Read a bounded resource continuation."],
 	["artifact.read", "Read a bounded artifact range."],
 	["runtime.jobs.list", "List managed jobs."],
+	[
+		"turn.prompt_status",
+		"Read the authoritative reconciliation status of a submitted prompt by command/turn IDs or clientRef.",
+	],
+	["models.profiles.list", "List the effective built-in and configured model profiles for this session."],
 ] as const;
 
 const reverse = [
@@ -191,6 +196,7 @@ function controlDisposition(id: string): Record<Adapter, AdapterDisposition> {
 
 function controlErrors(id: string): string[] {
 	const errors: Record<string, string[]> = {
+		C01: ["client_ref_conflict", "reconciliation_capacity"],
 		C06: ["action_claimed"],
 		C07: ["action_claimed", "terminal_uncertain"],
 		C08: ["action_claimed", "terminal_uncertain"],
@@ -224,14 +230,14 @@ function revision(id: string): string | undefined {
 }
 function queryContinuityClass(id: string): QueryContinuityClass {
 	if (["Q01", "Q02"].includes(id)) return "stable_prefix";
-	if (["Q04", "Q05", "Q06", "Q07", "Q08", "Q11", "Q12", "Q13", "Q20", "Q21", "Q22", "Q23"].includes(id))
+	if (["Q04", "Q05", "Q06", "Q07", "Q08", "Q11", "Q12", "Q13", "Q20", "Q21", "Q22", "Q23", "Q27"].includes(id))
 		return "retained_revision";
 	if (id === "Q24") return "content_addressed";
 	return "scalar_snapshot";
 }
 
 function queryDisposition(id: string): Record<Adapter, AdapterDisposition> {
-	if (["Q23", "Q24", "Q25"].includes(id))
+	if (["Q23", "Q24", "Q25", "Q26", "Q27"].includes(id))
 		return dispositions({ telegram: "prohibited", discord: "prohibited", slack: "prohibited" });
 	return dispositions();
 }
@@ -263,7 +269,12 @@ export const OPERATIONS: readonly Operation[] = [
 			kind: "global" as const,
 			description,
 			idempotency: "idempotent" as const,
-			errorCodes: id === "G02" ? ["endpoint_credential_forbidden"] : ["invalid_request"],
+			errorCodes:
+				id === "G02"
+					? ["endpoint_credential_forbidden"]
+					: ["G03", "G04", "G05"].includes(id)
+						? ["invalid_request", "unknown_model_profile", "model_profile_registry_error"]
+						: ["invalid_request"],
 			adapterDispositions:
 				id === "G02"
 					? dispositions({
@@ -286,7 +297,10 @@ export const OPERATIONS: readonly Operation[] = [
 			kind: "query" as const,
 			description,
 			idempotency: "idempotent" as const,
-			errorCodes: ["invalid_request", "resource_gone"],
+			errorCodes:
+				id === "Q27"
+					? ["invalid_request", "resource_gone", "model_profile_registry_error"]
+					: ["invalid_request", "resource_gone"],
 			continuityClass: queryContinuityClass(id),
 			adapterDispositions: queryDisposition(id),
 			testIds: ["packages/coding-agent/test/sdk-operation-inventory.test.ts"],

package/src/sdk/session-directory.ts

@@ -38,7 +38,11 @@ export type ResolveManagedSessionScopeResult =
 				| "network_unsupported"
 				| "sessions_root_unavailable"
 				| "binding_conflict"
-				| "binding_invalid";
+				| "binding_invalid"
+				| "atomic_unavailable"
+				| "durability_not_provable"
+				| "durability_failed"
+				| "invalid_request";
 			message: string;
 	  };
 

package/src/sdk/session.ts

@@ -92,6 +92,7 @@ import type { FileSlashCommand } from "../extensibility/slash-commands";
 import type { HindsightSessionState } from "../hindsight/state";
 import { initializeLocalRoot, LocalProtocolHandler, type LocalProtocolOptions } from "../internal-urls";
 import { resolveMemoryBackend } from "../memory-backend";
+import btwUserPrompt from "../prompts/system/btw-user.md" with { type: "text" };
 import asyncResultTemplate from "../prompts/tools/async-result.md" with { type: "text" };
 import { AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
 import { MCPManager } from "../runtime-mcp";
@@ -149,6 +150,7 @@ import {
 	ReadTool,
 	ResolveTool,
 	SearchTool,
+	setConfiguredImageModel,
 	setPreferredImageProvider,
 	setPreferredSearchProvider,
 	setSearchFallbackProviders,
@@ -1158,14 +1160,27 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		applyConfiguredSearchTimeout(settings);
 
 		const imageProvider = settings.get("providers.image");
+		const imageModel = settings.get("providers.imageModel");
+		const imageCustomUrl = settings.get("providers.imageCustomUrl");
+		const imageCustomKey = settings.get("providers.imageCustomKey");
+		const imageCustomKeyEnv = settings.get("providers.imageCustomKeyEnv");
 		if (
 			imageProvider === "auto" ||
 			imageProvider === "openai" ||
 			imageProvider === "gemini" ||
 			imageProvider === "openrouter" ||
-			imageProvider === "antigravity"
+			imageProvider === "antigravity" ||
+			imageProvider === "alibaba" ||
+			imageProvider === "custom"
 		) {
-			setPreferredImageProvider(imageProvider);
+			setPreferredImageProvider(imageProvider === "custom" ? "auto" : imageProvider);
+			setConfiguredImageModel({
+				provider: imageProvider,
+				model: imageModel ?? null,
+				customUrl: imageCustomUrl,
+				customKey: imageCustomKey,
+				customKeyEnv: imageCustomKeyEnv,
+			});
 		}
 
 		const sessionManager =
@@ -1509,6 +1524,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			isManagedSessionDestination: () => sessionManager.isManagedDestination(),
 			getActiveSkillState: () => session?.getActiveSkillState(),
 			getActiveSkillPhase: () => session?.getActiveSkillPhase(),
+			getDeepInterviewAskStage: () => session?.getDeepInterviewAskStage(),
 			getHindsightSessionState: () => session?.getHindsightSessionState(),
 			get model() {
 				return agent?.state.model ?? model;
@@ -1590,13 +1606,19 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		// which collapses to the parent's dir for subagents (they adopt the
 		// parent's ArtifactManager) so one lookup hits everything.
 		const getArtifactsDir = () => sessionManager.getArtifactsDir();
+		const localProtocolOptions = options.localProtocolOptions ?? {
+			getArtifactsDir,
+			isManagedDestination: () => sessionManager.isManagedDestination(),
+			getManagedLegacyLocalMigrationSource: () => sessionManager.getManagedLegacyLocalMigrationSource(),
+			getSessionId: () => sessionManager.getSessionId(),
+		};
 		if (!options.parentTaskPrefix) {
 			setActiveSkills(skills);
 			setActiveRules([...rulebookRules, ...alwaysApplyRules]);
 			if (asyncJobManager) AsyncJobManager.setInstance(asyncJobManager);
 		}
+		await initializeLocalRoot(localProtocolOptions);
 		if (options.localProtocolOptions) {
-			await initializeLocalRoot(options.localProtocolOptions);
 			disposeLocalProtocolOverride = LocalProtocolHandler.installOverride(options.localProtocolOptions);
 		}
 		toolSession.getArtifactsDir = getArtifactsDir;
@@ -1849,9 +1871,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 						spawnedByGjc,
 						sdkHostModeSupported: options.sdkHostModeSupported,
 						ensureProviderDaemon: options.ensureNotificationProviderDaemon,
-						runEphemeralTurn: async (promptText, signal) => {
+						runBtwTurn: async (question, signal) => {
 							if (!session) throw new Error("Ephemeral turns are unavailable.");
-							const { replyText } = await session.runEphemeralTurn({ promptText, signal });
+							const { replyText } = await session.runEphemeralTurn({
+								purpose: "btw",
+								turn: { question, scope: session.createBtwConversationScope(btwUserPrompt) },
+								signal,
+							});
 							return { replyText };
 						},
 					});

package/src/sdk/startup-capability.ts

@@ -1,3 +1,8 @@
+import {
+	isModelProfileError,
+	type ModelProfileErrorCode,
+	type ModelProfileErrorDetails,
+} from "../config/model-profile-contract";
 export type SdkStartupPhase = "registration" | "startup";
 
 export type SdkStartupReason = "disabled" | "ineligible" | "factory_absent" | "runner_absent" | "pending" | "failed";
@@ -6,6 +11,8 @@ export interface SdkStartupFailure {
 	phase: SdkStartupPhase;
 	reason: SdkStartupReason;
 	message: string;
+	code?: ModelProfileErrorCode;
+	details?: ModelProfileErrorDetails;
 }
 
 export type SdkStartupResult = { status: "started" } | { status: "failed"; failure: SdkStartupFailure };
@@ -134,7 +141,8 @@ export function normalizeSdkStartupFailure(
 							? "SDK startup did not complete before readiness cutoff."
 							: FALLBACK_MESSAGE;
 	const message = sanitizeSdkStartupMessage(error, knownSecrets);
-	return { phase, reason, message: message === FALLBACK_MESSAGE ? fallback : message };
+	const profileError = isModelProfileError(error) ? { code: error.code, details: error.details } : {};
+	return { phase, reason, message: message === FALLBACK_MESSAGE ? fallback : message, ...profileError };
 }
 
 /** Collect process-scoped credentials without exposing a raw-secret API. */