@gajae-code/coding-agent 0.16.1 → 0.16.3

package/src/modes/acp/acp-agent.ts

@@ -1699,9 +1699,13 @@ export class AcpAgent implements Agent {
 		try {
 			await record.adapter.ensureProviders();
 		} catch (error) {
-			if (waiter.settled || record.cancelRequested || record.activePrompt !== waiter) {
+			if (waiter.settled || record.activePrompt !== waiter) {
 				this.#retiredPromptAcknowledgements.delete(params.sessionId);
-				if (!waiter.settled) await this.#settleCancelledPrompt(params.sessionId, record, waiter);
+				return await response;
+			}
+			if (record.cancelRequested && waiter.cancelAcknowledged) {
+				this.#retiredPromptAcknowledgements.delete(params.sessionId);
+				await this.#settleCancelledPrompt(params.sessionId, record, waiter);
 				return await response;
 			}
 			if (record.activePrompt === waiter) {
@@ -1712,9 +1716,13 @@ export class AcpAgent implements Agent {
 			}
 			throw error;
 		}
-		if (waiter.settled || record.cancelRequested || record.activePrompt !== waiter) {
+		if (waiter.settled || record.activePrompt !== waiter) {
 			this.#retiredPromptAcknowledgements.delete(params.sessionId);
-			if (!waiter.settled) await this.#settleCancelledPrompt(params.sessionId, record, waiter);
+			return await response;
+		}
+		if (record.cancelRequested && waiter.cancelAcknowledged) {
+			this.#retiredPromptAcknowledgements.delete(params.sessionId);
+			await this.#settleCancelledPrompt(params.sessionId, record, waiter);
 			return await response;
 		}
 
@@ -1739,8 +1747,11 @@ export class AcpAgent implements Agent {
 			);
 		}
 		waiter.dispatched = true;
-		if (waiter.settled || record.cancelRequested || record.activePrompt !== waiter) {
-			if (!waiter.settled) await this.#settleCancelledPrompt(params.sessionId, record, waiter);
+		if (waiter.settled || record.activePrompt !== waiter) {
+			return await response;
+		}
+		if (record.cancelRequested && waiter.cancelAcknowledged) {
+			await this.#settleCancelledPrompt(params.sessionId, record, waiter);
 			return await response;
 		}
 
@@ -1922,7 +1933,7 @@ export class AcpAgent implements Agent {
 			// return the semantically meaningful `cancelled` stop reason, so that Clients
 			// can reliably confirm the cancellation." Surfacing the transport's `busy`
 			// rejection instead would show the user a spurious error for their own cancel.
-			if (record.cancelRequested) {
+			if (record.cancelRequested && waiter.cancelAcknowledged) {
 				record.cancelRequested = false;
 				// The client's turn is settled by the return; the advisory idle publication
 				// must not gate it and must still be attempted so the running phase is
@@ -2006,11 +2017,6 @@ export class AcpAgent implements Agent {
 			}
 			waiter?.cancelAttemptResolve?.(true);
 		} catch (error) {
-			if (waiter && !waiter.dispatched) {
-				await this.#settleCancelledPrompt(params.sessionId, record, waiter);
-				waiter.cancelAttemptResolve?.(true);
-				return;
-			}
 			if (!waiter) record.cancelRequested = false;
 			// Only the LAST in-flight attempt resolves the shared promise false;
 			// an earlier attempt may still acknowledge (review thread P2). After
@@ -2058,7 +2064,8 @@ export class AcpAgent implements Agent {
 
 	async #settleCancelledPrompt(id: string, record: SessionRecord, waiter: PromptWaiter): Promise<void> {
 		// The authoritative terminal wins whenever it arrives in time; this only runs
-		// when nothing settled the prompt the client already asked to cancel.
+		// when nothing settled the prompt after the SDK acknowledged the cancellation.
+		if (!waiter.cancelAcknowledged) return;
 		if (this.#sessions.get(id) !== record || record.activePrompt !== waiter || waiter.settled) return;
 		if (waiter.terminalReserved) return;
 		record.activePrompt = undefined;
@@ -2896,6 +2903,14 @@ export class AcpAgent implements Agent {
 			if (reconnected) {
 				const waiter = record.activePrompt;
 				if (waiter && !waiter.settled && !waiter.terminal) {
+					// A successful abort acknowledgement is authoritative for this prompt even
+					// when the SDK transport changes identity during the cancellation grace.
+					// Treating the reconnect as owner loss would replace the acknowledged
+					// cancellation with connection_closed and leave cancellation nondeterministic.
+					if (record.cancelRequested && waiter.cancelAcknowledged) {
+						await this.#settleCancelledPrompt(id, record, waiter);
+						return;
+					}
 					record.activePrompt = undefined;
 					record.busy = record.backgroundBusy;
 					clearPromptWatchdog(waiter);
@@ -3113,7 +3128,7 @@ export class AcpAgent implements Agent {
 		id: string,
 		notification: SessionNotification,
 		adapter: AcpSdkAdapter,
-		publicationGeneration: number,
+		_publicationGeneration: number,
 	): void {
 		const prior = this.#failureDiagnosticTails.get(id) ?? Promise.resolve();
 		const task = prior.then(async () => {

package/src/prompts/tools/bash.md

@@ -18,7 +18,7 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 {{/if}}
 {{#if foregroundFoldEnabled}}
 - In the interactive TUI, the user can press the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via the `app.tool.backgroundFold` keybinding) while a foreground command is still running to fold it into a background job. All three command surfaces fold: managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded command keeps its original timeout and is never killed or restarted by folding; a folded PTY continues output-only, so it stops accepting input. The turn then ends cleanly and a later turn resumes automatically with the command's result, so the interrupted task is finished rather than abandoned. `task`/`subagent` waits are deliberately NOT foldable. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
-- A user steer folds the same way: when the user sends a message while a foreground command has already run for at least 2 seconds, the command is folded into a background job and this call returns the background-start result plus the line `Folded into background job <id> because a user steer arrived; the command keeps running with its original timeout and its result will wake a later turn.` The steer is then delivered at this tool boundary, so handle it next; do not re-run the folded command. Steers that arrive within the first 2 seconds let the command finish normally. This applies only while `busyPromptMode` is `steer` and `toolInterruptPolicy` is `abort_tools`.
+- A user steer folds the same way: when the user sends a message while a foreground command has already run for at least 2 seconds, the command is folded into a background job and this call returns the background-start result plus the line `Folded into background job <id> because a user steer arrived; the command keeps running with its original timeout and its result will wake a later turn.` The steer is then delivered at this tool boundary, so handle it next; do not re-run the folded command. Steers that arrive within the first 2 seconds let the command finish normally. This applies only while `busyPromptMode` is `steer`; `toolInterruptPolicy` is not a gate, since a fold never kills the command.
 {{/if}}
 </instruction>
 {{#if restrictedAllowedPrefixes}}

package/src/prompts/tools/job.md

@@ -2,7 +2,7 @@ Inspects, waits, or cancels async jobs.
 
 Background job results are delivered automatically when complete. Jobs that back task subagents should be controlled via the `subagent` tool when it is available; use `job` for non-subagent jobs (async bash, monitors) and as a compatibility fallback. Running job output stays quiet by default to avoid flooding the conversation; use `tail` when you explicitly want to show/reopen retained output. Reach for this tool only when you need to inspect or intervene.
 
-In the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`), or automatically when the user sends a steer after the command has run for at least 2 seconds (with `busyPromptMode=steer` and `toolInterruptPolicy=abort_tools`). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. Job listings expose `foldReason` (`steer`, `chord`, `timer`, or `sdk_control`) beside `backgrounded` so you can tell why a job left the foreground. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
+In the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`), or automatically when the user sends a steer after the command has run for at least 2 seconds (with `busyPromptMode=steer` (`toolInterruptPolicy` is not a gate)). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. Job listings expose `foldReason` (`steer`, `chord`, `timer`, or `sdk_control`) beside `backgrounded` so you can tell why a job left the foreground. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
 
 # Operations
 

package/src/sdk/acp/adapter.ts

@@ -875,7 +875,7 @@ export class AcpSdkAdapter {
 
 	#expiredOwnedLeaseFrame(frame: Record<string, unknown>): boolean {
 		const response = this.#leaseErrorFrame(frame);
-		if (!response || response.ok !== false) return false;
+		if (response?.ok !== false) return false;
 		const leaseId = typeof response.leaseId === "string" ? response.leaseId : "";
 		const connectionId = typeof response.connectionId === "string" ? response.connectionId : "";
 		if (!leaseId || !this.#ownsLeaseId(leaseId)) return false;

package/src/sdk/bus/chat-daemon-runtime.ts

@@ -471,7 +471,14 @@ export class ChatDaemonRuntime {
 	}
 
 	async #onAttachment(attachment: SessionAttachment): Promise<void> {
+		const revivedTransport = this.#attachments.get(attachment.sessionId) === attachment;
 		this.#attachments.set(attachment.sessionId, attachment);
+		if (revivedTransport) {
+			this.#presentation?.connectSession(attachment.sessionId, {
+				sendReply: route => attachment.send({ type: "reply", id: route.actionId, answer: route.answer }),
+			});
+			return;
+		}
 		const discord = this.#discord;
 		const slack = this.#slack;
 		const barrier = (async () => {

package/src/sdk/cli/rows.ts

@@ -78,6 +78,43 @@ export interface SdkTailEnvelopeV1 {
 	items: SdkTailItemV1[];
 }
 
+export function tailItemKey(item: SdkTailItemV1): string {
+	// (generation, seq) restarts per revision; without the revision two turns'
+	// first frames share "1:1" and the second is silently dropped (#5200).
+	if (item.generation !== undefined && item.seq !== undefined) {
+		if (item.revision === undefined || !Number.isSafeInteger(item.revision) || item.revision < 0)
+			throw new Error("Cannot key a positioned tail item without its authoritative revision.");
+		return `${item.kind}\u0000${item.revision}\u0000${item.generation}\u0000${item.seq}`;
+	}
+	if (item.id !== undefined) return `${item.kind}\u0000${item.id}`;
+	return `${item.kind}\u0000${JSON.stringify(item.payload)}`;
+}
+
+/** Holds positioned live frames until the checkpoint can stamp their authoritative revision. */
+export class TailRevisionBuffer {
+	#pending: SdkTailItemV1[] = [];
+	#resolved = false;
+
+	push(item: SdkTailItemV1): SdkTailItemV1[] {
+		if (item.revision !== undefined || item.generation === undefined || item.seq === undefined) return [item];
+		if (!this.#resolved) {
+			this.#pending.push(item);
+			return [];
+		}
+		throw new Error("A positioned live tail item arrived without an authoritative revision after checkpoint.");
+	}
+
+	resolve(revision: number): SdkTailItemV1[] {
+		if (!Number.isSafeInteger(revision) || revision < 0)
+			throw new Error("Tail revision must be a non-negative integer.");
+		this.#resolved = true;
+		const pending = this.#pending;
+		this.#pending = [];
+		for (const item of pending) item.revision = revision;
+		return pending;
+	}
+}
+
 const SECRET_FIELD = /(?:secret|token|password|credential|authorization|api[_-]?key)/i;
 
 /** Recursively removes secret-shaped fields (defense in depth for DTO output). */
@@ -228,12 +265,20 @@ export function toTailItemV1(
 	const item: SdkTailItemV1 = {
 		kind,
 		...(payloadId !== undefined ? { id: payloadId } : id !== undefined ? { id } : {}),
-		...(typeof value.revision === "number" ? { revision: value.revision } : {}),
+		...(typeof value.revision === "number" && Number.isSafeInteger(value.revision) && value.revision >= 0
+			? { revision: value.revision }
+			: {}),
 		...(typeof value.generation === "number" ? { generation: value.generation } : {}),
 		...(typeof value.seq === "number" ? { seq: value.seq } : {}),
 		payload: stripSecretFields(payload),
 	};
-	if (fallback.revision !== undefined && item.revision === undefined) item.revision = fallback.revision;
+	if (
+		fallback.revision !== undefined &&
+		Number.isSafeInteger(fallback.revision) &&
+		fallback.revision >= 0 &&
+		item.revision === undefined
+	)
+		item.revision = fallback.revision;
 	if (fallback.generation !== undefined && item.generation === undefined) item.generation = fallback.generation;
 	if (fallback.seq !== undefined && item.seq === undefined) item.seq = fallback.seq;
 	return item;

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

@@ -38,10 +38,13 @@ import { SESSION_REQUEST_TIMEOUT_MS } from "../session-reconnect";
 import {
 	type SdkCheckpointRecordV1,
 	type SdkRetentionGapV1,
+	type SdkRingPositionV1,
 	type SdkSessionRowV1,
 	type SdkTailItemV1,
 	SESSION_ROWS_VERSION,
 	stripSecretFields,
+	TailRevisionBuffer,
+	tailItemKey,
 	toCheckpointRecordV1,
 	toRetentionGapV1,
 	toSessionRowV1,
@@ -985,13 +988,6 @@ function extractTranscriptPage(response: unknown): { items: unknown[]; complete:
 	};
 }
 
-function tailItemKey(item: SdkTailItemV1): string {
-	if (item.generation !== undefined && item.seq !== undefined)
-		return `${item.kind}\u0000${item.generation}\u0000${item.seq}`;
-	if (item.id !== undefined) return `${item.kind}\u0000${item.id}`;
-	return `${item.kind}\u0000${JSON.stringify(item.payload)}`;
-}
-
 function mergeTailItems(
 	target: SdkTailItemV1[],
 	seen: Set<string>,
@@ -1006,8 +1002,9 @@ function mergeTailItems(
 	}
 }
 
-/** Canonical ring position of an event item, when the host stated one. */
-type TailSeqKey = { generation: number; seq: number };
+/** Canonical session-wide ring position of an event item, when the host stated one. */
+type TailSeqKey = SdkRingPositionV1;
+type TailLocalPosition = Pick<SdkRingPositionV1, "generation" | "seq">;
 
 function isPositionCoordinate(value: unknown): value is number {
 	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
@@ -1057,7 +1054,7 @@ function classifyRawEventPosition(event: unknown): "unpositioned" | "malformed"
  * it is never silently downgraded to unpositioned. Claiming neither coordinate
  * is a genuine unpositioned event.
  */
-function classifyTailPosition(item: SdkTailItemV1): TailSeqKey | "unpositioned" | "malformed" {
+function classifyTailPosition(item: SdkTailItemV1): TailLocalPosition | "unpositioned" | "malformed" {
 	if (item.generation === undefined && item.seq === undefined) return "unpositioned";
 	if (!isPositionCoordinate(item.generation) || !isPositionCoordinate(item.seq)) return "malformed";
 	return { generation: item.generation, seq: item.seq };
@@ -1065,10 +1062,13 @@ function classifyTailPosition(item: SdkTailItemV1): TailSeqKey | "unpositioned"
 
 function tailSeqKey(item: SdkTailItemV1): TailSeqKey | undefined {
 	const position = classifyTailPosition(item);
-	return typeof position === "string" ? undefined : position;
+	return typeof position === "string" || !isPositionCoordinate(item.revision)
+		? undefined
+		: { revision: item.revision, ...position };
 }
 
 function compareTailSeqKeys(left: TailSeqKey, right: TailSeqKey): number {
+	if (left.revision !== right.revision) return left.revision - right.revision;
 	return left.generation !== right.generation ? left.generation - right.generation : left.seq - right.seq;
 }
 
@@ -1112,10 +1112,12 @@ function mergeEventTailItems(
 			target.unpositioned.push(item);
 			continue;
 		}
+		const orderedPosition = tailSeqKey(item);
+		if (orderedPosition === undefined) throw new Error("A positioned tail item has no authoritative revision.");
 		let index = target.positioned.length;
 		for (; index > 0; index--) {
 			const previous = tailSeqKey(target.positioned[index - 1]!);
-			if (previous === undefined || compareTailSeqKeys(previous, position) <= 0) break;
+			if (previous === undefined || compareTailSeqKeys(previous, orderedPosition) <= 0) break;
 		}
 		target.positioned.splice(index, 0, item);
 	}
@@ -1158,11 +1160,13 @@ function tailItemFromRouterFrame(frame: SessionRouterFrame): SdkTailItemV1 | und
 	return toTailItemV1(
 		{
 			kind: frame.name,
+			...(frame.revision === undefined ? {} : { revision: frame.revision }),
 			...(seq === undefined ? {} : { generation: frame.generation, seq }),
 			payload: frame.body,
 		},
 		{
 			kind: frame.name,
+			...(frame.revision === undefined ? {} : { revision: frame.revision }),
 			...(seq === undefined ? {} : { generation: frame.generation, seq }),
 		},
 	);
@@ -1406,6 +1410,7 @@ async function runLiveTail(
 	// evidence.
 	const seenTranscript = new Set<string>();
 	const seenEvents = new Set<string>();
+	const liveRevisionBuffer = new TailRevisionBuffer();
 	let checkpoint: SdkCheckpointRecordV1 | undefined;
 	let gap: SdkRetentionGapV1 | undefined;
 	let liveReason: TailExitReason | undefined;
@@ -1445,7 +1450,7 @@ async function runLiveTail(
 				// close at a contested position win instead of failing closed, and
 				// checking it after the monotonic guard would silently skip a
 				// conflicting kind at an already-decided position.
-				const positionKey = `${position.generation}\u0000${position.seq}`;
+				const positionKey = `${position.revision}\u0000${position.generation}\u0000${position.seq}`;
 				const claimed = claimedLifecycleKinds.get(positionKey);
 				if (claimed !== undefined && claimed !== item.kind) {
 					malformed ??= new SdkSessionCliError(
@@ -1487,9 +1492,17 @@ async function runLiveTail(
 		if (attachment.sessionId !== sessionId) return;
 		const item = tailItemFromRouterFrame(frame);
 		if (!item) return;
-		if (item.revision === undefined && checkpoint?.revision !== undefined) item.revision = checkpoint.revision;
-		// If checkpoint was undefined, queue for later stamping? For now leave without rev
-		applyLifecycle(mergeEventTailItems(eventItems, seenEvents, [item], include));
+		try {
+			applyLifecycle(mergeEventTailItems(eventItems, seenEvents, liveRevisionBuffer.push(item), include));
+		} catch (error) {
+			malformed ??= new SdkSessionCliError(
+				"protocol_error",
+				error instanceof Error ? error.message : "A live tail item had no authoritative revision.",
+				1,
+				{ sessionId, kind: item.kind, generation: item.generation, seq: item.seq },
+			);
+			rejectLive?.(malformed);
+		}
 	};
 
 	return await withRouter(
@@ -1511,6 +1524,10 @@ async function runLiveTail(
 			const extraction = extractCheckpoint(checkpointResponse);
 			checkpoint = extraction.record;
 			gap = extraction.gap;
+			if (checkpoint !== undefined)
+				applyLifecycle(
+					mergeEventTailItems(eventItems, seenEvents, liveRevisionBuffer.resolve(checkpoint.revision), include),
+				);
 			if (gap !== undefined && args.strict === true)
 				throw new SdkSessionCliError(
 					"retention_gap",
@@ -1595,7 +1612,11 @@ async function runLiveTail(
 			applyLifecycle(mergeEventTailItems(eventItems, seenEvents, replayItems, include));
 			if (malformed !== undefined) throw malformed;
 			if (checkpoint !== undefined) {
-				const checkpointKey = { generation: checkpoint.generation, seq: checkpoint.seq };
+				const checkpointKey = {
+					revision: checkpoint.revision,
+					generation: checkpoint.generation,
+					seq: checkpoint.seq,
+				};
 				if (turnStateKey === undefined || compareTailSeqKeys(checkpointKey, turnStateKey) >= 0) {
 					turnStateKey = checkpointKey;
 					turnIdle = checkpoint.idle;

package/src/sdk/host/events.ts

@@ -32,11 +32,20 @@ export class SessionEventStream {
 	#frames: EventFrame[] = [];
 	readonly #ringSize: number;
 	readonly #resyncQueries: string[];
+	readonly #revisionProvider: (() => number | undefined) | undefined;
 
-	constructor(options: { generation?: number; ringSize?: number; resyncQueryIds?: string[] } = {}) {
+	constructor(
+		options: {
+			generation?: number;
+			ringSize?: number;
+			resyncQueryIds?: string[];
+			revisionProvider?: () => number | undefined;
+		} = {},
+	) {
 		this.#generation = options.generation ?? 0;
 		this.#ringSize = options.ringSize ?? 256;
 		this.#resyncQueries = options.resyncQueryIds ?? ["Q01", "Q02", "Q03"];
+		this.#revisionProvider = options.revisionProvider;
 	}
 
 	get generation(): number {
@@ -54,7 +63,21 @@ export class SessionEventStream {
 	}
 
 	emit(frame: SdkFrame): EventFrame {
-		const event: EventFrame = { ...frame, type: "event", generation: this.#generation, seq: ++this.#seq };
+		const suppliedRevision = frame.revision;
+		const providedRevision = this.#revisionProvider?.();
+		const revision =
+			typeof suppliedRevision === "number" && Number.isSafeInteger(suppliedRevision) && suppliedRevision >= 0
+				? suppliedRevision
+				: typeof providedRevision === "number" && Number.isSafeInteger(providedRevision) && providedRevision >= 0
+					? providedRevision
+					: undefined;
+		const event: EventFrame = {
+			...frame,
+			type: "event",
+			...(revision === undefined ? {} : { revision }),
+			generation: this.#generation,
+			seq: ++this.#seq,
+		};
 		this.#frames.push(event);
 		if (this.#frames.length > this.#ringSize) this.#frames.shift();
 		return event;

package/src/sdk/host/host.ts

@@ -47,6 +47,8 @@ export type SessionActivationGate = (input: { sessionId: string; generation: num
 export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	control?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
 	query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
+	/** Supplies the durable transcript revision stamped on ordinary emitted events. */
+	eventRevision?: () => number | undefined;
 	/** Test/lifecycle seam invoked synchronously before fire-and-forget dispatch. */
 	onFrameAdmitted?: (connectionId: string, frame: SdkFrame) => void;
 	/** Synchronously rejects external input while a runtime is being replaced. */
@@ -199,7 +201,7 @@ function has(frame: SdkFrame, field: string): boolean {
 
 /** Adapter-based session host; bus wiring owns NotificationServer creation and transport framing. */
 export class SessionSdkHost {
-	readonly events = new SessionEventStream();
+	readonly events: SessionEventStream;
 	readonly reverse: ReverseLeaseRuntime;
 	readonly #options: SessionSdkHostOptions;
 	#started = false;
@@ -214,6 +216,7 @@ export class SessionSdkHost {
 
 	constructor(options: SessionSdkHostOptions) {
 		this.#options = options;
+		this.events = new SessionEventStream({ revisionProvider: options.eventRevision });
 		this.reverse = new ReverseLeaseRuntime({
 			sendFrame: options.sendFrame,
 			installDefinitions: options.installProviderDefinitions,

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

@@ -1220,6 +1220,7 @@ describe("SessionSdkSessionRuntime", () => {
 		const transport = memoryTransport();
 		const runtime = new SessionSdkSessionRuntime({
 			transport,
+			eventRevision: () => 7,
 			control: async (_connectionId, frame) => ({ id: frame.id, ok: true, result: { operation: frame.operation } }),
 			query: async (_connectionId, frame) => ({ id: frame.id, ok: true, result: { query: frame.query } }),
 		});
@@ -1239,7 +1240,7 @@ describe("SessionSdkSessionRuntime", () => {
 		});
 		transport.feed("client", { type: "query_request", id: "query", query: "Q18", input: {} });
 		await Bun.sleep(0);
-		expect(transport.broadcasts.some(frame => frame.kind === "session_ready")).toBe(true);
+		expect(transport.broadcasts).toContainEqual(expect.objectContaining({ kind: "session_ready", revision: 7 }));
 		expect(transport.sent).toEqual(
 			expect.arrayContaining([
 				expect.objectContaining({ type: "event_replay_result", id: "replay", ok: true }),
@@ -2833,26 +2834,32 @@ describe("SessionSdkSessionRuntime", () => {
 
 			// B's accepted receipt is redacted to {} once its submission rejects,
 			// so select its record by the stable clientRef instead.
-			// Let the async rejection settle and retire B's pending entry.
-			await Bun.sleep(50);
 			// The rejected submission must TERMINALIZE as failed (#4668 review
 			// P1): agent_failed alone is diagnostic-only, so the settlement also
 			// writes agent_end. Before that fix B stayed accepted forever.
 			{
 				const ids = { clientRef: "fail-b-ref" };
-				transport.feed("conn-b", {
-					type: "query_request",
-					id: "fail-b-status",
-					query: "turn.prompt_status",
-					input: { kind: "prompt", ...ids },
-				} as SdkFrame);
-				// waitResponse polls control_response only; queries get query_response.
 				const statusDeadline = Date.now() + 15_000;
-				while (!transport.sent.some(frame => frame.id === "fail-b-status")) {
+				let status: Record<string, unknown> | undefined;
+				for (let attempt = 0; status === undefined; attempt += 1) {
+					const id = `fail-b-status-${attempt}`;
+					transport.feed("conn-b", {
+						type: "query_request",
+						id,
+						query: "turn.prompt_status",
+						input: { kind: "prompt", ...ids },
+					} as SdkFrame);
+					while (!transport.sent.some(frame => frame.id === id)) {
+						if (Date.now() > statusDeadline) throw new Error("Timed out waiting for fail-b-status");
+						await Bun.sleep(20);
+					}
+					const response = transport.sent.find(frame => frame.id === id);
+					const result = response?.result as Record<string, unknown> | undefined;
+					if (result?.status === "failed") status = response;
+					else await Bun.sleep(20);
 					if (Date.now() > statusDeadline) throw new Error("Timed out waiting for fail-b-status");
-					await Bun.sleep(20);
 				}
-				expect(transport.sent.find(frame => frame.id === "fail-b-status")).toMatchObject({
+				expect(status).toMatchObject({
 					ok: true,
 					result: expect.objectContaining({ status: "failed" }),
 				});
@@ -4765,7 +4772,7 @@ describe("post-acceptance invocation terminalization", () => {
 			const harness = await invocationHarness("successor-progress", cwd, {
 				settings: {
 					get: (key: string) =>
-						key === "sdk.promptDeadlineMs" ? 25 : key === "sdk.promptMaxRuntimeMs" ? 60_000 : undefined,
+						key === "sdk.promptDeadlineMs" ? 2_000 : key === "sdk.promptMaxRuntimeMs" ? 60_000 : undefined,
 				} as unknown as Settings,
 				sendUserMessage: async (_content, options) => {
 					prompts += 1;
@@ -4790,7 +4797,7 @@ describe("post-acceptance invocation terminalization", () => {
 			await successorStarted.promise;
 			for (let index = 0; index < 4; index += 1) {
 				await harness.emit("tool_execution_start");
-				await Bun.sleep(15);
+				await Bun.sleep(800);
 			}
 			expect(await harness.query("turn.prompt_status", successorIds)).toMatchObject({
 				result: { status: expect.stringMatching(/accepted|in_flight/) },
@@ -5553,9 +5560,13 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 		// renewal wiring at the SDK boundary.
 		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-renew-attached-"));
 		try {
+			const renewalSettings = {
+				get: (key: string) =>
+					key === "sdk.promptDeadlineMs" ? 2_000 : key === "sdk.promptMaxRuntimeMs" ? 60_000 : undefined,
+			} as unknown as Settings;
 			let promoted: ((promotion: { startsOwnRun: boolean }) => void) | undefined;
 			const harness = await invocationHarness("renew-attached", cwd, {
-				settings: zeroProgressSettings,
+				settings: renewalSettings,
 				sendUserMessage: async (content, options) => {
 					await options?.onPreflightAcceptCommit?.();
 					if (content === "consumed") {
@@ -5574,12 +5585,12 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			expect(consumed.ok).toBe(true);
 			promoted?.({ startsOwnRun: false });
 			const ids = { commandId: consumed.result?.commandId, turnId: consumed.result?.turnId };
-			// Past the 25ms lease, repeated tool activity keeps the attached
-			// correlation alive: without renewal it would already be
-			// prompt_deadline_exceeded by the first sleep boundary.
+			// Past the initial 2s lease, repeated tool activity keeps the
+			// attached correlation alive. Each interval stays well within one
+			// renewed lease while their cumulative duration exceeds the original.
 			for (let i = 0; i < 3; i += 1) {
 				await harness.emit("tool_execution_start");
-				await Bun.sleep(15);
+				await Bun.sleep(800);
 			}
 			const midRun = await harness.query("turn.prompt_status", ids);
 			expect(midRun.result?.status).not.toBe("failed");
@@ -5783,7 +5794,7 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			const harness = await invocationHarness("dispatch-race-lease", cwd, {
 				settings: {
 					get: (key: string) =>
-						key === "sdk.promptDeadlineMs" ? 25 : key === "sdk.promptMaxRuntimeMs" ? 60_000 : undefined,
+						key === "sdk.promptDeadlineMs" ? 2_000 : key === "sdk.promptMaxRuntimeMs" ? 60_000 : undefined,
 				} as unknown as Settings,
 				sendUserMessage: async (content, options) => {
 					await options?.onPreflightAcceptCommit?.();
@@ -5808,9 +5819,9 @@ describe("accepted-control zero-execution bound (#4668)", () => {
 			const raced = await harness.control("turn.prompt", { text: "raced" });
 			expect(raced.ok).toBe(true);
 			const idsRaced = { commandId: raced.result?.commandId, turnId: raced.result?.turnId };
-			// Far past the 25ms lease while queued: the acceptance-anchored lease
+			// Far past the 2s lease while queued: the acceptance-anchored lease
 			// was dropped at the divert disposition, so no false deadline fire.
-			await Bun.sleep(120);
+			await Bun.sleep(2_200);
 			const queued = await harness.query("turn.prompt_status", idsRaced);
 			expect(queued.result?.status).not.toBe("failed");
 			// Real consumption re-leases and attaches to the in-flight run.

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

@@ -5224,6 +5224,10 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		};
 		runtime = new SessionSdkSessionRuntime({
 			transport,
+			eventRevision: () =>
+				typeof (ctx as Partial<ExtensionContext>).getTranscript === "function"
+					? ctx.getTranscript().length
+					: undefined,
 			masterCapabilityVerify: frame =>
 				verifyMasterCapabilityFrame({
 					frame,