@gajae-code/coding-agent 0.16.7 → 0.17.1

package/src/sdk/host/session-runtime.ts

@@ -47,6 +47,7 @@ import {
 	type MasterRoleAttestationV2,
 	resolveSessionLocator,
 	SessionIndex,
+	type SessionIndexEvent,
 	type SessionLocatorV2,
 } from "../broker/session-index";
 import {
@@ -58,7 +59,16 @@ import {
 } from "../model-profile-model";
 import { projectQ10Models } from "../models.js";
 import { PromptDeadlineManager, type PromptTerminalTransitionEvidence } from "../prompt-deadline-manager";
-import { formatPromptFailureForLocalLog, sanitizePromptFailure } from "../prompt-failure";
+import {
+	assistantFailureCode,
+	failedPromptOutcome,
+	failureEvidence,
+	formatPromptFailureForLocalLog,
+	PROMPT_FAILURE_MESSAGE_SUBMISSION,
+	type PromptFailureEvidence,
+	rephaseFailedOutcome,
+	sanitizePromptFailure,
+} from "../prompt-failure";
 import type { SdkPromptTerminalOutcome } from "../prompt-status";
 import { validateRequiredPromptText } from "../protocol/adapter-validation";
 import { OPERATIONS } from "../protocol/operation-registry";
@@ -524,6 +534,8 @@ export interface CreateSdkSessionRuntimeOptions {
 	brokerRegistrationRequired?: boolean;
 	/** Trusted broker-issued lifecycle marker bound to lifecycle host index events. */
 	lifecycleRequestId?: string;
+	/** Startup surface that owns host-level permission and lifecycle authority. */
+	primaryControlSurface?: "cli" | "sdk";
 	createTransport(input: {
 		sessionId: string;
 		stateRoot: string;
@@ -597,24 +609,39 @@ const isPreservedProviderFailure = (code: string | undefined): boolean =>
  * classifier so a failed terminal can never be quarantined on reload.
  */
 function canonicalFailedOutcome(
-	failure?: { code?: unknown; message?: unknown },
+	failure?: { code?: unknown; message?: unknown; providerCode?: unknown },
 	provenance: "agent_failed" | "deadline" = "agent_failed",
+	evidence: PromptFailureEvidence = {},
+	providerCode?: string,
 ): InvocationOutcome {
 	const deadline = provenance === "deadline" || failure?.code === "prompt_deadline_exceeded";
-	return {
-		kind: "failed",
+	const known = typeof failure?.code === "string" ? failure.code : undefined;
+	const explicit = providerCode ?? (typeof failure?.providerCode === "string" ? failure.providerCode : undefined);
+	return failedPromptOutcome({
 		code: deadline ? "prompt_deadline_exceeded" : "prompt_failed",
-		message: deadline ? "Prompt deadline exceeded." : EMPTY_PROMPT_FAILURE.message,
 		provenance: deadline ? "deadline" : "agent_failed",
-	};
+		...(explicit !== undefined
+			? { providerCode: explicit }
+			: known !== undefined && known !== "prompt_failed" && known !== "prompt_deadline_exceeded"
+				? { providerCode: known }
+				: {}),
+		evidence,
+	});
 }
 
 function canonicalTerminalOutcome(
 	outcome: unknown,
-	failure?: { code?: unknown; message?: unknown },
+	failure?: { code?: unknown; message?: unknown; providerCode?: unknown },
+	evidence: PromptFailureEvidence = {},
 ): InvocationOutcome | undefined {
 	if (outcome && typeof outcome === "object") {
-		const candidate = outcome as { kind?: unknown; reason?: unknown; provenance?: unknown; code?: unknown };
+		const candidate = outcome as {
+			kind?: unknown;
+			reason?: unknown;
+			provenance?: unknown;
+			code?: unknown;
+			providerCode?: unknown;
+		};
 		if (candidate.kind === "stopped") {
 			if (candidate.reason === "cancelled" && candidate.provenance === "client_cancel")
 				return { kind: "stopped", reason: "cancelled", provenance: "client_cancel" };
@@ -626,9 +653,11 @@ function canonicalTerminalOutcome(
 			return canonicalFailedOutcome(
 				{ code: candidate.code, message: (outcome as { message?: unknown }).message },
 				candidate.provenance === "deadline" ? "deadline" : "agent_failed",
+				evidence,
+				typeof candidate.providerCode === "string" ? candidate.providerCode : undefined,
 			);
 	}
-	if (failure !== undefined) return canonicalFailedOutcome(failure);
+	if (failure !== undefined) return canonicalFailedOutcome(failure, "agent_failed", evidence);
 	return undefined;
 }
 interface InvocationRecord extends InvocationCorrelation {
@@ -1183,7 +1212,9 @@ export function createInvocationReconciliation(
 				delete (next as unknown as { pendingOutcome?: unknown }).pendingOutcome;
 				delete (next as unknown as { pendingReceiptState?: unknown }).pendingReceiptState;
 				next.content = reduceTurnResultContent(next.content, frame.content);
-				const incomingOutcome = canonicalTerminalOutcome(frame.outcome) ?? canonicalTerminalOutcome(pendingOutcome);
+				const incomingOutcome =
+					canonicalTerminalOutcome(frame.outcome, undefined, failureEvidence(next, frame.hasActivity)) ??
+					canonicalTerminalOutcome(pendingOutcome, undefined, failureEvidence(next, frame.hasActivity));
 				if (
 					incomingOutcome?.kind === "stopped" &&
 					(next.error === undefined || next.error.code === "prompt_deadline_exceeded")
@@ -1192,9 +1223,21 @@ export function createInvocationReconciliation(
 					if (next.error?.code === "prompt_deadline_exceeded") delete next.error;
 					next.status = "terminal_ok";
 				} else if (incomingOutcome?.kind === "failed") {
-					next.outcome = incomingOutcome;
+					// The provider diagnostic recorded before the boundary carries the
+					// bounded classifier; prefer it over a generic frame outcome that lost
+					// the provider code.
+					const recordErrorOutcome =
+						next.error !== undefined && next.error.code !== "prompt_deadline_exceeded"
+							? canonicalFailedOutcome(next.error, "agent_failed", failureEvidence(next))
+							: undefined;
+					const preferRecordError =
+						recordErrorOutcome?.kind === "failed" &&
+						recordErrorOutcome.providerCode !== undefined &&
+						incomingOutcome.providerCode === undefined;
+					next.outcome = preferRecordError ? recordErrorOutcome : incomingOutcome;
 					if (next.error === undefined)
 						next.error = { code: incomingOutcome.code, message: incomingOutcome.message };
+					else next.error = { code: next.error.code, message: incomingOutcome.message };
 					next.status = "failed";
 				} else if (next.error !== undefined) {
 					next.outcome = canonicalFailedOutcome(next.error);
@@ -1209,6 +1252,15 @@ export function createInvocationReconciliation(
 					next.error = EMPTY_PROMPT_FAILURE;
 					next.outcome = canonicalFailedOutcome(EMPTY_PROMPT_FAILURE);
 				} else next.status = "terminal_ok";
+				if (next.outcome !== undefined)
+					next.outcome = rephaseFailedOutcome(
+						next.outcome as SdkPromptTerminalOutcome,
+						failureEvidence(next, frame.hasActivity),
+					);
+				if ((next.outcome as SdkPromptTerminalOutcome | undefined)?.kind === "failed") {
+					const failed = next.outcome as Extract<SdkPromptTerminalOutcome, { kind: "failed" }>;
+					next.error = { code: next.error?.code ?? failed.code, message: failed.message };
+				}
 				next.receiptState = reduceReceiptState(
 					next.receiptState,
 					reportableTurnResultContent(next.content) ? "present" : "missing",
@@ -1270,11 +1322,12 @@ export function createInvocationReconciliation(
 		hydrate,
 		async claimPendingOutcome(kind, correlation, outcome) {
 			const record = records.get(key(kind, correlation));
-			const normalized = canonicalTerminalOutcome(outcome);
+			const normalized = canonicalTerminalOutcome(outcome, undefined, failureEvidence(record ?? {}));
 			if (normalized === undefined) throw new Error("Invalid terminal outcome.");
 			if (!record || record.terminalAt !== undefined || record.kind !== kind) return normalized;
 			const pending = (record as unknown as { pendingOutcome?: unknown }).pendingOutcome;
-			if (pending !== undefined) return canonicalTerminalOutcome(pending) ?? normalized;
+			if (pending !== undefined)
+				return canonicalTerminalOutcome(pending, undefined, failureEvidence(record)) ?? normalized;
 			const next = { ...record, revision: ++mutationRevision } as InvocationRecord & { pendingOutcome?: unknown };
 			next.pendingOutcome = normalized;
 			records.set(key(kind, correlation), next);
@@ -1318,14 +1371,22 @@ export function createInvocationReconciliation(
 			if (!record || record.terminalAt !== undefined || record.kind !== kind) return;
 			const requestedOutcome = canonicalTerminalOutcome(
 				outcome ?? (record as unknown as { pendingOutcome?: unknown }).pendingOutcome,
+				undefined,
+				failureEvidence(record, evidence?.hasActivity),
 			);
 			const priorFailure = record.error;
+			const requestedProviderCode = requestedOutcome?.kind === "failed" ? requestedOutcome.providerCode : undefined;
 			// A provider diagnostic recorded before a deadline finalization is stronger
 			// than the synthetic deadline claim. Preserve it as the terminal failure
 			// intent instead of allowing a later agent_end to look successful.
 			const finalOutcome =
 				priorFailure !== undefined && priorFailure.code !== "prompt_deadline_exceeded"
-					? canonicalFailedOutcome(priorFailure)
+					? canonicalFailedOutcome(
+							priorFailure,
+							"agent_failed",
+							failureEvidence(record, evidence?.hasActivity),
+							requestedProviderCode,
+						)
 					: requestedOutcome?.kind === "stopped"
 						? requestedOutcome
 						: priorFailure !== undefined &&
@@ -1333,12 +1394,22 @@ export function createInvocationReconciliation(
 									(requestedOutcome.kind === "failed" &&
 										(requestedOutcome.code === "prompt_deadline_exceeded" ||
 											priorFailure.code !== "prompt_deadline_exceeded")))
-							? canonicalFailedOutcome(priorFailure)
+							? canonicalFailedOutcome(
+									priorFailure,
+									"agent_failed",
+									failureEvidence(record, evidence?.hasActivity),
+									requestedProviderCode,
+								)
 							: requestedOutcome;
 			const previousRecord = { ...record };
 			const finalizedRecord: InvocationRecord = { ...record, revision: ++mutationRevision, terminalAt: Date.now() };
 			finalizedRecord.content = reduceTurnResultContent(finalizedRecord.content, evidence?.content);
 			let resolvedOutcome = finalOutcome;
+			if (resolvedOutcome !== undefined)
+				resolvedOutcome = rephaseFailedOutcome(
+					resolvedOutcome,
+					failureEvidence(record, evidence?.hasActivity),
+				) as InvocationOutcome;
 			if (resolvedOutcome?.kind === "stopped") {
 				// Stopped is a successful terminal boundary: it must never coexist with
 				// an earlier diagnostic failure.
@@ -1348,11 +1419,11 @@ export function createInvocationReconciliation(
 				finalizedRecord.status = "failed";
 				finalizedRecord.error =
 					recordError !== undefined
-						? { code: recordError.code, message: recordError.message }
+						? { code: recordError.code, message: resolvedOutcome.message }
 						: priorFailure !== undefined &&
 								(resolvedOutcome.code === "prompt_deadline_exceeded" ||
 									priorFailure.code !== "prompt_deadline_exceeded")
-							? priorFailure
+							? { code: priorFailure.code, message: resolvedOutcome.message }
 							: { code: resolvedOutcome.code, message: resolvedOutcome.message };
 			} else if (kind === "prompt") {
 				// Evidence-based empty predicate (exact-head review P1/P2): the same
@@ -1361,9 +1432,14 @@ export function createInvocationReconciliation(
 				// only a genuinely empty, no-activity completion fails closed.
 				const terminalText = evidence?.content?.text.trim() ?? "";
 				if (terminalText === "" && !evidence?.hasActivity && evidence?.outcomeKind !== "stopped") {
-					resolvedOutcome = canonicalFailedOutcome(EMPTY_PROMPT_FAILURE);
+					const emptyOutcome = canonicalFailedOutcome(
+						EMPTY_PROMPT_FAILURE,
+						"agent_failed",
+						failureEvidence(finalizedRecord, evidence?.hasActivity),
+					) as Extract<InvocationOutcome, { kind: "failed" }>;
+					resolvedOutcome = emptyOutcome;
 					finalizedRecord.status = "failed";
-					finalizedRecord.error = EMPTY_PROMPT_FAILURE;
+					finalizedRecord.error = { code: emptyOutcome.code, message: emptyOutcome.message };
 				} else finalizedRecord.status = "terminal_ok";
 			} else finalizedRecord.status = "terminal_ok";
 			finalizedRecord.receiptState = reduceReceiptState(
@@ -1454,6 +1530,8 @@ export interface SdkSurfaceFactoryOptions {
 	ctx: ExtensionContext;
 	id: string;
 	api: ExtensionAPI;
+	/** Startup surface that owns host-level permission and lifecycle authority. */
+	primaryControlSurface?: "cli" | "sdk";
 	policy?: SdkSurfacePolicy;
 	getInstalledDefinitions?: (capability: string) => unknown | undefined;
 	getLiveState?: () => { isStreaming: boolean; steeringQueueDepth: number; followupQueueDepth: number };
@@ -1499,6 +1577,7 @@ function createQuerySurface(
 		steerStatusLookup?: (selector: { commandId?: string; turnId?: string; clientRef?: string }) => unknown;
 		hostTools?: boolean | (() => boolean);
 		getRuntimeHost?: () => SessionSdkHost | undefined;
+		primaryControlSurface?: "cli" | "sdk";
 	} = {},
 ): SessionSurface {
 	const policy =
@@ -1881,7 +1960,7 @@ function createQuerySurface(
 		getStats: () => ctx.sessionManager.getUsageStatistics(),
 		getBranchCandidates: () => ctx.getBranchCandidates(),
 		getLastAssistant: lastAssistant,
-		getCapabilities: () => createSdkCapabilities(policy, hasHostTools()),
+		getCapabilities: () => createSdkCapabilities(policy, hasHostTools(), options.primaryControlSurface),
 		getAuthProviders: () => [...new Set(ctx.modelRegistry.getAll().map(model => model.provider))],
 		getActiveProviders: () => ctx.modelRegistry.getActiveProviders(),
 		getTools: () => {
@@ -1974,6 +2053,7 @@ export function createSdkSurfaceFactory(
 		steerStatusLookup: options.steerStatusLookup,
 		hostTools: options.hostTools,
 		getRuntimeHost: options.getRuntimeHost,
+		primaryControlSurface: options.primaryControlSurface,
 	});
 	return {
 		policy,
@@ -2121,7 +2201,9 @@ function rejectionRecoveryIntent(error: unknown): { code: string; message: strin
  * after retry/fallback policy has settled, so this is the safe boundary at which
  * to publish the additive failure diagnostic before terminal reconciliation.
  */
-function providerFailureFromAgentEnd(event: unknown): { code: string; message: string } | undefined {
+function providerFailureFromAgentEnd(
+	event: unknown,
+): { code: string; message: string; providerCode?: string } | undefined {
 	try {
 		if (!event || typeof event !== "object") return undefined;
 		const messages = (event as { messages?: unknown }).messages;
@@ -2137,7 +2219,8 @@ function providerFailureFromAgentEnd(event: unknown): { code: string; message: s
 			errorMessage?: unknown;
 			errorKind?: unknown;
 			errorStatus?: unknown;
-			transportFailure?: { status?: unknown };
+			errorCode?: unknown;
+			transportFailure?: { status?: unknown; providerCode?: unknown };
 		};
 		let stopReason: unknown;
 		try {
@@ -2183,10 +2266,24 @@ function providerFailureFromAgentEnd(event: unknown): { code: string; message: s
 				// A throwing transport metadata accessor is also statusless.
 			}
 		}
+		const providerCode = assistantFailureCode(assistant);
 		if (status === 402 || status === 429)
-			return { code: `provider_http_${status}`, message: "Prompt submission failed." };
-		if (status !== undefined) return { code: "provider_rejected", message: "Prompt submission failed." };
-		return { code: "provider_rejected", message: "Prompt submission failed." };
+			return {
+				code: `provider_http_${status}`,
+				message: PROMPT_FAILURE_MESSAGE_SUBMISSION,
+				...(providerCode !== undefined ? { providerCode } : {}),
+			};
+		if (status !== undefined)
+			return {
+				code: "provider_rejected",
+				message: PROMPT_FAILURE_MESSAGE_SUBMISSION,
+				...(providerCode !== undefined ? { providerCode } : {}),
+			};
+		return {
+			code: "provider_rejected",
+			message: PROMPT_FAILURE_MESSAGE_SUBMISSION,
+			...(providerCode !== undefined ? { providerCode } : {}),
+		};
 	} catch {
 		// Provider metadata is untrusted: an SDK/provider adapter may expose a
 		// throwing getter while the lifecycle boundary still needs to terminalize.
@@ -2199,32 +2296,76 @@ interface PromptTerminalEvidence {
 	hasActivity: boolean;
 }
 
+function assistantMessageHasPromptActivity(assistant: object): boolean {
+	const hasUsage = Object.hasOwn(assistant, "usage");
+	const usage = hasUsage ? (assistant as { usage?: unknown }).usage : undefined;
+	const hasTokenActivity =
+		hasUsage &&
+		usage !== null &&
+		typeof usage === "object" &&
+		!Array.isArray(usage) &&
+		typeof (usage as { totalTokens?: unknown }).totalTokens === "number" &&
+		Number.isFinite((usage as { totalTokens: number }).totalTokens) &&
+		(usage as { totalTokens: number }).totalTokens > 0;
+	if (hasTokenActivity) return true;
+	const content = (assistant as { content?: unknown }).content;
+	if (typeof content === "string") return content.trim().length > 0;
+	if (!Array.isArray(content)) return false;
+	return content.some(block => {
+		if (block === null || typeof block !== "object") return false;
+		const type = (block as { type?: unknown }).type;
+		if (type === "text") {
+			const text = (block as { text?: unknown }).text;
+			return typeof text === "string" && text.trim().length > 0;
+		}
+		if (type === "thinking") {
+			const thinking = (block as { thinking?: unknown }).thinking;
+			return typeof thinking === "string" && thinking.trim().length > 0;
+		}
+		if (type === "redactedThinking") {
+			const data = (block as { data?: unknown }).data;
+			return typeof data === "string" && data.trim().length > 0;
+		}
+		if (type !== "toolCall") return false;
+		const toolCall = block as {
+			id?: unknown;
+			name?: unknown;
+			arguments?: unknown;
+			incompleteArguments?: unknown;
+			incompleteArgumentsReason?: unknown;
+		};
+		return (
+			typeof toolCall.id === "string" &&
+			toolCall.id.trim().length > 0 &&
+			typeof toolCall.name === "string" &&
+			toolCall.name.trim().length > 0 &&
+			toolCall.arguments !== null &&
+			typeof toolCall.arguments === "object" &&
+			!Array.isArray(toolCall.arguments) &&
+			(toolCall.incompleteArguments === undefined || toolCall.incompleteArguments === false) &&
+			toolCall.incompleteArgumentsReason === undefined
+		);
+	});
+}
+
 function promptTerminalEvidenceFromAgentEnd(event: unknown): PromptTerminalEvidence {
 	try {
 		if (!event || typeof event !== "object") return { hasActivity: false };
 		const messages = (event as { messages?: unknown }).messages;
 		if (!Array.isArray(messages)) return { hasActivity: false };
-		const assistant = [...messages]
-			.reverse()
-			.find(
-				message => message && typeof message === "object" && (message as { role?: unknown }).role === "assistant",
-			);
-		if (!assistant || typeof assistant !== "object") return { hasActivity: false };
+		const assistants = messages.filter(
+			(message): message is object =>
+				message !== null && typeof message === "object" && (message as { role?: unknown }).role === "assistant",
+		);
+		const assistant = assistants.at(-1);
+		if (!assistant) return { hasActivity: false };
+		const hasActivity = assistants.some(assistantMessageHasPromptActivity);
 		const content = (assistant as { content?: unknown }).content;
 		if (typeof content === "string") {
 			const bounded = sanitizeTurnResultContent(content);
-			return { content: bounded, hasActivity: content.trim().length > 0 };
+			return { content: bounded, hasActivity };
 		}
 		if (Array.isArray(content)) {
-			const hasActivity = content.some(block => {
-				if (block === null || typeof block !== "object") return false;
-				const type = (block as { type?: unknown }).type;
-				if (type === "text") {
-					const text = (block as { text?: unknown }).text;
-					return typeof text === "string" && text.trim().length > 0;
-				}
-				return typeof type === "string" && type.length > 0;
-			});
 			const text = content
 				.filter(
 					(block): block is { type: "text"; text: string } =>
@@ -2237,7 +2378,7 @@ function promptTerminalEvidenceFromAgentEnd(event: unknown): PromptTerminalEvide
 				.join("");
 			return { content: sanitizeTurnResultContent(text), hasActivity };
 		}
-		return { content: sanitizeTurnResultContent(""), hasActivity: false };
+		return { content: sanitizeTurnResultContent(""), hasActivity };
 	} catch {
 		return { hasActivity: false };
 	}
@@ -5028,6 +5169,9 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 	api.on("tool_execution_start", async (_event, ctx) => {
 		renewAttributableProgress("tool_execution_start", ctx);
 	});
+	api.on("tool_execution_update", async (_event, ctx) => {
+		renewAttributableProgress("tool_execution_update", ctx);
+	});
 	api.on("tool_execution_end", async (_event, ctx) => {
 		renewAttributableProgress("tool_execution_end", ctx);
 	});
@@ -5131,6 +5275,9 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			configOverrides: options.configOverrides,
 			settings: options.settings,
 			getRuntimeHost: () => runtime?.host,
+			// Origin is explicit at the session bootstrap boundary. The low-level
+			// runtime defaults to SDK for existing embedders; CLI roots pass cli.
+			primaryControlSurface: options.primaryControlSurface ?? "sdk",
 		});
 		const queryHandlers = new QueryHandlers(surfaceFactory.query, sessionId, revisions, cursors);
 		const inputGate = { quiescing: false };
@@ -5730,6 +5877,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 					pid: process.pid,
 					processIncarnation: effectiveIncarnation,
 				});
+				let registration: SessionIndexEvent | undefined;
 				await runtime.registerWithBroker({
 					register: async input => {
 						if (publishedEndpointUrl === undefined)
@@ -5756,7 +5904,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 							processIncarnation: effectiveIncarnation,
 							direct,
 						});
-						await index.append({
+						registration = await index.append({
 							type: "host_registered",
 							...input,
 							locator,
@@ -5768,13 +5916,17 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 						});
 					},
 					unregister: async input => {
-						await index.append({
-							type: "host_unregistered",
-							...input,
-							locator,
-							pid: process.pid,
-							...(options.lifecycleRequestId ? { lifecycleRequestId: options.lifecycleRequestId } : {}),
-						});
+						const expected = registration;
+						if (
+							!expected ||
+							expected.sessionId !== input.sessionId ||
+							expected.endpointGeneration !== input.endpointGeneration ||
+							path.resolve(expected.locator.stateRoot) !== path.resolve(input.stateRoot)
+						)
+							return;
+						// Use the successful publication's proof, never a teardown-time file read.
+						await index.unregisterIfCurrent(expected);
+						if (registration === expected) registration = undefined;
 					},
 				});
 				brokerRegistered = true;

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

@@ -107,13 +107,20 @@ export interface SdkCapabilities {
 	operations: string[];
 	hostTools: boolean;
 	promptTerminalOutcomeVersion: 1;
+	/** Startup surface that owns host-level permission and lifecycle authority. */
+	primaryControlSurface: "cli" | "sdk";
 }
 
-export function createSdkCapabilities(policy: SdkSurfacePolicy, hostTools = false): SdkCapabilities {
+export function createSdkCapabilities(
+	policy: SdkSurfacePolicy,
+	hostTools = false,
+	primaryControlSurface: SdkCapabilities["primaryControlSurface"] = "sdk",
+): SdkCapabilities {
 	return {
 		operations: [...policy.installedControls, ...policy.installedQueries],
 		hostTools,
 		promptTerminalOutcomeVersion: 1,
+		primaryControlSurface,
 	};
 }