@sayknow-cli/coding-agent 0.3.11 → 0.3.13

package/src/modes/irc-observation-ledger.ts

@@ -0,0 +1,127 @@
+import * as crypto from "node:crypto";
+
+import type { ParsedIrcMessage } from "./utils/irc-message";
+
+type InlineMode = "persistent" | "ephemeral";
+
+const MAX_RECORDS = 10_000;
+const MAX_RETAINED_UTF8_BYTES = 16 * 1024 * 1024;
+const MAX_SEEN_IDENTITIES = 100_000;
+
+export type IrcObservationRecord = Readonly<
+	ParsedIrcMessage & {
+		mode: InlineMode;
+		observedAt: number;
+		sequence: number;
+		expiresAt?: number;
+		retainedUtf8Bytes: number;
+	}
+>;
+
+function measureRetainedUtf8Bytes(message: ParsedIrcMessage): number {
+	let bytes = 4;
+	for (const value of [message.observationId, message.from, message.to, message.text, message.kind]) {
+		bytes += Buffer.byteLength(value, "utf8");
+		if (bytes > MAX_RETAINED_UTF8_BYTES) return bytes;
+	}
+	return bytes;
+}
+
+function tombstoneIdentity(observationId: string): string {
+	const hash = crypto.createHash("sha256");
+	hash.update("skc:irc:observation-id:utf16le:v1\0");
+	for (let offset = 0; offset < observationId.length; offset += 4_096) {
+		hash.update(Buffer.from(observationId.slice(offset, offset + 4_096), "utf16le"));
+	}
+	return hash.digest("hex");
+}
+
+/** Runtime-only IRC observations. This intentionally has no persistence layer. */
+export class IrcObservationLedger {
+	#records = new Map<string, IrcObservationRecord>();
+	#retainedUtf8Bytes = 0;
+	#nextSequence = 0;
+	#seenObservationIdentities = new Set<string>();
+	#identityCapacityExhausted = false;
+	#evictedObservationIds = new Set<string>();
+
+	#rememberObservationIdentity(observationId: string): boolean {
+		const identity = tombstoneIdentity(observationId);
+		if (this.#seenObservationIdentities.has(identity) || this.#identityCapacityExhausted) return false;
+		if (this.#seenObservationIdentities.size >= MAX_SEEN_IDENTITIES) {
+			this.#identityCapacityExhausted = true;
+			return false;
+		}
+		this.#seenObservationIdentities.add(identity);
+		return true;
+	}
+
+	#evict(observationId: string): void {
+		const record = this.#records.get(observationId);
+		if (!record) return;
+		this.#records.delete(observationId);
+		this.#retainedUtf8Bytes -= record.retainedUtf8Bytes;
+		this.#evictedObservationIds.add(observationId);
+	}
+
+	#enforceBounds(): void {
+		while (this.#records.size > MAX_RECORDS || this.#retainedUtf8Bytes > MAX_RETAINED_UTF8_BYTES) {
+			const oldestObservationId = this.#records.keys().next().value;
+			if (oldestObservationId === undefined) return;
+			this.#evict(oldestObservationId);
+		}
+	}
+
+	/** Inline observations expire after 10 seconds; closed-panel observations persist inline. */
+	observe(message: ParsedIrcMessage, panelVisibleAtObservation: boolean): IrcObservationRecord | undefined {
+		const existing = this.#records.get(message.observationId);
+		if (existing) return existing;
+		if (!this.#rememberObservationIdentity(message.observationId)) return undefined;
+
+		const estimatedBytes = measureRetainedUtf8Bytes(message);
+		if (estimatedBytes > MAX_RETAINED_UTF8_BYTES) return undefined;
+
+		const observedAt = Date.now();
+		const mode: InlineMode = panelVisibleAtObservation ? "ephemeral" : "persistent";
+		const record: IrcObservationRecord = Object.freeze({
+			...message,
+			mode,
+			observedAt,
+			sequence: this.#nextSequence++,
+			...(mode === "ephemeral" ? { expiresAt: observedAt + 10_000 } : {}),
+			retainedUtf8Bytes: estimatedBytes,
+		});
+		this.#records.set(record.observationId, record);
+		this.#retainedUtf8Bytes += estimatedBytes;
+		this.#enforceBounds();
+		return this.#records.get(record.observationId);
+	}
+
+	getRecord(observationId: string): IrcObservationRecord | undefined {
+		return this.#records.get(observationId);
+	}
+
+	getSidebarRecords(): readonly IrcObservationRecord[] {
+		return [...this.#records.values()];
+	}
+
+	getInlineProjection(now: number): readonly IrcObservationRecord[] {
+		return [...this.#records.values()].filter(record => record.mode === "persistent" || now < record.expiresAt!);
+	}
+
+	/** Returns and clears IDs whose retained payload was released. */
+	drainEvictedObservationIds(): readonly string[] {
+		const observationIds = [...this.#evictedObservationIds];
+		this.#evictedObservationIds.clear();
+		return observationIds;
+	}
+
+	reset(): void {
+		for (const observationId of this.#records.keys()) {
+			this.#evictedObservationIds.add(observationId);
+		}
+		this.#records.clear();
+		this.#retainedUtf8Bytes = 0;
+		this.#nextSequence = 0;
+	}
+}

package/src/modes/rpc/rpc-client.ts

@@ -8,7 +8,8 @@ import type { CompactionResult } from "@sayknow-cli/agent-core/compaction";
 import type { ImageContent, Model } from "@sayknow-cli/ai";
 import { isRecord, ptree, readJsonl } from "@sayknow-cli/utils";
 import type { BashResult } from "../../exec/bash-executor";
-import type { SessionStats } from "../../session/agent-session";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+import { AGENT_WIRE_EVENT_TYPES, type AgentWireEventType } from "../shared/agent-wire/event-contract";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
@@ -64,6 +65,7 @@ export interface RpcClientOptions {
 export type ModelInfo = Pick<Model, "provider" | "id" | "contextWindow" | "reasoning" | "thinking">;
 
 export type RpcEventListener = (event: AgentEvent) => void;
+export type RpcSessionEventListener = (event: AgentSessionEvent) => void;
 
 export interface RpcClientToolContext<TDetails = unknown> {
 	toolCallId: string;
@@ -91,7 +93,8 @@ export function defineRpcClientTool<
 	return tool;
 }
 
-const agentEventTypes = new Set<AgentEvent["type"]>([
+const agentWireEventTypes = new Set<AgentWireEventType>(AGENT_WIRE_EVENT_TYPES);
+const coreAgentEventTypes = new Set<AgentEvent["type"]>([
 	"agent_start",
 	"agent_end",
 	"turn_start",
@@ -116,13 +119,16 @@ function isRpcResponse(value: unknown): value is RpcResponse {
 	return true;
 }
 
-function isAgentEvent(value: unknown): value is AgentEvent {
+function isAgentSessionEvent(value: unknown): value is AgentSessionEvent {
 	if (!isRecord(value)) return false;
 	const type = value.type;
 	if (typeof type !== "string") return false;
-	return agentEventTypes.has(type as AgentEvent["type"]);
+	return agentWireEventTypes.has(type as AgentWireEventType);
 }
 
+function isCoreAgentEvent(value: AgentSessionEvent): value is AgentEvent {
+	return coreAgentEventTypes.has(value.type as AgentEvent["type"]);
+}
 function isRpcHostToolCallRequest(value: unknown): value is RpcHostToolCallRequest {
 	if (!isRecord(value)) return false;
 	return (
@@ -378,6 +384,7 @@ export class RpcClient {
 	#transport: RpcTransport | null = null;
 	#transportClosed = false;
 	#eventListeners: RpcEventListener[] = [];
+	#sessionEventListeners: RpcSessionEventListener[] = [];
 	#pendingRequests: Map<string, { resolve: (response: RpcResponse) => void; reject: (error: Error) => void }> =
 		new Map();
 	#customTools: RpcClientCustomTool[] = [];
@@ -442,7 +449,7 @@ export class RpcClient {
 	}
 
 	/**
-	 * Subscribe to agent events.
+	 * Subscribe to the legacy core AgentEvent subset.
 	 */
 	onEvent(listener: RpcEventListener): () => void {
 		this.#eventListeners.push(listener);
@@ -454,6 +461,19 @@ export class RpcClient {
 		};
 	}
 
+	/**
+	 * Subscribe to all renderer-facing agent session events.
+	 */
+	onSessionEvent(listener: RpcSessionEventListener): () => void {
+		this.#sessionEventListeners.push(listener);
+		return () => {
+			const index = this.#sessionEventListeners.indexOf(listener);
+			if (index !== -1) {
+				this.#sessionEventListeners.splice(index, 1);
+			}
+		};
+	}
+
 	/**
 	 * Subscribe to workflow lifecycle gates emitted by RPC mode.
 	 */
@@ -928,8 +948,12 @@ export class RpcClient {
 
 		// Canonical agent-wire event frame: { type:"event", payload:{ event_type, event } }.
 		const event = unwrapAgentWireEventFrame(data);
-		if (!isAgentEvent(event)) return;
+		if (!isAgentSessionEvent(event)) return;
 
+		for (const listener of this.#sessionEventListeners) {
+			listener(event);
+		}
+		if (!isCoreAgentEvent(event)) return;
 		for (const listener of this.#eventListeners) {
 			listener(event);
 		}

package/src/modes/shared/agent-wire/deep-interview-gate.ts

@@ -44,6 +44,8 @@ export interface AskGateQuestion {
 	deepInterview?: AskGateDeepInterviewState;
 	/** Override the emitted workflow gate address for non-deep-interview ask prompts. */
 	workflowGate?: AskGateWorkflowGateMeta;
+	allowEmpty?: boolean;
+	navigationLabel?: "Next" | "Done";
 }
 
 export interface AskGateResult {
@@ -119,7 +121,7 @@ function questionAnswerSchema(question: AskGateQuestion, labels: string[]): RpcJ
 	const selectedBase: RpcJsonSchema = { type: "array", items: selectedItems, uniqueItems: true };
 	const selectedOnly: RpcJsonSchema = {
 		...selectedBase,
-		minItems: 1,
+		minItems: question.allowEmpty ? 0 : 1,
 		...(multi ? {} : { maxItems: 1 }),
 	};
 	const selectedWithOther: RpcJsonSchema = {
@@ -216,6 +218,8 @@ export function questionToGate(question: AskGateQuestion): OpenGateInput {
 				options: labels,
 				other_option: GATE_OTHER_OPTION,
 				clarification_action: "clarify",
+				allow_empty: question.allowEmpty === true,
+				navigation_label: question.navigationLabel,
 				...(question.deepInterview
 					? structuredDeepInterviewState(question.deepInterview)
 					: deepInterviewQuestionState(question.question)),
@@ -280,12 +284,21 @@ export function gateAnswerToResult(question: AskGateQuestion, answer: unknown):
 	}
 	const other = answer.other === true;
 	const totalPicks = deduped.length + (other ? 1 : 0);
-	if (totalPicks === 0) {
+	if (totalPicks === 0 && !question.allowEmpty) {
 		throw new DeepInterviewGateError(
 			"empty_selection",
 			"at least one option (or the free-text other) must be selected",
 		);
 	}
+	if (totalPicks === 0) {
+		return {
+			id: question.id,
+			question: question.question,
+			options: labels,
+			multi,
+			selectedOptions: [],
+		};
+	}
 	if (!multi && totalPicks > 1) {
 		throw new DeepInterviewGateError("multi_not_allowed", "this question accepts a single selection");
 	}
@@ -302,6 +315,36 @@ export function gateAnswerToResult(question: AskGateQuestion, answer: unknown):
 	};
 }
 
+/**
+ * Classify an accepted ask-domain gate answer independently of its transport.
+ * Schema-invalid and semantically invalid answers throw, so callers leave the
+ * durable gate pending rather than treating them as a non-committing answer.
+ */
+export function classifyAskGateDisposition(
+	gate: Pick<OpenGateInput, "context" | "options">,
+	answer: unknown,
+): "commit" | "resolve_without_commit" {
+	const state = gate.context?.stage_state;
+	if (typeof state !== "object" || state === null) return "commit";
+	const questionId = (state as Record<string, unknown>).question_id;
+	if (typeof questionId !== "string") return "commit";
+	const question: AskGateQuestion = {
+		id: questionId,
+		question: typeof gate.context?.prompt === "string" ? gate.context.prompt : questionId,
+		options: (gate.options ?? []).map(option => ({
+			label: typeof option.value === "string" ? option.value : option.label,
+		})),
+		multi: (state as Record<string, unknown>).multi === true,
+		allowEmpty: (state as Record<string, unknown>).allow_empty === true,
+	};
+	if (typeof answer === "object" && answer !== null && (answer as Record<string, unknown>).action === "clarify") {
+		gateAnswerToResult(question, answer);
+		return "resolve_without_commit";
+	}
+	const result = gateAnswerToResult(question, answer);
+	return result.selectedOptions.length === 0 && result.customInput === undefined ? "resolve_without_commit" : "commit";
+}
+
 /** Convenience: map a batch of ask questions to gate open-inputs. */
 export function questionsToGates(questions: AskGateQuestion[]): OpenGateInput[] {
 	return questions.map(questionToGate);

package/src/modes/shared/agent-wire/unattended-session.ts

@@ -15,6 +15,7 @@
  * RPC server can route `negotiate_unattended` + `workflow_gate_response` here.
  */
 import type { Model } from "@sayknow-cli/ai";
+import type { AskSelectedAckOutcome } from "../../../tools";
 import type {
 	RpcCommand,
 	RpcUnattendedAccepted,
@@ -30,7 +31,53 @@ import {
 	type UnattendedAuditEvent,
 	UnattendedRunController,
 } from "./unattended-run-controller";
-import { type GateStore, MemoryGateStore, type OpenGateInput, WorkflowGateBroker } from "./workflow-gate-broker";
+import {
+	type GateStore,
+	MemoryGateStore,
+	type OpenGateInput,
+	type PersistedAckPolicy,
+	type PersistedGate,
+	type PersistedSemanticDisposition,
+	WorkflowGateBroker,
+} from "./workflow-gate-broker";
+
+export interface WorkflowGateTerminalController {
+	completeGateInteractions(gateId: string): void | Promise<void>;
+	cancelGateInteractions(gateId: string, reason: string): void | Promise<void>;
+}
+
+export interface WorkflowGateTerminalEvent {
+	gateId: string;
+	kind: "accepted" | "cancelled";
+	origin?: "rpc" | "bridge" | "other" | "telegram_notification";
+	reason?: string;
+}
+
+export interface NotificationGateResolutionOptions {
+	interactionActionId: string;
+	replyReceiptId: string;
+	answerJson: string;
+	idempotencyKey?: string;
+	requestSelectedAck(input: {
+		replyReceiptId: string;
+		actionId: string;
+		commitKey: string;
+		daemonDeadlineAt: number;
+		hostTimeoutMs: number;
+	}): Promise<AskSelectedAckOutcome>;
+	resolveClaim(): void;
+	closeClaimInvalid(reason: string): void;
+}
+
+export interface AskSelectedAckRecoveryParticipant {
+	requestRecoveredAskSelectedAck(input: {
+		sessionId: string;
+		actionId: string;
+		commitKey: string;
+		deadlineAt: number;
+		hostTimeoutMs: number;
+	}): Promise<AskSelectedAckOutcome>;
+}
 
 /**
  * RPC commands that perform agent/tool work and therefore consume one unit of the
@@ -66,7 +113,13 @@ export interface WorkflowGateEmitter {
 	 */
 	onGateEmitted?(listener: (gate: RpcWorkflowGate) => void): () => void;
 	resolveGate?(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+	resolveGateFromNotification?(
+		response: RpcWorkflowGateResponse,
+		options: NotificationGateResolutionOptions,
+	): Promise<RpcWorkflowGateResolution>;
+	registerGateTerminalController?(controller: WorkflowGateTerminalController): () => void;
 	listPendingGates?(): RpcWorkflowGate[];
+	setAckRecoveryParticipant?(participant: AskSelectedAckRecoveryParticipant | null): void;
 }
 
 export interface UnattendedSessionOptions {
@@ -91,6 +144,12 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 	readonly #pending = new Map<string, { resolve: (answer: unknown) => void; reject: (err: Error) => void }>();
 	readonly #earlyAnswers = new Map<string, unknown>();
 	readonly #gateListeners = new Set<(gate: RpcWorkflowGate) => void>();
+	#terminalController: WorkflowGateTerminalController | undefined;
+	#brokerReady = false;
+	#recoveryPromise: Promise<void> | undefined;
+	#disposed = false;
+	#recoveryParticipant: AskSelectedAckRecoveryParticipant | undefined;
+	#participantReady = Promise.withResolvers<void>();
 
 	constructor(private readonly opts: UnattendedSessionOptions) {}
 
@@ -108,6 +167,38 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 		return this.#controller;
 	}
 
+	registerGateTerminalController(controller: WorkflowGateTerminalController): () => void {
+		if (this.#terminalController && this.#terminalController !== controller) {
+			throw new Error("a workflow gate terminal controller is already registered");
+		}
+		this.#terminalController = controller;
+		return () => {
+			if (this.#terminalController === controller) this.#terminalController = undefined;
+		};
+	}
+
+	setAckRecoveryParticipant(participant: AskSelectedAckRecoveryParticipant | null): void {
+		this.#recoveryParticipant = participant ?? undefined;
+		if (participant) this.#participantReady.resolve();
+		void this.startRecoveryOnce();
+	}
+
+	async #completeGateInteractions(gateId: string): Promise<void> {
+		try {
+			await this.#terminalController?.completeGateInteractions(gateId);
+		} catch (error) {
+			this.opts.audit?.({ event: "gate_interaction_completion_failed", gate_id: gateId, error: String(error) });
+		}
+	}
+
+	async #cancelGateInteractions(gateId: string, reason: string): Promise<void> {
+		try {
+			await this.#terminalController?.cancelGateInteractions(gateId, reason);
+		} catch (error) {
+			this.opts.audit?.({ event: "gate_interaction_cancellation_failed", gate_id: gateId, error: String(error) });
+		}
+	}
+
 	negotiate(declaration: RpcUnattendedDeclaration): RpcUnattendedAccepted {
 		const controller = UnattendedRunController.negotiate(declaration, {
 			runId: this.opts.runId,
@@ -140,7 +231,11 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 				// openGate returns and the caller starts awaiting.
 				this.#earlyAnswers.set(gate.gate_id, answer);
 			},
+			finalizeAccepted: record => this.#finalizeAcceptedGate(record),
 		});
+		this.#brokerReady = true;
+		void this.startRecoveryOnce();
+
 		return {
 			run_id: this.opts.runId,
 			actor: controller.actor,
@@ -190,12 +285,203 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 	}
 
 	resolveGate(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution> {
+		if (this.#disposed) return Promise.reject(new Error("unattended session is disposed"));
 		if (!this.#broker) {
 			return Promise.reject(new Error("workflow gates are not available until unattended mode is negotiated"));
 		}
 		return this.#broker.resolve(response);
 	}
 
+	async resolveGateFromNotification(
+		response: RpcWorkflowGateResponse,
+		options: NotificationGateResolutionOptions,
+	): Promise<RpcWorkflowGateResolution> {
+		let claimSettled = false;
+		const resolveClaim = () => {
+			if (claimSettled) return;
+			claimSettled = true;
+			try {
+				options.resolveClaim();
+			} catch (error) {
+				this.opts.audit?.({
+					event: "notification_claim_resolution_failed",
+					gate_id: response.gate_id,
+					error: String(error),
+				});
+			}
+		};
+		const closeClaimInvalid = (reason: string) => {
+			if (claimSettled) return;
+			claimSettled = true;
+			try {
+				options.closeClaimInvalid(reason);
+			} catch (error) {
+				this.opts.audit?.({
+					event: "notification_claim_close_failed",
+					gate_id: response.gate_id,
+					error: String(error),
+				});
+			}
+		};
+		if (this.#disposed) {
+			closeClaimInvalid("unattended_session_disposed");
+			throw new Error("unattended session is disposed");
+		}
+		if (!this.#broker) {
+			closeClaimInvalid("workflow_gate_unavailable");
+			throw new Error("workflow gates are not available until unattended mode is negotiated");
+		}
+		try {
+			JSON.parse(options.answerJson);
+		} catch {
+			closeClaimInvalid("invalid_structured_answer");
+			return {
+				gate_id: response.gate_id,
+				status: "rejected",
+				answer_hash: "",
+				resolved_at: new Date().toISOString(),
+				error: this.#broker.validationError(response.gate_id, "json_parse", "invalid structured answer"),
+			};
+		}
+		let disposition: PersistedSemanticDisposition;
+		try {
+			disposition = this.#broker.classifyDisposition(response.gate_id, response.answer);
+		} catch (error) {
+			closeClaimInvalid(error instanceof Error ? error.message : "invalid_answer");
+			return {
+				gate_id: response.gate_id,
+				status: "rejected",
+				answer_hash: "",
+				resolved_at: new Date().toISOString(),
+				error: this.#broker.validationError(
+					response.gate_id,
+					"semantic_disposition",
+					error instanceof Error ? error.message : "invalid answer",
+				),
+			};
+		}
+
+		const commitKey = `${response.gate_id}:${options.idempotencyKey ?? options.replyReceiptId}`;
+		const ackPolicy: PersistedAckPolicy =
+			disposition === "commit"
+				? {
+						kind: "telegram_selected_v1",
+						commitKey,
+						actionId: options.interactionActionId,
+						state: "pending",
+						updatedAt: new Date().toISOString(),
+					}
+				: { kind: "none", reason: "semantic_noncommit" };
+		let resolution: RpcWorkflowGateResolution;
+		try {
+			resolution = await this.#broker.resolve(response, {
+				resolutionOrigin: { kind: "telegram_notification", interactionActionId: options.interactionActionId },
+				ackPolicy,
+				semanticDisposition: disposition,
+
+				beforeAdvance: async () => {
+					if (ackPolicy.kind === "telegram_selected_v1") {
+						this.#broker?.updateAckPolicy(response.gate_id, {
+							...ackPolicy,
+							state: "attempt_started",
+							updatedAt: new Date().toISOString(),
+						});
+						let outcome: AskSelectedAckOutcome;
+						try {
+							outcome = await options.requestSelectedAck({
+								replyReceiptId: options.replyReceiptId,
+								actionId: options.interactionActionId,
+								commitKey,
+								daemonDeadlineAt: Date.now() + 8_000,
+								hostTimeoutMs: 10_000,
+							});
+						} catch {
+							outcome = { status: "unknown", reason: "host_timeout" };
+						}
+						this.#broker?.updateAckPolicy(response.gate_id, {
+							...ackPolicy,
+							state: outcome.status,
+							outcome,
+							updatedAt: new Date().toISOString(),
+						});
+					}
+					resolveClaim();
+				},
+			});
+		} catch (error) {
+			closeClaimInvalid(error instanceof Error ? error.message : "invalid_answer");
+			throw error;
+		}
+		if (resolution.status === "accepted") resolveClaim();
+		else closeClaimInvalid(resolution.error?.code ?? "invalid_answer");
+		return resolution;
+	}
+
+	async startRecoveryOnce(options: { participantGraceMs?: number } = {}): Promise<void> {
+		if (this.#disposed || !this.#brokerReady) return;
+		if (this.#recoveryPromise) return this.#recoveryPromise;
+		this.#recoveryPromise = (async () => {
+			if (!this.#recoveryParticipant) {
+				const grace = options.participantGraceMs ?? 2_000;
+				await Promise.race([
+					this.#participantReady.promise,
+					new Promise<void>(resolve => setTimeout(resolve, grace)),
+				]);
+			}
+			if (!this.#disposed) await this.#broker?.recover();
+		})();
+		return this.#recoveryPromise;
+	}
+
+	async #finalizeAcceptedGate(record: PersistedGate): Promise<void> {
+		const policy = record.ackPolicy;
+		if (policy?.kind === "telegram_selected_v1" && policy.state === "pending") {
+			let outcome: AskSelectedAckOutcome;
+			const participant = this.#recoveryParticipant;
+			if (!participant || !this.opts.sessionId) {
+				outcome = { status: "failed", reason: "no_participant" };
+			} else {
+				this.#broker?.updateAckPolicy(record.gate.gate_id, {
+					...policy,
+					state: "attempt_started",
+					updatedAt: new Date().toISOString(),
+				});
+				try {
+					outcome = await participant.requestRecoveredAskSelectedAck({
+						sessionId: this.opts.sessionId,
+						actionId: policy.actionId,
+						commitKey: policy.commitKey,
+						deadlineAt: Date.now() + 8_000,
+						hostTimeoutMs: 10_000,
+					});
+				} catch {
+					outcome = { status: "unknown", reason: "host_timeout" };
+				}
+			}
+			this.#broker?.updateAckPolicy(record.gate.gate_id, {
+				...policy,
+				state: outcome.status,
+				outcome,
+				updatedAt: new Date().toISOString(),
+			});
+		}
+		if (policy?.kind === "telegram_selected_v1" && policy.state === "attempt_started") {
+			this.#broker?.updateAckPolicy(record.gate.gate_id, {
+				...policy,
+				state: "unknown",
+				outcome: { status: "unknown", reason: "shutdown" },
+				updatedAt: new Date().toISOString(),
+			});
+		}
+		await this.#completeGateInteractions(record.gate.gate_id);
+	}
+
+	dispose(reason = "session_shutdown"): void {
+		this.#disposed = true;
+		for (const gateId of this.#pending.keys()) void this.#cancelGateInteractions(gateId, reason);
+		this.#rejectAllPending(new Error(`unattended session disposed: ${reason}`));
+	}
+
 	listPendingGates(): import("../../rpc/rpc-types").RpcWorkflowGate[] {
 		const store = this.opts.store;
 		if (!store) return [];
@@ -206,6 +492,7 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 	}
 
 	emitGate(input: OpenGateInput): Promise<unknown> {
+		if (this.#disposed) return Promise.reject(new Error("unattended session is disposed"));
 		if (!this.#broker) {
 			return Promise.reject(new Error("cannot emit a workflow gate before unattended mode is negotiated"));
 		}