@gajae-code/coding-agent 0.15.6 → 0.16.1

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

@@ -1,11 +1,12 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import { createHash } from "node:crypto";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import { logger } from "@gajae-code/utils";
 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,
@@ -16,7 +17,8 @@ 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,
@@ -90,6 +92,7 @@ function extensionContext(
 		goalState?: unknown;
 		branch?: unknown[];
 		liveState?: { isStreaming: boolean; steeringQueueDepth: number; followupQueueDepth: number };
+		transcript?: ExtensionTranscriptEntry[];
 	} = {},
 ): ExtensionContext {
 	return {
@@ -102,6 +105,7 @@ function extensionContext(
 			getSessionName: () => undefined,
 			getBranch: () => options.branch ?? [],
 		},
+		getTranscript: () => options.transcript ?? [],
 		getGoalState: () => options.goalState,
 	} as unknown as ExtensionContext;
 }
@@ -148,6 +152,97 @@ 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" };
@@ -160,7 +255,10 @@ test("native prompt reconciliation fails closed for an explicitly empty assistan
 		receiptState: "missing",
 	});
 	reconciliation.noteTransition(correlation, { type: "agent_end", finalText: "late text" });
-	expect(reconciliation.lookup({ clientRef: "native-empty-ref" })).toMatchObject({ status: "failed" });
+	expect(reconciliation.lookup({ clientRef: "native-empty-ref" })).toMatchObject({
+		status: "failed",
+		receiptState: "present",
+	});
 });
 
 test("broker reconciliation fails closed for an empty prompt and persists the first terminal result", async () => {
@@ -189,7 +287,9 @@ test("broker reconciliation fails closed for an empty prompt and persists the fi
 	expect(reloaded.lookupResult("prompt", { clientRef: "broker-empty-ref" })).toMatchObject({
 		status: "failed",
 		error: { code: "prompt_failed" },
+		content: { text: "late text", byteLength: 9, truncated: false },
 	});
+	expect(reloaded.lookup("prompt", { clientRef: "broker-empty-ref" })).toMatchObject({ receiptState: "present" });
 	const noOpCorrelation = { commandId: "broker-noop-command", turnId: "broker-noop-turn" };
 	await reconciliation.noteAccepted("prompt", noOpCorrelation, "broker-noop-ref");
 	await reconciliation.finalizeOutcome(
@@ -352,6 +452,42 @@ test("SDK-only finalizeOutcome keeps legacy recordError positional compatibility
 	});
 });
 
+test("SDK-only terminal outcomes survive result projection and durable reload", 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 stopped = { kind: "stopped", reason: "cancelled", provenance: "client_cancel" } as const;
+	const reconciliation = createInvocationReconciliation({ store });
+	const correlation = { commandId: "outcome-command", turnId: "outcome-turn" };
+	await reconciliation.noteAccepted("prompt", correlation, "outcome-ref");
+	await reconciliation.claimPendingOutcome("prompt", correlation, stopped);
+	await reconciliation.finalizeOutcome("prompt", correlation);
+	const projected = reconciliation.lookupResult("prompt", { clientRef: "outcome-ref" });
+	expect(projected).toMatchObject({ status: "terminal_ok", outcome: stopped, receiptState: "unknown" });
+	expect(reconciliation.lookup("prompt", { clientRef: "outcome-ref" })).toMatchObject({ outcome: stopped });
+
+	const reopened = createInvocationReconciliation({ store });
+	await reopened.hydrate();
+	expect(reopened.lookupResult("prompt", { clientRef: "outcome-ref" })).toMatchObject({
+		status: "terminal_ok",
+		outcome: stopped,
+	});
+
+	const direct = createInvocationReconciliation();
+	const directCorrelation = { commandId: "direct-outcome-command", turnId: "direct-outcome-turn" };
+	await direct.noteAccepted("prompt", directCorrelation, "direct-outcome-ref");
+	await direct.noteTransition("prompt", directCorrelation, { type: "agent_end", outcome: stopped });
+	expect(direct.lookupResult("prompt", { clientRef: "direct-outcome-ref" })).toMatchObject({
+		status: "terminal_ok",
+		outcome: stopped,
+	});
+});
+
 test("a late agent failure never overwrites the reason an already terminal record carries", async () => {
 	const reconciliation = createInvocationReconciliation();
 	const correlation = { commandId: "first-reason-command", turnId: "first-reason-turn" };
@@ -399,7 +535,7 @@ test("a failed acceptance persist rolls back the provisional record and reservat
 		"accept persist failed",
 	);
 	reconciliation.release("prompt", "accept-failed-ref");
-	expect(reconciliation.lookup("prompt", first)).toEqual({ status: "unknown" });
+	expect(reconciliation.lookup("prompt", first)).toEqual({ status: "unknown", receiptState: "unknown" });
 
 	const retry = { commandId: "accept-retry-command", turnId: "accept-retry-turn" };
 	reconciliation.admit("prompt", "accept-failed-ref");
@@ -454,6 +590,54 @@ test("a failed uncertainty persist restores the durable deadline terminal until
 	]);
 });
 
+test("SDK-only markUncertain persists an active-schema record without quarantining siblings", async () => {
+	const root = await mkdtemp(path.join(os.tmpdir(), "gjc-sdk-uncertain-reload-"));
+	try {
+		const sessionFile = path.join(root, "session.jsonl");
+		await Bun.write(sessionFile, "");
+		const store = createReconciliationStore({ sessionFile, sessionId: "uncertain-reload" });
+		const reconciliation = createInvocationReconciliation({ store });
+		const correlation = { commandId: "uncertain-reload-command", turnId: "uncertain-reload-turn" };
+		const sibling = { commandId: "uncertain-sibling-command", turnId: "uncertain-sibling-turn" };
+		await reconciliation.noteAccepted("prompt", correlation, "uncertain-reload-ref");
+		await reconciliation.finalizeOutcome("prompt", correlation, {
+			kind: "failed",
+			code: "prompt_deadline_exceeded",
+			message: "deadline",
+		});
+		await reconciliation.noteAccepted("skill", sibling, "uncertain-sibling-ref");
+		await reconciliation.finalizeOutcome("skill", sibling, {
+			kind: "stopped",
+			code: "cancelled",
+			message: "cancelled",
+		});
+
+		await reconciliation.markUncertain("prompt", correlation, undefined, 5_000);
+		const active = store
+			.snapshot()
+			.find(record => record.kind === "prompt" && record.commandId === correlation.commandId) as
+			| Record<string, unknown>
+			| undefined;
+		expect(active).toMatchObject({ status: "accepted", deadlineRecoveryPending: true, deadlineMaxAt: 5_000 });
+		expect(active?.terminalAt).toBeUndefined();
+		expect(active?.receiptState).toBeUndefined();
+		expect(active?.outcome).toBeUndefined();
+		expect(active?.pendingOutcome).toBeUndefined();
+		expect(active?.pendingReceiptState).toBeUndefined();
+
+		const reopenedStore = createReconciliationStore({ sessionFile, sessionId: "uncertain-reload" });
+		const reopened = createInvocationReconciliation({ store: reopenedStore });
+		await reopened.hydrate();
+		expect(reopened.lookup("prompt", { clientRef: "uncertain-reload-ref" })).toMatchObject({ status: "accepted" });
+		expect(reopened.lookup("skill", { clientRef: "uncertain-sibling-ref" })).toMatchObject({
+			status: "terminal_ok",
+		});
+		expect((await readdir(root)).some(name => name.includes("corrupt"))).toBe(false);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});
+
 test("durable reload keeps agent_end terminal across a paused successor transition", async () => {
 	let records: unknown[] = [];
 	let pauseWrites = 0;
@@ -817,8 +1001,13 @@ test("finalization without an explicit outcome follows the noteTransition eviden
 	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({
+	await legacyArg5.noteTransition("prompt", legacyCorrelation, {
+		type: "agent_end",
+		content: { version: 1, type: "text", text: "later", byteLength: 5, truncated: false },
+	});
+	expect(legacyArg5.lookupResult("prompt", { clientRef: "final-legacy-ref" })).toMatchObject({
 		status: "terminal_ok",
+		content: { text: "legacy", byteLength: 6, truncated: false },
 	});
 
 	const explicitFailure = createInvocationReconciliation({ store: makeLocalStore() });
@@ -830,9 +1019,58 @@ test("finalization without an explicit outcome follows the noteTransition eviden
 		message: "provider rejected",
 	});
 	expect(explicitFailure.lookup("prompt", { clientRef: "final-failure-ref" })).toMatchObject({
+		status: "failed",
+		receiptState: "unknown",
+		outcome: { kind: "failed", code: "prompt_failed", provenance: "agent_failed" },
+		error: { code: "prompt_failed" },
+	});
+});
+
+test("provider failures outrank later stopped outcomes in both SDK-only terminal paths", async () => {
+	const providerError = Object.assign(new Error("provider rejected"), { code: "provider_rejected" });
+	const transition = createInvocationReconciliation();
+	const transitionCorrelation = { commandId: "precedence-transition-command", turnId: "precedence-transition-turn" };
+	await transition.noteAccepted("prompt", transitionCorrelation, "precedence-transition-ref");
+	await transition.noteTransition("prompt", transitionCorrelation, { type: "agent_failed", error: providerError });
+	await transition.noteTransition("prompt", transitionCorrelation, {
+		type: "agent_end",
+		outcome: { kind: "stopped", reason: "cancelled", provenance: "client_cancel" },
+	});
+	expect(transition.lookupResult("prompt", { clientRef: "precedence-transition-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "provider_rejected" },
+	});
+
+	const finalized = createInvocationReconciliation();
+	const finalizedCorrelation = { commandId: "precedence-finalize-command", turnId: "precedence-finalize-turn" };
+	await finalized.noteAccepted("prompt", finalizedCorrelation, "precedence-finalize-ref");
+	await finalized.noteTransition("prompt", finalizedCorrelation, { type: "agent_failed", error: providerError });
+	await finalized.claimPendingOutcome("prompt", finalizedCorrelation, {
+		kind: "failed",
+		code: "prompt_deadline_exceeded",
+		message: "deadline",
+	});
+	await finalized.finalizeOutcome("prompt", finalizedCorrelation);
+	expect(finalized.lookupResult("prompt", { clientRef: "precedence-finalize-ref" })).toMatchObject({
 		status: "failed",
 		error: { code: "provider_rejected" },
 	});
+
+	const generic = createInvocationReconciliation();
+	const genericCorrelation = { commandId: "precedence-generic-command", turnId: "precedence-generic-turn" };
+	await generic.noteAccepted("prompt", genericCorrelation, "precedence-generic-ref");
+	await generic.noteTransition("prompt", genericCorrelation, {
+		type: "agent_failed",
+		error: Object.assign(new Error("generic failure"), { code: "agent_failed" }),
+	});
+	await generic.noteTransition("prompt", genericCorrelation, {
+		type: "agent_end",
+		outcome: { kind: "stopped", reason: "cancelled", provenance: "client_cancel" },
+	});
+	expect(generic.lookupResult("prompt", { clientRef: "precedence-generic-ref" })).toMatchObject({
+		status: "failed",
+		error: { code: "agent_failed", message: "Prompt submission failed." },
+	});
 });
 
 test("a reason attached after a prompt settled is never replaced by a later failure", async () => {
@@ -851,6 +1089,8 @@ test("a reason attached after a prompt settled is never replaced by a later fail
 		clientRef: "late-reason-ref",
 		acceptedAt: expect.any(Number),
 		terminalAt: expect.any(Number),
+		receiptState: "present",
+		content: { version: 1, type: "text", text: "completed", byteLength: 9, truncated: false },
 	});
 	// A failure delivered after the record settled enriches it with the sanitized reason and
 	// leaves the terminal claim itself (status, terminalAt, identity) untouched.
@@ -958,6 +1198,7 @@ test("capacity eviction still releases the clientRef and reports honest unknown"
 	}
 	expect(reconciliation.lookup("prompt", { clientRef: "capacity-ref-1" })).toEqual({
 		status: "unknown",
+		receiptState: "unknown",
 	});
 	expect(() => reconciliation.admit("prompt", "capacity-ref-1")).not.toThrow();
 	const retained = {
@@ -1008,8 +1249,114 @@ describe("SessionSdkSessionRuntime", () => {
 		);
 		await runtime.stop();
 	});
+	test("SDK-only host publishes one replayable bash_folded frame per fold and drops the subscription on shutdown", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-sdk-bash-folded-"));
+		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);
+			},
+			sendUserMessage: async () => {},
+		} as unknown as ExtensionAPI;
+		const transport = memoryTransport();
+		createSdkSessionRuntimeExtension(api, { agentDir: cwd, createTransport: async () => transport });
+		const listeners = new Set<(event: { jobId: string; generation: string; reason: string }) => void>();
+		const ctx = {
+			...extensionContext(transport.sessionId, cwd),
+			onJobFold: (listener: (event: { jobId: string; generation: string; reason: string }) => void) => {
+				listeners.add(listener);
+				return () => listeners.delete(listener);
+			},
+		} as unknown as ExtensionContext;
+		try {
+			await handlers.get("session_start")?.({}, ctx);
+			expect(listeners.size).toBe(1);
+			for (const listener of listeners) listener({ jobId: "bg_7", generation: "bg_7:1", reason: "steer" });
+			transport.feed("client", { type: "event_replay", id: "fold-replay", sinceSeq: 0 });
+			await Bun.sleep(0);
+			const replay = transport.sent.find(
+				frame => frame.type === "event_replay_result" && frame.id === "fold-replay",
+			) as { events?: Array<{ kind?: unknown; payload?: Record<string, unknown> }> } | undefined;
+			const folded = replay?.events?.filter(event => event.kind === "bash_folded") ?? [];
+			expect(folded).toEqual([
+				expect.objectContaining({
+					kind: "bash_folded",
+					payload: {
+						type: "bash_folded",
+						sessionId: transport.sessionId,
+						jobId: "bg_7",
+						generation: "bg_7:1",
+						reason: "steer",
+					},
+				}),
+			]);
+		} finally {
+			await handlers.get("session_shutdown")?.({}, ctx);
+		}
+		expect(listeners.size).toBe(0);
+	});
+
+	test("SDK-only host logs a bash_folded publication failure and keeps the fold replayable", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-sdk-bash-folded-fail-"));
+		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);
+			},
+			sendUserMessage: async () => {},
+		} as unknown as ExtensionAPI;
+		const transport = memoryTransport();
+		const broadcastFrame = transport.broadcastFrame?.bind(transport);
+		let failNextBroadcast = false;
+		transport.broadcastFrame = frame => {
+			if (failNextBroadcast && frame.kind === "bash_folded") {
+				failNextBroadcast = false;
+				throw new Error("broadcast socket closed");
+			}
+			broadcastFrame?.(frame);
+		};
+		createSdkSessionRuntimeExtension(api, { agentDir: cwd, createTransport: async () => transport });
+		const listeners = new Set<(event: { jobId: string; generation: string; reason: string }) => void>();
+		const ctx = {
+			...extensionContext(transport.sessionId, cwd),
+			onJobFold: (listener: (event: { jobId: string; generation: string; reason: string }) => void) => {
+				listeners.add(listener);
+				return () => listeners.delete(listener);
+			},
+		} as unknown as ExtensionContext;
+		const warnings: Array<{ message: string; data?: Record<string, unknown> }> = [];
+		const warn = spyOn(logger, "warn").mockImplementation((message, data) => {
+			warnings.push({ message: String(message), data: data as Record<string, unknown> | undefined });
+		});
+		try {
+			await handlers.get("session_start")?.({}, ctx);
+			failNextBroadcast = true;
+			// The listener call must not throw back into the manager: publication failure is evidence, not a fold error.
+			for (const listener of listeners) listener({ jobId: "bg_9", generation: "bg_9:1", reason: "chord" });
+			expect(warnings.filter(entry => entry.message === "sdk: bash_folded publication failed")).toEqual([
+				expect.objectContaining({
+					data: expect.objectContaining({ jobId: "bg_9", reason: "chord", error: "broadcast socket closed" }),
+				}),
+			]);
+			// The frame was appended to the ring before the broadcast failed, so it still replays.
+			transport.feed("client", { type: "event_replay", id: "fold-replay-fail", sinceSeq: 0 });
+			await Bun.sleep(0);
+			const replay = transport.sent.find(
+				frame => frame.type === "event_replay_result" && frame.id === "fold-replay-fail",
+			) as { events?: Array<{ kind?: unknown; payload?: Record<string, unknown> }> } | undefined;
+			expect(replay?.events?.filter(event => event.kind === "bash_folded")).toEqual([
+				expect.objectContaining({ payload: expect.objectContaining({ jobId: "bg_9", reason: "chord" }) }),
+			]);
+		} finally {
+			warn.mockRestore();
+			await handlers.get("session_shutdown")?.({}, ctx);
+		}
+	});
+
 	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) {
@@ -1045,7 +1392,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",
+						},
+					};
 				},
 			},
 		});
@@ -1140,7 +1493,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 });
 		}
@@ -1351,7 +1740,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 = {
@@ -3172,6 +3625,7 @@ describe("SessionSdkSessionRuntime", () => {
 			},
 		} as any;
 		const sessionId = "broker-recovery";
+		const endpointUrl = "ws://127.0.0.1:1";
 		createSdkSessionRuntimeExtension(api, {
 			agentDir,
 			createTransport: async ({ stateRoot, token }) => ({
@@ -3183,8 +3637,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 () => {},
 			}),
@@ -3241,6 +3695,7 @@ describe("SessionSdkSessionRuntime", () => {
 		createSdkSessionRuntimeExtension(api, {
 			agentDir,
 			brokerRegistrationRequired: true,
+			lifecycleRequestId: "broker-required-marker",
 			createTransport: async ({ sessionId, stateRoot, token }) => ({
 				sessionId,
 				stateRoot,
@@ -3306,6 +3761,8 @@ async function invocationHarness(
 		onLifecycleDrainTimeout?: () => void;
 		onFailureDiagnosticKeyCount?: (count: number) => void;
 		agentFailedWriteFailures?: number;
+		branch?: unknown[];
+		onInvocationCompletionReconciled?: (kind: string, correlation: { commandId: string; turnId: string }) => void;
 	},
 ): Promise<InvocationHarness> {
 	const waiters = new Map<string, (frame: ResponseFrame) => void>();
@@ -3348,6 +3805,9 @@ async function invocationHarness(
 		...(hooks.onFailureDiagnosticKeyCount
 			? { onFailureDiagnosticKeyCountForTests: hooks.onFailureDiagnosticKeyCount }
 			: {}),
+		...(hooks.onInvocationCompletionReconciled
+			? { onInvocationCompletionReconciledForTests: hooks.onInvocationCompletionReconciled }
+			: {}),
 		...(hooks.settings ? { settings: hooks.settings } : {}),
 		createTransport: async ({ sessionId: id, stateRoot, token }) => ({
 			sessionId: id,
@@ -3386,7 +3846,7 @@ async function invocationHarness(
 			getSessionId: () => sessionId,
 			getSessionFile: () => path.join(cwd, ".gjc", "state", `${sessionId}.jsonl`),
 			getSessionName: () => undefined,
-			getBranch: () => [],
+			getBranch: () => hooks.branch ?? [],
 		},
 	};
 	await handlers.get("session_start")?.({}, ctx);
@@ -4261,7 +4721,9 @@ describe("post-acceptance invocation terminalization", () => {
 			expect(secondIds.turnId).not.toBe(firstIds.turnId);
 			await harness.emit("agent_start");
 			await successorStarted.promise;
-			await harness.emit("agent_end");
+			await harness.emit("agent_end", {
+				messages: [{ role: "assistant", content: "predecessor delayed" }],
+			});
 			expect(await harness.query("turn.prompt_status", secondIds)).toMatchObject({
 				result: { status: expect.stringMatching(/accepted|in_flight/) },
 			});
@@ -4269,10 +4731,23 @@ describe("post-acceptance invocation terminalization", () => {
 				status: "failed",
 				error: { code: "aborted" },
 			});
+			const firstResult = await harness.query("turn.result", { kind: "prompt", ...firstIds });
+			expect(firstResult).toMatchObject({
+				result: { status: "failed", content: { text: "predecessor delayed" } },
+			});
 			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			expect(await settledStatus(harness, "turn.prompt_status", secondIds)).toMatchObject({
 				status: "terminal_ok",
 			});
+			expect(await harness.query("turn.result", { kind: "prompt", ...secondIds })).toMatchObject({
+				result: {
+					status: "terminal_ok",
+					content: { text: "completed", byteLength: 9, truncated: false },
+				},
+			});
+			expect(await harness.query("turn.result", { kind: "prompt", ...firstIds })).toMatchObject({
+				result: { content: { text: "predecessor delayed" } },
+			});
 			expect(prompts).toBe(2);
 			await harness.stop();
 		} finally {
@@ -4469,6 +4944,190 @@ describe("post-acceptance invocation terminalization", () => {
 			await rm(cwd, { recursive: true, force: true });
 		}
 	});
+	test("captures exact bounded content from actual prompt agent_end messages", async () => {
+		const cases = [
+			{ name: "short", agent: "SDK_OK", expected: "SDK_OK", bytes: 6, truncated: false },
+			{ name: "max", agent: "x".repeat(16_384), expected: "x".repeat(16_384), bytes: 16_384, truncated: false },
+			{ name: "blank", agent: " ", expected: undefined, bytes: 0, truncated: false },
+			{
+				name: "overflow",
+				agent: `${"😀".repeat(4_096)}tail`,
+				expected: "😀".repeat(4_096),
+				bytes: 16_384,
+				truncated: true,
+			},
+		] as const;
+		for (const testCase of cases) {
+			const cwd = await mkdtemp(path.join(os.tmpdir(), `gjc-terminal-content-${testCase.name}-`));
+			try {
+				const harness = await invocationHarness(`terminal-content-${testCase.name}`, cwd, {
+					sendUserMessage: async (_content, options) => {
+						await options?.onPreflightAcceptCommit?.();
+						await Promise.withResolvers<void>().promise;
+					},
+				});
+				const accepted = await harness.control("turn.prompt", { text: "hello" });
+				await harness.emit("agent_start");
+				await harness.emit("agent_end", { messages: [{ role: "assistant", content: testCase.agent }] });
+				const result = await settledStatus(harness, "turn.result", {
+					kind: "prompt",
+					commandId: accepted.result?.commandId,
+					turnId: accepted.result?.turnId,
+				});
+				if (testCase.expected === undefined) {
+					expect(result).toMatchObject({ status: "failed" });
+					expect((result as Record<string, unknown>).content).toBeUndefined();
+				} else {
+					expect(result).toMatchObject({
+						status: "terminal_ok",
+						content: {
+							text: testCase.expected,
+							byteLength: testCase.bytes,
+							truncated: testCase.truncated,
+						},
+					});
+				}
+				await harness.stop();
+			} finally {
+				await rm(cwd, { recursive: true, force: true });
+			}
+		}
+	});
+	test("does not reuse a previous branch assistant for a new textless prompt", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminal-order-previous-assistant-"));
+		try {
+			const harness = await invocationHarness("terminal-order-previous-assistant", cwd, {
+				branch: [{ type: "message", message: { role: "assistant", content: "PREVIOUS" } }],
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await Promise.withResolvers<void>().promise;
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "textless" });
+			const selector = {
+				kind: "prompt" as const,
+				commandId: accepted.result?.commandId,
+				turnId: accepted.result?.turnId,
+			};
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", { messages: [] });
+			const result = await settledStatus(harness, "turn.result", selector);
+			expect((result as Record<string, unknown>).content).toBeUndefined();
+			await harness.stop();
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+	test("reconciles contract-valid skill completion and agent_end ordering", async () => {
+		const cases = [
+			{
+				name: "completion-real-agent-real",
+				order: "completion-first",
+				completion: "completion",
+				agent: "agent",
+				expected: "completion",
+			},
+			{
+				name: "completion-blank-agent-real",
+				order: "completion-first",
+				completion: " ",
+				agent: "agent",
+				expected: "agent",
+			},
+			{
+				name: "completion-none-agent-real",
+				order: "completion-first",
+				completion: null,
+				agent: "agent",
+				expected: "agent",
+			},
+			{
+				name: "agent-real-completion-real",
+				order: "agent-first",
+				completion: "completion",
+				agent: "agent",
+				expected: "agent",
+			},
+			{
+				name: "agent-real-completion-blank",
+				order: "agent-first",
+				completion: " ",
+				agent: "agent",
+				expected: "agent",
+			},
+			{
+				name: "agent-blank-completion-real",
+				order: "agent-first",
+				completion: "completion",
+				agent: " ",
+				expected: "completion",
+			},
+			{
+				name: "agent-blank-completion-none",
+				order: "agent-first",
+				completion: null,
+				agent: " ",
+				expected: undefined,
+			},
+			{
+				name: "agent-none-completion-real",
+				order: "agent-first",
+				completion: "completion",
+				agent: null,
+				expected: "completion",
+			},
+			{
+				name: "agent-none-completion-blank",
+				order: "agent-first",
+				completion: " ",
+				agent: null,
+				expected: undefined,
+			},
+		] as const;
+		for (const testCase of cases) {
+			const cwd = await mkdtemp(path.join(os.tmpdir(), `gjc-skill-terminal-order-${testCase.name}-`));
+			const completion = Promise.withResolvers<unknown>();
+			const completionReconciled = Promise.withResolvers<void>();
+			try {
+				const harness = await invocationHarness(`skill-terminal-order-${testCase.name}`, cwd, {
+					onInvocationCompletionReconciled: kind => {
+						if (kind === "skill") completionReconciled.resolve();
+					},
+					invokeSkill: async (_name, _args, options) => {
+						await options?.onPreflightAcceptCommit?.();
+						return await completion.promise;
+					},
+				});
+				const accepted = await harness.control("skill.invoke", { name: "ralplan" });
+				const selector = {
+					kind: "skill" as const,
+					commandId: accepted.result?.commandId,
+					turnId: accepted.result?.turnId,
+				};
+				await harness.emit("agent_start");
+				const emitAgentEnd = () =>
+					harness.emit("agent_end", {
+						messages: testCase.agent === null ? [] : [{ role: "assistant", content: testCase.agent }],
+					});
+				if (testCase.order === "completion-first") {
+					completion.resolve(testCase.completion);
+					await completionReconciled.promise;
+					await emitAgentEnd();
+				} else {
+					await emitAgentEnd();
+					completion.resolve(testCase.completion);
+					await completionReconciled.promise;
+				}
+				const result = await harness.query("turn.result", selector);
+				const content = (result.result as { content?: { text?: string } } | undefined)?.content;
+				expect(content?.text).toBe(testCase.expected);
+				await harness.stop();
+			} finally {
+				completion.resolve(undefined);
+				await rm(cwd, { recursive: true, force: true });
+			}
+		}
+	}, 30_000);
 	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 {
@@ -4587,7 +5246,7 @@ describe("post-acceptance invocation terminalization", () => {
 			const rejected = await harness.control("turn.prompt", { text: "hello", clientRef: "preflight-ref" });
 			expect(rejected.ok).toBe(false);
 			const status = await harness.query("turn.prompt_status", { clientRef: "preflight-ref" });
-			expect(status.result).toEqual({ status: "unknown" });
+			expect(status.result as Record<string, unknown>).toEqual({ status: "unknown", receiptState: "unknown" });
 			await harness.stop();
 		} finally {
 			await Bun.sleep(50);