@gajae-code/coding-agent 0.15.4 → 0.15.6

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

@@ -13,6 +13,8 @@ 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 {
@@ -146,6 +148,76 @@ async function queryGoalState(
 	return response.page?.items[0];
 }
 
+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 +477,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 +530,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 +601,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 +701,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 +717,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 +918,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 +951,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",
@@ -742,7 +1017,7 @@ describe("SessionSdkSessionRuntime", () => {
 			},
 			sendUserMessage: async (_content: string, options: { onPreflightAcceptCommit?: () => Promise<void> }) => {
 				await options?.onPreflightAcceptCommit?.();
-				await new Promise<void>(() => {});
+				await neverSettlingPromise();
 			},
 		} as unknown as ExtensionAPI;
 		const transport = memoryTransport();
@@ -994,7 +1269,7 @@ describe("SessionSdkSessionRuntime", () => {
 			},
 			sendUserMessage: async (_content: string, options: { onPreflightAcceptCommit?: () => Promise<void> }) => {
 				await options?.onPreflightAcceptCommit?.();
-				await new Promise<void>(() => {});
+				await neverSettlingPromise();
 			},
 		} as unknown as ExtensionAPI;
 		const transport = memoryTransport();
@@ -1356,7 +1631,7 @@ describe("SessionSdkSessionRuntime", () => {
 			},
 			sendUserMessage: async (_content: string, options: { onPreflightAcceptCommit?: () => Promise<void> }) => {
 				await options?.onPreflightAcceptCommit?.();
-				await new Promise<void>(() => {});
+				await neverSettlingPromise();
 			},
 		} as unknown as ExtensionAPI;
 		const transport = memoryTransport();
@@ -1710,7 +1985,7 @@ describe("SessionSdkSessionRuntime", () => {
 				// Production-faithful: an accepted run stays in-flight for the whole
 				// test; sendUserMessage resolution (turn completion) never precedes
 				// agent_start (#4668 success-retirement).
-				await new Promise<void>(() => {});
+				await neverSettlingPromise();
 			},
 		} as unknown as ExtensionAPI;
 		const transport = memoryTransport();
@@ -1870,10 +2145,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 +2262,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
@@ -2959,6 +3268,8 @@ interface PreflightHooks {
 interface ResponseFrame {
 	id?: string;
 	ok?: boolean;
+	code?: string;
+	error?: { code: string; message: string };
 	result?: { status?: string; commandId?: string; turnId?: string; error?: { code: string; message: string } };
 }
 
@@ -2966,6 +3277,11 @@ interface InvocationHarness {
 	control(operation: string, input: Record<string, unknown>): Promise<ResponseFrame>;
 	query(name: string, input: Record<string, unknown>): Promise<ResponseFrame>;
 	emit(event: string, payload?: unknown): Promise<void>;
+	switchSession(sessionId: string): Promise<void>;
+	branch(sessionId: string): Promise<void>;
+	requestOnSession(sessionId: string, frame: Record<string, unknown>): Promise<ResponseFrame>;
+	sendToSession(sessionId: string, frame: Record<string, unknown>): void;
+	sent(sessionId: string): SdkFrame[];
 	readonly broadcasts: SdkFrame[];
 	stop(): Promise<void>;
 }
@@ -2978,13 +3294,17 @@ 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;
 		settings?: Settings;
 		/** Throw to inject a durable-write failure for matching transitions. */
 		persistInterceptor?: (transition: { type: string }) => void;
+		/** Hold one matching durable transition until the test releases it. */
+		persistHold?: { type: string; onEntered: () => void; release: Promise<void> };
+		onLifecycleDrainTimeout?: () => void;
+		onFailureDiagnosticKeyCount?: (count: number) => void;
 		agentFailedWriteFailures?: number;
 	},
 ): Promise<InvocationHarness> {
@@ -2992,18 +3312,28 @@ async function invocationHarness(
 	const handlers = new Map<string, (event: unknown, ctx: unknown) => Promise<void> | void>();
 	const broadcasts: SdkFrame[] = [];
 	let deliver: ((connectionId: string, frame: SdkFrame) => void) | undefined;
+	const deliveries = new Map<string, (connectionId: string, frame: SdkFrame) => void>();
+	const sentFrames = new Map<string, SdkFrame[]>();
 	let nextId = 0;
 	const api = {
 		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(hooks.persistInterceptor, hooks.agentFailedWriteFailures)
+		? createInterceptorReconciliationStore(
+				hooks.persistInterceptor,
+				hooks.agentFailedWriteFailures,
+				hooks.persistHold,
+			)
 		: undefined;
 	createSdkSessionRuntimeExtension(api, {
 		agentDir: cwd,
+		...(hooks.onLifecycleDrainTimeout ? { onLifecycleDrainTimeoutForTests: hooks.onLifecycleDrainTimeout } : {}),
 		...(interceptorStore
 			? {
 					terminalAbortSeams: {
@@ -3015,6 +3345,9 @@ async function invocationHarness(
 					},
 				}
 			: {}),
+		...(hooks.onFailureDiagnosticKeyCount
+			? { onFailureDiagnosticKeyCountForTests: hooks.onFailureDiagnosticKeyCount }
+			: {}),
 		...(hooks.settings ? { settings: hooks.settings } : {}),
 		createTransport: async ({ sessionId: id, stateRoot, token }) => ({
 			sessionId: id,
@@ -3022,12 +3355,17 @@ async function invocationHarness(
 			token,
 			onFrame(handler) {
 				deliver = handler;
+				deliveries.set(id, handler);
 				return () => {
 					if (deliver === handler) deliver = undefined;
+					if (deliveries.get(id) === handler) deliveries.delete(id);
 				};
 			},
 			sendFrame(_connectionId, frame) {
 				const response = frame as ResponseFrame;
+				const frames = sentFrames.get(id) ?? [];
+				frames.push(frame);
+				sentFrames.set(id, frames);
 				if (typeof response.id === "string") waiters.get(response.id)?.(response);
 			},
 			broadcastFrame(frame) {
@@ -3046,6 +3384,7 @@ async function invocationHarness(
 		...(hooks.invokeSkill ? { invokeSkill: hooks.invokeSkill } : {}),
 		sessionManager: {
 			getSessionId: () => sessionId,
+			getSessionFile: () => path.join(cwd, ".gjc", "state", `${sessionId}.jsonl`),
 			getSessionName: () => undefined,
 			getBranch: () => [],
 		},
@@ -3069,6 +3408,44 @@ async function invocationHarness(
 		stop: async () => {
 			await handlers.get("session_shutdown")?.({}, ctx);
 		},
+		switchSession: async sessionId => {
+			await handlers.get("session_switch")?.(
+				{},
+				{
+					...ctx,
+					sessionManager: {
+						...ctx.sessionManager,
+						getSessionId: () => sessionId,
+						getSessionFile: () => path.join(cwd, ".gjc", "state", `${sessionId}.jsonl`),
+					},
+				},
+			);
+		},
+		branch: async sessionId => {
+			await handlers.get("session_branch")?.(
+				{},
+				{
+					...ctx,
+					sessionManager: {
+						...ctx.sessionManager,
+						getSessionId: () => sessionId,
+						getSessionFile: () => path.join(cwd, ".gjc", "state", `${sessionId}.jsonl`),
+					},
+				},
+			);
+		},
+		requestOnSession: (sessionId, frame) => {
+			const id = `frame-${nextId}`;
+			nextId += 1;
+			const { promise, resolve } = Promise.withResolvers<ResponseFrame>();
+			waiters.set(id, resolve);
+			deliveries.get(sessionId)?.("client", { ...frame, id } as SdkFrame);
+			return promise;
+		},
+		sendToSession: (sessionId, frame) => {
+			deliveries.get(sessionId)?.("client", frame as SdkFrame);
+		},
+		sent: sessionId => sentFrames.get(sessionId) ?? [],
 	};
 }
 
@@ -3078,34 +3455,46 @@ async function invocationHarness(
 function createInterceptorReconciliationStore(
 	interceptor: (transition: { type: string }) => void,
 	agentFailedWriteFailures = 1,
+	persistHold?: { type: string; onEntered: () => void; release: Promise<void> },
 ): SdkOnlyReconciliationStore {
 	const failureCounts = new Map<string, number>();
+	let holdConsumed = false;
 	const backing = createInterceptorBackingStore();
 	return {
 		path: null,
 		load: async () => backing.records.map(record => ({ ...record })),
 		async transact(mutator) {
 			const records = mutator(backing.records.map(record => ({ ...record })));
+			let transitionType: "agent_failed" | "agent_end" | undefined;
 			for (const record of records as Array<{ status?: string; terminalAt?: number; commandId?: string }>) {
 				// The intermediate durable state an agent_failed write produces:
 				// the reason is set but the row is not terminal yet. Tests choose how
 				// many consecutive writes fail before the recovery replay succeeds.
 				const identity = String(record?.commandId ?? "unknown");
 				const failureCount = failureCounts.get(identity) ?? 0;
+				if (record?.terminalAt === undefined && (record as { error?: unknown }).error !== undefined)
+					transitionType ??= "agent_failed";
 				if (
 					record?.terminalAt === undefined &&
 					(record as { error?: unknown }).error !== undefined &&
 					failureCount < agentFailedWriteFailures
 				) {
+					transitionType = "agent_failed";
 					failureCounts.set(identity, failureCount + 1);
 					interceptor({ type: "agent_failed" });
 					throw Object.assign(new Error("injected persistence failure"), { code: "io_error" });
 				}
 				const previous = backing.records.find(candidate => candidate.commandId === record.commandId);
-				if (record.terminalAt !== undefined && previous?.terminalAt === undefined) {
+				if (record?.terminalAt !== undefined && previous?.terminalAt === undefined) {
+					transitionType = "agent_end";
 					interceptor({ type: "agent_end" });
 				}
 			}
+			if (persistHold && !holdConsumed && persistHold.type === transitionType) {
+				holdConsumed = true;
+				persistHold.onEntered();
+				await persistHold.release;
+			}
 			backing.records = records;
 		},
 		snapshotTerminalScopes: () => [],
@@ -3125,65 +3514,109 @@ 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> {
+	return Promise.withResolvers<void>().promise;
 }
 
 describe("post-acceptance invocation terminalization", () => {
-	test("a prompt killed by a provider stream interrupt reports a terminal failed status", async () => {
-		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-prompt-"));
+	test.each([
+		{ status: 402, code: "provider_http_402" },
+		{ status: 429, code: "provider_http_429" },
+		{ status: 500, code: "provider_rejected" },
+	])("terminalizes a streamed provider HTTP $status rejection and permits a healthy abort_and_prompt replacement", async ({
+		status,
+		code,
+	}) => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), `gjc-provider-http-${status}-`));
 		try {
-			const harness = await invocationHarness("terminalize-prompt", cwd, {
+			let prompts = 0;
+			const harness = await invocationHarness(`provider-http-${status}`, cwd, {
 				sendUserMessage: async (_content, options) => {
+					prompts += 1;
 					await options?.onPreflightAcceptCommit?.();
-					await new Promise<void>(() => {});
+					if (prompts === 1) await neverSettlingPromise();
 				},
 			});
-			const accepted = await harness.control("turn.prompt", { text: "hello" });
-			expect(accepted.ok).toBe(true);
-			const { commandId, turnId } = accepted.result ?? {};
+			const failed = await harness.control("turn.prompt", { text: "provider rejects", clientRef: `http-${status}` });
+			expect(failed.ok).toBe(true);
+			const failedIds = { commandId: failed.result?.commandId, turnId: failed.result?.turnId };
 			await harness.emit("agent_start");
-			await harness.emit("agent_failed", {
-				error: Object.assign(new Error("stream interrupted"), { code: "upstream_stream_interrupted" }),
+			await harness.emit("agent_end", {
+				messages: [
+					{
+						role: "assistant",
+						stopReason: "error",
+						errorStatus: status,
+						transportFailure: { kind: "transport", status },
+					},
+				],
 			});
-			await harness.emit("agent_end");
-			// Provider text is redacted on the wire by contract (sanitizePromptFailure);
-			// the failure reason survives as the safe-token code.
-			expect(await settledStatus(harness, "turn.prompt_status", { commandId, turnId })).toMatchObject({
+
+			const terminal = await settledStatus(harness, "turn.result", {
+				kind: "prompt",
+				clientRef: `http-${status}`,
+			});
+			expect(terminal).toMatchObject({
 				status: "failed",
-				error: { code: "upstream_stream_interrupted", message: "Prompt submission failed." },
+				error: { code, message: "Prompt submission failed." },
+				terminalAt: expect.any(Number),
+			});
+			const stable = await harness.query("turn.result", { kind: "prompt", ...failedIds });
+			expect(stable.result).toEqual(terminal);
+
+			const replacement = await harness.control("turn.abort_and_prompt", { text: "replacement" });
+			expect(replacement).toMatchObject({ ok: true, result: { accepted: true } });
+			const replacementIds = { commandId: replacement.result?.commandId, turnId: replacement.result?.turnId };
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", {
+				messages: [
+					{ role: "assistant", stopReason: "error", errorStatus: 429 },
+					{ role: "assistant", stopReason: "stop" },
+				],
+			});
+			expect(await settledStatus(harness, "turn.prompt_status", replacementIds)).toMatchObject({
+				status: "terminal_ok",
 			});
+			expect(prompts).toBe(2);
 			await harness.stop();
 		} finally {
-			// Let the reconciliation store finish its atomic write before the state root disappears.
 			await Bun.sleep(50);
 			await rm(cwd, { recursive: true, force: true });
 		}
 	});
 
-	test("a canceled prompt reports a terminal failed status instead of hanging", async () => {
-		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-abort-"));
+	test("classifies a statusless provider error completion as rejected", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-provider-statusless-"));
 		try {
-			const harness = await invocationHarness("terminalize-abort", cwd, {
+			const harness = await invocationHarness("provider-statusless", cwd, {
 				sendUserMessage: async (_content, options) => {
 					await options?.onPreflightAcceptCommit?.();
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
-				abort: () => {},
 			});
-			const accepted = await harness.control("turn.prompt", { text: "hello" });
-			const { commandId, turnId } = accepted.result ?? {};
+			const accepted = await harness.control("turn.prompt", { text: "provider rejects" });
+			expect(accepted.ok).toBe(true);
+			const ids = { commandId: accepted.result?.commandId, turnId: accepted.result?.turnId };
 			await harness.emit("agent_start");
-			await harness.emit("agent_failed", { error: Object.assign(new Error("turn aborted"), { code: "aborted" }) });
-			await harness.emit("agent_end");
-			expect(await settledStatus(harness, "turn.prompt_status", { commandId, turnId })).toMatchObject({
+			await harness.emit("agent_end", { messages: [{ role: "assistant", stopReason: "error" }] });
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
 				status: "failed",
-				error: { code: "aborted" },
+				error: { code: "provider_rejected" },
 			});
 			await harness.stop();
 		} finally {
@@ -3191,46 +3624,652 @@ describe("post-acceptance invocation terminalization", () => {
 			await rm(cwd, { recursive: true, force: true });
 		}
 	});
-	test("immediate prompt after abort ack is not terminalized by the aborted turn's delayed agent_end", async () => {
-		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-abort-immediate-prompt-"));
+
+	test("upgrades a generic agent_failed diagnostic when agent_end proves provider rejection", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-provider-statusless-upgrade-"));
 		try {
-			const firstInflight = Promise.withResolvers<void>();
-			const successorStarted = Promise.withResolvers<void>();
-			let prompts = 0;
-			const harness = await invocationHarness("abort-immediate-prompt", cwd, {
+			const harness = await invocationHarness("provider-statusless-upgrade", cwd, {
 				sendUserMessage: async (_content, options) => {
-					prompts += 1;
 					await options?.onPreflightAcceptCommit?.();
-					if (prompts === 1) {
-						await firstInflight.promise;
-						return;
-					}
-					successorStarted.resolve();
-					await Promise.withResolvers<void>().promise;
+					await neverSettlingPromise();
 				},
 			});
-			const first = await harness.control("turn.prompt", { text: "first" });
-			expect(first.ok).toBe(true);
-			const firstIds = { commandId: first.result?.commandId, turnId: first.result?.turnId };
-			await harness.emit("agent_start");
-			expect(await harness.control("turn.abort", {})).toMatchObject({ ok: true });
-			firstInflight.reject(Object.assign(new Error("turn aborted"), { code: "aborted" }));
-			const second = await harness.control("turn.prompt", { text: "successor" });
-			expect(second.ok).toBe(true);
-			const secondIds = { commandId: second.result?.commandId, turnId: second.result?.turnId };
-			expect(secondIds.commandId).not.toBe(firstIds.commandId);
-			expect(secondIds.turnId).not.toBe(firstIds.turnId);
+			const accepted = await harness.control("turn.prompt", { text: "provider rejects" });
+			expect(accepted.ok).toBe(true);
+			const ids = { commandId: accepted.result?.commandId, turnId: accepted.result?.turnId };
 			await harness.emit("agent_start");
-			await successorStarted.promise;
-			await harness.emit("agent_end");
-			expect(await harness.query("turn.prompt_status", secondIds)).toMatchObject({
-				result: { status: expect.stringMatching(/accepted|in_flight/) },
+			await harness.emit("agent_failed", {
+				error: Object.assign(new Error("generic agent failure"), { code: "agent_failed" }),
 			});
-			expect(await settledStatus(harness, "turn.prompt_status", firstIds)).toMatchObject({
+			await harness.emit("agent_end", { messages: [{ role: "assistant", stopReason: "error" }] });
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
 				status: "failed",
-				error: { code: "aborted" },
+				error: { code: "provider_rejected" },
 			});
-			await harness.emit("agent_end");
+			const failures = harness.broadcasts.filter(frame => frame.kind === "agent_failed");
+			expect(failures.at(-1)).toMatchObject({ payload: { error: { code: "provider_rejected" } } });
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("preserves a specific agent_failed diagnostic when agent_end is statusless", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-provider-statusless-specific-"));
+		try {
+			const harness = await invocationHarness("provider-statusless-specific", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await neverSettlingPromise();
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "provider unavailable" });
+			expect(accepted.ok).toBe(true);
+			const ids = { commandId: accepted.result?.commandId, turnId: accepted.result?.turnId };
+			await harness.emit("agent_start");
+			await harness.emit("agent_failed", {
+				error: Object.assign(new Error("provider unavailable"), { code: "provider_unavailable" }),
+			});
+			await harness.emit("agent_end", { messages: [{ role: "assistant", stopReason: "error" }] });
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
+				status: "failed",
+				error: { code: "provider_unavailable" },
+			});
+			expect(harness.broadcasts.filter(frame => frame.kind === "agent_failed")).toHaveLength(1);
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("upgrades every shared generic diagnostic on a statusless provider end", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-provider-statusless-shared-"));
+		try {
+			let promoted: ((promotion: { startsOwnRun?: boolean }) => void) | undefined;
+			const harness = await invocationHarness("provider-statusless-shared", cwd, {
+				sendUserMessage: async (content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					if (content === "attached") {
+						promoted = (options as { onQueuedPromoted?: (promotion: { startsOwnRun?: boolean }) => void })
+							?.onQueuedPromoted;
+						return;
+					}
+					await neverSettlingPromise();
+				},
+			});
+			const first = await harness.control("turn.prompt", { text: "first" });
+			expect(first.ok).toBe(true);
+			await harness.emit("agent_start");
+			const attached = await harness.control("turn.follow_up", { text: "attached" });
+			expect(attached.ok).toBe(true);
+			promoted?.({ startsOwnRun: false });
+			const firstIds = { commandId: first.result?.commandId, turnId: first.result?.turnId };
+			const attachedIds = { commandId: attached.result?.commandId, turnId: attached.result?.turnId };
+			await harness.emit("agent_failed", { error: Object.assign(new Error("generic"), { code: "agent_failed" }) });
+			await harness.emit("agent_end", { messages: [{ role: "assistant", stopReason: "error" }] });
+			expect(await settledStatus(harness, "turn.prompt_status", firstIds)).toMatchObject({
+				status: "failed",
+				error: { code: "provider_rejected" },
+			});
+			expect(await settledStatus(harness, "turn.prompt_status", attachedIds)).toMatchObject({
+				status: "failed",
+				error: { code: "provider_rejected" },
+			});
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("does not misclassify a local malformed-tool circuit breaker as provider rejection", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-local-malformed-tool-"));
+		try {
+			const harness = await invocationHarness("local-malformed-tool", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await neverSettlingPromise();
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "local malformed tool" });
+			expect(accepted.ok).toBe(true);
+			const ids = { commandId: accepted.result?.commandId, turnId: accepted.result?.turnId };
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", {
+				messages: [
+					{
+						role: "assistant",
+						stopReason: "error",
+						errorMessage:
+							"Stopping after 3 consecutive turns of malformed tool calls; the model did not produce a usable tool call or answer.",
+					},
+				],
+			});
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
+				status: "failed",
+				error: { code: "prompt_failed" },
+			});
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("does not misclassify a local composer policy breaker as provider rejection", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-local-composer-policy-"));
+		try {
+			const harness = await invocationHarness("local-composer-policy", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await neverSettlingPromise();
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "local composer policy" });
+			expect(accepted.ok).toBe(true);
+			const ids = { commandId: accepted.result?.commandId, turnId: accepted.result?.turnId };
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", {
+				messages: [
+					{
+						role: "assistant",
+						stopReason: "error",
+						errorMessage:
+							"Composer bash policy blocked repository file I/O again after its one automatic recovery turn.",
+					},
+				],
+			});
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
+				status: "failed",
+				error: { code: "prompt_failed" },
+			});
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("terminalizes when provider end metadata exposes a throwing accessor", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-provider-throwing-metadata-"));
+		try {
+			const harness = await invocationHarness("provider-throwing-metadata", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await neverSettlingPromise();
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "provider metadata" });
+			expect(accepted.ok).toBe(true);
+			const ids = { commandId: accepted.result?.commandId, turnId: accepted.result?.turnId };
+			await harness.emit("agent_start");
+			const event = {} as Record<string, unknown>;
+			Object.defineProperty(event, "messages", {
+				get() {
+					throw new Error("provider metadata accessor failed");
+				},
+			});
+			await harness.emit("agent_end", event);
+			expect(await settledStatus(harness, "turn.prompt_status", ids)).toMatchObject({
+				status: "failed",
+				error: { code: "prompt_failed" },
+			});
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("binds a delayed predecessor provider failure to its own batch after a replacement starts", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-delayed-provider-batch-"));
+		try {
+			const firstInflight = Promise.withResolvers<void>();
+			const secondInflight = Promise.withResolvers<void>();
+			let prompts = 0;
+			const harness = await invocationHarness("delayed-provider-batch", cwd, {
+				sendUserMessage: async (_content, options) => {
+					prompts += 1;
+					await options?.onPreflightAcceptCommit?.();
+					if (prompts === 1) await firstInflight.promise;
+					if (prompts === 2) await secondInflight.promise;
+				},
+				persistInterceptor: () => {},
+			});
+			const first = await harness.control("turn.prompt", { text: "first", clientRef: "delayed-first" });
+			expect(first.ok).toBe(true);
+			const firstIds = { commandId: first.result?.commandId, turnId: first.result?.turnId };
+			await harness.emit("agent_start");
+			const replacement = await harness.control("turn.abort_and_prompt", { text: "replacement" });
+			expect(replacement).toMatchObject({ ok: true, result: { accepted: true } });
+			const replacementIds = { commandId: replacement.result?.commandId, turnId: replacement.result?.turnId };
+			await harness.emit("agent_start");
+			expect((await harness.query("turn.prompt_status", replacementIds)).result?.status).toBe("in_flight");
+			await harness.emit("agent_end", {
+				messages: [{ role: "assistant", stopReason: "error", errorStatus: 402 }],
+			});
+			expect(await settledStatus(harness, "turn.prompt_status", firstIds)).toMatchObject({
+				status: "failed",
+				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", content: "completed" }],
+			});
+			expect(await settledStatus(harness, "turn.prompt_status", replacementIds)).toMatchObject({
+				status: "terminal_ok",
+			});
+			firstInflight.resolve();
+			secondInflight.resolve();
+			expect(prompts).toBe(2);
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test.each([
+		{ operation: "switchSession" as const, label: "session switch" },
+		{ operation: "branch" as const, label: "session branch" },
+	])("keeps a held 402/429 predecessor terminal across $label", async ({ operation }) => {
+		for (const { status, code } of [
+			{ status: 402, code: "provider_http_402" },
+			{ status: 429, code: "provider_http_429" },
+		]) {
+			const cwd = await mkdtemp(path.join(os.tmpdir(), `gjc-${operation}-provider-race-`));
+			try {
+				const entered = Promise.withResolvers<void>();
+				const release = Promise.withResolvers<void>();
+				const firstInflight = Promise.withResolvers<void>();
+				const secondInflight = Promise.withResolvers<void>();
+				let timeoutWarnings = 0;
+				const diagnosticKeyCounts: number[] = [];
+				let prompts = 0;
+				const harness = await invocationHarness(`${operation}-provider-race`, cwd, {
+					persistInterceptor: () => {},
+					onLifecycleDrainTimeout: () => {
+						timeoutWarnings += 1;
+					},
+					onFailureDiagnosticKeyCount: count => {
+						diagnosticKeyCounts.push(count);
+					},
+					persistHold: { type: "agent_failed", onEntered: entered.resolve, release: release.promise },
+					agentFailedWriteFailures: 0,
+					sendUserMessage: async (_content, options) => {
+						prompts += 1;
+						await options?.onPreflightAcceptCommit?.();
+						if (prompts === 1) await firstInflight.promise;
+						if (prompts === 2) await secondInflight.promise;
+					},
+				});
+				const first = await harness.control("turn.prompt", {
+					text: "first",
+					clientRef: `${operation}-${status}-first`,
+				});
+				expect(first.ok).toBe(true);
+				const firstIds = { commandId: first.result?.commandId, turnId: first.result?.turnId };
+				await harness.emit("agent_start");
+				const end = harness.emit("agent_end", {
+					messages: [{ role: "assistant", stopReason: "error", errorStatus: status }],
+				});
+				await entered.promise;
+				const lifecycleChange = harness[operation](`${operation}-successor`);
+				await Bun.sleep(10);
+				const [oldControl, oldQuery, oldReplay, oldProvider, oldReverse] = await Promise.all([
+					harness.requestOnSession(`${operation}-provider-race`, {
+						type: "control_request",
+						operation: "turn.prompt",
+						input: {},
+					}),
+					harness.requestOnSession(`${operation}-provider-race`, {
+						type: "query_request",
+						query: "turn.prompt_status",
+						input: {},
+					}),
+					harness.requestOnSession(`${operation}-provider-race`, {
+						type: "event_replay",
+						sinceGeneration: 0,
+						sinceSeq: 0,
+					}),
+					harness.requestOnSession(`${operation}-provider-race`, {
+						type: "register_provider",
+						capability: "fs",
+						definitions: {},
+					}),
+					harness.requestOnSession(`${operation}-provider-race`, {
+						type: "reverse_response",
+						leaseId: "old-lease",
+						ok: true,
+						result: {},
+					}),
+				]);
+				harness.sendToSession(`${operation}-provider-race`, { type: "provider_heartbeat", leaseId: "old-lease" });
+				harness.sendToSession(`${operation}-provider-race`, { type: "lease_release", leaseId: "old-lease" });
+				expect(
+					[oldControl, oldQuery, oldReplay, oldProvider, oldReverse].map(
+						response => response.error?.code ?? response.code,
+					),
+				).toEqual([
+					"session_quiescing",
+					"session_quiescing",
+					"session_quiescing",
+					"session_quiescing",
+					"session_quiescing",
+				]);
+				expect(
+					harness.sent(`${operation}-provider-race`).filter(frame => frame.type === "transport_error"),
+				).toHaveLength(3);
+				release.resolve();
+				await Promise.all([end, lifecycleChange]);
+				expect(timeoutWarnings).toBe(0);
+				expect(diagnosticKeyCounts.at(-1)).toBe(0);
+				const failure = harness.broadcasts.find(frame => {
+					const payload = frame.payload;
+					return (
+						frame.kind === "agent_failed" &&
+						typeof payload === "object" &&
+						payload !== null &&
+						(payload as { commandId?: unknown }).commandId === firstIds.commandId &&
+						(payload as { turnId?: unknown }).turnId === firstIds.turnId
+					);
+				});
+				expect(failure).toMatchObject({ kind: "agent_failed", payload: { error: { code } } });
+				expect(harness.broadcasts.filter(frame => frame.kind === "agent_end").length).toBeGreaterThan(0);
+
+				const successor = await harness.control("turn.prompt", { text: "successor" });
+				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", content: "completed" }],
+				});
+				secondInflight.resolve();
+				expect(await settledStatus(harness, "turn.prompt_status", successorIds)).toMatchObject({
+					status: "terminal_ok",
+				});
+				firstInflight.resolve();
+				expect(prompts).toBe(2);
+				await harness.stop();
+			} finally {
+				await Bun.sleep(50);
+				await rm(cwd, { recursive: true, force: true });
+			}
+		}
+	});
+
+	test.each([
+		{ operation: "switchSession" as const, label: "session switch" },
+		{ operation: "branch" as const, label: "session branch" },
+	])("bounds a stalled 402/429 lifecycle drain during $label", async ({ operation }) => {
+		for (const status of [402, 429]) {
+			const cwd = await mkdtemp(path.join(os.tmpdir(), `gjc-${operation}-provider-stall-`));
+			try {
+				const entered = Promise.withResolvers<void>();
+				const release = Promise.withResolvers<void>();
+				const firstInflight = Promise.withResolvers<void>();
+				let timeoutWarnings = 0;
+				const harness = await invocationHarness(`${operation}-provider-stall`, cwd, {
+					persistInterceptor: () => {},
+					onLifecycleDrainTimeout: () => {
+						timeoutWarnings += 1;
+					},
+					persistHold: { type: "agent_failed", onEntered: entered.resolve, release: release.promise },
+					agentFailedWriteFailures: 0,
+					sendUserMessage: async (_content, options) => {
+						await options?.onPreflightAcceptCommit?.();
+						await firstInflight.promise;
+					},
+				});
+				const first = await harness.control("turn.prompt", { text: "first" });
+				expect(first.ok).toBe(true);
+				await harness.emit("agent_start");
+				const end = harness.emit("agent_end", {
+					messages: [{ role: "assistant", stopReason: "error", errorStatus: status }],
+				});
+				await entered.promise;
+				const startedAt = Date.now();
+				const lifecycleChange = harness[operation](`${operation}-stall-successor`);
+				await lifecycleChange;
+				expect(Date.now() - startedAt).toBeLessThan(1_500);
+				expect(timeoutWarnings).toBe(1);
+				release.resolve();
+				firstInflight.resolve();
+				await end;
+				await harness.stop();
+			} finally {
+				await Bun.sleep(50);
+				await rm(cwd, { recursive: true, force: true });
+			}
+		}
+	});
+
+	test("deduplicates repeated agent_failed diagnostics for one invocation", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-agent-failed-dedupe-"));
+		try {
+			const inflight = Promise.withResolvers<void>();
+			const harness = await invocationHarness("agent-failed-dedupe", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await inflight.promise;
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			expect(accepted.ok).toBe(true);
+			const correlation = accepted.result;
+			await harness.emit("agent_start");
+			const failure = { error: Object.assign(new Error("provider failed"), { code: "provider_rejected" }) };
+			await harness.emit("agent_failed", failure);
+			await harness.emit("agent_failed", failure);
+			expect(
+				harness.broadcasts.filter(
+					frame =>
+						frame.kind === "agent_failed" &&
+						(frame.payload as { commandId?: string }).commandId === correlation?.commandId &&
+						(frame.payload as { turnId?: string }).turnId === correlation?.turnId,
+				),
+			).toHaveLength(1);
+			await harness.emit("agent_end");
+			inflight.resolve();
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("routes a delayed predecessor agent_end after replacement completion to the retired owner", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-delayed-retired-owner-"));
+		try {
+			const firstInflight = Promise.withResolvers<void>();
+			const secondInflight = Promise.withResolvers<void>();
+			let prompts = 0;
+			const harness = await invocationHarness("retired-owner-a", cwd, {
+				persistInterceptor: () => {},
+				sendUserMessage: async (_content, options) => {
+					prompts += 1;
+					await options?.onPreflightAcceptCommit?.();
+					if (prompts === 1) await firstInflight.promise;
+					if (prompts === 2) await secondInflight.promise;
+				},
+			});
+			const first = await harness.control("turn.prompt", { text: "first" });
+			expect(first.ok).toBe(true);
+			const firstIds = { commandId: first.result?.commandId, turnId: first.result?.turnId };
+			await harness.emit("agent_start");
+			await harness.switchSession("retired-owner-b");
+			await harness.emit("agent_end", {
+				messages: [{ role: "assistant", stopReason: "error", errorStatus: 402 }],
+			});
+			const failure = harness.broadcasts.find(frame => {
+				const payload = frame.payload;
+				return (
+					frame.kind === "agent_failed" &&
+					typeof payload === "object" &&
+					payload !== null &&
+					(payload as { commandId?: unknown }).commandId === firstIds.commandId &&
+					(payload as { turnId?: unknown }).turnId === firstIds.turnId
+				);
+			});
+			expect(failure).toMatchObject({ kind: "agent_failed", payload: { error: { code: "provider_http_402" } } });
+			const successor = await harness.control("turn.prompt", { text: "successor" });
+			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", content: "completed" }],
+			});
+			secondInflight.resolve();
+			expect(await settledStatus(harness, "turn.prompt_status", successorIds)).toMatchObject({
+				status: "terminal_ok",
+			});
+			firstInflight.resolve();
+			expect(prompts).toBe(2);
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("fails closed for tokenless delayed events when a session id is reused", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-reused-session-retired-owner-"));
+		try {
+			const firstInflight = Promise.withResolvers<void>();
+			const harness = await invocationHarness("reused-session", cwd, {
+				persistInterceptor: () => {},
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await firstInflight.promise;
+				},
+			});
+			const first = await harness.control("turn.prompt", { text: "first" });
+			expect(first.ok).toBe(true);
+			const firstIds = { commandId: first.result?.commandId, turnId: first.result?.turnId };
+			await harness.emit("agent_start");
+			await harness.switchSession("different-session");
+			await harness.switchSession("reused-session");
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", {
+				messages: [{ role: "assistant", stopReason: "error", errorStatus: 402 }],
+			});
+			const failure = harness.broadcasts.find(frame => {
+				const payload = frame.payload;
+				return (
+					frame.kind === "agent_failed" &&
+					typeof payload === "object" &&
+					payload !== null &&
+					(payload as { commandId?: unknown }).commandId === firstIds.commandId &&
+					(payload as { turnId?: unknown }).turnId === firstIds.turnId
+				);
+			});
+			expect(failure).toBeUndefined();
+			firstInflight.resolve();
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("a prompt killed by a provider stream interrupt reports a terminal failed status", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-prompt-"));
+		try {
+			const harness = await invocationHarness("terminalize-prompt", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await neverSettlingPromise();
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			expect(accepted.ok).toBe(true);
+			const { commandId, turnId } = accepted.result ?? {};
+			await harness.emit("agent_start");
+			await harness.emit("agent_failed", {
+				error: Object.assign(new Error("stream interrupted"), { code: "upstream_stream_interrupted" }),
+			});
+			await harness.emit("agent_end");
+			// Provider text is redacted on the wire by contract (sanitizePromptFailure);
+			// the failure reason survives as the safe-token code.
+			expect(await settledStatus(harness, "turn.prompt_status", { commandId, turnId })).toMatchObject({
+				status: "failed",
+				error: { code: "upstream_stream_interrupted", message: "Prompt submission failed." },
+			});
+			await harness.stop();
+		} finally {
+			// Let the reconciliation store finish its atomic write before the state root disappears.
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("a canceled prompt reports a terminal failed status instead of hanging", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-abort-"));
+		try {
+			const harness = await invocationHarness("terminalize-abort", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await neverSettlingPromise();
+				},
+				abort: () => {},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			const { commandId, turnId } = accepted.result ?? {};
+			await harness.emit("agent_start");
+			await harness.emit("agent_failed", { error: Object.assign(new Error("turn aborted"), { code: "aborted" }) });
+			await harness.emit("agent_end");
+			expect(await settledStatus(harness, "turn.prompt_status", { commandId, turnId })).toMatchObject({
+				status: "failed",
+				error: { code: "aborted" },
+			});
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+	test("immediate prompt after abort ack is not terminalized by the aborted turn's delayed agent_end", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-abort-immediate-prompt-"));
+		try {
+			const firstInflight = Promise.withResolvers<void>();
+			const successorStarted = Promise.withResolvers<void>();
+			let prompts = 0;
+			const harness = await invocationHarness("abort-immediate-prompt", cwd, {
+				sendUserMessage: async (_content, options) => {
+					prompts += 1;
+					await options?.onPreflightAcceptCommit?.();
+					if (prompts === 1) {
+						await firstInflight.promise;
+						return;
+					}
+					successorStarted.resolve();
+					await Promise.withResolvers<void>().promise;
+				},
+			});
+			const first = await harness.control("turn.prompt", { text: "first" });
+			expect(first.ok).toBe(true);
+			const firstIds = { commandId: first.result?.commandId, turnId: first.result?.turnId };
+			await harness.emit("agent_start");
+			expect(await harness.control("turn.abort", {})).toMatchObject({ ok: true });
+			firstInflight.reject(Object.assign(new Error("turn aborted"), { code: "aborted" }));
+			const second = await harness.control("turn.prompt", { text: "successor" });
+			expect(second.ok).toBe(true);
+			const secondIds = { commandId: second.result?.commandId, turnId: second.result?.turnId };
+			expect(secondIds.commandId).not.toBe(firstIds.commandId);
+			expect(secondIds.turnId).not.toBe(firstIds.turnId);
+			await harness.emit("agent_start");
+			await successorStarted.promise;
+			await harness.emit("agent_end");
+			expect(await harness.query("turn.prompt_status", secondIds)).toMatchObject({
+				result: { status: expect.stringMatching(/accepted|in_flight/) },
+			});
+			expect(await settledStatus(harness, "turn.prompt_status", firstIds)).toMatchObject({
+				status: "failed",
+				error: { code: "aborted" },
+			});
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
 			expect(await settledStatus(harness, "turn.prompt_status", secondIds)).toMatchObject({
 				status: "terminal_ok",
 			});
@@ -3281,8 +4320,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",
 			});
@@ -3293,6 +4332,55 @@ describe("post-acceptance invocation terminalization", () => {
 		}
 	});
 
+	test("reused-session successor tool progress renews its active deadline", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-reused-successor-progress-"));
+		try {
+			const firstInflight = Promise.withResolvers<void>();
+			const successorStarted = Promise.withResolvers<void>();
+			let prompts = 0;
+			const harness = await invocationHarness("reused-successor-progress", cwd, {
+				settings: {
+					get: (key: string) =>
+						key === "sdk.promptDeadlineMs" ? 25 : key === "sdk.promptMaxRuntimeMs" ? 60_000 : undefined,
+				} as unknown as Settings,
+				sendUserMessage: async (_content, options) => {
+					prompts += 1;
+					await options?.onPreflightAcceptCommit?.();
+					if (prompts === 1) {
+						await firstInflight.promise;
+						return;
+					}
+					successorStarted.resolve();
+					await Promise.withResolvers<void>().promise;
+				},
+			});
+			const first = await harness.control("turn.prompt", { text: "first" });
+			expect(first.ok).toBe(true);
+			await harness.emit("agent_start");
+			await harness.switchSession("reused-successor-progress-other");
+			await harness.switchSession("reused-successor-progress");
+			const successor = await harness.control("turn.prompt", { text: "successor" });
+			expect(successor.ok).toBe(true);
+			const successorIds = { commandId: successor.result?.commandId, turnId: successor.result?.turnId };
+			await harness.emit("agent_start");
+			await successorStarted.promise;
+			for (let index = 0; index < 4; index += 1) {
+				await harness.emit("tool_execution_start");
+				await Bun.sleep(15);
+			}
+			expect(await harness.query("turn.prompt_status", successorIds)).toMatchObject({
+				result: { status: expect.stringMatching(/accepted|in_flight/) },
+			});
+			await harness.emit("agent_end");
+			firstInflight.resolve();
+			await harness.stop();
+			expect(prompts).toBe(2);
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
 	test("abort_and_prompt starts exactly one successor and is not duplicated by delayed abort teardown", async () => {
 		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-abort-and-prompt-once-"));
 		try {
@@ -3321,7 +4409,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",
 			});
@@ -3339,7 +4427,7 @@ describe("post-acceptance invocation terminalization", () => {
 			const harness = await invocationHarness("terminalize-skill", cwd, {
 				invokeSkill: async (_name, _args, options) => {
 					await options?.onPreflightAcceptCommit?.();
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const accepted = await harness.control("skill.invoke", { name: "ralplan" });
@@ -3520,7 +4608,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" }));
@@ -3563,7 +4651,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 				sendUserMessage: async (_content, options) => {
 					await options?.onPreflightAcceptCommit?.();
 					// Accepted, then permanently no execution progress and no agent_start.
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const accepted = await harness.control("turn.prompt", { text: "hello" });
@@ -3597,7 +4685,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 				settings: zeroProgressSettings,
 				sendUserMessage: async (_content, options) => {
 					await options?.onPreflightAcceptCommit?.();
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const original = await harness.control("turn.prompt", { text: "original" });
@@ -3688,7 +4776,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 });
@@ -3731,7 +4819,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 						return;
 					}
 					// The first turn accepts and then never makes progress.
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const first = await harness.control("turn.prompt", { text: "first" });
@@ -3817,7 +4905,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 						)?.onQueuedPromoted;
 						return;
 					}
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const first = await harness.control("turn.prompt", { text: "first" });
@@ -3836,7 +4924,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();
@@ -3873,7 +4961,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 					promoted = options?.onQueuedPromoted;
 					return;
 				}
-				await new Promise<void>(() => {});
+				await neverSettlingPromise();
 			},
 		} as unknown as ExtensionAPI;
 		const transport = memoryTransport();
@@ -3931,7 +5019,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",
@@ -3994,7 +5082,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 						return;
 					}
 					// The first turn accepts and then keeps streaming.
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const first = await harness.control("turn.prompt", { text: "first" });
@@ -4009,7 +5097,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",
 			});
@@ -4052,7 +5140,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 						return;
 					}
 					// The first turn accepts and then keeps streaming.
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const first = await harness.control("turn.prompt", { text: "first" });
@@ -4068,7 +5156,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",
 			});
@@ -4128,7 +5216,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 				} as unknown as Settings,
 				sendUserMessage: async (_content, options) => {
 					await options?.onPreflightAcceptCommit?.();
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 				persistInterceptor: transition => {
 					if (transition.type === "agent_failed") {
@@ -4212,7 +5300,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			const harness = await invocationHarness("skill-terminal-retry", cwd, {
 				invokeSkill: async (_name, _args, options) => {
 					await options?.onPreflightAcceptCommit?.();
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 				persistInterceptor: transition => {
 					if (transition.type === "agent_end" && failedWrites < 2) {
@@ -4245,6 +5333,48 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 		}
 	});
 
+	test("retains skill terminal recovery across session replacement", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-skill-terminal-replacement-"));
+		let failFirstTerminalWrite = true;
+		try {
+			const harness = await invocationHarness("skill-terminal-replacement", cwd, {
+				invokeSkill: async (_name, _args, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await neverSettlingPromise();
+				},
+				persistInterceptor: transition => {
+					if (transition.type === "agent_end" && failFirstTerminalWrite) {
+						failFirstTerminalWrite = false;
+						throw Object.assign(new Error("injected terminal persistence failure"), { code: "io_error" });
+					}
+				},
+			});
+			const submitted = await harness.control("skill.invoke", {
+				name: "replacement-hang",
+				args: "",
+				clientRef: "skill-terminal-replacement-ref",
+			});
+			expect(submitted.ok).toBe(true);
+			await harness.emit("agent_start");
+			await harness.emit("agent_end");
+			await Bun.sleep(50);
+			await harness.switchSession("skill-terminal-replacement-next");
+			await Bun.sleep(1_100);
+			let settled: { status?: string; error?: { code?: string } } | undefined;
+			for (let attempt = 0; attempt < 500 && settled === undefined; attempt += 1) {
+				const frame = await harness.query("skill.invoke_status", { clientRef: "skill-terminal-replacement-ref" });
+				const result = frame.result as { status?: string; error?: { code?: string } } | undefined;
+				if (result?.status === "terminal_ok" || result?.status === "failed") settled = result;
+				else await Bun.sleep(10);
+			}
+			expect(settled?.status).toBe("terminal_ok");
+			await harness.stop();
+		} finally {
+			await Bun.sleep(50);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
 	test("a rejected prompt replays its failure reason, never a bare terminal_ok", async () => {
 		// Exact-head review HIGH: after failed agent_failed persistence, recovery
 		// replayed only agent_end, so an abandoned/rejected prompt became durable
@@ -4335,7 +5465,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 						)?.onQueuedPromoted;
 						return;
 					}
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const first = await harness.control("turn.prompt", { text: "first" });
@@ -4369,7 +5499,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 				sendUserMessage: async (_content, options) => {
 					await options?.onPreflightAcceptCommit?.();
 					// The failing turn accepts and then never makes progress on its own.
-					await new Promise<void>(() => {});
+					await neverSettlingPromise();
 				},
 			});
 			const failing = await harness.control("turn.prompt", { text: "failing" });
@@ -4420,7 +5550,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 				options: { onPreflightAcceptCommit?: () => Promise<void> } | undefined,
 			) => {
 				await options?.onPreflightAcceptCommit?.();
-				if (content === "hangs") await new Promise<void>(() => {});
+				if (content === "hangs") await neverSettlingPromise();
 			},
 		} as unknown as ExtensionAPI;
 		const transport = memoryTransport();
@@ -4466,6 +5596,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",
@@ -4477,10 +5608,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",
@@ -4818,7 +5951,7 @@ test("SDK-only host keeps the idle-submitted prompt's owner when isIdle flips du
 			// Production-faithful: the accepted run stays in-flight; sendUserMessage
 			// resolution (turn completion) never precedes agent_start (#4668
 			// success-retirement).
-			await new Promise<void>(() => {});
+			await neverSettlingPromise();
 		},
 	} as unknown as ExtensionAPI;
 	const transport = memoryTransport();
@@ -5155,7 +6288,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();
@@ -5243,7 +6376,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 = () =>