@gajae-code/coding-agent 0.15.5 → 0.16.0

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

@@ -5,7 +5,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { AsyncJobManager } from "../../async";
 import type { Settings } from "../../config/settings";
-import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
+import type { ExtensionAPI, ExtensionContext, ExtensionTranscriptEntry } from "../../extensibility/extensions";
 import {
 	registerOwnedRegistration,
 	resetTerminalAbortRegistriesForTests,
@@ -13,8 +13,11 @@ import {
 	unregisterOwnedRegistration,
 } from "../../session/terminal-abort";
 import { Broker } from "../broker/broker";
+import { createKindAwareReconciliation } from "../bus/kind-aware-reconciliation";
+import { createPromptReconciliation } from "../bus/prompt-reconciliation";
 import { createReconciliationStore } from "../bus/reconciliation-store";
-import { CursorRegistry, QueryHandlers, RevisionStore } from "./query";
+import { BROKER_RUNTIME_ABORT_CAPABILITY_FIELD, setBrokerRuntimeAbortCapabilityForTest } from "./control/runtime-gate";
+import { CursorRegistry, QueryHandlers, type QueryResponse, RevisionStore } from "./query";
 import {
 	createInvocationReconciliation,
 	createSdkSessionRuntimeExtension,
@@ -88,6 +91,7 @@ function extensionContext(
 		goalState?: unknown;
 		branch?: unknown[];
 		liveState?: { isStreaming: boolean; steeringQueueDepth: number; followupQueueDepth: number };
+		transcript?: ExtensionTranscriptEntry[];
 	} = {},
 ): ExtensionContext {
 	return {
@@ -100,6 +104,7 @@ function extensionContext(
 			getSessionName: () => undefined,
 			getBranch: () => options.branch ?? [],
 		},
+		getTranscript: () => options.transcript ?? [],
 		getGoalState: () => options.goalState,
 	} as unknown as ExtensionContext;
 }
@@ -146,6 +151,167 @@ async function queryGoalState(
 	return response.page?.items[0];
 }
 
+async function queryLastAssistant(ctx: ExtensionContext, sessionId: string): Promise<QueryResponse> {
+	const surface = createSdkSurfaceFactory({
+		ctx,
+		id: sessionId,
+		api: {} as ExtensionAPI,
+	}).query;
+	const store = new RevisionStore(sessionId);
+	const response = await new QueryHandlers(
+		surface,
+		sessionId,
+		store,
+		new CursorRegistry("last-assistant-test-token", store),
+	).dispatch({
+		query: "session.last_assistant",
+		connectionId: "last-assistant-test-connection",
+	});
+	return response;
+}
+
+test("session.last_assistant returns the latest projected readable text past non-text assistant tails", async () => {
+	const sessionId = "last-assistant-readable-tail";
+	const transcript: ExtensionTranscriptEntry[] = [
+		{
+			id: "visible-readable",
+			role: "assistant",
+			textSummary: "first line second line",
+			ts: new Date(1).toISOString(),
+			content: [
+				{ type: "text", text: "first line" },
+				{ type: "thinking", thinking: "private reasoning" },
+				{ type: "text", text: "second line" },
+			],
+		},
+		...Array.from(
+			{ length: 2_000 },
+			(_, index): ExtensionTranscriptEntry => ({
+				id: `tool-tail-${index}`,
+				role: "assistant",
+				textSummary: "",
+				ts: new Date(index + 2).toISOString(),
+				body: index % 3 === 0 ? "" : index % 3 === 1 ? " \n\t " : undefined,
+				content:
+					index % 3 === 2
+						? [
+								{ type: "thinking", thinking: "not readable" },
+								{ type: "toolCall", id: `call-${index}`, name: "read", arguments: {} },
+							]
+						: undefined,
+			}),
+		),
+	];
+	const ctx = extensionContext(sessionId, "/tmp", {
+		transcript,
+		branch: [
+			{
+				type: "message",
+				message: { role: "assistant", content: [{ type: "text", text: "raw private tail" }] },
+			},
+		],
+	});
+
+	expect(await queryLastAssistant(ctx, sessionId)).toMatchObject({
+		ok: true,
+		page: { items: ["first line\nsecond line"] },
+	});
+});
+
+test("session.last_assistant returns resource_gone when the projected transcript has no readable assistant text", async () => {
+	const sessionId = "last-assistant-empty";
+	const ctx = extensionContext(sessionId, "/tmp", {
+		transcript: [
+			{
+				id: "user",
+				role: "user",
+				textSummary: "hello",
+				ts: new Date(1).toISOString(),
+				body: "hello",
+			},
+			{
+				id: "thinking-only",
+				role: "assistant",
+				textSummary: "",
+				ts: new Date(2).toISOString(),
+				content: [{ type: "thinking", thinking: "private reasoning" }],
+			},
+		],
+	});
+
+	expect(await queryLastAssistant(ctx, sessionId)).toMatchObject({ ok: false, error: { code: "resource_gone" } });
+});
+
+test("native prompt reconciliation fails closed for an explicitly empty assistant result", () => {
+	const reconciliation = createPromptReconciliation();
+	const correlation = { commandId: "native-empty-command", turnId: "native-empty-turn" };
+	reconciliation.admit("native-empty-ref");
+	reconciliation.noteAccepted(correlation, "native-empty-ref");
+	reconciliation.noteTransition(correlation, { type: "agent_end", finalText: "" });
+	expect(reconciliation.lookup({ clientRef: "native-empty-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "prompt_failed" },
+		receiptState: "missing",
+	});
+	reconciliation.noteTransition(correlation, { type: "agent_end", finalText: "late text" });
+	expect(reconciliation.lookup({ clientRef: "native-empty-ref" })).toMatchObject({ status: "failed" });
+});
+
+test("broker reconciliation fails closed for an empty prompt and persists the first terminal result", async () => {
+	let records: unknown[] = [];
+	const store = {
+		load: async () => records,
+		transact: async (mutator: (current: never[]) => never[]) => {
+			records = mutator(records as never);
+		},
+	} as never;
+	const reconciliation = createKindAwareReconciliation({ store });
+	const correlation = { commandId: "broker-empty-command", turnId: "broker-empty-turn" };
+	await reconciliation.noteAccepted("prompt", correlation, "broker-empty-ref");
+	await reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "", byteLength: 0, truncated: false },
+	});
+	const settled = reconciliation.lookupResult("prompt", { clientRef: "broker-empty-ref" });
+	expect(settled).toMatchObject({ status: "failed", error: { code: "prompt_failed" } });
+	await reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "late text", byteLength: 9, truncated: false },
+	});
+	const reloaded = createKindAwareReconciliation({ store });
+	await reloaded.hydrateFromStore();
+	expect(reloaded.lookupResult("prompt", { clientRef: "broker-empty-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "prompt_failed" },
+	});
+	const noOpCorrelation = { commandId: "broker-noop-command", turnId: "broker-noop-turn" };
+	await reconciliation.noteAccepted("prompt", noOpCorrelation, "broker-noop-ref");
+	await reconciliation.finalizeOutcome(
+		"prompt",
+		noOpCorrelation,
+		{ kind: "stopped", reason: "cancelled", provenance: "client_cancel" },
+		undefined,
+		"",
+	);
+	expect(reconciliation.lookupResult("prompt", { clientRef: "broker-noop-ref" })).toMatchObject({
+		status: "terminal_ok",
+	});
+});
+
+test("session-host prompt reconciliation fails closed when the accepted result is empty", async () => {
+	const reconciliation = createInvocationReconciliation();
+	const correlation = { commandId: "host-empty-command", turnId: "host-empty-turn" };
+	await reconciliation.noteAccepted("prompt", correlation, "host-empty-ref");
+	await reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "", byteLength: 0, truncated: false },
+	});
+	expect(reconciliation.lookup("prompt", { clientRef: "host-empty-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "prompt_failed" },
+	});
+});
+
 describe("SDK goal snapshot lifecycle", () => {
 	test("recovers an active nonzero-activity goal from the durable session projection", async () => {
 		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-sdk-goal-recovery-"));
@@ -405,7 +571,10 @@ test("durable reload keeps agent_end terminal across a paused successor transiti
 	const correlation = { commandId: "durable-race-command", turnId: "durable-race-turn" };
 	await reconciliation.noteAccepted("prompt", correlation, "durable-race-ref");
 	pauseWrites = 2;
-	const terminal = reconciliation.noteTransition("prompt", correlation, { type: "agent_end" });
+	const terminal = reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+	});
 	await writeStarted[0]!.promise;
 	// A successor lifecycle event arrives while the terminal write is held. It
 	// must observe the staged terminal record and never resurrect in_flight state.
@@ -455,7 +624,10 @@ test("agent_end is not swallowed when deadline persistence fails", async () => {
 		message: "deadline",
 	});
 	await persistStarted.promise;
-	const terminal = reconciliation.noteTransition("prompt", correlation, { type: "agent_end" });
+	const terminal = reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+	});
 	releasePersist.resolve();
 	await expect(deadline).rejects.toThrow("held store failed");
 	await terminal;
@@ -523,13 +695,86 @@ test("agent_end upgrades a durable deadline terminal when it races a successful
 		code: "prompt_deadline_exceeded",
 		message: "deadline",
 	});
-	await reconciliation.noteTransition("prompt", correlation, { type: "agent_end" });
+	await reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+	});
 	const reloaded = createInvocationReconciliation({ store });
 	await reloaded.hydrate();
 	expect(reloaded.lookup("prompt", { clientRef: "upgrade-race-ref" })).toMatchObject({ status: "terminal_ok" });
 });
 
-test("failed agent_end upgrade persistence retains the deadline record for retry", async () => {
+test("an empty late agent_end cannot upgrade a durable prompt deadline failure", async () => {
+	let records: unknown[] = [];
+	const store = {
+		path: null,
+		load: async () => records,
+		transact: async (mutator: (current: never[]) => never[]) => {
+			records = mutator(records as never);
+		},
+	} as never;
+	const reconciliation = createInvocationReconciliation({ store });
+	const correlation = { commandId: "empty-deadline-command", turnId: "empty-deadline-turn" };
+	await reconciliation.noteAccepted("prompt", correlation, "empty-deadline-ref");
+	await reconciliation.finalizeOutcome("prompt", correlation, {
+		kind: "failed",
+		code: "prompt_deadline_exceeded",
+		message: "deadline",
+	});
+	await reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "", byteLength: 0, truncated: false },
+	});
+	expect(reconciliation.lookup("prompt", { clientRef: "empty-deadline-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "prompt_deadline_exceeded" },
+	});
+	const reloaded = createInvocationReconciliation({ store });
+	await reloaded.hydrate();
+	expect(reloaded.lookup("prompt", { clientRef: "empty-deadline-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "prompt_deadline_exceeded" },
+	});
+});
+
+test("whitespace and provider failures stay actionable across a late empty agent_end", async () => {
+	let records: unknown[] = [];
+	const store = {
+		path: null,
+		load: async () => records,
+		transact: async (mutator: (current: never[]) => never[]) => {
+			records = mutator(records as never);
+		},
+	} as never;
+	const reconciliation = createInvocationReconciliation({ store });
+	const whitespace = { commandId: "whitespace-command", turnId: "whitespace-turn" };
+	await reconciliation.noteAccepted("prompt", whitespace, "whitespace-ref");
+	await reconciliation.noteTransition("prompt", whitespace, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: " \t\n ", byteLength: 4, truncated: false },
+	});
+	expect(reconciliation.lookup("prompt", { clientRef: "whitespace-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "prompt_failed", message: "Prompt submission failed." },
+	});
+
+	const providerFailure = { commandId: "provider-command", turnId: "provider-turn" };
+	await reconciliation.noteAccepted("prompt", providerFailure, "provider-ref");
+	await reconciliation.noteTransition("prompt", providerFailure, {
+		type: "agent_failed",
+		error: Object.assign(new Error("provider leaked detail"), { code: "provider_unavailable" }),
+	});
+	await reconciliation.noteTransition("prompt", providerFailure, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "", byteLength: 0, truncated: false },
+	});
+	expect(reconciliation.lookup("prompt", { clientRef: "provider-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "provider_unavailable", message: "Prompt submission failed." },
+	});
+});
+
+test("an empty prompt terminal remains failed after a late real failure", async () => {
 	let records: unknown[] = [];
 	let writes = 0;
 	const store = {
@@ -550,9 +795,12 @@ test("failed agent_end upgrade persistence retains the deadline record for retry
 		code: "prompt_deadline_exceeded",
 		message: "deadline",
 	});
-	await expect(reconciliation.noteTransition("prompt", correlation, { type: "agent_end" })).rejects.toThrow(
-		"upgrade persist failed",
-	);
+	await expect(
+		reconciliation.noteTransition("prompt", correlation, {
+			type: "agent_end",
+			content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+		}),
+	).rejects.toThrow("upgrade persist failed");
 	expect(reconciliation.lookup("prompt", { clientRef: "upgrade-failure-ref" })).toMatchObject({
 		status: "failed",
 		error: { code: "prompt_deadline_exceeded" },
@@ -563,17 +811,132 @@ test("failed agent_end upgrade persistence retains the deadline record for retry
 		status: "failed",
 		error: { code: "prompt_deadline_exceeded" },
 	});
-	await reconciliation.noteTransition("prompt", correlation, { type: "agent_end" });
+	await reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+	});
 	const reloaded = createInvocationReconciliation({ store });
 	await reloaded.hydrate();
 	expect(reloaded.lookup("prompt", { clientRef: "upgrade-failure-ref" })).toMatchObject({ status: "terminal_ok" });
 });
 
+test("late cancellation and non-text activity upgrade deadline terminals", async () => {
+	const makeStore = () => {
+		let records: unknown[] = [];
+		return {
+			path: null,
+			load: async () => records,
+			transact: async (mutator: (current: never[]) => never[]) => {
+				records = mutator(records as never);
+			},
+		} as never;
+	};
+	const cancelled = createInvocationReconciliation({ store: makeStore() });
+	const cancelledCorrelation = { commandId: "late-cancel-command", turnId: "late-cancel-turn" };
+	await cancelled.noteAccepted("prompt", cancelledCorrelation, "late-cancel-ref");
+	await cancelled.finalizeOutcome("prompt", cancelledCorrelation, {
+		kind: "failed",
+		code: "prompt_deadline_exceeded",
+		message: "deadline",
+	});
+	await cancelled.noteTransition("prompt", cancelledCorrelation, {
+		type: "agent_end",
+		outcome: { kind: "stopped", reason: "cancelled", provenance: "client_cancel" },
+	});
+	expect(cancelled.lookup("prompt", { clientRef: "late-cancel-ref" })).toMatchObject({ status: "terminal_ok" });
+
+	const activity = createInvocationReconciliation({ store: makeStore() });
+	const activityCorrelation = { commandId: "late-activity-command", turnId: "late-activity-turn" };
+	await activity.noteAccepted("prompt", activityCorrelation, "late-activity-ref");
+	await activity.finalizeOutcome("prompt", activityCorrelation, {
+		kind: "failed",
+		code: "prompt_deadline_exceeded",
+		message: "deadline",
+	});
+	await activity.noteTransition("prompt", activityCorrelation, { type: "agent_end", hasActivity: true });
+	expect(activity.lookup("prompt", { clientRef: "late-activity-ref" })).toMatchObject({ status: "terminal_ok" });
+});
+test("finalization without an explicit outcome follows the noteTransition evidence predicate", async () => {
+	const makeLocalStore = () => {
+		let records: unknown[] = [];
+		return {
+			path: null,
+			load: async () => records,
+			transact: async (mutator: (current: never[]) => never[]) => {
+				records = mutator(records as never);
+			},
+		} as never;
+	};
+	const contentBearing = createInvocationReconciliation({ store: makeLocalStore() });
+	const contentCorrelation = { commandId: "final-content-command", turnId: "final-content-turn" };
+	await contentBearing.noteAccepted("prompt", contentCorrelation, "final-content-ref");
+	await contentBearing.finalizeOutcome("prompt", contentCorrelation, undefined, undefined, undefined, {
+		content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+	});
+	expect(contentBearing.lookup("prompt", { clientRef: "final-content-ref" })).toMatchObject({
+		status: "terminal_ok",
+	});
+
+	const activityBearing = createInvocationReconciliation({ store: makeLocalStore() });
+	const activityCorrelation = { commandId: "final-activity-command", turnId: "final-activity-turn" };
+	await activityBearing.noteAccepted("prompt", activityCorrelation, "final-activity-ref");
+	await activityBearing.finalizeOutcome("prompt", activityCorrelation, undefined, undefined, undefined, {
+		hasActivity: true,
+	});
+	expect(activityBearing.lookup("prompt", { clientRef: "final-activity-ref" })).toMatchObject({
+		status: "terminal_ok",
+	});
+
+	const stoppedOutcome = createInvocationReconciliation({ store: makeLocalStore() });
+	const stoppedCorrelation = { commandId: "final-stopped-command", turnId: "final-stopped-turn" };
+	await stoppedOutcome.noteAccepted("prompt", stoppedCorrelation, "final-stopped-ref");
+	await stoppedOutcome.finalizeOutcome("prompt", stoppedCorrelation, undefined, undefined, undefined, {
+		outcomeKind: "stopped",
+	});
+	expect(stoppedOutcome.lookup("prompt", { clientRef: "final-stopped-ref" })).toMatchObject({
+		status: "terminal_ok",
+	});
+
+	const evidenceFree = createInvocationReconciliation({ store: makeLocalStore() });
+	const emptyCorrelation = { commandId: "final-empty-command", turnId: "final-empty-turn" };
+	await evidenceFree.noteAccepted("prompt", emptyCorrelation, "final-empty-ref");
+	await evidenceFree.finalizeOutcome("prompt", emptyCorrelation);
+	expect(evidenceFree.lookup("prompt", { clientRef: "final-empty-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "prompt_failed" },
+	});
+	const legacyArg5 = createInvocationReconciliation({ store: makeLocalStore() });
+	const legacyCorrelation = { commandId: "final-legacy-command", turnId: "final-legacy-turn" };
+	await legacyArg5.noteAccepted("prompt", legacyCorrelation, "final-legacy-ref");
+	await legacyArg5.finalizeOutcome("prompt", legacyCorrelation, undefined, undefined, {
+		content: { version: 1, type: "text", text: "legacy", byteLength: 6, truncated: false },
+	});
+	expect(legacyArg5.lookup("prompt", { clientRef: "final-legacy-ref" })).toMatchObject({
+		status: "terminal_ok",
+	});
+
+	const explicitFailure = createInvocationReconciliation({ store: makeLocalStore() });
+	const failureCorrelation = { commandId: "final-failure-command", turnId: "final-failure-turn" };
+	await explicitFailure.noteAccepted("prompt", failureCorrelation, "final-failure-ref");
+	await explicitFailure.finalizeOutcome("prompt", failureCorrelation, {
+		kind: "failed",
+		code: "provider_rejected",
+		message: "provider rejected",
+	});
+	expect(explicitFailure.lookup("prompt", { clientRef: "final-failure-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "provider_rejected" },
+	});
+});
+
 test("a reason attached after a prompt settled is never replaced by a later failure", async () => {
 	const reconciliation = createInvocationReconciliation();
 	const correlation = { commandId: "late-reason-command", turnId: "late-reason-turn" };
 	await reconciliation.noteAccepted("prompt", correlation, "late-reason-ref");
-	await reconciliation.noteTransition("prompt", correlation, { type: "agent_end" });
+	await reconciliation.noteTransition("prompt", correlation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+	});
 	const claimed = reconciliation.lookup("prompt", { clientRef: "late-reason-ref" }) as Record<string, unknown>;
 	expect(claimed).toEqual({
 		status: "terminal_ok",
@@ -649,7 +1012,10 @@ test("retains terminal host reconciliation records past the 15-minute window", a
 		reconciliation.admit("skill", "aged-skill-ref");
 		await reconciliation.noteAccepted("prompt", promptCorrelation, "aged-ref");
 		await reconciliation.noteAccepted("skill", skillCorrelation, "aged-skill-ref");
-		await reconciliation.noteTransition("prompt", promptCorrelation, { type: "agent_end" });
+		await reconciliation.noteTransition("prompt", promptCorrelation, {
+			type: "agent_end",
+			content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+		});
 		await reconciliation.noteTransition("skill", skillCorrelation, { type: "agent_end" });
 
 		clock += 15 * 60_000 + 1;
@@ -679,7 +1045,10 @@ test("capacity eviction still releases the clientRef and reports honest unknown"
 		const correlation = { commandId: `capacity-command-${index}`, turnId: `capacity-turn-${index}` };
 		reconciliation.admit("prompt", `capacity-ref-${index}`);
 		await reconciliation.noteAccepted("prompt", correlation, `capacity-ref-${index}`);
-		await reconciliation.noteTransition("prompt", correlation, { type: "agent_end" });
+		await reconciliation.noteTransition("prompt", correlation, {
+			type: "agent_end",
+			content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
+		});
 	}
 	expect(reconciliation.lookup("prompt", { clientRef: "capacity-ref-1" })).toEqual({
 		status: "unknown",
@@ -735,6 +1104,8 @@ describe("SessionSdkSessionRuntime", () => {
 	});
 	test("SDK-only host admits, replays, and conflicts terminal abort requests durably", async () => {
 		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-sdk-terminal-abort-"));
+		const operatorCapability = "runtime-terminal-abort-capability";
+		setBrokerRuntimeAbortCapabilityForTest(operatorCapability);
 		const handlers = new Map<string, (event: unknown, ctx: ExtensionContext) => Promise<void> | void>();
 		const api = {
 			on(event: string, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void) {
@@ -770,7 +1141,13 @@ describe("SessionSdkSessionRuntime", () => {
 				},
 				abortPromptAndWaitWithTerminal: async (handle, options) => {
 					seamCalls.push({ handle, scope: options.terminal?.scope ?? "none" });
-					return { status: "settled", terminalScope: {} };
+					return {
+						status: "settled",
+						terminalScope: {
+							abortedAttemptEpoch: activeEpoch,
+							lineageIdHash: "runtime-test-lineage",
+						},
+					};
 				},
 			},
 		});
@@ -865,7 +1242,43 @@ describe("SessionSdkSessionRuntime", () => {
 					}),
 				]),
 			);
+
+			// A separately connected, explicitly confirmed local operator may stop
+			// the active turn and its exact owned work without weakening ordinary
+			// connection ownership checks.
+			transport.feed("local-operator", {
+				type: "control_request",
+				id: "terminal-operator-abort",
+				operation: "turn.abort",
+				input: {
+					mode: "terminal",
+					scope: "owned",
+					operator: true,
+					[BROKER_RUNTIME_ABORT_CAPABILITY_FIELD]: operatorCapability,
+				},
+				confirm: true,
+				idempotencyKey: "terminal-operator-key",
+			} as SdkFrame);
+			await waitForFrame("terminal-operator-abort");
+			expect(seamCalls).toEqual([
+				{ handle: "exact-run-handle", scope: "turn" },
+				{ handle: "later-run-handle", scope: "owned" },
+			]);
+			expect(transport.sent.find(frame => frame.id === "terminal-operator-abort")).toMatchObject({
+				ok: true,
+				result: expect.objectContaining({ turn: "stopped", ownedWork: "stopped" }),
+			});
+			const operatorKeyHash = createHash("sha256").update("terminal-operator-key").digest("hex");
+			const deliveryDeadline = Date.now() + 15_000;
+			while (
+				reconciliationStore.snapshotTerminalScopes().find(record => record.idempotencyKeyHash === operatorKeyHash)
+					?.responseState !== "sent"
+			) {
+				if (Date.now() > deliveryDeadline) throw new Error("Timed out waiting for operator delivery receipt");
+				await Bun.sleep(20);
+			}
 		} finally {
+			setBrokerRuntimeAbortCapabilityForTest(undefined);
 			await handlers.get("session_shutdown")?.({}, ctx);
 			await rm(cwd, { recursive: true, force: true });
 		}
@@ -1076,7 +1489,71 @@ describe("SessionSdkSessionRuntime", () => {
 		}
 	});
 
-	test("SDK-only host re-reads the active prompt AND its owner after an owner-mismatch reservation wins the race", async () => {
+	test("SDK-only operator abort never adopts a turn that starts after idle admission", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-sdk-operator-idle-race-"));
+		const capability = "operator-idle-race-capability";
+		setBrokerRuntimeAbortCapabilityForTest(capability);
+		const handlers = new Map<string, (event: unknown, ctx: ExtensionContext) => Promise<void> | void>();
+		const api = {
+			on(event: string, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void) {
+				handlers.set(event, handler);
+			},
+		} as unknown as ExtensionAPI;
+		const transport = memoryTransport();
+		const reconciliationStore = createReconciliationStore({
+			sessionFile: path.join(cwd, "session.json"),
+			sessionId: transport.sessionId,
+		});
+		const seamCalls: string[] = [];
+		let promptReads = 0;
+		createSdkSessionRuntimeExtension(api, {
+			agentDir: cwd,
+			createTransport: async () => transport,
+			terminalAbortSeams: {
+				getReconciliationStore: () => reconciliationStore,
+				getTerminalTurnEpoch: () => (promptReads++ === 0 ? undefined : 9),
+				getActivePromptHandle: () => (promptReads === 0 ? undefined : "successor-handle"),
+				getActivePromptOwnerConnectionId: () => "successor-owner",
+				cancelPendingPreflightForTerminalAbort: () => {},
+				abortPromptAndWaitWithTerminal: async handle => {
+					seamCalls.push(handle);
+					return { status: "settled", terminalScope: {} };
+				},
+			},
+		});
+		const ctx = extensionContext(transport.sessionId, cwd);
+		try {
+			await handlers.get("session_start")?.({}, ctx);
+			transport.feed("local-operator", {
+				type: "control_request",
+				id: "operator-idle-race",
+				operation: "turn.abort",
+				input: {
+					mode: "terminal",
+					operator: true,
+					[BROKER_RUNTIME_ABORT_CAPABILITY_FIELD]: capability,
+				},
+				confirm: true,
+				idempotencyKey: "operator-idle-race-key",
+			} as SdkFrame);
+			const deadline = Date.now() + 15_000;
+			while (!transport.sent.some(frame => frame.id === "operator-idle-race")) {
+				if (Date.now() > deadline) throw new Error("Timed out waiting for operator idle-race response");
+				await Bun.sleep(20);
+			}
+			expect(transport.sent.find(frame => frame.id === "operator-idle-race")).toMatchObject({
+				ok: true,
+				result: expect.objectContaining({ turn: "no_active_turn", terminal: "terminal_no_effect" }),
+			});
+			expect(seamCalls).toHaveLength(0);
+		} finally {
+			setBrokerRuntimeAbortCapabilityForTest(undefined);
+			await handlers.get("session_shutdown")?.({}, ctx);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("SDK-only host re-reads the active prompt AND its owner after an owner-mismatch reservation race", async () => {
 		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-sdk-terminal-owner-race-"));
 		const handlers = new Map<string, (event: unknown, ctx: ExtensionContext) => Promise<void> | void>();
 		const api = {
@@ -1870,10 +2347,10 @@ describe("SessionSdkSessionRuntime", () => {
 			prompt("conn-b", "stale-b");
 			await waitResponse("stale-b");
 			// A later AGENT-INITIATED turn starts: the pending queue is empty, so
-			// the owner stays conn-a (B's stale connection is not associated).
+			// the predecessor's conn-a owner is cleared and no SDK client owns it.
 			await handlers.get("agent_start")?.({ type: "agent_start" }, ctx);
-			// B's abort must NOT stop the agent-initiated turn.
-			transport.feed("conn-b", {
+			// A's stale owner must NOT stop the agent-initiated turn.
+			transport.feed("conn-a", {
 				type: "control_request",
 				id: "stale-owner-abort",
 				operation: "turn.abort",
@@ -1987,6 +2464,40 @@ describe("SessionSdkSessionRuntime", () => {
 		}
 	});
 
+	test("agent-initiated successor activity cannot renew a stale predecessor deadline", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-sdk-stale-deadline-owner-"));
+		try {
+			const harness = await invocationHarness("stale-deadline-owner", cwd, {
+				settings: {
+					get: (key: string) =>
+						key === "sdk.promptDeadlineMs" ? 25 : key === "sdk.promptMaxRuntimeMs" ? 60_000 : undefined,
+				} as unknown as Settings,
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await neverSettlingPromise();
+				},
+			});
+			const prompt = await harness.control("turn.prompt", { text: "predecessor" });
+			expect(prompt.ok).toBe(true);
+			const ids = { commandId: prompt.result?.commandId, turnId: prompt.result?.turnId };
+			await harness.emit("agent_start");
+			// Empty drain represents an agent-initiated successor with no SDK owner.
+			await harness.emit("agent_start");
+			for (let i = 0; i < 3; i += 1) {
+				await harness.emit("tool_execution_start");
+				await Bun.sleep(15);
+			}
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
+				status: "failed",
+				error: { code: "prompt_deadline_exceeded" },
+			});
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
 	test("SDK-only host retires an accepted-then-failed submission so a later agent-initiated turn is not mis-owned", async () => {
 		// An idle submission is accepted (pending entry pushed) and then REJECTS
 		// before agent_start (e.g. the busy retry expires). The failed entry must
@@ -2863,6 +3374,7 @@ describe("SessionSdkSessionRuntime", () => {
 			},
 		} as any;
 		const sessionId = "broker-recovery";
+		const endpointUrl = "ws://127.0.0.1:1";
 		createSdkSessionRuntimeExtension(api, {
 			agentDir,
 			createTransport: async ({ stateRoot, token }) => ({
@@ -2874,8 +3386,8 @@ describe("SessionSdkSessionRuntime", () => {
 				start: async () => {
 					const endpoint = path.join(stateRoot, "sdk", `${sessionId}.json`);
 					await mkdir(path.dirname(endpoint), { recursive: true });
-					await writeFile(endpoint, JSON.stringify({ sessionId, token, pid: process.pid }));
-					return { url: "ws://127.0.0.1:1" };
+					await writeFile(endpoint, JSON.stringify({ sessionId, token, pid: process.pid, url: endpointUrl }));
+					return { url: endpointUrl };
 				},
 				stop: async () => {},
 			}),
@@ -2932,6 +3444,7 @@ describe("SessionSdkSessionRuntime", () => {
 		createSdkSessionRuntimeExtension(api, {
 			agentDir,
 			brokerRegistrationRequired: true,
+			lifecycleRequestId: "broker-required-marker",
 			createTransport: async ({ sessionId, stateRoot, token }) => ({
 				sessionId,
 				stateRoot,
@@ -2985,7 +3498,7 @@ async function invocationHarness(
 	sessionId: string,
 	cwd: string,
 	hooks: {
-		sendUserMessage?: (content: unknown, options?: PreflightHooks & { deliverAs?: string }) => Promise<void>;
+		sendUserMessage?: (content: unknown, options?: PreflightHooks & { deliverAs?: string }) => Promise<unknown>;
 		invokeSkill?: (name: string, args?: string, options?: PreflightHooks) => Promise<unknown>;
 		abort?: () => void;
 		isIdle?: () => boolean;
@@ -3010,7 +3523,10 @@ async function invocationHarness(
 		on(event: string, handler: (event: unknown, ctx: unknown) => Promise<void> | void) {
 			handlers.set(event, handler);
 		},
-		sendUserMessage: hooks.sendUserMessage ?? (async () => {}),
+		sendUserMessage: async (content: unknown, options?: PreflightHooks & { deliverAs?: string }) => {
+			const result = await hooks.sendUserMessage?.(content, options);
+			return result === undefined ? "completed" : result;
+		},
 	} as unknown as ExtensionAPI;
 	const interceptorStore = hooks.persistInterceptor
 		? createInterceptorReconciliationStore(
@@ -3202,13 +3718,19 @@ async function settledStatus(
 	name: string,
 	input: Record<string, unknown>,
 ): Promise<NonNullable<ResponseFrame["result"]>> {
-	for (let attempt = 0; attempt < 200; attempt += 1) {
+	// Wall-clock budget instead of a fixed poll count: CI runners can starve the
+	// event loop long enough to exhaust 200 ~1ms polls before a 25ms deadline
+	// timer is dispatched, failing a correct implementation on timing alone.
+	// The contract is unchanged — the status must still reach a terminal
+	// reconciliation state with the asserted shape within a bounded horizon.
+	const budgetEndsAt = Date.now() + 10_000;
+	for (;;) {
 		const frame = await harness.query(name, input);
 		const result = frame.result;
 		if (result && (result.status === "failed" || result.status === "terminal_ok")) return result;
+		if (Date.now() > budgetEndsAt) throw new Error(`${name} never reported a terminal reconciliation status`);
 		await Bun.sleep(1);
 	}
-	throw new Error(`${name} never reported a terminal reconciliation status`);
 }
 
 function neverSettlingPromise(): Promise<void> {
@@ -3429,7 +3951,10 @@ describe("post-acceptance invocation terminalization", () => {
 					},
 				],
 			});
-			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({ status: "terminal_ok" });
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
+				status: "failed",
+				error: { code: "prompt_failed" },
+			});
 			await harness.stop();
 		} finally {
 			await Bun.sleep(50);
@@ -3460,7 +3985,10 @@ describe("post-acceptance invocation terminalization", () => {
 					},
 				],
 			});
-			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({ status: "terminal_ok" });
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
+				status: "failed",
+				error: { code: "prompt_failed" },
+			});
 			await harness.stop();
 		} finally {
 			await Bun.sleep(50);
@@ -3489,7 +4017,8 @@ describe("post-acceptance invocation terminalization", () => {
 			});
 			await harness.emit("agent_end", event);
 			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
-				status: "terminal_ok",
+				status: "failed",
+				error: { code: "prompt_failed" },
 			});
 			await harness.stop();
 		} finally {
@@ -3530,7 +4059,9 @@ describe("post-acceptance invocation terminalization", () => {
 				error: { code: "provider_http_402" },
 			});
 			expect((await harness.query("turn.prompt_status", replacementIds)).result?.status).toBe("in_flight");
-			await harness.emit("agent_end", { messages: [{ role: "assistant", stopReason: "stop" }] });
+			await harness.emit("agent_end", {
+				messages: [{ role: "assistant", stopReason: "stop", content: "completed" }],
+			});
 			expect(await settledStatus(harness, "turn.prompt_status", replacementIds)).toMatchObject({
 				status: "terminal_ok",
 			});
@@ -3656,7 +4187,9 @@ describe("post-acceptance invocation terminalization", () => {
 				expect(successor.ok).toBe(true);
 				const successorIds = { commandId: successor.result?.commandId, turnId: successor.result?.turnId };
 				await harness.emit("agent_start");
-				await harness.emit("agent_end", { messages: [{ role: "assistant", stopReason: "stop" }] });
+				await harness.emit("agent_end", {
+					messages: [{ role: "assistant", stopReason: "stop", content: "completed" }],
+				});
 				secondInflight.resolve();
 				expect(await settledStatus(harness, "turn.prompt_status", successorIds)).toMatchObject({
 					status: "terminal_ok",
@@ -3789,7 +4322,9 @@ describe("post-acceptance invocation terminalization", () => {
 			expect(successor.ok).toBe(true);
 			const successorIds = { commandId: successor.result?.commandId, turnId: successor.result?.turnId };
 			await harness.emit("agent_start");
-			await harness.emit("agent_end", { messages: [{ role: "assistant", stopReason: "stop" }] });
+			await harness.emit("agent_end", {
+				messages: [{ role: "assistant", stopReason: "stop", content: "completed" }],
+			});
 			secondInflight.resolve();
 			expect(await settledStatus(harness, "turn.prompt_status", successorIds)).toMatchObject({
 				status: "terminal_ok",
@@ -3938,7 +4473,7 @@ describe("post-acceptance invocation terminalization", () => {
 				status: "failed",
 				error: { code: "aborted" },
 			});
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			expect(await settledStatus(harness, "turn.prompt_status", secondIds)).toMatchObject({
 				status: "terminal_ok",
 			});
@@ -3989,8 +4524,8 @@ describe("post-acceptance invocation terminalization", () => {
 			expect(await harness.query("turn.prompt_status", successorIds)).toMatchObject({
 				result: { status: expect.stringMatching(/accepted|in_flight/) },
 			});
-			await harness.emit("agent_end");
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			expect(await settledStatus(harness, "turn.prompt_status", successorIds)).toMatchObject({
 				status: "terminal_ok",
 			});
@@ -4078,7 +4613,7 @@ describe("post-acceptance invocation terminalization", () => {
 			expect(accepted.ok).toBe(true);
 			const successorIds = { commandId: accepted.result?.commandId, turnId: accepted.result?.turnId };
 			await harness.emit("agent_start");
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			expect(await settledStatus(harness, "turn.prompt_status", successorIds)).toMatchObject({
 				status: "terminal_ok",
 			});
@@ -4277,7 +4812,7 @@ describe("post-acceptance invocation terminalization", () => {
 			const accepted = await harness.control("turn.prompt", { text: "hello" });
 			const { commandId, turnId } = accepted.result ?? {};
 			await harness.emit("agent_start");
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			const claimed = await settledStatus(harness, "turn.prompt_status", { commandId, turnId });
 			expect(claimed).toMatchObject({ status: "terminal_ok" });
 			inflight.reject(Object.assign(new Error("late provider failure"), { code: "upstream_error" }));
@@ -4445,7 +4980,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			const first = await harness.control("turn.prompt", { text: "first" });
 			expect(first.ok).toBe(true);
 			await harness.emit("agent_start");
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			const followUpB = await harness.control("turn.follow_up", { text: "b" });
 			const followUpC = await harness.control("turn.follow_up", { text: "c" });
 			promoted[0]?.({ startsOwnRun: true });
@@ -4593,7 +5128,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			}
 			const midRun = await harness.query("turn.prompt_status", ids);
 			expect(midRun.result?.status).not.toBe("failed");
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			const final = await harness.query("turn.prompt_status", ids);
 			expect(final.result?.status).toBe("terminal_ok");
 			await harness.stop();
@@ -4688,7 +5223,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			// The consuming run ends. The consumed submission must terminalize
 			// WITH it (terminal_ok, never a fabricated prompt_deadline_exceeded):
 			// with the bug it would still be parked in pending as merely accepted.
-			await handlers.get("agent_end")?.({}, ctx);
+			await handlers.get("agent_end")?.({ messages: [{ role: "assistant", content: "completed" }] }, ctx);
 			const statusOf = async (ids: { commandId?: string; turnId?: string }, frameId: string) => {
 				transport.feed("conn-a", {
 					type: "query_request",
@@ -4766,7 +5301,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			expect(midRun.result?.status).not.toBe("terminal_ok");
 			expect(midRun.result?.status).not.toBe("failed");
 			// The in-flight run ends: the diverted correlation terminalizes with it.
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			expect(await settledStatus(harness, "turn.prompt_status", idsRaced)).toMatchObject({
 				status: "terminal_ok",
 			});
@@ -4825,7 +5360,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			expect(queued.result?.status).not.toBe("failed");
 			// Real consumption re-leases and attaches to the in-flight run.
 			consumed?.({ startsOwnRun: false });
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			expect(await settledStatus(harness, "turn.prompt_status", idsRaced)).toMatchObject({
 				status: "terminal_ok",
 			});
@@ -5265,6 +5800,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			const acceptedA = (await waitFrame("settle-early-a")) as { result?: { commandId?: string; turnId?: string } };
 			const idsA = { commandId: acceptedA.result?.commandId, turnId: acceptedA.result?.turnId };
 			const statusDeadline = Date.now() + 15_000;
+			let settledStatus: string | undefined;
 			for (;;) {
 				transport.feed("conn-a", {
 					type: "query_request",
@@ -5276,10 +5812,12 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 					result?: { status?: string };
 				};
 				transport.sent.splice(transport.sent.indexOf(statusFrame), 1);
-				if (statusFrame.result?.status === "terminal_ok") break;
+				settledStatus = statusFrame.result?.status;
+				if (statusFrame.result?.status === "terminal_ok" || statusFrame.result?.status === "failed") break;
 				if (Date.now() > statusDeadline) throw new Error("settled prompt never reported terminal_ok");
 				await Bun.sleep(20);
 			}
+			expect(settledStatus).toBe("failed");
 			// conn-b's prompt is accepted and hangs; its run then starts.
 			transport.feed("conn-b", {
 				type: "control_request",
@@ -5954,7 +6492,7 @@ test("SDK-only host lets every connection whose follow-up was promoted abort the
 			Promise.resolve(options?.onPreflightAcceptCommit?.()).then(() => {
 				if (options?.onQueuedPromoted) promoted.push(options.onQueuedPromoted);
 				options?.onPreflightAccepted?.();
-				return {};
+				return "completed";
 			}),
 	} as unknown as ExtensionAPI;
 	const transport = memoryTransport();
@@ -6042,7 +6580,7 @@ test("SDK-only host lets every connection whose follow-up was promoted abort the
 		// invocation left the remaining follow-ups durably accepted — their
 		// result lookups would never complete and a restart would report them
 		// failed even though they ran in the shared turn.
-		await handlers.get("agent_end")?.({ type: "agent_end" }, ctx);
+		await handlers.get("agent_end")?.({ type: "agent_end", stopReason: "cancelled", messages: [] }, ctx);
 		{
 			const terminalDeadline = Date.now() + 15_000;
 			const promptStatuses = () =>