@gajae-code/coding-agent 0.18.12 → 0.19.0

package/src/sdk/host/surface-policy.ts

@@ -80,6 +80,7 @@ export interface SdkSurfacePolicy {
 export interface SdkSurfacePolicyOptions {
 	bindings: Iterable<string>;
 	workflowGateAvailable: boolean;
+	imageUploadsAvailable?: boolean;
 	isBindingInstalled?: (binding: string) => boolean;
 }
 
@@ -96,6 +97,7 @@ export function createSdkSurfacePolicy(options: SdkSurfacePolicyOptions): SdkSur
 					operation.kind === kind &&
 					!BROKER_LIFECYCLE_CONTROL_OPERATIONS.has(operation.sdkId) &&
 					!UNINSTALLED_CONTROL_OPERATIONS.has(operation.sdkId) &&
+					(!operation.sdkId.startsWith("turn.image.") || options.imageUploadsAvailable === true) &&
 					(!WORKFLOW_GATE_CONTROL_OPERATIONS.has(operation.sdkId) || options.workflowGateAvailable) &&
 					(!required[operation.sdkId] || hasBinding(required[operation.sdkId]!)),
 			).map(operation => operation.sdkId),
@@ -129,11 +131,13 @@ export function createSdkCapabilities(
 export function createSdkSurfacePolicyForContext(
 	ctx: ExtensionContext,
 	workflowGateAvailable = false,
+	imageUploadsAvailable = false,
 ): SdkSurfacePolicy {
 	const bindings = ctx.sdkBindings?.() ?? [];
 	return createSdkSurfacePolicy({
 		bindings,
 		workflowGateAvailable,
+		imageUploadsAvailable,
 		isBindingInstalled: binding => typeof (ctx as unknown as Record<string, unknown>)[binding] === "function",
 	});
 }

package/src/sdk/host/websocket-transport.lifecycle.test.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { SdkClient } from "../client/client";
+import { SESSION_HOST_OBSERVER_CAPABILITY, TURN_STREAM_CAPABILITY } from "./host";
 import { SessionSdkSessionRuntime, type SessionSdkTransport } from "./session-runtime";
 import { createSdkWebSocketTransport, type SdkWebSocketTransportDependencies } from "./websocket-transport";
 
@@ -29,6 +30,28 @@ async function probeWebSocketEndpoint(url: string, token: string): Promise<void>
 	}
 }
 
+async function waitForFrame(
+	frames: readonly Record<string, unknown>[],
+	predicate: (frame: Record<string, unknown>) => boolean,
+	label: string,
+): Promise<Record<string, unknown>> {
+	const deadline = Date.now() + 5_000;
+	while (true) {
+		const frame = frames.find(predicate);
+		if (frame) return frame;
+		if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${label}`);
+		await Bun.sleep(5);
+	}
+}
+
+async function waitFor(predicate: () => boolean, label: string): Promise<void> {
+	const deadline = Date.now() + 5_000;
+	while (!predicate()) {
+		if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${label}`);
+		await Bun.sleep(5);
+	}
+}
+
 describe("SDK WebSocket transport lifecycle", () => {
 	test("concurrent start calls share one endpoint and one server", async () => {
 		const stateRoot = await tempStateRoot();
@@ -193,7 +216,72 @@ describe("SDK WebSocket transport lifecycle", () => {
 			await fs.rm(stateRoot, { recursive: true, force: true });
 		}
 	});
-	test("event replay capability claims cannot authorize gated replay", async () => {
+	test("loopback replay preserves replay-first, split, and subset capability negotiation", async () => {
+		const stateRoot = await tempStateRoot();
+		const transport = await createSdkWebSocketTransport({
+			sessionId: "loopback-split-capabilities",
+			stateRoot,
+			token: "token",
+		});
+		const runtime = new SessionSdkSessionRuntime({ transport });
+		const frames: Record<string, unknown>[] = [];
+		let socket: WebSocket | undefined;
+		const required = [TURN_STREAM_CAPABILITY, SESSION_HOST_OBSERVER_CAPABILITY];
+		try {
+			const endpoint = await runtime.start();
+			socket = new WebSocket(`${endpoint.url}?token=token`);
+			socket.addEventListener("message", event => {
+				frames.push(JSON.parse(String((event as MessageEvent).data)) as Record<string, unknown>);
+			});
+			await waitForFrame(frames, frame => frame.type === "hello", "server hello");
+			socket.send(
+				JSON.stringify({
+					type: "event_replay",
+					id: "replay-before-hello",
+					sinceSeq: 0,
+					capabilities: [],
+				}),
+			);
+			await waitForFrame(
+				frames,
+				frame => frame.type === "event_replay_result" && frame.id === "replay-before-hello",
+				"replay before hello",
+			);
+			socket.send(JSON.stringify({ type: "hello", protocolVersion: 3, capabilities: [TURN_STREAM_CAPABILITY] }));
+			await waitFor(
+				() => runtime.connectionIdsWithCapabilities([TURN_STREAM_CAPABILITY]).length === 1,
+				"hello after replay",
+			);
+
+			const replayIds = ["observer-addition", "observer-subset", "observer-empty"];
+			for (const [index, capabilities] of [
+				[SESSION_HOST_OBSERVER_CAPABILITY],
+				[SESSION_HOST_OBSERVER_CAPABILITY],
+				[],
+			].entries()) {
+				const id = replayIds[index]!;
+				socket.send(JSON.stringify({ type: "event_replay", id, sinceSeq: 0, capabilities }));
+				await waitForFrame(frames, frame => frame.type === "event_replay_result" && frame.id === id, id);
+				expect(runtime.connectionIdsWithCapabilities(required)).toHaveLength(1);
+			}
+
+			runtime.sendFrameToCapabilities(required, {
+				type: "event",
+				kind: "tool_activity",
+				payload: { phase: "started" },
+			});
+			await waitForFrame(
+				frames,
+				frame => frame.type === "event" && frame.kind === "tool_activity",
+				"live observer event",
+			);
+		} finally {
+			socket?.close();
+			await runtime.stop().catch(() => undefined);
+			await fs.rm(stateRoot, { recursive: true, force: true });
+		}
+	}, 30_000);
+	test("event replay keeps tool activity gated without tool_activity_v2", async () => {
 		const stateRoot = await tempStateRoot();
 		const transport = await createSdkWebSocketTransport({
 			sessionId: "replay-capability-claim",
@@ -223,7 +311,7 @@ describe("SDK WebSocket transport lifecycle", () => {
 					id: "forged-capability-claim",
 					sinceGeneration: 1,
 					sinceSeq: 0,
-					capabilities: ["tool_activity_v2"],
+					capabilities: [SESSION_HOST_OBSERVER_CAPABILITY],
 				}),
 			);
 			const frame = await replay;

package/src/sdk/host/websocket-transport.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { exactUnlink, type NativeExactFileIdentity } from "@gajae-code/natives";
 import {
+	AWAITING_INPUT_CAPABILITY,
 	canDeliverSdkEvent,
 	SESSION_HOST_OBSERVER_CAPABILITY,
 	TOOL_ACTIVITY_CAPABILITY,
@@ -167,6 +168,9 @@ export async function createSdkWebSocketTransport(
 			if (!socket) throw new Error("SDK connection is no longer available.");
 			socket.send(JSON.stringify(frame));
 		},
+		isConnectionOpen(connectionId) {
+			return sockets.has(connectionId);
+		},
 		start: async () => {
 			if (stopPromise) await stopPromise;
 			if (startPromise) return await startPromise;
@@ -203,6 +207,7 @@ export async function createSdkWebSocketTransport(
 										protocolVersion: 3,
 										connectionId: socket.data.connectionId,
 										capabilities: [
+											AWAITING_INPUT_CAPABILITY,
 											TOOL_ACTIVITY_CAPABILITY,
 											TURN_STREAM_CAPABILITY,
 											SESSION_HOST_OBSERVER_CAPABILITY,
@@ -226,16 +231,23 @@ export async function createSdkWebSocketTransport(
 										);
 										return;
 									}
-									if (
+									const isInitialHello =
 										frame.type === "hello" &&
 										frame.protocolVersion === 3 &&
-										(frame.capabilities === undefined || Array.isArray(frame.capabilities)) &&
-										!helloReceived.has(socket.data.connectionId)
+										!helloReceived.has(socket.data.connectionId);
+									if (
+										(isInitialHello || frame.type === "event_replay") &&
+										(frame.capabilities === undefined ||
+											(Array.isArray(frame.capabilities) &&
+												frame.capabilities.every((value: unknown) => typeof value === "string")))
 									) {
-										const capabilities = Array.isArray(frame.capabilities)
-											? frame.capabilities.filter((value): value is string => typeof value === "string")
-											: [];
-										helloReceived.add(socket.data.connectionId);
+										const capabilities = [
+											...new Set([
+												...(negotiatedCapabilities.get(socket.data.connectionId) ?? []),
+												...((frame.capabilities as string[] | undefined) ?? []),
+											]),
+										];
+										if (isInitialHello) helloReceived.add(socket.data.connectionId);
 										negotiatedCapabilities.set(socket.data.connectionId, new Set(capabilities));
 										capabilitiesHandler?.(socket.data.connectionId, capabilities);
 									}

package/src/sdk/lifecycle/service.ts

@@ -101,6 +101,10 @@ export type SessionCreateTarget = SessionLifecycleCoordinatorTarget & {
 	readonly body?: string;
 	readonly modelPreset?: string;
 	readonly mcpServers?: readonly Record<string, unknown>[];
+	/** Per-session environment for the hosted session; `GJC_*` names are reserved (#6735). */
+	readonly env?: Readonly<Record<string, string>>;
+	/** Inherited broker environment names removed from the hosted session (#6735). */
+	readonly unsetEnv?: readonly string[];
 	readonly worktree?: SessionLifecycleWorktreeTarget;
 	readonly readiness?: "immediate" | "deferred";
 	readonly readinessTimeoutMs?: number;
@@ -115,6 +119,10 @@ export type SessionForkTarget = SessionLifecycleCoordinatorTarget & {
 	readonly body?: string;
 	readonly modelPreset?: string;
 	readonly mcpServers?: readonly Record<string, unknown>[];
+	/** Per-session environment for the hosted session; `GJC_*` names are reserved (#6735). */
+	readonly env?: Readonly<Record<string, string>>;
+	/** Inherited broker environment names removed from the hosted session (#6735). */
+	readonly unsetEnv?: readonly string[];
 	readonly worktree?: SessionLifecycleWorktreeTarget;
 	readonly readinessTimeoutMs?: number;
 };
@@ -128,6 +136,10 @@ export type SessionResumeTarget = SessionLifecycleCoordinatorTarget & {
 	readonly body?: string;
 	readonly modelPreset?: string;
 	readonly mcpServers?: readonly Record<string, unknown>[];
+	/** Per-session environment for the hosted session; `GJC_*` names are reserved (#6735). */
+	readonly env?: Readonly<Record<string, string>>;
+	/** Inherited broker environment names removed from the hosted session (#6735). */
+	readonly unsetEnv?: readonly string[];
 	readonly worktree?: SessionLifecycleWorktreeTarget;
 	readonly readinessTimeoutMs?: number;
 };
@@ -550,7 +562,7 @@ export function validateSessionLifecycleMutationRequest(request: unknown): Sessi
 }
 
 function certaintyForBrokerCode(code: string): SessionLifecycleCertainty {
-	if (code === "terminal_uncertain") return "uncertain";
+	if (code === "terminal_uncertain" || code === "legacy_lifecycle_ambiguous") return "uncertain";
 	if (code === "cleanup_pending") return "cleanup_pending";
 	if (RETRYABLE_BROKER_ERRORS.has(code)) return "retryable";
 	return "terminal";
@@ -701,6 +713,7 @@ const savedSessionCandidateDetailCodes = new Set([
 	"cwd_not_utf8",
 	"cwd_network_unsupported",
 	"cwd_identity_unavailable",
+	"permission_denied",
 	"cwd_io_error",
 ]);
 

package/src/sdk/prompt-status.ts

@@ -40,12 +40,14 @@ export interface TurnPromptImageInput {
 	mimeType?: string;
 }
 
-/** Public input contract for ordered `turn.prompt`. */
-export interface TurnPromptInput {
+/** Public input contract for ordered `turn.prompt`; direct and staged images cannot be mixed. */
+export type TurnPromptInput = {
 	text: string;
-	images?: TurnPromptImageInput[];
 	clientRef?: string;
-}
+} & (
+	| { images?: TurnPromptImageInput[]; stagedImages?: never }
+	| { images?: never; stagedImages: Array<{ id: string }> }
+);
 
 /**
  * Terminal outcome is preserved exactly; active records never age into terminal. An

package/src/sdk/protocol/adapter-validation.ts

@@ -1,3 +1,5 @@
+import { MAX_STAGED_PROMPT_IMAGES } from "../../utils/image-limits";
+
 const RELOAD_COMPONENTS = new Set(["config", "models", "skills", "extensions", "tools"]);
 const SERVICE_TIERS = new Set([
 	"none",
@@ -73,10 +75,35 @@ function hasUsablePromptImage(value: unknown): boolean {
 	);
 }
 
+function hasValidStagedPromptImages(value: unknown): boolean {
+	if (!Array.isArray(value) || value.length === 0 || value.length > MAX_STAGED_PROMPT_IMAGES) return false;
+	const ids = new Set<string>();
+	return value.every(descriptor => {
+		if (!descriptor || typeof descriptor !== "object" || Array.isArray(descriptor)) return false;
+		const image = descriptor as Record<string, unknown>;
+		if (Object.keys(image).some(key => key !== "id") || typeof image.id !== "string" || image.id.trim().length === 0)
+			return false;
+		if (ids.has(image.id)) return false;
+		ids.add(image.id);
+		return true;
+	});
+}
+
 /** Rejects instruction-bearing controls before correlation or provider work. */
 export function validateRequiredPromptText(operation: string, input: Input): AdapterValidationError | undefined {
+	if (operation === "turn.prompt" && input.stagedImages !== undefined) {
+		if (input.images !== undefined)
+			return { code: "invalid_input", message: "Direct and staged images cannot be mixed." };
+		if (!hasValidStagedPromptImages(input.stagedImages))
+			return {
+				code: "invalid_input",
+				message: `stagedImages must contain 1–${MAX_STAGED_PROMPT_IMAGES} valid image IDs.`,
+			};
+	}
 	const hasUsableImage =
-		operation === "turn.prompt" && Array.isArray(input.images) && input.images.some(hasUsablePromptImage);
+		operation === "turn.prompt" &&
+		((Array.isArray(input.images) && input.images.some(hasUsablePromptImage)) ||
+			hasValidStagedPromptImages(input.stagedImages));
 	if (
 		PROMPT_OPERATIONS.has(operation) &&
 		(typeof input.text !== "string" || (input.text.trim().length === 0 && !hasUsableImage))

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

@@ -953,6 +953,78 @@
 			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
 		]
 	},
+	{
+		"sourceId": "registry:C54",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "turn.image.begin",
+		"adapterMappings": {
+			"telegram": "prohibited",
+			"discord": "prohibited",
+			"slack": "prohibited",
+			"mcp": "prohibited",
+			"acp": "prohibited",
+			"daemonCli": "machine_only"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
+	{
+		"sourceId": "registry:C55",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "turn.image.append",
+		"adapterMappings": {
+			"telegram": "prohibited",
+			"discord": "prohibited",
+			"slack": "prohibited",
+			"mcp": "prohibited",
+			"acp": "prohibited",
+			"daemonCli": "machine_only"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
+	{
+		"sourceId": "registry:C56",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "turn.image.finish",
+		"adapterMappings": {
+			"telegram": "prohibited",
+			"discord": "prohibited",
+			"slack": "prohibited",
+			"mcp": "prohibited",
+			"acp": "prohibited",
+			"daemonCli": "machine_only"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
+	{
+		"sourceId": "registry:C57",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "turn.image.discard",
+		"adapterMappings": {
+			"telegram": "prohibited",
+			"discord": "prohibited",
+			"slack": "prohibited",
+			"mcp": "prohibited",
+			"acp": "prohibited",
+			"daemonCli": "machine_only"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
 	{
 		"sourceId": "registry:G01",
 		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
@@ -2642,6 +2714,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:refreshEffectiveActiveWorkflowSkillState",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal durable workflow identity refresh before session safety checks, not an independent public SDK operation",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:replaceOwnedMcpManager",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -2891,6 +2974,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:notifySessionIdentityChanged",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal session-identity listener fan-out for in-process session surfaces; not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:emitNotice",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -2924,6 +3018,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:subscribeSessionIdentityChanges",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal session-identity subscription used by in-process adapters to follow session replacement; not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:dispose",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -3111,6 +3216,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:waitForAgentEndHandlingForTests",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only SDK terminal-event handler completion barrier, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:drainAsyncJobDeliveriesForAcp",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -3333,6 +3449,39 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:hasCommittedMCPToolSelectionAuthority",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal committed MCP-selection authority predicate used by catalog reconciliation; not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:hasMCPToolSelectionAuthority",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal MCP-selection authority predicate used by catalog and mode-transition reconciliation; not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:getActiveMCPToolNames",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal MCP bridge subset used by mode controllers to preserve live selections across tool swaps; not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:getSelectedMCPToolNames",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -4524,6 +4673,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:getActivatedModelProfile",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal model-profile activation provenance used to gate role-only materialization, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:setUnavailableModelProfile",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",

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

@@ -125,6 +125,10 @@ const controls = [
 	["retry.now", "Immediately retry pending backoff."],
 	["bash.background", "Move active managed bash to the background."],
 	["model.profile.set", "Activate a model profile for the current session."],
+	["turn.image.begin", "Begin a bounded host-owned image upload."],
+	["turn.image.append", "Append a canonical base64 image chunk."],
+	["turn.image.finish", "Verify and stage a complete image."],
+	["turn.image.discard", "Discard an unfinished or staged image."],
 ] as const;
 
 const globals = [
@@ -235,6 +239,15 @@ const reverse = [
 ] as const;
 
 function controlDisposition(id: string): Record<Adapter, AdapterDisposition> {
+	if (["C54", "C55", "C56", "C57"].includes(id))
+		return dispositions({
+			telegram: "prohibited",
+			discord: "prohibited",
+			slack: "prohibited",
+			mcp: "prohibited",
+			acp: "prohibited",
+			daemonCli: "machine_only",
+		});
 	if (["C25", "C26", "C27", "C28", "C29", "C30", "C31", "C32", "C34", "C48"].includes(id))
 		return dispositions({
 			telegram: "prohibited",
@@ -271,7 +284,13 @@ function controlErrors(id: string): string[] {
 		// C01/C05 submit a prompt and therefore run the prompt preflight, which
 		// refuses a session with no selected model before admission. The code is
 		// appended: ACP machine-only mapping reads errorCodes[0].
-		C01: ["client_ref_conflict", "reconciliation_capacity", "reconciliation_persist_failed", "model_not_selected"],
+		C01: [
+			"client_ref_conflict",
+			"reconciliation_capacity",
+			"reconciliation_persist_failed",
+			"model_not_selected",
+			"image_upload_unavailable",
+		],
 		C02: ["turn_not_active", "client_ref_conflict", "reconciliation_capacity", "reconciliation_persist_failed"],
 		C09: ["client_ref_conflict", "reconciliation_capacity", "reconciliation_persist_failed"],
 		C06: ["action_claimed"],
@@ -294,6 +313,10 @@ function controlErrors(id: string): string[] {
 		C50: ["nothing_to_retry", "busy"],
 		C51: ["retry_not_pending"],
 		C52: ["not_foldable", "already_backgrounded", "no_active_bash"],
+		C54: ["invalid_input", "busy", "resource_gone", "operation_prohibited"],
+		C55: ["invalid_input", "busy", "resource_gone", "operation_prohibited"],
+		C56: ["invalid_input", "busy", "resource_gone", "operation_prohibited"],
+		C57: ["invalid_input", "resource_gone", "operation_prohibited"],
 	};
 	return errors[id] ?? ["invalid_request", "busy"];
 }
@@ -354,8 +377,15 @@ export const OPERATIONS: readonly Operation[] = [
 					: id === "G10"
 						? ["invalid_input", "not_found", "idempotency_conflict", "lifecycle_pending", "terminal_uncertain"]
 						: ["G03", "G04", "G05"].includes(id)
-							? ["invalid_request", "unknown_model_profile", "model_profile_registry_error"]
-							: ["invalid_request"],
+							? [
+									"invalid_request",
+									"unknown_model_profile",
+									"model_profile_registry_error",
+									"legacy_lifecycle_ambiguous",
+								]
+							: ["G06", "G07", "G08"].includes(id)
+								? ["invalid_request", "legacy_lifecycle_ambiguous"]
+								: ["invalid_request"],
 			adapterDispositions:
 				id === "G02"
 					? dispositions({