@gajae-code/coding-agent 0.18.7 → 0.18.8

package/src/sdk/bus/index.ts

@@ -27,7 +27,13 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
-import { isNonDispatchedToolEvent, type RunSettlementProof, ThinkingLevel } from "@gajae-code/agent-core";
+import {
+	type AgentTerminalOwnerContext,
+	isNonDispatchedToolEvent,
+	type RunCancellationDomain,
+	type RunSettlementProof,
+	ThinkingLevel,
+} from "@gajae-code/agent-core";
 import type { ImageContent, TextContent, Tool } from "@gajae-code/ai/core";
 import type { NotificationServer as NativeNotificationServer } from "@gajae-code/natives";
 
@@ -1229,6 +1235,9 @@ export class PresentationArbiter {
 interface SessionRuntime {
 	server: NotificationServer;
 	host: SessionSdkHost;
+	getJoinedPromptCorrelations: (owner: AgentTerminalOwnerContext) => Array<{ commandId: string; turnId: string }>;
+	isPromptRunOwner: (correlation: { commandId: string; turnId: string }, owner: AgentTerminalOwnerContext) => boolean;
+	retireJoinedPromptOwners: () => void;
 	/** Delivers one ring-positioned event envelope to every attached subscriber
 	 *  connection, applying the same capability gate as event replay. */
 	broadcastEventFrame: (event: SdkFrame) => string[];
@@ -2618,6 +2627,12 @@ function sdkControlSurface(
 		error: unknown,
 	) => void | Promise<void> = () => {},
 	onPromptAcceptFailed: (correlation: { commandId: string; turnId: string }) => void = () => {},
+	onPromptDiverted: (correlation: { commandId: string; turnId: string }) => void,
+	onPromptPromoted: (
+		correlation: { commandId: string; turnId: string },
+		promotion: { startsOwnRun?: boolean; removed?: boolean },
+		handle: string | undefined,
+	) => void,
 	acceptGateResolution: () => boolean,
 	trackGateResolution: <T>(resolution: Promise<T>) => Promise<T>,
 	admitPrompt: (clientRef?: string) => void,
@@ -3019,6 +3034,7 @@ function sdkControlSurface(
 			admission.accepted();
 			accepting = false;
 			accepted = true;
+			if (effectiveDeliverAs !== undefined) onPromptDiverted(correlation);
 			// #4743: an accepted run owns a durable terminal publication when it
 			// settles; teardown joins it via this latch (never-accepted preflights
 			// produce no durable write and stay unjoined by design).
@@ -3044,7 +3060,14 @@ function sdkControlSurface(
 					...(effectiveDeliverAs ? { deliverAs: effectiveDeliverAs } : {}),
 					onPreflightAcceptCommit,
 					onPreflightAccepted,
-					...admission.hooks,
+					onQueuedPromoted: promotion => {
+						admission.hooks.onQueuedPromoted(promotion);
+						onPromptPromoted(correlation, promotion, ctx.getActivePromptHandle());
+					},
+					onDispatchDisposition: disposition => {
+						admission.hooks.onDispatchDisposition(disposition);
+						if (!disposition.startsOwnRun) onPromptDiverted(correlation);
+					},
 					preflightSignal: preflightController.signal,
 					...(sdkRunToken ? { sdkRunToken } : {}),
 				}),
@@ -4290,6 +4313,8 @@ export function createNotificationsExtension(
 		 * preflight outside the durable admission path (review thread P2).
 		 */
 		terminalAbortSeams?: {
+			getTerminalRunOwnerForEvent?: (event: object) => AgentTerminalOwnerContext | undefined;
+			getRunOwnerDomain?: (handle: string) => RunCancellationDomain | undefined;
 			getTerminalTurnEpoch: () => number | undefined;
 			cancelPendingPreflightForTerminalAbort: () => void;
 			captureTerminalAbortSteeringSnapshot?: () => void;
@@ -4577,6 +4602,7 @@ export function createNotificationsExtension(
 		if (reason === "session" && requestedRuntime) {
 			requestedRuntime.inboundFenced = true;
 			requestedRuntime.stopping = true;
+			requestedRuntime.retireJoinedPromptOwners();
 			requestedRuntime.abortEphemeralTurns();
 		}
 		if (reason === "session" && requestedRuntime) requestedRuntime.stopSessionNameObserver();
@@ -4845,6 +4871,19 @@ export function createNotificationsExtension(
 			return failLifecycleStartup("failed", "Lifecycle SDK startup requires an agent directory.");
 
 		const pendingInteractive = new Map<string, PendingInteractiveAsk>();
+		const queuedRemovalTerminals = new Map<string, Promise<boolean>>();
+		const joinedPromptOwners = new Map<
+			string,
+			{ correlation: { commandId: string; turnId: string }; owner: AgentTerminalOwnerContext }
+		>();
+		const getJoinedPromptCorrelations = (terminalOwner: AgentTerminalOwnerContext) =>
+			[...joinedPromptOwners.values()]
+				.filter(
+					({ owner }) =>
+						owner.resourceRunId === terminalOwner.resourceRunId && owner.domain === terminalOwner.domain,
+				)
+				.map(({ correlation }) => correlation);
+		const retireJoinedPromptOwners = (): void => joinedPromptOwners.clear();
 		const pendingPromptCorrelations: Array<{ commandId: string; turnId: string }> = [];
 		const pendingPromptCorrelationsBySdkRunToken = new Map<string, { commandId: string; turnId: string }>();
 		const workLease = ctx.getSessionWorkLease?.() ?? createSessionWorkLease();
@@ -5106,6 +5145,8 @@ export function createNotificationsExtension(
 			 * up to a hard maximum runtime anchored to acceptance.
 			 */
 			deadlineLease: PromptDeadlineLease;
+			deadlineSuspended?: true;
+			sdkRunToken?: string;
 			deadlineTimer?: Parameters<typeof clearTimeout>[0];
 			/**
 			 * Identity of the in-flight deadline expiry attempt (set synchronously
@@ -5314,10 +5355,12 @@ export function createNotificationsExtension(
 				submission.workLease = undefined;
 			}
 			promptSubmissions.delete(key);
+			const [commandId, turnId] = key.split(":", 2);
 			// A fatal closure is transport-level, not a committed semantic terminal: the
-			// durable record stays authoritative, so it must never leave a tombstone.
+			// durable record stays authoritative, so it must never leave a tombstone
+			// or release images still retained by an unsettled run. Runtime teardown
+			// releases those reservations even if this delivery record expires.
 			if (submission.fatal) return;
-			const [commandId, turnId] = key.split(":", 2);
 			if (!commandId || !turnId) return;
 			removePendingPromptCorrelation({ commandId, turnId });
 			addTerminalTombstone(key, submission.connectionId);
@@ -5664,7 +5707,7 @@ export function createNotificationsExtension(
 		 */
 		const armPromptDeadline = (key: string, correlation: { commandId: string; turnId: string }) => {
 			const submission = promptSubmissions.get(key);
-			if (!submission) return;
+			if (!submission || submission.deadlineSuspended) return;
 			const lease = submission.deadlineLease;
 			if (submission.deadlineTimer) clearTimeout(submission.deadlineTimer);
 			submission.deadlineTimer = setTimeout(
@@ -5772,25 +5815,37 @@ export function createNotificationsExtension(
 			);
 		};
 		const emitPromptEvent = (event: AgentSessionEvent) => {
-			if (!runtime?.activePromptCorrelation) return;
+			if (!runtime) return;
 			cleanupPromptRecords();
-			const correlation = runtime.activePromptCorrelation;
-			// Renewal is attributed exactly like the correlated delivery below.
-			renewPromptDeadline(correlation, event);
-			noteToolDispatchBoundary(correlation, event);
-			const submission = promptSubmissions.get(promptSubmissionKey(correlation));
-			if (!submission || submission.abandoned) return;
-			const frame = {
-				type: "event",
-				kind: event.type,
-				payload: toAgentWireEventPayload(event),
-				...correlation,
-			};
-			if (!submission.acknowledged) {
-				submission.bufferedFrames.push(frame);
-				return;
+			const handle = ctx.getActivePromptHandle();
+			const domain = handle ? terminalAbortSeams?.getRunOwnerDomain?.(handle) : undefined;
+			const correlations = handle && domain ? getJoinedPromptCorrelations({ resourceRunId: handle, domain }) : [];
+			const root = runtime.activePromptCorrelation;
+			if (
+				root &&
+				!correlations.some(
+					correlation => correlation.commandId === root.commandId && correlation.turnId === root.turnId,
+				)
+			)
+				correlations.unshift(root);
+			for (const correlation of correlations) {
+				// Renewal is attributed exactly like the correlated delivery below.
+				renewPromptDeadline(correlation, event);
+				noteToolDispatchBoundary(correlation, event);
+				const submission = promptSubmissions.get(promptSubmissionKey(correlation));
+				if (!submission || submission.abandoned) continue;
+				const frame = {
+					type: "event",
+					kind: event.type,
+					payload: toAgentWireEventPayload(event),
+					...correlation,
+				};
+				if (!submission.acknowledged) {
+					submission.bufferedFrames.push(frame);
+					continue;
+				}
+				deliverCorrelatedFrame(submission, frame);
 			}
-			deliverCorrelatedFrame(submission, frame);
 		};
 		/**
 		 * Status of a registered deadline expiry attempt after an awaited
@@ -5809,7 +5864,10 @@ export function createNotificationsExtension(
 			submission: PromptSubmission,
 			attempt: { lease: PromptDeadlineLease; generation: number; selfAbortStarted?: true },
 		): DeadlineAttemptStatus => {
-			if (promptSubmissions.get(key) !== submission || submission.deadlineLease !== attempt.lease) return "stale";
+			if (promptSubmissions.get(key) !== submission) return "stale";
+			if (!attempt.selfAbortStarted && (submission.deadlineSuspended || submission.deadlineLease !== attempt.lease))
+				return "superseded";
+			if (submission.deadlineLease !== attempt.lease) return "stale";
 			const lease = submission.deadlineLease;
 			// A deadline expiry attempt must not be superseded by progress that its
 			// OWN abort caused. Terminal fencing aborts the running tool, and the
@@ -6018,6 +6076,7 @@ export function createNotificationsExtension(
 					maxMs: resolveSdkPromptMaxRuntimeMs(settings?.get("sdk.promptMaxRuntimeMs")),
 				}),
 				phase: "active",
+				...(sdkRunToken ? { sdkRunToken } : {}),
 				...(workLeaseHandle ? { workLease: workLeaseHandle } : {}),
 				// Bound to the Agent run at `agent_start`; acceptance precedes execution.
 				executionHandle: undefined,
@@ -6123,12 +6182,75 @@ export function createNotificationsExtension(
 			correlation: { commandId: string; turnId: string },
 			handle: string | undefined,
 		) => {
-			const submission = promptSubmissions.get(promptSubmissionKey(correlation));
+			const key = promptSubmissionKey(correlation);
+			const submission = promptSubmissions.get(key);
 			if (submission) {
+				if (submission.deadlineSuspended) {
+					submission.deadlineSuspended = undefined;
+					submission.deadlineLease = createPromptDeadlineLease({
+						now: Date.now(),
+						leaseMs: submission.deadlineLease.leaseMs,
+						maxMs: submission.deadlineLease.maxMs,
+					});
+					armPromptDeadline(key, correlation);
+				}
 				submission.executionHandle = handle;
 				submission.preflightAbort = undefined;
 			}
 		};
+		const onPromptDiverted = (correlation: { commandId: string; turnId: string }) => {
+			const submission = promptSubmissions.get(promptSubmissionKey(correlation));
+			// A follow-up's private token can only be adopted by its exact future run.
+			// Implicit steering has no such future-run authority and must leave pending.
+			if (!submission?.sdkRunToken) removePendingPromptCorrelation(correlation);
+			if (!submission || submission.terminal) return;
+			submission.deadlineSuspended = true;
+			if (submission.deadlineTimer) clearTimeout(submission.deadlineTimer);
+			submission.deadlineTimer = undefined;
+		};
+		const onPromptPromoted = (
+			correlation: { commandId: string; turnId: string },
+			promotion: { startsOwnRun?: boolean; removed?: boolean },
+			handle: string | undefined,
+		) => {
+			const key = promptSubmissionKey(correlation);
+			removePendingPromptCorrelation(correlation);
+			if (promotion.removed) {
+				const completion: { terminalized?: boolean } = {};
+				const removal = terminalizePrompt(
+					correlation,
+					{ kind: "stopped", reason: "cancelled", provenance: "client_cancel" },
+					{},
+					undefined,
+					completion,
+				).then(() => completion.terminalized === true);
+				queuedRemovalTerminals.set(key, removal);
+				trackReconciliationProducer(
+					removal.finally(() => {
+						if (queuedRemovalTerminals.get(key) === removal) queuedRemovalTerminals.delete(key);
+					}),
+				);
+				return;
+			}
+			const submission = promptSubmissions.get(key);
+			if (!submission || submission.terminal) return;
+			submission.deadlineSuspended = undefined;
+			submission.deadlineLease = createPromptDeadlineLease({
+				now: Date.now(),
+				leaseMs: submission.deadlineLease.leaseMs,
+				maxMs: submission.deadlineLease.maxMs,
+			});
+			armPromptDeadline(key, correlation);
+			if (promotion.startsOwnRun === true) {
+				if (submission.sdkRunToken) pendingPromptCorrelationsBySdkRunToken.set(submission.sdkRunToken, correlation);
+				else pendingPromptCorrelations.push(correlation);
+			} else {
+				bindPromptExecutionHandle(correlation, handle);
+				const domain = handle ? terminalAbortSeams?.getRunOwnerDomain?.(handle) : undefined;
+				if (handle && domain)
+					joinedPromptOwners.set(key, { correlation, owner: { resourceRunId: handle, domain } });
+			}
+		};
 		const terminalizePrompt = async (
 			correlation: { commandId: string; turnId: string },
 			requestedOutcome: SdkPromptTerminalOutcome,
@@ -6156,6 +6278,7 @@ export function createNotificationsExtension(
 			// the seam must refuse to fence the successor's lineage (review
 			// thread P1).
 			const terminalExpectedEpoch = options.terminal ? terminalAbortSeams?.getTerminalTurnEpoch?.() : undefined;
+			const deadlineAttempt = submission.deadlineAttempt;
 			let winner: SdkPromptTerminalOutcome;
 			try {
 				winner = await kindReconciliation.claimPendingOutcome(
@@ -6179,7 +6302,6 @@ export function createNotificationsExtension(
 			// attempt must then back off — reset to active and reschedule —
 			// instead of fencing and publishing a deadline terminal for a live
 			// prompt. A re-accepted or evicted submission is never touched.
-			const deadlineAttempt = submission.deadlineAttempt;
 			if (deadlineAttempt) {
 				const key = promptSubmissionKey(correlation);
 				const status = deadlineAttemptStatus(key, submission, deadlineAttempt);
@@ -6366,6 +6488,7 @@ export function createNotificationsExtension(
 			}
 			if (submission.deadlineTimer) clearTimeout(submission.deadlineTimer);
 			if (!recordPromptTerminal(correlation)) return;
+			joinedPromptOwners.delete(promptSubmissionKey(correlation));
 			if (!runtime) {
 				// The runtime (and with it the positioned ring) is gone, so the
 				// terminal can never be published from this process; expire the
@@ -6547,6 +6670,8 @@ export function createNotificationsExtension(
 			recordPromptAccepted,
 			recordPromptFailure,
 			discardPromptAcceptance,
+			onPromptDiverted,
+			onPromptPromoted,
 			() => runtime?.stopping !== true,
 			trackGateResolution,
 			admitPromptSubmission,
@@ -6599,9 +6724,15 @@ export function createNotificationsExtension(
 							return { aborted: true, disposition: "cancelled" as const };
 						}
 					}
-					await terminalizePrompt({ commandId, turnId }, cancellationOutcome, {
-						fence: hasExecutionHandle || !submission.preflightAbort,
-					});
+					const removal = queuedRemovalTerminals.get(key);
+					if (removal) {
+						if (!(await removal))
+							throw new TypedControlError("busy", "Queued prompt cancellation could not be durably confirmed.");
+					} else {
+						await terminalizePrompt({ commandId, turnId }, cancellationOutcome, {
+							fence: hasExecutionHandle || !submission.preflightAbort,
+						});
+					}
 				}
 				return { aborted: true, disposition: "cancelled" as const };
 			},
@@ -7107,6 +7238,20 @@ export function createNotificationsExtension(
 							);
 							return already_terminalResult;
 						}
+						if (currentSubmission.preflightAbort) {
+							try {
+								await currentSubmission.preflightAbort();
+							} catch (error) {
+								logger.warn(`sdk: accepted queued cancellation failed: ${String(error)}`);
+								failPromptClosed(
+									{ commandId, turnId },
+									currentSubmission,
+									"terminal_uncertain",
+									"Accepted queued prompt could not be settled before cancellation.",
+								);
+								return { ok: false as const, reason: "worker_unsettled" as const };
+							}
+						}
 						if (preflightCancel?.hasPending()) {
 							preflightCancel.cancel();
 							// The seam cancels the SESSION-WIDE preflight controller:
@@ -7115,11 +7260,30 @@ export function createNotificationsExtension(
 							if (noOtherConnectionPreflights?.() !== false)
 								terminalAbortSeams?.cancelPendingPreflightForTerminalAbort?.();
 						}
-						await terminalizePrompt(
-							{ commandId, turnId },
-							{ kind: "stopped", reason: "cancelled", provenance: "client_cancel" },
-							{},
-						);
+						const removal = queuedRemovalTerminals.get(promptSubmissionKey({ commandId, turnId }));
+						const completion: { terminalized?: boolean } = {};
+						if (removal) completion.terminalized = await removal;
+						else
+							await terminalizePrompt(
+								{ commandId, turnId },
+								{ kind: "stopped", reason: "cancelled", provenance: "client_cancel" },
+								{ fence: Boolean(currentSubmission.executionHandle) },
+								undefined,
+								completion,
+							);
+						const durable = kindReconciliation.lookupResult(currentSubmission.reconciliationKind, {
+							commandId,
+							turnId,
+						});
+						if (
+							completion.terminalized !== true &&
+							(durable.terminalAt === undefined ||
+								(durable.status !== "terminal_ok" && durable.status !== "failed"))
+						) {
+							// The reserved marker remains uncertain; never commit deterministic no-effect
+							// authority while the accepted submission still lacks a durable terminal.
+							return { ok: false as const, reason: "worker_unsettled" as const };
+						}
 						// No prompt won the race: finalize the reserved row so a later
 						// same-key retry replays this deterministic no_active_turn result
 						// instead of reservation uncertainty (review thread P2).
@@ -7993,6 +8157,12 @@ export function createNotificationsExtension(
 		runtime = {
 			server,
 			host,
+			getJoinedPromptCorrelations,
+			isPromptRunOwner: (correlation, owner) => {
+				const handle = promptSubmissions.get(promptSubmissionKey(correlation))?.executionHandle;
+				return handle === owner.resourceRunId && terminalAbortSeams?.getRunOwnerDomain?.(handle) === owner.domain;
+			},
+			retireJoinedPromptOwners,
 			broadcastEventFrame,
 			broadcastEventFrameWithReceipts,
 			revisions,
@@ -9896,13 +10066,25 @@ export function createNotificationsExtension(
 		const id = sessionId(ctx);
 		const rt = runtimes.get(id);
 		if (!rt) return;
-		void rt.host
-			.reportActivity("idle")
-			.catch(error => logger.warn(`notifications: idle activity checkpoint failed: ${String(error)}`));
-		// Clear the streaming flag for SDK consumers even when notifications are off.
-		rt.busy = false;
-		const correlation = rt.activePromptCorrelation;
-		if (correlation) {
+		// The Agent's terminal owner is independent of delivery correlation. Never
+		// borrow a successor's run handle to settle a predecessor's SDK prompts.
+		const terminalOwner = terminalAbortSeams?.getTerminalRunOwnerForEvent?.(event);
+		const rootCorrelation = rt.activePromptCorrelation;
+		const correlations = terminalOwner ? rt.getJoinedPromptCorrelations(terminalOwner) : [];
+		if (
+			rootCorrelation &&
+			(!terminalOwner || rt.isPromptRunOwner(rootCorrelation, terminalOwner)) &&
+			!correlations.some(
+				correlation =>
+					correlation.commandId === rootCorrelation.commandId && correlation.turnId === rootCorrelation.turnId,
+			)
+		)
+			correlations.unshift(rootCorrelation);
+		for (const correlation of correlations) {
+			// This attributed agent_end is an execution boundary even when the
+			// subsequent durable terminal claim fails. A fatal transport closure
+			// clears attribution, so an unrelated later agent_end cannot settle a
+			// predecessor's prompt correlation.
 			const assistants = (Array.isArray(event.messages) ? [...event.messages].reverse() : []).filter(
 				message => message && typeof message === "object" && (message as { role?: unknown }).role === "assistant",
 			) as Array<{ stopReason?: unknown; errorKind?: unknown; errorCode?: unknown }>;
@@ -9990,11 +10172,24 @@ export function createNotificationsExtension(
 						}
 					: {}),
 			});
-		} else {
-			rt.emitPromptLifecycle(undefined, { type: "agent_end", sessionId: id });
 		}
+		if (correlations.length === 0) rt.emitPromptLifecycle(undefined, { type: "agent_end", sessionId: id });
+		if (
+			rootCorrelation &&
+			terminalOwner &&
+			!rt.isPromptRunOwner(rootCorrelation, terminalOwner) &&
+			!correlations.some(
+				correlation =>
+					correlation.commandId === rootCorrelation.commandId && correlation.turnId === rootCorrelation.turnId,
+			)
+		)
+			return;
+		rt.busy = false;
+		void rt.host
+			.reportActivity("idle")
+			.catch(error => logger.warn(`notifications: idle activity checkpoint failed: ${String(error)}`));
 		finishAgentWork(rt, event.stopReason === "paused");
-		rt.activePromptCorrelation = undefined;
+		if (rt.activePromptCorrelation === rootCorrelation) rt.activePromptCorrelation = undefined;
 		terminalizeInFlightTools(rt, id, event.stopReason === "cancelled" ? "cancelled" : "failed");
 		try {
 			pushSessionFrame(rt, { type: "activity", sessionId: id, state: "idle" });

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -296,8 +296,13 @@ export const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * so generation-191 owners cannot reap hosts with queued or promoted work.
  * Generation 193 gates streamed content on negotiated observer capabilities,
  * so existing owners are replaced before exposing the new observer path.
+ * Generation 201 binds queued cancellation and terminal deadlines to the exact
+ * consuming run, so pre-fix owners cannot serve the new generic lifecycle path.
+ * Generation 202 joins queued-removal terminal publication before ordinary
+ * abort acknowledgement, replacing owners that still acknowledge cancellation
+ * before its terminal record is durable.
  */
-export const DAEMON_GENERATION = 200;
+export const DAEMON_GENERATION = 202;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7

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

@@ -167,6 +167,8 @@ export function sdkPublicFailure(code: string, details?: unknown, proof?: Public
 	const kinds: Record<string, PublicFailureKind> = {
 		usage: "usage",
 		invalid_input: "usage",
+		unknown_operation: "usage",
+		not_a_repository: "usage",
 		invalid_json: "invalid_json",
 		broker_unavailable: "broker_unavailable",
 		session_unavailable: "endpoint_stale",
@@ -177,6 +179,7 @@ export function sdkPublicFailure(code: string, details?: unknown, proof?: Public
 		tail_timeout: "timeout",
 		wait_timeout: "wait_timeout",
 		uncertain_after_send: "uncertain_after_send",
+		busy: "busy",
 		authorization_denied: "authorization_denied",
 		unauthorized: "authorization_denied",
 		forbidden: "authorization_denied",
@@ -203,8 +206,15 @@ export function sdkPublicFailure(code: string, details?: unknown, proof?: Public
 		references,
 		// A typed `resource_gone` keeps its public classification; the fixed
 		// diagnostic only separates absent resource state from an empty result.
-		// It asserts no cause and echoes no host-supplied text.
-		...(code === "resource_gone" ? { diagnostics: ["sdk_resource_gone" as const] } : {}),
+		// It asserts no cause and echoes no host-supplied text. The usage-mapped
+		// codes likewise attach fixed guidance instead of the original message.
+		...(code === "resource_gone"
+			? { diagnostics: ["sdk_resource_gone" as const] }
+			: code === "unknown_operation"
+				? { diagnostics: ["sdk_unknown_operation" as const] }
+				: code === "not_a_repository"
+					? { diagnostics: ["sdk_scope_requires_repository" as const] }
+					: {}),
 	});
 }
 
@@ -1248,7 +1258,11 @@ async function runSend(agentDir: string, sessionId: string, args: SdkSessionCliA
 								? ("wait_timeout" as const)
 								: failure.input.kind,
 					}
-				: {}),
+				: failure.input.kind === "busy"
+					? // turn.prompt is refused while a turn runs and its admission is released
+						// before any execution, so the prompt definitively did not apply.
+						{ proof: "pre-effect" as const }
+					: {}),
 			references: failure.input.references,
 		});
 	}

package/src/sdk/client/client.ts

@@ -100,6 +100,8 @@ export interface SdkClientOptions {
 
 export interface SdkRequestOptions {
 	timeoutMs?: number;
+	/** Absolute wall-clock deadline for this request, including connection setup. */
+	deadline?: number;
 	idempotencyKey?: string;
 	confirm?: boolean;
 	/**
@@ -496,6 +498,14 @@ export class SdkClient {
 			if (options.connectedOnly && error instanceof SdkClientError) throw new SdkPreparedDispatchError(error);
 			throw error;
 		}
+		const requestDeadline =
+			typeof options.deadline === "number" && Number.isFinite(options.deadline)
+				? Math.min(options.deadline, this.#deadline ?? Number.POSITIVE_INFINITY)
+				: this.#deadline;
+		if (requestDeadline !== undefined && Date.now() >= requestDeadline) {
+			const error = this.#deadlineError();
+			throw options.connectedOnly ? new SdkPreparedDispatchError(error) : error;
+		}
 		let incarnation: Incarnation;
 		if (options.connectedOnly) {
 			try {
@@ -504,8 +514,8 @@ export class SdkClient {
 				if (error instanceof SdkClientError) throw new SdkPreparedDispatchError(error);
 				throw error;
 			}
-		} else incarnation = await this.#connect();
-		const timeoutMs = this.#remainingTimeout(options.timeoutMs ?? this.#timeoutMs);
+		} else incarnation = await this.#connect(requestDeadline);
+		const timeoutMs = this.#remainingTimeout(options.timeoutMs ?? this.#timeoutMs, requestDeadline);
 		if (timeoutMs <= 0) {
 			const error = this.#deadlineError();
 			throw options.connectedOnly ? new SdkPreparedDispatchError(error) : error;
@@ -615,7 +625,7 @@ export class SdkClient {
 				);
 			return await deferred.promise;
 		}
-		if (this.#deadline !== undefined && Date.now() >= this.#deadline) {
+		if (requestDeadline !== undefined && Date.now() >= requestDeadline) {
 			const error = this.#deadlineError();
 			this.#settlePending(id, pending, options.connectedOnly ? new SdkPreparedDispatchError(error) : error);
 			return await deferred.promise;
@@ -686,17 +696,18 @@ export class SdkClient {
 		return transportError("timeout", "SDK client deadline elapsed.", undefined, reconnect);
 	}
 
-	#remainingTimeout(limit = this.#timeoutMs): number {
-		if (this.#deadline === undefined) return limit;
-		return Math.min(limit, Math.max(0, this.#deadline - Date.now()));
+	#remainingTimeout(limit = this.#timeoutMs, deadline = this.#deadline): number {
+		if (deadline === undefined) return limit;
+		return Math.min(limit, Math.max(0, deadline - Date.now()));
 	}
 
 	#throwIfDeadlineElapsed(): void {
 		if (this.#deadline !== undefined && Date.now() >= this.#deadline) throw this.#deadlineError();
 	}
 
-	async #connect(): Promise<Incarnation> {
+	async #connect(requestDeadline?: number): Promise<Incarnation> {
 		this.#throwIfDeadlineElapsed();
+		if (requestDeadline !== undefined && Date.now() >= requestDeadline) throw this.#deadlineError();
 		const current = this.#currentSocketRecord;
 		if (current && this.#isActive(current) && current.socket.readyState === WebSocket.OPEN) return current;
 		if (current)
@@ -708,7 +719,16 @@ export class SdkClient {
 			this.#opening = cycle;
 			cycle.promise = this.#openWithRetry(cycle);
 		}
-		return await cycle.promise!;
+		if (requestDeadline === undefined) return await cycle.promise!;
+		const remaining = requestDeadline - Date.now();
+		if (remaining <= 0) throw this.#deadlineError();
+		const expired = Promise.withResolvers<never>();
+		const timer = setTimeout(() => expired.reject(this.#deadlineError()), remaining);
+		try {
+			return await Promise.race([cycle.promise!, expired.promise]);
+		} finally {
+			clearTimeout(timer);
+		}
 	}
 
 	#requireConnectedIncarnation(): Incarnation {

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

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
+import type { ProjectProgressSnapshot } from "../../../progress/progress-contract.js";
 import { PROMPT_CLIENT_REF_MAX_LENGTH } from "../../prompt-status.js";
 import { TURN_RESULT_PROMPT_ALIAS, TURN_RESULT_SKILL_ALIAS } from "../../protocol/operation-registry.js";
-
 import type { ActiveProviderDescriptor } from "../../providers.js";
 import { ActiveProviderResolutionError } from "../../providers.js";
 
@@ -51,6 +51,8 @@ export interface SessionSurface {
 		| Promise<{ bytes: Uint8Array; totalBytes: number } | undefined>;
 
 	getJobs(): unknown | Promise<unknown>;
+	/** Q32 read-only project progress snapshot (`gjc.project_progress.v1`). */
+	getProjectProgress?(): ProjectProgressSnapshot | Promise<ProjectProgressSnapshot>;
 	/** Q26 keyed lookup of a submitted prompt's authoritative reconciliation status. */
 	getPromptStatus?(selector: { commandId?: string; turnId?: string; clientRef?: string }): unknown | Promise<unknown>;
 	getSkillInvokeStatus?(selector: {
@@ -152,6 +154,7 @@ const sources: Record<string, { resource: string; method: keyof SessionSurface;
 	Q25: { resource: "jobs", method: "getJobs", mvcc: false },
 	Q29: { resource: "activeProviders", method: "getActiveProviders", mvcc: false },
 	Q27: { resource: "modelProfiles", method: "getModelProfiles", mvcc: true },
+	Q32: { resource: "progress", method: "getProjectProgress", mvcc: false },
 };
 const names = [
 	"transcript.list",
@@ -186,6 +189,7 @@ const names = [
 	"providers.list/active",
 	"session.checkpoint",
 	"turn.steer_status",
+	"session.progress",
 ];
 
 export class QueryHandlers {
@@ -275,6 +279,10 @@ export class QueryHandlers {
 				);
 			if (query === "Q29" && typeof this.surface.getActiveProviders !== "function")
 				return this.#error(request, "unavailable", false, "providers.list/active is unavailable for this session.");
+			if (query === "Q32" && request.input && Object.keys(request.input).length > 0)
+				return this.#error(request, "invalid_request", false, "session.progress does not accept input fields.");
+			if (query === "Q32" && typeof this.surface.getProjectProgress !== "function")
+				return this.#error(request, "unavailable", false, "session.progress is unavailable for this session.");
 			const source = sources[query];
 			if (!source) return this.#error(request, "invalid_request");
 			return await this.#pageSource(request, query, source);