@gajae-code/coding-agent 0.13.0 → 0.13.1

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

@@ -55,6 +55,12 @@ export interface SessionSurface {
 		turnId?: string;
 		clientRef?: string;
 	}): unknown | Promise<unknown>;
+	getTurnResult?(selector: {
+		kind: "prompt" | "skill";
+		clientRef?: string;
+		commandId?: string;
+		turnId?: string;
+	}): unknown | Promise<unknown>;
 	/** Q27 effective model-profile catalog from the live session registry. */
 	getModelProfiles?(): unknown[] | Promise<unknown[]>;
 	/**
@@ -167,7 +173,7 @@ const names = [
 	"resource.body",
 	"artifact.read",
 	"runtime.jobs.list",
-	"turn.prompt_status",
+	"turn.result",
 	"models.profiles.list",
 	"skill.invoke_status",
 	"providers.list/active",
@@ -183,11 +189,35 @@ export class QueryHandlers {
 	) {}
 	async dispatch(request: QueryRequest): Promise<QueryResponse> {
 		try {
+			if (request.query === "turn.result") {
+				if (this.surface.installedQueries instanceof Set && !this.surface.installedQueries.has("turn.result"))
+					return this.#error(
+						request,
+						"operation_not_session_owned",
+						false,
+						"turn.result is not installed for this session.",
+					);
+				return await this.#turnResult(request);
+			}
+			if (request.query === "turn.prompt_status") return await this.#promptTurnResult(request);
+			if (request.query === "skill.invoke_status") return await this.#skillTurnResult(request);
+
 			const query = request.query.startsWith("Q")
 				? request.query
 				: request.query === "models.list" || request.query === "models.current"
 					? "Q10"
 					: `Q${String(names.indexOf(request.query) + 1).padStart(2, "0")}`;
+			if (query === "Q26") {
+				if (this.surface.installedQueries instanceof Set && !this.surface.installedQueries.has("turn.result"))
+					return this.#error(
+						request,
+						"operation_not_session_owned",
+						false,
+						"turn.result is not installed for this session.",
+					);
+				return await this.#turnResult(request);
+			}
+			if (query === "Q28") return await this.#skillTurnResult(request);
 			if (
 				this.surface.installedQueries instanceof Set &&
 				!this.surface.installedQueries.has(names[Number(query.slice(1)) - 1] ?? "")
@@ -220,8 +250,6 @@ 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 === "Q28") return await this.#skillInvokeStatus(request);
 			if (query === "Q24") return await this.#artifact(request);
 			if (query === "Q30") return await this.#checkpoint(request);
 			if (query === "Q27" && request.input && Object.keys(request.input).length > 0)
@@ -532,6 +560,35 @@ export class QueryHandlers {
 		if (!range) return this.#error(request, "resource_gone");
 		return this.#chunkRange(request, "transcript", "default", revision, range, selector, { entryId, highWatermark });
 	}
+	async #turnResult(request: QueryRequest): Promise<QueryResponse> {
+		const input = request.input ?? {};
+		const keys = Object.keys(input);
+		const kind = input.kind;
+		const rawClientRef = typeof input.clientRef === "string" ? input.clientRef : undefined;
+		const clientRef = rawClientRef?.trim();
+		const hasClient = clientRef !== undefined;
+		const hasPair = typeof input.commandId === "string" && typeof input.turnId === "string";
+		if (
+			(kind !== "prompt" && kind !== "skill") ||
+			hasClient === hasPair ||
+			keys.some(k => !["kind", "clientRef", "commandId", "turnId"].includes(k)) ||
+			(hasClient && (!clientRef || clientRef.length > PROMPT_CLIENT_REF_MAX_LENGTH || keys.length !== 2)) ||
+			(hasPair && (!input.commandId || !input.turnId || keys.length !== 3))
+		)
+			return this.#error(request, "invalid_request", false, "turn.result requires kind and exactly one selector");
+		// Turn results carry bounded content (≤ TURN_RESULT_CONTENT_MAX_BYTES, 16 KiB)
+		// and fit inline within a single query response. Cursored continuation is
+		// unreachable: the bounded content cap is well under both RESPONSE_CEILING_BYTES
+		// and TARGET_PAGE_BYTES, so no revision is ever created. Reject cursors
+		// upfront instead of advertising a continuation path that can never fire.
+		if (request.cursor) return this.#error(request, "invalid_cursor", false, "turn.result does not support cursors.");
+		if (typeof this.surface.getTurnResult !== "function") return this.#error(request, "unavailable");
+		const result = await this.surface.getTurnResult({
+			kind,
+			...(hasClient ? { clientRef } : { commandId: input.commandId as string, turnId: input.turnId as string }),
+		});
+		return { id: request.id, ok: true, result };
+	}
 
 	async #resourceBody(request: QueryRequest): Promise<QueryResponse> {
 		let selector = selectorFor("Q23", request.input);
@@ -566,6 +623,32 @@ export class QueryHandlers {
 		});
 	}
 
+	async #promptTurnResult(request: QueryRequest): Promise<QueryResponse> {
+		if (this.surface.installedQueries instanceof Set && !this.surface.installedQueries.has("turn.result"))
+			return this.#error(
+				request,
+				"operation_not_session_owned",
+				false,
+				"turn.result is not installed for this session.",
+			);
+		const input = request.input ?? {};
+		if (input.kind !== undefined && input.kind !== "prompt")
+			return this.#error(request, "invalid_request", false, "turn.prompt_status only accepts prompt selectors.");
+		return await this.#turnResult({ ...request, input: { ...input, kind: "prompt" } });
+	}
+	async #skillTurnResult(request: QueryRequest): Promise<QueryResponse> {
+		if (this.surface.installedQueries instanceof Set && !this.surface.installedQueries.has("skill.invoke_status"))
+			return this.#error(
+				request,
+				"operation_not_session_owned",
+				false,
+				"skill.invoke_status is not installed for this session.",
+			);
+		const input = request.input ?? {};
+		if (input.kind !== undefined && input.kind !== "skill")
+			return this.#error(request, "invalid_request", false, "skill.invoke_status only accepts skill selectors.");
+		return await this.#turnResult({ ...request, input: { ...input, kind: "skill" } });
+	}
 	async #artifact(request: QueryRequest): Promise<QueryResponse> {
 		const input = request.input ?? {};
 		const artifactId = String(input.artifactId ?? "");
@@ -696,102 +779,6 @@ export class QueryHandlers {
 		return { id: request.id, ok: true, page };
 	}
 
-	async #skillInvokeStatus(request: QueryRequest): Promise<QueryResponse> {
-		if (request.cursor)
-			return this.#error(request, "invalid_request", false, "skill.invoke_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,
-					`skill.invoke_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,
-				"skill.invoke_status requires a commandId/turnId pair or a clientRef.",
-			);
-		if (typeof this.surface.getSkillInvokeStatus !== "function")
-			return this.#error(request, "unavailable", false, "skill.invoke_status is unavailable for this session.");
-		const result = await this.surface.getSkillInvokeStatus(
-			clientRef !== undefined ? { clientRef } : { commandId: commandId!, turnId: turnId! },
-		);
-		return { id: request.id, ok: true, result };
-	}
-
-	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,
@@ -802,7 +789,19 @@ export class QueryHandlers {
 }
 function selectorFor(queryId: string, input: Record<string, unknown> | undefined): CursorSelector {
 	const selector: CursorSelector = { queryId };
-	for (const key of ["entryId", "field", "fileId", "hunkId", "resourceKind", "resourceId", "itemId"] as const)
+	for (const key of [
+		"entryId",
+		"field",
+		"fileId",
+		"hunkId",
+		"resourceKind",
+		"resourceId",
+		"itemId",
+		"kind",
+		"clientRef",
+		"commandId",
+		"turnId",
+	] as const)
 		if (input?.[key] !== undefined) selector[key] = String(input[key]);
 	return selector;
 }

package/src/sdk/host/sdk-surface-parity.test.ts

@@ -114,7 +114,7 @@ describe("SDK surface parity", () => {
 		expect([...nativePolicy.installedControls]).toEqual([...loopbackPolicy.installedControls]);
 		expect([...nativePolicy.installedQueries]).toEqual([...loopbackPolicy.installedQueries]);
 		expect(createSdkCapabilities(nativePolicy, false)).toEqual(createSdkCapabilities(loopbackPolicy, false));
-		expect(nativePolicy.installedQueries).toContain("turn.prompt_status");
+		expect(nativePolicy.installedQueries).toContain("turn.result");
 		expect(nativePolicy.installedQueries).toContain("skill.invoke_status");
 		expect(nativePolicy.installedQueries).toContain("session.checkpoint");
 	});

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

@@ -440,6 +440,7 @@ async function invocationHarness(
 		sendUserMessage?: (content: unknown, options?: PreflightHooks & { deliverAs?: string }) => Promise<void>;
 		invokeSkill?: (name: string, args?: string, options?: PreflightHooks) => Promise<unknown>;
 		abort?: () => void;
+		isIdle?: () => boolean;
 	},
 ): Promise<InvocationHarness> {
 	const waiters = new Map<string, (frame: ResponseFrame) => void>();
@@ -477,7 +478,7 @@ async function invocationHarness(
 		cwd,
 		workflowGate: undefined,
 		sdkBindings: () => (hooks.invokeSkill ? ["invokeSkill"] : []),
-		isIdle: () => true,
+		isIdle: hooks.isIdle ?? (() => true),
 		abort: hooks.abort ?? (() => {}),
 		...(hooks.invokeSkill ? { invokeSkill: hooks.invokeSkill } : {}),
 		sessionManager: { getSessionId: () => sessionId, getSessionName: () => undefined },
@@ -595,6 +596,102 @@ describe("post-acceptance invocation terminalization", () => {
 			await rm(cwd, { recursive: true, force: true });
 		}
 	});
+	test("a completed prompt reports a terminal successful status", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-completed-prompt-"));
+		try {
+			const harness = await invocationHarness("terminalize-completed-prompt", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			expect(accepted.ok).toBe(true);
+			const { commandId, turnId } = accepted.result ?? {};
+			expect(await settledStatus(harness, "turn.prompt_status", { commandId, turnId })).toMatchObject({
+				status: "terminal_ok",
+				terminalAt: expect.any(Number),
+			});
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+	test("a queued follow-up prompt is not terminalized before the turn runs", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-followup-"));
+		try {
+			const turnRunning = Promise.withResolvers<void>();
+			const harness = await invocationHarness("terminalize-followup", cwd, {
+				sendUserMessage: async (_content, options) => {
+					if (options?.deliverAs === "followUp") {
+						await options?.onPreflightAcceptCommit?.();
+						// #queueFollowUp resolves immediately; the turn has not run yet.
+						return;
+					}
+					await options?.onPreflightAcceptCommit?.();
+					await turnRunning.promise;
+				},
+			});
+			const accepted = await harness.control("turn.follow_up", { text: "hello" });
+			expect(accepted.ok).toBe(true);
+			const { commandId, turnId } = accepted.result ?? {};
+			// The follow-up submission must NOT report terminal_ok while the turn is still pending.
+			const status = await harness.query("turn.prompt_status", { commandId, turnId });
+			expect(status.result?.status).toMatch(/accepted|in_flight|unknown/);
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+	test("a prompt queued as steer while streaming is not terminalized before the turn runs", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-prompt-while-busy-"));
+		try {
+			const harness = await invocationHarness("terminalize-prompt-while-busy", cwd, {
+				sendUserMessage: async (_content, options) => {
+					// Session is streaming: sendUserMessage diverts to #queueSteer and resolves.
+					await options?.onPreflightAcceptCommit?.();
+				},
+				isIdle: () => false,
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			expect(accepted.ok).toBe(true);
+			const { commandId, turnId } = accepted.result ?? {};
+			// The diverted prompt must NOT report terminal_ok while the turn is still pending.
+			const status = await harness.query("turn.prompt_status", { commandId, turnId });
+			expect(status.result?.status).toMatch(/accepted|in_flight|unknown/);
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+	test("a queued prompt stays non-terminal even if isIdle flips during the accept window", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-race-"));
+		let idle = false;
+		try {
+			const harness = await invocationHarness("terminalize-race", cwd, {
+				sendUserMessage: async (_content, options) => {
+					// The session is streaming when the submission starts (divert to steer).
+					// During accept()->persist(), the prior turn unwinds and isIdle flips to true.
+					await options?.onPreflightAcceptCommit?.();
+					idle = true;
+				},
+				isIdle: () => idle,
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			expect(accepted.ok).toBe(true);
+			const { commandId, turnId } = accepted.result ?? {};
+			// The snapshot taken at dispatch time (idle=false) must hold: the prompt was
+			// queued, so it must not report terminal_ok even though isIdle is now true.
+			const status = await harness.query("turn.prompt_status", { commandId, turnId });
+			expect(status.result?.status).toMatch(/accepted|in_flight|unknown/);
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
 
 	test("a pre-acceptance failure rejects the submission without creating a record", async () => {
 		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-preflight-"));

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

@@ -270,6 +270,7 @@ export interface InvocationReconciliation {
 		frame: { type: "agent_start" | "agent_end" } | { type: "agent_failed"; error: unknown },
 	): Promise<void>;
 	lookup(kind: InvocationKind, selector: { commandId?: string; turnId?: string; clientRef?: string }): unknown;
+	lookupResult(kind: InvocationKind, selector: { commandId?: string; turnId?: string; clientRef?: string }): unknown;
 	hydrate(): Promise<void>;
 }
 
@@ -473,6 +474,10 @@ export function createInvocationReconciliation(
 				...(record.error === undefined ? {} : { error: record.error }),
 			};
 		},
+		lookupResult(kind, selector) {
+			const result = this.lookup(kind, selector) as Record<string, unknown>;
+			return result.status === "unknown" ? result : { kind, ...result };
+		},
 		hydrate,
 	};
 }
@@ -487,8 +492,12 @@ export interface SdkSurfaceFactoryOptions {
 	configOverrides?: ReadonlyMap<string, unknown>;
 	/** Session settings; used for model-usage preferences in profile-limit resolution. */
 	settings?: Settings;
-	promptStatusLookup?: (selector: { commandId?: string; turnId?: string; clientRef?: string }) => unknown;
-	skillStatusLookup?: (selector: { commandId?: string; turnId?: string; clientRef?: string }) => unknown;
+	turnResultLookup?: (selector: {
+		kind: "prompt" | "skill";
+		commandId?: string;
+		turnId?: string;
+		clientRef?: string;
+	}) => unknown;
 	hostTools?: boolean | (() => boolean);
 	/** Q30 event-ring watermark source (the live session event stream); synchronous. */
 	getEventWatermark?: () => { generation: number; seq: number };
@@ -513,8 +522,12 @@ function createQuerySurface(
 		configOverrides?: ReadonlyMap<string, unknown>;
 		/** Session settings; used for model-usage preferences in profile-limit resolution. */
 		settings?: Settings;
-		promptStatusLookup?: (selector: { commandId?: string; turnId?: string; clientRef?: string }) => unknown;
-		skillStatusLookup?: (selector: { commandId?: string; turnId?: string; clientRef?: string }) => unknown;
+		turnResultLookup?: (selector: {
+			kind: "prompt" | "skill";
+			commandId?: string;
+			turnId?: string;
+			clientRef?: string;
+		}) => unknown;
 		hostTools?: boolean | (() => boolean);
 		/** Q30 event-ring watermark source (the live session event stream); synchronous. */
 		getEventWatermark?: () => { generation: number; seq: number };
@@ -782,9 +795,15 @@ function createQuerySurface(
 		getArtifactRange: (artifactId, offset, length) => ctx.getArtifactRange?.(artifactId, offset, length),
 		getJobs: () => ctx.getJobs(),
 		getPromptStatus: (selector: { commandId?: string; turnId?: string; clientRef?: string }) =>
-			(options.promptStatusLookup ?? (value => reconciliation.lookup("prompt", value)))(selector),
+			reconciliation.lookup("prompt", selector),
 		getSkillInvokeStatus: (selector: { commandId?: string; turnId?: string; clientRef?: string }) =>
-			(options.skillStatusLookup ?? (value => reconciliation.lookup("skill", value)))(selector),
+			reconciliation.lookup("skill", selector),
+		getTurnResult: (selector: {
+			kind: "prompt" | "skill";
+			commandId?: string;
+			turnId?: string;
+			clientRef?: string;
+		}) => (options.turnResultLookup ?? (value => reconciliation.lookupResult(value.kind, value)))(selector),
 		getModelProfiles: async () => {
 			const profiles = ctx.modelRegistry.getModelProfiles();
 			const authenticatedProviders = await collectAuthenticatedProfileProviders(profiles, provider =>
@@ -845,8 +864,7 @@ export function createSdkSurfaceFactory(
 		getLiveState: options.getLiveState,
 		configOverrides: options.configOverrides,
 		settings: options.settings,
-		promptStatusLookup: options.promptStatusLookup,
-		skillStatusLookup: options.skillStatusLookup,
+		turnResultLookup: options.turnResultLookup,
 		hostTools: options.hostTools,
 		getEventWatermark: options.getEventWatermark,
 	});
@@ -1039,9 +1057,10 @@ function createControlSurface(
 		run: (options: {
 			onPreflightAccepted: () => void;
 			onPreflightAcceptCommit: () => Promise<void>;
-		}) => Promise<void>,
+		}) => Promise<unknown>,
 		acceptedFields?: () => Record<string, unknown>,
 		allowCompletionFallback = false,
+		alwaysQueued = false,
 	): Promise<unknown> => {
 		const retainedClientRef = normalizeClientRef(clientRef);
 		reconciliation.admit(kind, retainedClientRef);
@@ -1051,6 +1070,7 @@ function createControlSurface(
 		let settled = false;
 		const accept = async (): Promise<void> => {
 			if (settled) return;
+
 			try {
 				await reconciliation.noteAccepted(kind, correlation, retainedClientRef);
 				accepted = true;
@@ -1063,6 +1083,11 @@ function createControlSurface(
 				throw error;
 			}
 		};
+		// Snapshot before run(): if the session is streaming when the submission starts,
+		// sendUserMessage will divert to steer-queue and resolve before the turn runs.
+		// Re-reading ctx.isIdle() after run() would race — accept() does async fs I/O that
+		// yields, so isStreaming can flip during the persist window.
+		const queuedAtDispatch = alwaysQueued || !ctx.isIdle();
 		try {
 			const submission = Promise.resolve(
 				run({
@@ -1071,9 +1096,20 @@ function createControlSurface(
 				}),
 			);
 			void submission.then(
-				() => {
+				result => {
 					if (settled) {
-						if (kind === "skill") void reconciliation.noteTransition(kind, correlation, { type: "agent_end" });
+						// A resolved submission after preflight acceptance means the work is over
+						// for every kind. `noteTransition` ignores an already-terminal record, so
+						// terminalizing here is safe — unless the submission resolved at queue time
+						// (followUp, or a prompt diverted to steer while streaming), in which case
+						// the turn's own lifecycle events drive terminalization.
+						if (!queuedAtDispatch)
+							void reconciliation.noteTransition(kind, correlation, {
+								type: "agent_end",
+								...(typeof result === "string"
+									? { content: { version: 1, type: "text", text: result, byteLength: 0, truncated: false } }
+									: {}),
+							});
 						return;
 					}
 					if (allowCompletionFallback) {
@@ -1128,7 +1164,14 @@ function createControlSurface(
 			return { commandId: crypto.randomUUID(), accepted: true };
 		},
 		followUp: async text =>
-			submit("prompt", undefined, options => api.sendUserMessage(text, { ...options, deliverAs: "followUp" })),
+			submit(
+				"prompt",
+				undefined,
+				options => api.sendUserMessage(text, { ...options, deliverAs: "followUp" }),
+				undefined,
+				false,
+				true,
+			),
 		abort: () => {
 			ctx.abort();
 			return { aborted: true };
@@ -1168,7 +1211,7 @@ function createControlSurface(
 						onSkillPrepared: meta => {
 							prepared = meta;
 						},
-					}).then(() => undefined),
+					}).then(result => result),
 				() => ({
 					name: prepared?.name ?? String(name),
 					path: prepared?.path ?? "",
@@ -1413,8 +1456,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			id: sessionId,
 			api,
 			reconciliation,
-			promptStatusLookup: selector => reconciliation.lookup("prompt", selector),
-			skillStatusLookup: selector => reconciliation.lookup("skill", selector),
+			turnResultLookup: selector => reconciliation.lookupResult(selector.kind, selector),
 			configOverrides: options.configOverrides,
 			settings: options.settings,
 			getEventWatermark: () => eventWatermarkSource(),