@gajae-code/coding-agent 0.11.11 → 0.12.1

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

@@ -209,7 +209,12 @@ export function buildActionMarkdown(action: {
 	if (action.kind === "idle") {
 		return action.summary ? `🟢 Agent idle\n${action.summary}` : "🟢 Agent idle";
 	}
-	const heading = `❓ **${action.question ?? "Question"}**`;
+	const question = (action.question ?? "Question")
+		.split(/\r\n|\r|\n/)
+		.map(line => line.trimEnd())
+		.map(line => (line ? `**${line}**` : ""))
+		.join("  \n");
+	const heading = `❓ ${question}`;
 	const options = action.options ?? [];
 	const displayOptions = withRecommendedOptionLabel(options, action.recommendedIndex);
 	if (options.length === 0) return `${heading}\n\n(reply with text)`;
@@ -217,19 +222,43 @@ export function buildActionMarkdown(action: {
 	return `${heading}\n\n${list}`;
 }
 
+export type TelegramNotificationSound = "all" | "important" | "none";
+
+export type TelegramDeliveryLane = "ask" | "idle" | "live" | "finalized";
+
+/**
+ * Resolve Telegram's optional silent-delivery flag. `finalChunk` silences
+ * non-final actionable chunks under the `important` policy; `undefined`
+ * intentionally omits the field so Telegram uses its normal audible delivery
+ * behavior.
+ */
+export function telegramDisableNotification(
+	sound: TelegramNotificationSound | undefined,
+	lane: TelegramDeliveryLane,
+	finalChunk = true,
+): true | undefined {
+	if (sound === "none") return true;
+	if (sound !== "important") return undefined;
+	return (lane === "ask" || lane === "idle") && finalChunk ? undefined : true;
+}
+
 /** Send Telegram HTML text chunks sequentially so long messages preserve order. */
 export async function sendTelegramHtmlChunks(
 	send: TelegramSend,
 	chatId: string,
 	text: string,
 	inlineKeyboard?: InlineButton[][],
+	sound?: TelegramNotificationSound,
+	lane: TelegramDeliveryLane = "ask",
 ): Promise<void> {
 	const chunks = splitTelegramHtml(text);
 	for (let i = 0; i < chunks.length; i++) {
+		const disableNotification = telegramDisableNotification(sound, lane, i === chunks.length - 1);
 		await send("sendMessage", {
 			chat_id: chatId,
 			text: chunks[i]!,
 			parse_mode: TELEGRAM_PARSE_MODE,
+			...(disableNotification === true ? { disable_notification: true } : {}),
 			...(i === chunks.length - 1 && inlineKeyboard ? { reply_markup: { inline_keyboard: inlineKeyboard } } : {}),
 		});
 	}
@@ -348,6 +377,7 @@ export interface TelegramReferenceOptions {
 	endpointFile: string;
 	apiBase?: string;
 	fetchImpl?: typeof fetch;
+	sound?: TelegramNotificationSound;
 }
 
 /**
@@ -395,7 +425,14 @@ export async function runTelegramReferenceClient(opts: TelegramReferenceOptions)
 				controls: msg.controls,
 				summary: msg.summary,
 			});
-			await sendTelegramHtmlChunks(send, opts.chatId, rendered.text, rendered.inline_keyboard);
+			await sendTelegramHtmlChunks(
+				send,
+				opts.chatId,
+				rendered.text,
+				rendered.inline_keyboard,
+				opts.sound,
+				msg.kind ?? "ask",
+			);
 		} else if (msg.type === "action_unavailable") {
 			const requiredCapabilities = Array.isArray(msg.requiredCapabilities)
 				? msg.requiredCapabilities
@@ -416,7 +453,7 @@ export async function runTelegramReferenceClient(opts: TelegramReferenceOptions)
 			// session's forum topic; this reference shows the minimal handling.
 			const threaded = renderThreadedFrame(msg as never);
 			if (threaded?.text) {
-				await sendTelegramHtmlChunks(send, opts.chatId, threaded.text);
+				await sendTelegramHtmlChunks(send, opts.chatId, threaded.text, undefined, opts.sound, threaded.lane);
 			}
 		}
 	};

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

@@ -18,13 +18,13 @@ export interface ThreadedSend {
 	method: "sendMessage" | "sendPhoto" | "sendDocument";
 	/** Rate-limit lane for prioritisation/fairness. */
 	lane: RateLimitLane;
-	/** Message text (sendMessage) or photo caption (sendPhoto). */
+	/** Message text (sendMessage) or media caption (sendPhoto/sendDocument). */
 	text?: string;
 	/** Base64 image bytes for sendPhoto. */
 	photoBase64?: string;
 	/** Base64 file bytes for sendDocument. */
 	documentBase64?: string;
-	/** Image MIME type for sendPhoto. */
+	/** Uploaded media MIME type. */
 	mime?: string;
 	/** Suggested document filename. */
 	fileName?: string;
@@ -100,6 +100,40 @@ function str(v: unknown): string | undefined {
 	return typeof v === "string" && v.length > 0 ? v : undefined;
 }
 
+function baseMimeType(mime: string): string {
+	return mime.split(";", 1)[0]!.trim().toLowerCase();
+}
+
+export function supportsTelegramPhotoUpload(mime: string | undefined): boolean {
+	if (mime === undefined) return true;
+	const normalized = baseMimeType(mime);
+	return normalized === "image/jpeg" || normalized === "image/png";
+}
+
+function imageDocumentFileName(mime: string | undefined): string {
+	switch (mime === undefined ? "" : baseMimeType(mime)) {
+		case "image/webp":
+			return "image.webp";
+		case "image/gif":
+			return "image.gif";
+		case "image/svg+xml":
+			return "image.svg";
+		case "image/avif":
+			return "image.avif";
+		case "image/bmp":
+		case "image/x-ms-bmp":
+			return "image.bmp";
+		case "image/tiff":
+			return "image.tiff";
+		case "image/heic":
+			return "image.heic";
+		case "image/heif":
+			return "image.heif";
+		default:
+			return "image";
+	}
+}
+
 function isDotOnlyText(value: string): boolean {
 	return /^[.\s]+$/.test(value);
 }
@@ -244,11 +278,22 @@ export function renderThreadedFrame(frame: ThreadedFrame): ThreadedSend | undefi
 			const data = str(frame.data);
 			if (!data) return undefined;
 			const caption = str(frame.caption);
+			const mime = str(frame.mime);
+			if (!supportsTelegramPhotoUpload(mime)) {
+				return {
+					method: "sendDocument",
+					lane: "finalized",
+					documentBase64: data,
+					mime,
+					fileName: imageDocumentFileName(mime),
+					text: finalizeTelegramHtml(caption === undefined ? undefined : escapeHtml(caption)),
+				};
+			}
 			return {
 				method: "sendPhoto",
 				lane: "finalized",
 				photoBase64: data,
-				mime: str(frame.mime),
+				mime,
 				text: finalizeTelegramHtml(caption === undefined ? undefined : escapeHtml(caption)),
 			};
 		}

package/src/sdk/bus/topic-registry.ts

@@ -43,6 +43,8 @@ export interface TopicRecord {
 	creationLeaseEpoch?: number;
 	/** An uncertain delete fences future creation and inbound routing. */
 	authorityState?: "active" | "delete_pending";
+	/** Provenance for topics created by the user and adopted by GJC. Missing means daemon-created. */
+	topicOrigin?: "user_created";
 	/** Telegram chat and endpoint authority last proven to use this topic. */
 	chatId?: string;
 	/** Canonical endpoint tuple (URL + token) that currently holds the lease. */
@@ -234,6 +236,7 @@ export class TopicRegistry {
 				...(raw.authorityState === "delete_pending" || fenceSupersedesRecord
 					? { authorityState: "delete_pending" as const }
 					: {}),
+				...(raw.topicOrigin === "user_created" ? { topicOrigin: "user_created" as const } : {}),
 				...(isValidBindingString(raw.chatId) ? { chatId: raw.chatId } : {}),
 				...(isValidBindingString(raw.endpointKey) ? { endpointKey: raw.endpointKey } : {}),
 				...(isValidBindingString(raw.endpointDigest) ? { endpointDigest: raw.endpointDigest } : {}),
@@ -307,6 +310,21 @@ export class TopicRegistry {
 		const record = this.topics.get(sessionId);
 		return record?.authorityState !== "delete_pending" && this.byTopic.get(record?.topicId ?? "") === sessionId;
 	}
+	/**
+	 * Pure read-only availability check for user-topic adoption. Rejects invalid
+	 * ids and any id already committed, delete-pending/fenced, staged, or
+	 * ambiguous, without mutating maps, epochs, or persistence. Used inside the
+	 * {@link getOrCreateTopic} create callback to fail-closed before adopting a
+	 * user-created topic id.
+	 */
+	isTopicIdAvailable(topicId: string): boolean {
+		if (!isValidTopicId(topicId)) return false;
+		if (this.#ambiguousTopicIds.has(topicId)) return false;
+		if (this.byTopic.has(topicId)) return false;
+		for (const record of this.topics.values()) if (record.topicId === topicId) return false;
+		for (const record of this.staged.values()) if (record.topicId === topicId) return false;
+		return true;
+	}
 
 	/**
 	 * Resolve endpoint authority for identity-less replay. An endpoint may bootstrap
@@ -455,6 +473,7 @@ export class TopicRegistry {
 		binding?: TopicEndpointBinding,
 		commit?: () => Promise<void>,
 		transientClaimant?: object,
+		topicOrigin?: TopicRecord["topicOrigin"],
 	): Promise<TopicRecord> {
 		const existing = this.topics.get(sessionId);
 		if (existing?.authorityState === "delete_pending") throw new Error("topic authority is deletion-fenced");
@@ -491,6 +510,7 @@ export class TopicRegistry {
 						}
 					: {}),
 				...(revoked ? { authorityState: "delete_pending" as const } : {}),
+				...(topicOrigin === "user_created" ? { topicOrigin: "user_created" as const } : {}),
 			};
 			if (revoked) {
 				this.topics.set(sessionId, record);

package/src/sdk/host/control/dispatch.ts

@@ -158,7 +158,11 @@ function invoke(
 		case "workflow.plan_approve":
 			return surface.approvePlan(text(input, "id"), input.choice, input.expectedSessionId as string | undefined);
 		case "skill.invoke":
-			return surface.invokeSkill(text(input, "name"), input.args);
+			return surface.invokeSkill(
+				text(input, "name"),
+				input.args,
+				typeof input.clientRef === "string" ? input.clientRef : undefined,
+			);
 		case "mode.plan.set":
 			return surface.setPlanMode(input.on as boolean);
 		case "mode.goal.operate":

package/src/sdk/host/control/operations.ts

@@ -19,7 +19,7 @@ export interface ControlSurface {
 		idempotencyKey?: string,
 	): Promise<ControlValue> | ControlValue;
 	approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
-	invokeSkill(name: string, args: ControlValue): Promise<ControlValue> | ControlValue;
+	invokeSkill(name: string, args: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
 	setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;
 	operateGoal(op: string, objective?: string): Promise<ControlValue> | ControlValue;
 	replaceTodo(items: ControlValue): Promise<ControlValue> | ControlValue;

package/src/sdk/host/host.ts

@@ -9,6 +9,13 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
 	/** Best-effort diagnostic observation of accepted control/query frames. */
 	onRequest?: SdkRequestObserver;
+	/** Runs before a control response is sent; identity transitions use sendTerminal. */
+	beforeControlResponse?: (
+		connectionId: string,
+		request: SdkFrame,
+		response: SdkFrame,
+		sendTerminal: () => Promise<void>,
+	) => void | Promise<void>;
 	/** Runs only after a successful control response has been sent to the client. */
 	afterControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame) => void | Promise<void>;
 	installProviderDefinitions?: (capability: string, definitions: unknown) => void;
@@ -36,6 +43,14 @@ function errorFrame(connectionId: string, frame: SdkFrame, error: unknown): SdkF
 				? candidate.code
 				: "internal";
 	const message = typeof candidate?.message === "string" ? candidate.message : "SDK host operation failed.";
+	if (frame.type === "control_request") {
+		return {
+			type: "control_response",
+			id: typeof frame.id === "string" ? frame.id : "",
+			ok: false,
+			error: { code, message },
+		};
+	}
 	return {
 		type: "reverse_response",
 		id: typeof frame.id === "string" ? frame.id : "",
@@ -214,7 +229,14 @@ export class SessionSdkHost {
 					const result = await this.#options.control?.(connectionId, frame);
 					if (result !== undefined) {
 						const response = { type: "control_response", ...(result as SdkFrame) };
-						await this.#send(connectionId, response);
+						let terminalSent = false;
+						const sendTerminal = async (): Promise<void> => {
+							if (terminalSent) return;
+							terminalSent = true;
+							await this.#send(connectionId, response);
+						};
+						await this.#options.beforeControlResponse?.(connectionId, frame, response, sendTerminal);
+						await sendTerminal();
 						await this.#options.afterControlResponse?.(connectionId, frame, response);
 					}
 					break;

package/src/sdk/host/query/handlers.ts

@@ -46,6 +46,11 @@ export interface SessionSurface {
 	getJobs(): unknown | Promise<unknown>;
 	/** Q26 keyed lookup of a submitted prompt's authoritative reconciliation status. */
 	getPromptStatus?(selector: { commandId?: string; turnId?: string; clientRef?: string }): unknown | Promise<unknown>;
+	getSkillInvokeStatus?(selector: {
+		commandId?: string;
+		turnId?: string;
+		clientRef?: string;
+	}): unknown | Promise<unknown>;
 	/** Q27 effective model-profile catalog from the live session registry. */
 	getModelProfiles?(): unknown[] | Promise<unknown[]>;
 	/** Query rows backed by the session's installed binding map. */
@@ -127,6 +132,7 @@ const names = [
 	"runtime.jobs.list",
 	"turn.prompt_status",
 	"models.profiles.list",
+	"skill.invoke_status",
 ];
 
 export class QueryHandlers {
@@ -156,6 +162,7 @@ export class QueryHandlers {
 			if (query === "Q02") return await this.#transcriptBody(request);
 			if (query === "Q23") return await this.#resourceBody(request);
 			if (query === "Q26") return await this.#promptStatus(request);
+			if (query === "Q28") return await this.#skillInvokeStatus(request);
 			if (query === "Q24") return await this.#artifact(request);
 			if (query === "Q27" && request.input && Object.keys(request.input).length > 0)
 				return this.#error(request, "invalid_request", false, "models.profiles.list does not accept input fields.");
@@ -517,6 +524,54 @@ export class QueryHandlers {
 		return { id: request.id, ok: true, page };
 	}
 
+	async #skillInvokeStatus(request: QueryRequest): Promise<QueryResponse> {
+		if (request.cursor)
+			return this.#error(request, "invalid_request", false, "skill.invoke_status does not support cursors.");
+		const input = request.input ?? {};
+		for (const key of Object.keys(input))
+			if (key !== "commandId" && key !== "turnId" && key !== "clientRef")
+				return this.#error(
+					request,
+					"invalid_request",
+					false,
+					`skill.invoke_status does not accept selector field "${key}".`,
+				);
+		const commandId = typeof input.commandId === "string" && input.commandId ? input.commandId : undefined;
+		const turnId = typeof input.turnId === "string" && input.turnId ? input.turnId : undefined;
+		const rawClientRef = typeof input.clientRef === "string" ? input.clientRef : undefined;
+		const trimmedClientRef = rawClientRef?.trim();
+		if (rawClientRef !== undefined && (!trimmedClientRef || trimmedClientRef.length > PROMPT_CLIENT_REF_MAX_LENGTH))
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"clientRef must be a non-empty string of at most 128 characters.",
+			);
+		const clientRef = trimmedClientRef || undefined;
+		if ((commandId === undefined) !== (turnId === undefined))
+			return this.#error(request, "invalid_request", false, "commandId and turnId must be provided together.");
+		if (commandId !== undefined && clientRef !== undefined)
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"Provide exactly one selector: a commandId/turnId pair or a clientRef.",
+			);
+		if (commandId === undefined && clientRef === undefined)
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"skill.invoke_status requires a commandId/turnId pair or a clientRef.",
+			);
+		if (typeof this.surface.getSkillInvokeStatus !== "function")
+			return this.#error(request, "unavailable", false, "skill.invoke_status is unavailable for this session.");
+		const result = await this.surface.getSkillInvokeStatus(
+			clientRef !== undefined ? { clientRef } : { commandId: commandId!, turnId: turnId! },
+		);
+		return { id: request.id, ok: true, result };
+	}
+
 	async #promptStatus(request: QueryRequest): Promise<QueryResponse> {
 		if (request.cursor)
 			return this.#error(request, "invalid_request", false, "turn.prompt_status does not support cursors.");

package/src/sdk/host/query/revision-store.ts

@@ -2,6 +2,32 @@ import { createHash } from "node:crypto";
 import { chmod, mkdir, mkdtemp, open, readFile, rename, rm, unlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { postmortem } from "@gajae-code/utils";
+
+/**
+ * Spill directories this process created under the system temp dir.
+ *
+ * `close()` removes a store's own directory, but an abnormal exit never reaches
+ * it, and these hold real spilled snapshot data rather than a marker. The two
+ * sibling temp-artifact caches (`shell-snapshot`, `python-runner-artifact`)
+ * already register a postmortem sweep; this does the same.
+ *
+ * Only `mkdtemp` directories are tracked. A caller-supplied `storageDir` is
+ * durable session storage and must never be swept here.
+ */
+const processSpillDirectories = new Set<string>();
+
+/** Test seam: spill directories currently tracked for postmortem cleanup. */
+export function trackedSpillDirectoriesForTest(): string[] {
+	return [...processSpillDirectories];
+}
+
+postmortem.register("sdk-revision-store:spill", async () => {
+	for (const dir of [...processSpillDirectories]) {
+		processSpillDirectories.delete(dir);
+		await rm(dir, { recursive: true, force: true }).catch(() => undefined);
+	}
+});
 
 export const MAX_REVISIONS_PER_RESOURCE = 8;
 export const MAX_PINNED_REVISIONS = 128;
@@ -512,7 +538,10 @@ export class RevisionStore {
 			this.#memoryBytes = 0;
 			this.#chunkRefs.clear();
 			this.#manifestRefs.clear();
-			if (this.#directory) await rm(this.#directory, { recursive: true, force: true });
+			if (this.#directory) {
+				processSpillDirectories.delete(this.#directory);
+				await rm(this.#directory, { recursive: true, force: true });
+			}
 		})();
 		return this.#closePromise;
 	}
@@ -1040,7 +1069,12 @@ export class RevisionStore {
 	}
 
 	async #spillDirectory(): Promise<string> {
-		if (!this.#directory) this.#directory = await mkdtemp(join(tmpdir(), "gjc-sdk-snapshots-"));
+		if (!this.#directory) {
+			this.#directory = await mkdtemp(join(tmpdir(), "gjc-sdk-snapshots-"));
+			// Only temp spill directories are swept on abnormal exit; a caller-supplied
+			// storageDir is durable and never enters this set.
+			processSpillDirectories.add(this.#directory);
+		}
 		await mkdir(join(this.#directory, "objects"), { recursive: true, mode: 0o700 });
 		await mkdir(join(this.#directory, "manifests"), { recursive: true, mode: 0o700 });
 		await chmod(this.#directory, 0o700);

package/src/sdk/host/reverse-leases.ts

@@ -41,6 +41,8 @@ interface Outstanding {
 	leaseId: string;
 	resolve: (value: unknown) => void;
 	reject: (reason: Error) => void;
+	signal?: AbortSignal;
+	onAbort?: () => void;
 }
 
 export interface ReverseLeaseOptions {
@@ -188,7 +190,7 @@ export class ReverseLeaseRuntime {
 		this.#cancelForConnection(connectionId, "provider_disconnected");
 	}
 
-	request(capability: string, method: string, payload: unknown): Promise<unknown> {
+	request(capability: string, method: string, payload: unknown, signal?: AbortSignal): Promise<unknown> {
 		if (this.#disposing) throw new Error("reverse runtime is disposing");
 		this.#assertPayload(payload);
 		const lease = this.#liveLease(capability);
@@ -198,16 +200,42 @@ export class ReverseLeaseRuntime {
 				throw new ReverseLeaseError("lease_unavailable");
 			throw new ReverseLeaseError("provider_required");
 		}
+		if (signal?.aborted)
+			return Promise.reject(Object.assign(new Error("request_cancelled"), { name: "request_cancelled" }));
 		if (this.#outstanding.size >= MAX_REVERSE_OUTSTANDING) throw new ReverseLeaseError("too_many_outstanding");
 		const id = randomUUID();
 		return new Promise((resolve, reject) => {
-			this.#outstanding.set(id, {
+			const outstanding: Outstanding = {
 				connectionId: lease.connectionId,
 				capability,
 				leaseId: lease.leaseId,
 				resolve,
 				reject,
-			});
+				...(signal ? { signal } : {}),
+			};
+			this.#outstanding.set(id, outstanding);
+			if (signal) {
+				outstanding.onAbort = () => {
+					if (this.#takeOutstanding(id) !== outstanding) return;
+					try {
+						const cancellation = this.#sendFrame(lease.connectionId, {
+							type: "reverse_cancel",
+							id,
+							connectionId: lease.connectionId,
+							leaseId: lease.leaseId,
+						});
+						void Promise.resolve(cancellation).catch(() => {});
+					} catch {
+						// Cancellation is best effort; the caller is already settled locally.
+					}
+					reject(Object.assign(new Error("request_cancelled"), { name: "request_cancelled" }));
+				};
+				signal.addEventListener("abort", outstanding.onAbort, { once: true });
+				if (signal.aborted) {
+					outstanding.onAbort();
+					return;
+				}
+			}
 			let delivery: void | Promise<void>;
 			try {
 				delivery = this.#sendFrame(lease.connectionId, {
@@ -219,12 +247,12 @@ export class ReverseLeaseRuntime {
 					payload: { method, payload },
 				});
 			} catch (error) {
-				this.#outstanding.delete(id);
+				this.#takeOutstanding(id);
 				reject(error instanceof Error ? error : new Error(String(error)));
 				return;
 			}
 			Promise.resolve(delivery).catch(error => {
-				this.#outstanding.delete(id);
+				if (this.#takeOutstanding(id) !== outstanding) return;
 				reject(error instanceof Error ? error : new Error(String(error)));
 			});
 		});
@@ -242,7 +270,7 @@ export class ReverseLeaseRuntime {
 		if (!request) throw new ReverseLeaseError("unknown_request");
 		if (request.connectionId !== connectionId || request.leaseId !== leaseId)
 			throw new ReverseLeaseError("not_lease_owner");
-		this.#outstanding.delete(id);
+		this.#takeOutstanding(id);
 		if (error) {
 			const rejection = new Error(error.message);
 			rejection.name = error.code;
@@ -270,6 +298,8 @@ export class ReverseLeaseRuntime {
 		this.#installedCapabilities.clear();
 		this.#leases.clear();
 		this.#idempotency.clear();
+		for (const request of outstanding.map(([, request]) => request))
+			if (request.signal && request.onAbort) request.signal.removeEventListener("abort", request.onAbort);
 		for (const [id, request] of outstanding) {
 			request.reject(new Error("request_cancelled"));
 			try {
@@ -304,11 +334,18 @@ export class ReverseLeaseRuntime {
 	#cancelForConnection(connectionId: string, reason: "provider_disconnected" | "lease_released"): void {
 		for (const [id, request] of this.#outstanding)
 			if (request.connectionId === connectionId) {
-				this.#outstanding.delete(id);
+				this.#takeOutstanding(id);
 				request.reject(new Error("request_cancelled"));
 				this.#onCancel?.(id, reason);
 			}
 	}
+	#takeOutstanding(id: string): Outstanding | undefined {
+		const request = this.#outstanding.get(id);
+		if (!request) return undefined;
+		this.#outstanding.delete(id);
+		if (request.signal && request.onAbort) request.signal.removeEventListener("abort", request.onAbort);
+		return request;
+	}
 	#installDefinitionsFor(capability: string, definitions: unknown): void {
 		this.#installDefinitions?.(capability, definitions);
 		this.#installedCapabilities.add(capability);

package/src/sdk/mcp/server.ts

@@ -301,9 +301,16 @@ export function createSdkMcpServer(options: SdkMcpServerOptions = {}) {
 export async function runSdkMcpStdio(options: SdkMcpServerOptions = {}): Promise<void> {
 	const server = createSdkMcpServer(options);
 	let buffer = "";
+	const inflight = new Set<Promise<void>>();
 	process.stdin.setEncoding("utf8");
-	await new Promise<void>(resolve => {
-		process.stdin.on("data", (chunk: string) => {
+
+	const track = (work: Promise<void>): void => {
+		inflight.add(work);
+		void work.finally(() => inflight.delete(work));
+	};
+
+	await new Promise<void>((resolve, reject) => {
+		const onData = (chunk: string) => {
 			buffer += chunk;
 			let index = buffer.indexOf("\n");
 			while (index >= 0) {
@@ -311,22 +318,43 @@ export async function runSdkMcpStdio(options: SdkMcpServerOptions = {}): Promise
 				buffer = buffer.slice(index + 1);
 				index = buffer.indexOf("\n");
 				if (!line) continue;
-				void (async () => {
-					let request: JsonRpcRequest;
-					try {
-						request = JSON.parse(line) as JsonRpcRequest;
-					} catch {
-						process.stdout.write(
-							`${JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse_error" } })}\n`,
-						);
-						return;
-					}
-					const response = await server.handleJsonRpc(request);
-					// JSON-RPC notifications (no id) receive no response.
-					if (request.id !== undefined) process.stdout.write(`${JSON.stringify(response)}\n`);
-				})();
+				track(
+					(async () => {
+						let request: JsonRpcRequest;
+						try {
+							request = JSON.parse(line) as JsonRpcRequest;
+						} catch {
+							process.stdout.write(
+								`${JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse_error" } })}\n`,
+							);
+							return;
+						}
+						const response = await server.handleJsonRpc(request);
+						// JSON-RPC notifications (no id) receive no response.
+						if (request.id !== undefined) process.stdout.write(`${JSON.stringify(response)}\n`);
+					})(),
+				);
 			}
-		});
-		process.stdin.on("end", () => resolve());
+		};
+		const onEnd = () => {
+			process.stdin.off("data", onData);
+			process.stdin.off("end", onEnd);
+			process.stdin.off("error", onError);
+			resolve();
+		};
+		const onError = (error: Error) => {
+			process.stdin.off("data", onData);
+			process.stdin.off("end", onEnd);
+			process.stdin.off("error", onError);
+			reject(error);
+		};
+		process.stdin.on("data", onData);
+		process.stdin.on("end", onEnd);
+		process.stdin.on("error", onError);
 	});
+
+	// Stdin EOF must not drop in-flight tools/call handlers (WS connect/query).
+	// Awaiting them also prevents the process from exiting before responses flush,
+	// and lets clients close so the event loop can drain deterministically.
+	await Promise.allSettled([...inflight]);
 }