@gajae-code/coding-agent 0.18.11 → 0.19.0

package/src/sdk/bus/reconciliation-store.ts

@@ -670,11 +670,22 @@ export interface ReconciliationStore {
 	delete(): Promise<void>;
 }
 
+export interface ReconciliationStoreInstrumentationEvent {
+	at: number;
+	phase: "enqueued" | "started" | "completed" | "failed";
+	operation?: string;
+	substep?: string;
+	error?: string;
+	/** Detailed information about lock acquisition, promise identity, db state, etc. */
+	detail?: string;
+}
+
 export function createReconciliationStore(options: {
 	sessionFile: string | null | undefined;
 	sessionId: string;
 	fs?: ReconciliationStoreFs;
 	now?: () => number;
+	onInstrumentationForTests?: (event: ReconciliationStoreInstrumentationEvent) => void;
 }): ReconciliationStore {
 	const fileFs = options.fs ?? nodeFs;
 	const now = options.now ?? Date.now;
@@ -701,20 +712,56 @@ export function createReconciliationStore(options: {
 		const directory = path.dirname(filePath);
 		let temporary: string | undefined;
 		try {
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "mkdir" });
+			} catch {}
 			await fileFs.mkdir(directory, { recursive: true, mode: 0o700 });
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "mkdir" });
+			} catch {}
 			temporary = `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "writeFile" });
+			} catch {}
 			await fileFs.writeFile(temporary, `${JSON.stringify(document)}\n`, { mode: 0o600 });
 			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "writeFile" });
+			} catch {}
+			try {
+				try {
+					options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "open" });
+				} catch {}
 				const handle = await fileFs.open(temporary, "r+");
 				try {
+					options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "open" });
+				} catch {}
+				try {
+					try {
+						options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "sync" });
+					} catch {}
 					await handle.sync();
+					try {
+						options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "sync" });
+					} catch {}
 				} finally {
+					try {
+						options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "close" });
+					} catch {}
 					await handle.close();
+					try {
+						options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "close" });
+					} catch {}
 				}
 			} catch {
 				// fsync optional on some fs seams
 			}
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "rename" });
+			} catch {}
 			await fileFs.rename(temporary, filePath);
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "rename" });
+			} catch {}
 		} catch (error) {
 			// Every persistence-path failure (mkdir included) is evidence a drained
 			// window must surface, never silently treat as quiescent (#4743).
@@ -723,6 +770,9 @@ export function createReconciliationStore(options: {
 				code: "reconciliation_persist_failed",
 			});
 			unreportedPersistFailures.push(coded);
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "failed", error: coded.message });
+			} catch {}
 			throw coded;
 		}
 	};
@@ -795,7 +845,26 @@ export function createReconciliationStore(options: {
 	const transact = async (
 		mutator: (records: DurableReconciliationRecord[]) => DurableReconciliationRecord[],
 	): Promise<void> => {
+		const promiseId = `reconcil-transact-${randomUUID().slice(0, 8)}`;
+		const enqueueTime = Date.now();
 		const run = async () => {
+			const lockWaitMs = Date.now() - enqueueTime;
+			try {
+				options.onInstrumentationForTests?.({
+					at: enqueueTime,
+					phase: "enqueued",
+					operation: "transact",
+					detail: `promise=${promiseId}`,
+				});
+			} catch {}
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "started",
+					operation: "transact",
+					detail: `promise=${promiseId} lock-wait=${lockWaitMs}ms`,
+				});
+			} catch {}
 			const next = mutator(memory.map(r => ({ ...r })));
 			await writeAtomic({
 				version: RECONCILIATION_STORE_VERSION,
@@ -805,19 +874,55 @@ export function createReconciliationStore(options: {
 				...(terminalKeyMemory.length > 0 ? { evictedTerminalKeys: terminalKeyMemory } : {}),
 			});
 			memory = next;
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "completed",
+					operation: "transact",
+					detail: `promise=${promiseId}`,
+				});
+			} catch {}
 		};
 		const pending = chain.then(run, run);
-		chain = pending.then(
+		const settled = pending.then(
 			() => undefined,
 			() => undefined,
 		);
-		await pending;
+		chain = settled;
+		try {
+			await pending;
+		} catch (error) {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "failed",
+					operation: "transact",
+					detail: `promise=${promiseId} lock-wait=${Date.now() - enqueueTime}ms`,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			} catch {}
+			throw error;
+		}
 	};
 
 	const transactTerminalScopes = async (
 		mutator: (scopes: DurableTerminalScopeRecord[]) => DurableTerminalScopeRecord[],
 	): Promise<void> => {
 		const run = async () => {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "enqueued",
+					operation: "transactTerminalScopes",
+				});
+			} catch {}
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "started",
+					operation: "transactTerminalScopes",
+				});
+			} catch {}
 			const next = mutator(terminalMemory.map(s => ({ ...s })));
 			await writeAtomic({
 				version: RECONCILIATION_STORE_VERSION,
@@ -827,13 +932,33 @@ export function createReconciliationStore(options: {
 				...(terminalKeyMemory.length > 0 ? { evictedTerminalKeys: terminalKeyMemory } : {}),
 			});
 			terminalMemory = next;
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "completed",
+					operation: "transactTerminalScopes",
+				});
+			} catch {}
 		};
 		const pending = chain.then(run, run);
-		chain = pending.then(
+		const settled = pending.then(
 			() => undefined,
 			() => undefined,
 		);
-		await pending;
+		chain = settled;
+		try {
+			await pending;
+		} catch (error) {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "failed",
+					operation: "transactTerminalScopes",
+					error: error instanceof Error ? error.message : String(error),
+				});
+			} catch {}
+			throw error;
+		}
 	};
 
 	const transactTerminalState = async (
@@ -843,6 +968,20 @@ export function createReconciliationStore(options: {
 		},
 	): Promise<void> => {
 		const run = async () => {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "enqueued",
+					operation: "transactTerminalState",
+				});
+			} catch {}
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "started",
+					operation: "transactTerminalState",
+				});
+			} catch {}
 			const next = mutator({
 				scopes: terminalMemory.map(s => ({ ...s })),
 				keys: terminalKeyMemory.map(k => ({ ...k })),
@@ -856,19 +995,53 @@ export function createReconciliationStore(options: {
 			});
 			terminalMemory = next.scopes;
 			terminalKeyMemory = next.keys;
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "completed",
+					operation: "transactTerminalState",
+				});
+			} catch {}
 		};
 		const pending = chain.then(run, run);
-		chain = pending.then(
+		const settled = pending.then(
 			() => undefined,
 			() => undefined,
 		);
-		await pending;
+		chain = settled;
+		try {
+			await pending;
+		} catch (error) {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "failed",
+					operation: "transactTerminalState",
+					error: error instanceof Error ? error.message : String(error),
+				});
+			} catch {}
+			throw error;
+		}
 	};
 
 	const transactTerminalKeys = async (
 		mutator: (keys: EvictedTerminalKeyEntry[]) => EvictedTerminalKeyEntry[],
 	): Promise<void> => {
 		const run = async () => {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "enqueued",
+					operation: "transactTerminalKeys",
+				});
+			} catch {}
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "started",
+					operation: "transactTerminalKeys",
+				});
+			} catch {}
 			const next = mutator(terminalKeyMemory.map(k => ({ ...k })));
 			await writeAtomic({
 				version: RECONCILIATION_STORE_VERSION,
@@ -878,13 +1051,33 @@ export function createReconciliationStore(options: {
 				...(next.length > 0 ? { evictedTerminalKeys: next } : {}),
 			});
 			terminalKeyMemory = next;
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "completed",
+					operation: "transactTerminalKeys",
+				});
+			} catch {}
 		};
 		const pending = chain.then(run, run);
-		chain = pending.then(
+		const settled = pending.then(
 			() => undefined,
 			() => undefined,
 		);
-		await pending;
+		chain = settled;
+		try {
+			await pending;
+		} catch (error) {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "failed",
+					operation: "transactTerminalKeys",
+					error: error instanceof Error ? error.message : String(error),
+				});
+			} catch {}
+			throw error;
+		}
 	};
 
 	const deleteStore = async (): Promise<void> => {

package/src/sdk/bus/session-control.ts

@@ -1,3 +1,4 @@
+import { setSessionOutboundRedact } from "../host/events";
 import {
 	type GenericNotificationSessionSource,
 	getCurrentTelegramActivationMarker,
@@ -480,6 +481,7 @@ export class NotificationSessionController {
 		policy: Omit<NotificationRuntimePolicy, "mode">,
 		mode: NotificationRuntimePolicy["mode"],
 	): void {
+		setSessionOutboundRedact(binding.sessionId, policy.redact);
 		runtime?.refreshPolicy?.(binding, { ...policy, mode });
 	}
 

package/src/sdk/bus/slack-daemon.ts

@@ -58,6 +58,7 @@ function slackPublicationClientMsgId(publicationId: string): string {
 
 // Durable filesystem publication leases must outlast one event-loop and persistence turn.
 const MIN_PUBLICATION_LEASE_MS = 100;
+const ROOT_PUBLICATION_POLL_MS = 50;
 const INBOUND_REACTION_DEADLINE_MS = 5_000;
 const RETIREMENT_DRAIN_MS = 5_000;
 const INBOUND_REACTION = "eyes";
@@ -800,6 +801,7 @@ export class SlackNotificationDaemon {
 		endpointGeneration?: number,
 		requestedClientMsgId?: string,
 	): Promise<SlackRootPublication> {
+		const lifecycleGeneration = this.#lifecycleGeneration;
 		const endpoint = await this.#resolveAttachment(sessionId);
 		if (!endpoint || (endpointGeneration !== undefined && endpoint.generation !== endpointGeneration))
 			throw new SlackEndpointBindingError("Slack root publication requires the current session endpoint.");
@@ -816,7 +818,14 @@ export class SlackNotificationDaemon {
 			)
 				return current;
 			if (current?.state === "posting_root") {
-				if (current.rootPublicationOwner === this.#publicationOwnerId) return current;
+				// A live lease of our own belongs to an in-flight post; an expired one is
+				// reclaimed under a new fence exactly like a crashed peer's, otherwise the
+				// root waiter would re-enter postRoot forever.
+				if (
+					current.rootPublicationOwner === this.#publicationOwnerId &&
+					!this.#leaseExpired(current.rootPublicationLeaseExpiresAt, now)
+				)
+					return current;
 				claimed = true;
 				return nextRecord(current, {
 					rootPublicationOwner: this.#publicationOwnerId,
@@ -859,7 +868,17 @@ export class SlackNotificationDaemon {
 		}
 		if (!pending?.clientMsgId) throw new Error("Unable to persist Slack root post intent");
 		if (!claimed)
-			return { conversation: await this.#waitForRoot(pendingKey, sessionId, body, generation), created: false };
+			return {
+				conversation: await this.#waitForRoot(
+					pendingKey,
+					sessionId,
+					body,
+					generation,
+					lifecycleGeneration,
+					endpoint.authorityId,
+				),
+				created: false,
+			};
 		if (pending.endpointGeneration !== generation) throw new SlackEndpointBindingError();
 		const clientMsgId = pending.clientMsgId;
 		const fence = pending.rootPublicationFence;
@@ -907,7 +926,7 @@ export class SlackNotificationDaemon {
 		// dispatch; resume performs any required replacement after reconciliation.
 		const active = await this.store.transact(pendingKey, current => {
 			if (
-				!current ||
+				current?.state !== "posting_root" ||
 				current.clientMsgId !== clientMsgId ||
 				current.rootPublicationOwner !== this.#publicationOwnerId ||
 				current.rootPublicationFence !== fence
@@ -926,7 +945,17 @@ export class SlackNotificationDaemon {
 		});
 		if (!active) throw new Error("Slack root mapping disappeared");
 		if (active.state !== "active")
-			return { conversation: await this.#waitForRoot(pendingKey, sessionId, body, generation), created: false };
+			return {
+				conversation: await this.#waitForRoot(
+					pendingKey,
+					sessionId,
+					body,
+					generation,
+					lifecycleGeneration,
+					endpoint.authorityId,
+				),
+				created: false,
+			};
 		return { conversation: active, created: createdRootEffect };
 	}
 
@@ -1267,8 +1296,12 @@ export class SlackNotificationDaemon {
 				)
 					return record;
 				inboundDispatches = [...(record.inboundDispatches ?? [])];
+				// Fence the publisher before an abort-ignoring provider can renew or reactivate this mapping.
 				return nextRecord(record, {
 					state: "closed_marker",
+					rootPublicationOwner: undefined,
+					rootPublicationLeaseExpiresAt: undefined,
+					rootPublicationFence: (record.rootPublicationFence ?? 0) + 1,
 					pendingActionId: undefined,
 					cleanupEffectId: undefined,
 					inboundDispatches: [],
@@ -3105,7 +3138,7 @@ export class SlackNotificationDaemon {
 			let renewed = false;
 			await this.store.transact(key, current => {
 				if (
-					!current ||
+					current?.state !== "posting_root" ||
 					current.clientMsgId !== clientMsgId ||
 					current.rootPublicationOwner !== this.#publicationOwnerId ||
 					current.rootPublicationFence !== fence
@@ -3269,18 +3302,82 @@ export class SlackNotificationDaemon {
 		sessionId: string,
 		body: string,
 		endpointGeneration: number,
+		lifecycleGeneration: number,
+		attachmentAuthorityId?: string,
 	): Promise<SlackConversation> {
-		for (let attempt = 0; attempt < 100; attempt++) {
-			await Bun.sleep(10);
+		// Another owner may renew this lease while provider work is active, so wait for the durable transition.
+		while (true) {
+			if (lifecycleGeneration !== this.#lifecycleGeneration)
+				throw new Error("Slack daemon stopped while waiting for root publication");
+			await Bun.sleep(ROOT_PUBLICATION_POLL_MS);
+			if (lifecycleGeneration !== this.#lifecycleGeneration)
+				throw new Error("Slack daemon stopped while waiting for root publication");
 			const current = await this.store.read(key);
+			if (lifecycleGeneration !== this.#lifecycleGeneration)
+				throw new Error("Slack daemon stopped while waiting for root publication");
 			if (current?.state === "active") {
 				const currentGeneration = this.#requireEndpointGeneration(current);
-				if (currentGeneration === endpointGeneration) return current;
+				if (currentGeneration === endpointGeneration) {
+					const endpoint = await this.#resolveAttachment(sessionId);
+					if (lifecycleGeneration !== this.#lifecycleGeneration)
+						throw new Error("Slack daemon stopped while waiting for root publication");
+					if (
+						!endpoint?.isCurrent() ||
+						endpoint.sessionId !== sessionId ||
+						endpoint.generation !== endpointGeneration ||
+						endpoint.authorityId !== attachmentAuthorityId ||
+						current.attachmentAuthorityId !== attachmentAuthorityId
+					)
+						throw new SlackEndpointBindingError("Slack root publication was retired before completion.");
+					return current;
+				}
 				if (currentGeneration > endpointGeneration)
 					throw new SlackEndpointBindingError("Slack root belongs to a newer endpoint generation.");
 				return await this.resume(sessionId, body, endpointGeneration);
 			}
+			if (current?.state === "closed_marker") {
+				const currentGeneration = this.#requireEndpointGeneration(current);
+				if (currentGeneration > endpointGeneration)
+					throw new SlackEndpointBindingError("Slack root belongs to a newer endpoint generation.");
+				const endpoint = await this.#resolveAttachment(sessionId);
+				if (lifecycleGeneration !== this.#lifecycleGeneration)
+					throw new Error("Slack daemon stopped while waiting for root publication");
+				if (
+					!endpoint?.isCurrent() ||
+					endpoint.sessionId !== sessionId ||
+					endpoint.generation !== endpointGeneration ||
+					endpoint.authorityId !== attachmentAuthorityId
+				)
+					throw new SlackEndpointBindingError("Slack root publication was retired before completion.");
+				if (currentGeneration === endpointGeneration) {
+					if (!current.rootTs)
+						throw new SlackEndpointBindingError("Slack root publication was retired before completion.");
+					if (
+						current.rootPublicationOwner !== undefined &&
+						!this.#leaseExpired(current.rootPublicationLeaseExpiresAt, this.#now())
+					)
+						continue;
+					return await this.postRoot(sessionId, body, endpointGeneration);
+				}
+				if (
+					current.rootPublicationOwner !== undefined &&
+					!this.#leaseExpired(current.rootPublicationLeaseExpiresAt, this.#now())
+				)
+					continue;
+				return await this.resume(sessionId, body, endpointGeneration);
+			}
+			if (current?.state === "resumed_root") {
+				const currentGeneration = this.#requireEndpointGeneration(current);
+				if (currentGeneration > endpointGeneration)
+					throw new SlackEndpointBindingError("Slack root belongs to a newer endpoint generation.");
+				if (
+					current.rootPublicationOwner === undefined ||
+					this.#leaseExpired(current.rootPublicationLeaseExpiresAt, this.#now())
+				)
+					return await this.resume(sessionId, body, endpointGeneration);
+			}
 			if (
+				current === undefined ||
 				current?.state === "error" ||
 				(current?.state === "posting_root" &&
 					this.#leaseExpired(current.rootPublicationLeaseExpiresAt, this.#now())) ||
@@ -3291,7 +3388,6 @@ export class SlackNotificationDaemon {
 				return await this.postRoot(sessionId, body, endpointGeneration);
 			}
 		}
-		throw new Error("Slack root post is still pending");
 	}
 
 	async #waitForAction(key: string, sessionId: string, body: string, actionId: string): Promise<SlackConversation> {

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -301,8 +301,16 @@ export const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * Generation 202 joins queued-removal terminal publication before ordinary
  * abort acknowledgement, replacing owners that still acknowledge cancellation
  * before its terminal record is durable.
+ * Generation 203 replaces owners that still treat a project `.gjc` file as an
+ * explicit deadline-autosave opt-in for a primary checkout.
+ * Generation 205 replaces owners whose process descendant walk can adopt
+ * children of a recycled PID. Generation 206 verifies macOS descendant
+ * identities and parentage before retaining PTY termination authority, and
+ * reaps adopted Linux PTY descendants when GJC is a child reaper.
+ * Generation 209 installs connection-owned private SDK image staging with
+ * execution-owned reservations, replacing hosts without that lifecycle contract.
  */
-export const DAEMON_GENERATION = 202;
+export const DAEMON_GENERATION = 209;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7

package/src/sdk/bus/telegram-daemon.ts

@@ -302,6 +302,8 @@ export const ASK_SELECTED_ACK_CAPABILITY = "ask_selected_ack_v1";
 export const ASK_CONTROLS_CAPABILITY = "ask_controls_v1";
 /** Capability for the closed tool phase set: started, completed, failed, and cancelled. */
 export const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v2";
+/** Receive content-free notifications when a running command needs host-side authentication. */
+export const AWAITING_INPUT_CAPABILITY = "awaiting_input_v1";
 /** Receive-only compatibility capability for pre-v2 hosts. */
 export const LEGACY_TOOL_ACTIVITY_CAPABILITY = "tool_activity_v1";
 /** Public `sdk/bus/telegram-daemon` path for the canonical `sdk/host` capability token. */
@@ -5428,6 +5430,7 @@ export class TelegramNotificationDaemon {
 					ASK_CONTROLS_CAPABILITY,
 					ASK_SELECTED_ACK_CAPABILITY,
 					TOOL_ACTIVITY_CAPABILITY,
+					AWAITING_INPUT_CAPABILITY,
 					LEGACY_TOOL_ACTIVITY_CAPABILITY,
 					POSITIONED_NOTIFICATION_EFFECTS_CAPABILITY,
 					"ephemeral_turn_v1",
@@ -7255,6 +7258,7 @@ export class TelegramNotificationDaemon {
 		"config_update",
 		"control_command_result",
 		"tool_activity",
+		"awaiting_input",
 		"reasoning_summary",
 	]);
 
@@ -10874,8 +10878,12 @@ export class TelegramNotificationDaemon {
 				this.failLegacyToolStart(toolActivity);
 				await this.#failPublicationPreSend(publicationId, "topic authority is inactive or malformed");
 			}
+			const flatSend =
+				threadedFrame.type === "awaiting_input"
+					? { ...send, text: `${send.text} · ${sessionTag(logicalSessionId)}` }
+					: send;
 			if (!send.identity && !existingTopic && !this.flatIdentitySent.has(logicalSessionId)) {
-				await this.deliverFlatFallback(logicalSessionId, send, toolActivity, socketLease, publicationId);
+				await this.deliverFlatFallback(logicalSessionId, flatSend, toolActivity, socketLease, publicationId);
 				return;
 			}
 			const topicId =
@@ -10896,7 +10904,7 @@ export class TelegramNotificationDaemon {
 					abandonStaleToolStart();
 					return;
 				}
-				await this.deliverFlatFallback(logicalSessionId, send, toolActivity, socketLease, publicationId);
+				await this.deliverFlatFallback(logicalSessionId, flatSend, toolActivity, socketLease, publicationId);
 				return;
 			}
 			if (send.identity) {

package/src/sdk/bus/threaded-render.ts

@@ -2,7 +2,7 @@
  * Pure rendering of threaded-session frames into Telegram send specs.
  *
  * The daemon receives the additive `ServerMessage` frames (identity_header,
- * context_update, turn_stream, image_attachment, config_update) over the session
+ * context_update, turn_stream, image_attachment, config_update, awaiting_input) over the session
  * WS and must turn each into a Bot API call scoped to the session's forum topic
  * (`message_thread_id`), throttled through the shared rate-limit pool. This
  * module is the pure frame→send mapping (including the priority lane and live-
@@ -80,6 +80,7 @@ interface ThreadedFrame {
 	// tool_activity
 	toolCallId?: unknown;
 	toolName?: unknown;
+	kind?: unknown;
 	argsSummary?: unknown;
 	resultSummary?: unknown;
 	isError?: unknown;
@@ -261,6 +262,24 @@ export function renderThreadedFrame(frame: ThreadedFrame): ThreadedSend | undefi
 				terminal: phase !== "started",
 			};
 		}
+		case "awaiting_input": {
+			const toolCallId = str(frame.toolCallId);
+			if (!toolCallId) return undefined;
+			let text: string;
+			switch (frame.kind) {
+				case "browser_auth":
+					text =
+						"⏳ A running command is waiting for browser sign-in. Finish it on the host; the agent continues when the command does.";
+					break;
+				case "device_code":
+					text =
+						"⏳ A running command is waiting for a device-code sign-in. Finish it on the host; the agent continues when the command does.";
+					break;
+				default:
+					return undefined;
+			}
+			return { method: "sendMessage", lane: "ask", text, coalesceKey: `awaiting:${toolCallId}` };
+		}
 		case "reasoning_summary": {
 			const text = str(frame.text);
 			if (!text) return undefined;

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

@@ -258,17 +258,34 @@ function normalizeSessionFailure(error: unknown, args: SdkSessionCliArgs): Publi
 }
 
 /** Lifecycle terminality/retryability is not, by itself, proof of an effect outcome. */
+/**
+ * Lifecycle codes the broker produces when it refuses the request payload itself. Input shape is
+decided before the request can be dispatched, and an outcome the broker cannot establish comes
+back as `terminal_uncertain` instead, so these codes never stand for an applied operation. They
+still collapse into `operation_failed` below, which cannot say why the request was refused, so
+the refusal class survives as one fixed diagnostic.
+ */
+const LIFECYCLE_INPUT_REFUSAL_CODES = new Set(["invalid_input", "invalid_request"]);
+
 export function lifecyclePublicFailure(outcome: Extract<SessionLifecycleResult, { ok: false }>): PublicCommandFailure {
 	const failure = sdkPublicFailure(outcome.error.code);
 	// The service emits retryable protocol_error only when requestSent is explicitly false.
 	const proof: PublicEffectProof =
 		outcome.certainty === "retryable" && outcome.error.code === "protocol_error" ? "pre-send" : "unknown";
-	// `operation_failed` cannot distinguish a conflict from any other failed operation, so
-	// the conflict survives as one fixed diagnostic. The broker message itself is never
-	// rendered: it may carry request keys, paths, or credentials, and its cause is not
-	// decidable from the code alone.
+	// `operation_failed` cannot distinguish a conflict or an input refusal from any other failed
+	// operation, so each survives as one fixed diagnostic. The broker message itself is never
+	// rendered: it may carry request keys, paths, or credentials, and its cause is not decidable
+	// from the code alone.
+	let diagnostic: PublicCommandDiagnosticCode | undefined;
+	if (outcome.error.code === "idempotency_conflict") {
+		diagnostic = "lifecycle_idempotency_conflict";
+	} else if (outcome.error.code === "legacy_lifecycle_ambiguous") {
+		diagnostic = "lifecycle_legacy_history_ambiguous";
+	} else if (LIFECYCLE_INPUT_REFUSAL_CODES.has(outcome.error.code)) {
+		diagnostic = "lifecycle_input_refused";
+	}
 	const diagnostics: readonly PublicCommandDiagnosticCode[] | undefined =
-		outcome.error.code === "idempotency_conflict" ? ["lifecycle_idempotency_conflict"] : undefined;
+		diagnostic === undefined ? undefined : [diagnostic];
 	return new PublicCommandFailure({
 		...failure.input,
 		...(diagnostics === undefined ? {} : { diagnostics }),
@@ -2209,7 +2226,7 @@ async function runRawControl(
 	input: JsonRecord,
 	args: SdkSessionCliArgs,
 ): Promise<unknown> {
-	const invalid = validateAdapterControl(operation, input);
+	const invalid = validateAdapterControl(operation, input, { allowUltrafastTier: true });
 	if (invalid) throw new SdkSessionCliError(invalid.code, invalid.message, 2);
 	await ensureBroker({ agentDir });
 	const operatorRequest = operatorAbortBrokerRequest(sessionId, operation, input, args);