@gajae-code/coding-agent 0.16.1 → 0.16.4

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 }),
@@ -2124,7 +2125,7 @@ describe("SessionSdkSessionRuntime", () => {
 			while (!transport.sent.some(frame => frame.id === "predecessor-prompt")) await Bun.sleep(10);
 			await handlers.get("agent_start")?.({}, ctx); // lifecycle epoch 1
 			await handlers.get("agent_end")?.(
-				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "completed" },
+				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "compacted" },
 				ctx,
 			);
 			transport.feed("client", {
@@ -2147,7 +2148,7 @@ describe("SessionSdkSessionRuntime", () => {
 			while (abortCalls < 1) await Bun.sleep(10);
 			await handlers.get("agent_end")?.({ type: "agent_end" }, ctx); // delayed predecessor
 			await handlers.get("agent_end")?.(
-				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "completed" },
+				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "compacted" },
 				ctx,
 			);
 			abortRelease.resolve();
@@ -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

@@ -4,7 +4,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { promisify } from "node:util";
-import { ThinkingLevel } from "@gajae-code/agent-core";
+import { isContinuingMidRunMaintenanceOutcome, ThinkingLevel } from "@gajae-code/agent-core";
 import type { Api, ImageContent, Model } from "@gajae-code/ai/core";
 import { logger } from "@gajae-code/utils";
 import { AsyncJobManager } from "../../async";
@@ -27,7 +27,10 @@ import { resolveModelChainWithAuth, splitSelectorThinkingSuffix } from "../../co
 import { type ModelSelectorValue, normalizeModelSelectorValue } from "../../config/model-selector-value";
 import { type Settings, validateSettingPatch } from "../../config/settings";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "../../extensibility/extensions";
+import type { AgentEndEvent } from "../../extensibility/shared-events";
 import { normalizeGoal } from "../../goals/state";
+import { toAgentWireEventPayload } from "../../modes/shared/agent-wire/event-envelope";
+import type { AgentSessionEvent } from "../../session/agent-session";
 import type { SdkRunCapability } from "../../session/sdk-run-capability";
 import {
 	boundTerminalRetentionState,
@@ -192,6 +195,24 @@ class DiffQueryError extends Error {
 	}
 }
 
+/**
+ * Normalize an agent-loop stop reason into the published terminal outcome.
+ *
+ * Only reached for a boundary that actually terminalizes an owned invocation,
+ * so every result is a `stopped` disposition: a failed run publishes its own
+ * correlated `agent_failed` frame with the sanitized cause instead.
+ */
+export function terminalStoppedOutcome(
+	stopReason: AgentEndEvent["stopReason"],
+	maintenanceOutcome: string | undefined,
+): Extract<SdkPromptTerminalOutcome, { kind: "stopped" }> {
+	// An aborted maintenance checkpoint is the one maintenance path that really
+	// ends the run, and it ends it the same way an explicit stop does.
+	return stopReason === "cancelled" || maintenanceOutcome === "aborted"
+		? { kind: "stopped", reason: "cancelled", provenance: "client_cancel" }
+		: { kind: "stopped", reason: "end_turn", provenance: "agent" };
+}
+
 /** Transport-neutral endpoint contract consumed by the SDK session runtime. */
 export interface SessionSdkTransport {
 	readonly sessionId: string;
@@ -395,6 +416,28 @@ export class SessionSdkSessionRuntime {
 		this.transport.broadcastFrame?.(event);
 	}
 
+	/**
+	 * Deliver a frame to specific connections without recording it.
+	 *
+	 * Deliberately not `emitEvent`: that assigns a ring position and broadcasts to
+	 * every authenticated socket. Streamed turn content is high-frequency and
+	 * unbounded in size, so a count-bounded ring would evict the lifecycle events
+	 * clients depend on -- including the `agent_end` that settles their prompt --
+	 * and broadcasting would hand every subscriber a stream only the submitter
+	 * asked for. Delivery failure is ignored: a disconnected consumer must never
+	 * disturb the turn producing the content.
+	 */
+	sendFrameTo(connectionIds: Iterable<string>, frame: SdkFrame): void {
+		for (const connectionId of connectionIds) {
+			try {
+				const result = this.transport.sendFrame(connectionId, frame);
+				if (result instanceof Promise) result.catch(() => undefined);
+			} catch {
+				// A dead connection is reaped by the transport's own close handling.
+			}
+		}
+	}
+
 	publish(frame: SdkFrame): void {
 		this.emitEvent(frame);
 	}
@@ -577,6 +620,8 @@ function canonicalTerminalOutcome(
 		if (candidate.kind === "stopped") {
 			if (candidate.reason === "cancelled" && candidate.provenance === "client_cancel")
 				return { kind: "stopped", reason: "cancelled", provenance: "client_cancel" };
+			if (candidate.reason === "end_turn" && candidate.provenance === "agent")
+				return { kind: "stopped", reason: "end_turn", provenance: "agent" };
 			return undefined;
 		}
 		if (candidate.kind === "failed")
@@ -2239,6 +2284,7 @@ function createControlSurface(
 	canResolveGate: () => boolean = () => true,
 	trackGateResolution: <T>(resolution: Promise<T>) => Promise<T> = async resolution => await resolution,
 	onInvocationCompletionReconciledForTests?: (kind: InvocationKind, correlation: InvocationCorrelation) => void,
+	publishLifecycleFrame?: (frame: SdkFrame) => void,
 ): ControlSurface {
 	const normalizePromptImages = (value: unknown): ImageContent[] => {
 		if (!Array.isArray(value)) return [];
@@ -2376,6 +2422,24 @@ function createControlSurface(
 		const correlation = newCorrelation();
 		const sdkRunToken = `${correlation.commandId}:${correlation.turnId}`;
 		const sdkRunCapability = createSdkRunCapability(sdkRunToken);
+		const publishTerminal = (outcome: InvocationOutcome): void => {
+			publishLifecycleFrame?.({
+				type: "agent_end",
+				sessionId: ctx.sessionManager.getSessionId(),
+				...correlation,
+				outcome,
+			});
+		};
+		const publishFailure = (error: unknown): void => {
+			const failure = sanitizePromptFailure(error);
+			publishLifecycleFrame?.({
+				type: "agent_failed",
+				sessionId: ctx.sessionManager.getSessionId(),
+				...correlation,
+				error: failure,
+			});
+			publishTerminal(canonicalFailedOutcome(failure));
+		};
 		const preflight = Promise.withResolvers<void>();
 		let accepted = false;
 		let settled = false;
@@ -2484,11 +2548,25 @@ function createControlSurface(
 							retirePendingOwner?.(kind, correlation);
 							const attemptTerminalization = async (remaining: number): Promise<void> => {
 								try {
+									const before = reconciliation.lookup(kind, correlation) as {
+										status?: string;
+									};
+									const alreadyTerminal = before.status === "terminal_ok" || before.status === "failed";
 									await reconciliation.noteTransition(kind, correlation, {
 										type: "agent_end",
 										...(typeof result === "string" ? { content: sanitizeTurnResultContent(result) } : {}),
 									});
 									onInvocationCompletionReconciledForTests?.(kind, correlation);
+									if (!alreadyTerminal) {
+										const settledRecord = reconciliation.lookup(kind, correlation) as {
+											status?: string;
+											outcome?: unknown;
+											error?: { code?: unknown; message?: unknown };
+										};
+										const outcome = canonicalTerminalOutcome(settledRecord.outcome, settledRecord.error);
+										if (outcome?.kind === "failed") publishFailure(settledRecord.error ?? outcome);
+										else if (outcome) publishTerminal(outcome);
+									}
 									retirePendingOwner?.(kind, correlation, "always");
 								} catch (transitionError) {
 									if (kind === "prompt" || kind === "skill") {
@@ -2585,6 +2663,7 @@ function createControlSurface(
 								}
 								try {
 									await reconciliation.noteTransition(kind, correlation, { type: "agent_end" });
+									publishFailure(error);
 								} catch (transitionError) {
 									if (kind === "prompt" || kind === "skill") {
 										retirePendingOwner?.(
@@ -3940,7 +4019,11 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 				waitForGateResolutionQuiescence: () => Promise<void>;
 				activeInvocation?: { kind: InvocationKind; correlation: InvocationCorrelation };
 				drainedInvocations?: Array<{ kind: InvocationKind; correlation: InvocationCorrelation }>;
-				attachedInvocations?: Array<{ kind: InvocationKind; correlation: InvocationCorrelation }>;
+				attachedInvocations?: Array<{
+					kind: InvocationKind;
+					correlation: InvocationCorrelation;
+					connectionId: string | undefined;
+				}>;
 				openLifecycleBatches: Array<{
 					epoch: number;
 					invocations: Array<{
@@ -3949,7 +4032,11 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 						connectionId: string | undefined;
 						sdkRunToken: string;
 					}>;
-					attachedInvocations: Array<{ kind: InvocationKind; correlation: InvocationCorrelation }>;
+					attachedInvocations: Array<{
+						kind: InvocationKind;
+						correlation: InvocationCorrelation;
+						connectionId: string | undefined;
+					}>;
 				}>;
 				disposeGate?: () => void;
 				lifecycleActive: boolean;
@@ -4142,6 +4229,8 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		terminalContent?: TurnResultContent,
 		terminalHasActivity = false,
 		terminalOutcome?: InvocationOutcome,
+		stopReason?: AgentEndEvent["stopReason"],
+		startToken?: string,
 	): Promise<void> => {
 		const current = lifecycleOwner?.state ?? active;
 		if (!current) return;
@@ -4216,19 +4305,44 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			// turn (queued-while-streaming submissions never push), so a mid-prompt
 			// continuation agent_start with an empty queue leaves the current owner
 			// untouched (review thread P1).
-			const drained = current.pending
-				.splice(0)
+			const matchingPending =
+				typeof startToken === "string" && startToken.length > 0
+					? current.pending.filter(entry => entry.sdkRunToken === startToken)
+					: current.pending.slice();
+			const matchingKeys = new Set(matchingPending.map(entry => entry.sdkRunToken));
+			const pendingSnapshot = current.pending.splice(0);
+			const drained = pendingSnapshot
+				.filter(entry => matchingKeys.has(entry.sdkRunToken))
 				.filter(entry => entry.kind !== "prompt" || !current.deadlineManager.isExpiring(entry.correlation));
+			current.pending.push(...pendingSnapshot.filter(entry => !matchingKeys.has(entry.sdkRunToken)));
+			const existingTokenBatch =
+				typeof startToken === "string" && startToken.length > 0
+					? lifecycleRunOwners.get(startToken)?.batch
+					: undefined;
 			if (drained.length > 0) {
-				current.openLifecycleBatches.push({
+				const batch: LifecycleBatch = {
 					epoch: current.lifecycleEpoch,
 					invocations: drained,
 					attachedInvocations: [],
-				});
+				};
+				current.openLifecycleBatches.push(batch);
+				if (typeof startToken === "string" && startToken.length > 0) {
+					const entry = drained.find(item => item.sdkRunToken === startToken);
+					lifecycleRunOwners.set(startToken, {
+						state: current,
+						batch,
+						...(entry ? { correlationKey: lifecycleCorrelationKey(entry.correlation) } : {}),
+					});
+				}
 				adoptLifecycleBatch(drained);
 				if (current.activeInvocation?.kind === "prompt") {
 					current.deadlineManager.onAccepted(current.activeInvocation.correlation);
 				}
+			} else if (existingTokenBatch && current.openLifecycleBatches.includes(existingTokenBatch)) {
+				// A continuation within the same SDK-owned run carries the same token
+				// but has no newly pending invocation. Preserve the established owner so
+				// later chunks and the final terminal remain directed to its submitters.
+				adoptLifecycleBatch(existingTokenBatch.invocations);
 			} else {
 				// An empty drain is an agent-initiated successor run. Clear the
 				// predecessor's SDK owner and active invocation so abort ownership and
@@ -4240,7 +4354,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			// Pair this agent_end with the oldest unmatched start. A delayed
 			// aborted-turn end that lands after a successor agent_start must
 			// terminalize the aborted invocation, never the successor.
-			const ended = current.openLifecycleBatches[0];
+			const ended = failureBatch ?? current.openLifecycleBatches[0];
 			const baseTransitions = ended
 				? ended.invocations.map(({ kind, correlation }) => ({ kind, correlation }))
 				: current.activeInvocation
@@ -4364,7 +4478,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			};
 			void attempt().finally(() => skillTerminalRecoveryControllers.delete(recoveryKey));
 		};
-		if (type === "agent_end" && maintenanceOutcome !== undefined && maintenanceOutcome !== "aborted") {
+		if (type === "agent_end" && isContinuingMidRunMaintenanceOutcome(maintenanceOutcome)) {
 			try {
 				current.runtime.emitEvent({ type, sessionId: ctx.sessionManager.getSessionId() });
 			} catch {
@@ -4485,7 +4599,31 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 						observed = false;
 					}
 				}
+			} else if (type === "agent_end" && transitions.length > 0) {
+				// An invocation-owned terminal must carry the identity it was accepted
+				// under and the normalized outcome. A client that submitted this turn
+				// matches the terminal against its own acknowledged correlation and
+				// refuses an unowned one, so the bare `{ type, sessionId }` boundary left
+				// every externally submitted prompt reporting `working` forever even
+				// though the turn had finished -- ACP dropped it as
+				// `incomplete_correlation`, and the notifications runtime has always
+				// stamped both fields for exactly this reason. One frame per invocation,
+				// matching the agent_failed shape above, also lets a shared run attribute
+				// the boundary to each owner instead of one signal nobody can claim. A
+				// continuing maintenance checkpoint never reaches this branch: it returned
+				// above with the one uncorrelated frame, so it cannot settle a live prompt.
+				const outcome = terminalOutcome ?? terminalStoppedOutcome(stopReason, maintenanceOutcome);
+				for (const invocation of transitions) {
+					try {
+						current.runtime.emitEvent({ type, sessionId, ...invocation.correlation, outcome });
+					} catch {
+						observed = false;
+					}
+				}
 			} else {
+				// Everything that does not terminalize an owned invocation keeps the one
+				// uncorrelated frame: `agent_start` and a host-originated run (autonomous
+				// continuation, cron, monitor) that owns no invocation.
 				try {
 					current.runtime.emitEvent({ type, sessionId });
 				} catch {
@@ -4495,7 +4633,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		} catch {
 			observed = false;
 		}
-		if (type === "agent_end" && maintenanceOutcome !== undefined && maintenanceOutcome !== "aborted") return;
+		if (type === "agent_end" && isContinuingMidRunMaintenanceOutcome(maintenanceOutcome)) return;
 		if (type === "agent_end") {
 			if (current.lifecycleEpoch !== eventLifecycleEpoch) {
 				// A successor agent_start won the lifecycle race while this event's
@@ -4553,29 +4691,22 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 	};
 	api.on("agent_start", (event, ctx) => {
 		const owner = lifecycleStateForEvent(ctx, "agent_start", event.sdkRunToken);
-		return trackLifecycle(async () => {
-			await emitLifecycle(
-				"agent_start",
-				ctx,
-				undefined,
-				undefined,
-				owner ? { state: owner, sessionId: owner.sessionId } : undefined,
-			);
-			if (owner && typeof event.sdkRunToken === "string" && event.sdkRunToken.length > 0) {
-				const batch = owner.openLifecycleBatches.at(-1);
-				const entry = batch?.invocations.find(item => item.sdkRunToken === event.sdkRunToken);
-				const previous = lifecycleRunOwners.get(event.sdkRunToken);
-				lifecycleRunOwners.set(event.sdkRunToken, {
-					state: owner,
-					batch,
-					...(previous?.correlationKey !== undefined
-						? { correlationKey: previous.correlationKey }
-						: entry
-							? { correlationKey: lifecycleCorrelationKey(entry.correlation) }
-							: {}),
-				});
-			}
-		}, owner);
+		return trackLifecycle(
+			async () =>
+				emitLifecycle(
+					"agent_start",
+					ctx,
+					undefined,
+					undefined,
+					owner ? { state: owner, sessionId: owner.sessionId } : undefined,
+					undefined,
+					false,
+					undefined,
+					undefined,
+					typeof event.sdkRunToken === "string" ? event.sdkRunToken : undefined,
+				),
+			owner,
+		);
 	});
 	api.on("agent_end", (event, ctx) => {
 		const tokenBinding =
@@ -4608,11 +4739,20 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		const failureAlreadyPublished = failure === undefined || (hasExistingFailure && genericFailureKeys.length === 0);
 		const terminalEvidence = promptTerminalEvidenceFromAgentEnd(event);
 		const terminalOutcome =
-			event.stopReason === "cancelled"
-				? ({ kind: "stopped", reason: "cancelled", provenance: "client_cancel" } as const)
-				: failure === undefined
-					? undefined
-					: canonicalFailedOutcome(failure);
+			event.stopReason === "cancelled" ||
+			(event.stopReason === "maintenance" && event.maintenanceOutcome === "aborted")
+				? terminalStoppedOutcome(
+						event.stopReason,
+						event.stopReason === "maintenance" ? event.maintenanceOutcome : undefined,
+					)
+				: failure !== undefined
+					? canonicalFailedOutcome(failure)
+					: terminalEvidence.content?.text.trim() || terminalEvidence.hasActivity
+						? terminalStoppedOutcome(
+								event.stopReason,
+								event.stopReason === "maintenance" ? event.maintenanceOutcome : undefined,
+							)
+						: canonicalFailedOutcome(EMPTY_PROMPT_FAILURE);
 		return trackLifecycle(async () => {
 			if (failure && !failureAlreadyPublished) {
 				for (const key of genericFailureKeys) owner?.failureDiagnosticKeys.delete(key);
@@ -4627,6 +4767,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 				terminalEvidence.content,
 				terminalEvidence.hasActivity,
 				terminalOutcome,
+				event.stopReason,
 			);
 		}, owner).finally(() => {
 			if (typeof event.sdkRunToken === "string" && lifecycleRunOwners.get(event.sdkRunToken)?.state === owner)
@@ -4716,11 +4857,84 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 				current.deadlineManager.onAttributableEvent(invocation.correlation, eventType);
 		}
 	};
-	api.on("tool_execution_start", async (_event, ctx) => {
+	/**
+	 * Stream one turn event to the connections that submitted the running turn.
+	 *
+	 * This is the same frame the notifications runtime sends for an ACP-launched
+	 * session (`{ type: "event", kind, payload: { event_type, event }, ...correlation }`),
+	 * built from the same shared producer, so an ACP client attached to a live
+	 * interactive session renders assistant text and tool calls exactly as it does
+	 * for a session it started itself. Without it an attached client could drive
+	 * the session and see the turn settle but never receive a single word of the
+	 * answer.
+	 *
+	 * Scoped to the owning invocations of the batch that is actually running: a
+	 * turn nobody submitted over the SDK (an ordinary terminal prompt, an
+	 * autonomous continuation, cron, monitor) has no owner connection and streams
+	 * nothing at all, so a session with no attached client pays one map lookup.
+	 */
+	const STREAMED_TURN_EVENT_TYPES: ReadonlySet<string> = new Set([
+		"message_update",
+		"message_end",
+		"tool_execution_start",
+		"tool_execution_update",
+		"tool_execution_end",
+	]);
+	const streamTurnEvent = (event: { type?: unknown } | null | undefined, ctx: ExtensionContext): void => {
+		const current = lifecycleStateForContext(ctx, "agent_start");
+		const activeInvocation = current?.activeInvocation;
+		if (!current) return;
+		const batch = activeInvocation
+			? current.openLifecycleBatches.find(candidate =>
+					candidate.invocations.some(
+						entry =>
+							entry.correlation.commandId === activeInvocation.correlation.commandId &&
+							entry.correlation.turnId === activeInvocation.correlation.turnId,
+					),
+				)
+			: undefined;
+		const invocations = batch
+			? [...batch.invocations, ...batch.attachedInvocations]
+			: current.lifecycleActive
+				? (current.attachedInvocations ?? [])
+				: [];
+		if (invocations.length === 0) return;
+		// The handlers below also renew prompt deadlines, so streaming must never
+		// throw out of them: a frame the wire producer does not recognize is dropped.
+		if (!event || typeof event.type !== "string" || !STREAMED_TURN_EVENT_TYPES.has(event.type)) return;
+		try {
+			const payload = toAgentWireEventPayload(event as AgentSessionEvent);
+			// One frame per owning invocation, each carrying its own correlation, so a
+			// shared run lets every submitter attribute the content to its own prompt.
+			for (const invocation of invocations) {
+				if (invocation.connectionId === undefined) continue;
+				current.runtime.sendFrameTo([invocation.connectionId], {
+					type: "event",
+					kind: event.type,
+					payload,
+					...invocation.correlation,
+				});
+			}
+		} catch {
+			// Streamed content is best-effort; the turn producing it is authoritative.
+		}
+	};
+	api.on("tool_execution_start", async (event, ctx) => {
 		renewAttributableProgress("tool_execution_start", ctx);
+		streamTurnEvent(event, ctx);
+	});
+	api.on("tool_execution_update", async (event, ctx) => {
+		streamTurnEvent(event, ctx);
 	});
-	api.on("tool_execution_end", async (_event, ctx) => {
+	api.on("tool_execution_end", async (event, ctx) => {
 		renewAttributableProgress("tool_execution_end", ctx);
+		streamTurnEvent(event, ctx);
+	});
+	api.on("message_update", async (event, ctx) => {
+		streamTurnEvent(event, ctx);
+	});
+	api.on("message_end", async (event, ctx) => {
+		streamTurnEvent(event, ctx);
 	});
 	const errorCode = (error: unknown): string | undefined =>
 		typeof error === "object" &&
@@ -4784,7 +4998,11 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 				connectionId: string | undefined;
 				sdkRunToken: string;
 			}>;
-			attachedInvocations: Array<{ kind: InvocationKind; correlation: InvocationCorrelation }>;
+			attachedInvocations: Array<{
+				kind: InvocationKind;
+				correlation: InvocationCorrelation;
+				connectionId: string | undefined;
+			}>;
 		}> = [];
 		const configRevision = { current: 0 };
 		let acceptingGateResolutions = true;
@@ -4913,6 +5131,19 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 					// 2. Terminal boundary. The durable error from step 1 makes this
 					// classify as failed, never terminal_ok.
 					await reconciliation.noteTransition(kind, correlation, { type: "agent_end" });
+					const failure = sanitizePromptFailure(Object.assign(new Error(error.message), { code: error.code }));
+					runtime.emitEvent({
+						type: "agent_failed",
+						sessionId,
+						...correlation,
+						error: failure,
+					});
+					runtime.emitEvent({
+						type: "agent_end",
+						sessionId,
+						...correlation,
+						outcome: canonicalFailedOutcome(failure),
+					});
 					// 3. Release recovery ownership ONLY after durable terminalization.
 					deadlineManager.clear(correlation);
 				} catch (transitionError) {
@@ -5065,7 +5296,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 								entry.correlation.turnId === correlation.turnId,
 						)
 					)
-						current.attachedInvocations.push({ kind, correlation });
+						current.attachedInvocations.push({ kind, correlation, connectionId });
 					if (
 						activeBatch &&
 						!activeBatch.attachedInvocations.some(
@@ -5074,7 +5305,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 								entry.correlation.turnId === correlation.turnId,
 						)
 					)
-						activeBatch.attachedInvocations.push({ kind, correlation });
+						activeBatch.attachedInvocations.push({ kind, correlation, connectionId });
 					bindPromotedToken(activeBatch);
 					return;
 				}
@@ -5157,6 +5388,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			() => acceptingGateResolutions,
 			trackGateResolution,
 			options.onInvocationCompletionReconciledForTests,
+			frame => runtime.emitEvent(frame),
 		);
 		const installProviderDefinitions = (capability: string, definitions: unknown): void => {
 			if (capability === "permission") {
@@ -5224,6 +5456,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,