opencode-tbot 0.1.25 → 0.1.27

package/dist/plugin.js

@@ -1,4 +1,4 @@
-import { c as loadAppConfig, i as preparePluginConfiguration, o as OPENCODE_TBOT_VERSION } from "./assets/plugin-config-CCeFjxSf.js";
+import { c as loadAppConfig, i as preparePluginConfiguration, o as OPENCODE_TBOT_VERSION } from "./assets/plugin-config-DNeV2Ckw.js";
 import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import { parse, printParseErrorCode } from "jsonc-parser";
@@ -218,6 +218,17 @@ var OpenCodePromptTimeoutError = class extends Error {
 		this.data = data;
 	}
 };
+var OpenCodeMessageAbortedError = class extends Error {
+	data;
+	constructor(message = "Request was aborted.") {
+		super(message);
+		this.name = "MessageAbortedError";
+		this.data = { message };
+	}
+};
+function createMessageAbortedError(message = "Request was aborted.") {
+	return new OpenCodeMessageAbortedError(message);
+}
 var EMPTY_RESPONSE_TEXT = "OpenCode returned empty response.";
 var PROMPT_MESSAGE_POLL_INITIAL_DELAYS_MS = [
 	0,
@@ -227,11 +238,13 @@ var PROMPT_MESSAGE_POLL_INITIAL_DELAYS_MS = [
 	1e3
 ];
 var PROMPT_MESSAGE_POLL_INTERVAL_MS = 2e3;
-var PROMPT_POLL_REQUEST_TIMEOUT_MS = 15e3;
-var PROMPT_SEND_TIMEOUT_MS = 3e4;
-var PROMPT_MESSAGE_POLL_TIMEOUT_MS = 6e4;
 var PROMPT_MESSAGE_POLL_LIMIT = 20;
 var PROMPT_LOG_SERVICE = "opencode-tbot";
+var DEFAULT_OPENCODE_PROMPT_TIMEOUT_POLICY = {
+	pollRequestTimeoutMs: 15e3,
+	recoveryInactivityTimeoutMs: 12e4,
+	waitTimeoutMs: 18e5
+};
 var STRUCTURED_REPLY_SCHEMA = {
 	type: "json_schema",
 	retryCount: 2,
@@ -253,134 +266,94 @@ var StructuredReplySchema = z.object({ body_md: z.string() });
 var OpenCodeClient = class {
 	client;
 	fetchFn;
-	promptRequestTimeouts = {
-		pollRequestMs: PROMPT_POLL_REQUEST_TIMEOUT_MS,
-		sendMs: PROMPT_SEND_TIMEOUT_MS,
-		totalPollMs: PROMPT_MESSAGE_POLL_TIMEOUT_MS
-	};
+	promptTimeoutPolicy;
 	modelCache = {
 		expiresAt: 0,
 		promise: null,
 		value: null
 	};
-	constructor(options, client, fetchFn = fetch) {
+	constructor(options, client, fetchFn = fetch, promptTimeoutPolicy = {}) {
 		if (!options && !client) throw new Error("OpenCodeClient requires either base URL options or an injected SDK client.");
 		this.client = client ?? createOpencodeClient(buildOpenCodeSdkConfig(options));
 		this.fetchFn = fetchFn;
+		this.promptTimeoutPolicy = resolvePromptTimeoutPolicy(promptTimeoutPolicy);
+	}
+	configurePromptTimeoutPolicy(promptTimeoutPolicy) {
+		this.promptTimeoutPolicy = resolvePromptTimeoutPolicy({
+			...this.promptTimeoutPolicy,
+			...promptTimeoutPolicy
+		});
+	}
+	async callScopedSdkMethod(scope, method, input) {
+		const target = this.client[scope];
+		const handler = target?.[method];
+		if (typeof handler !== "function") throw new Error(`OpenCode SDK client does not expose a compatible ${scope}.${method} method.`);
+		const options = {
+			...SDK_OPTIONS,
+			...input.signal ? { signal: input.signal } : {}
+		};
+		return unwrapSdkData(input.parameters === void 0 ? await handler.call(target, options) : await handler.call(target, input.parameters, options));
 	}
 	async getHealth() {
-		const rawClient = getRawSdkClient(this.client);
-		if (rawClient?.get) return await this.requestRaw("get", { url: "/global/health" });
-		const healthEndpoint = this.client.global?.health;
-		if (typeof healthEndpoint === "function") return unwrapSdkData(await healthEndpoint.call(this.client.global, SDK_OPTIONS));
-		if (!rawClient?.get) throw new Error("OpenCode SDK client does not expose a compatible health endpoint.");
-		return this.requestRaw("get", { url: "/global/health" });
+		return this.callScopedSdkMethod("global", "health", {});
 	}
 	async abortSession(sessionId) {
-		if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", {
-			url: "/session/{sessionID}/abort",
-			path: { sessionID: sessionId }
-		});
-		return unwrapSdkData(await this.client.session.abort({ sessionID: sessionId }, SDK_OPTIONS));
+		return this.callScopedSdkMethod("session", "abort", { parameters: { sessionID: sessionId } });
 	}
 	async deleteSession(sessionId) {
-		if (hasRawSdkMethod(this.client, "delete")) return this.requestRaw("delete", {
-			url: "/session/{sessionID}",
-			path: { sessionID: sessionId }
-		});
-		return unwrapSdkData(await this.client.session.delete({ sessionID: sessionId }, SDK_OPTIONS));
+		return this.callScopedSdkMethod("session", "delete", { parameters: { sessionID: sessionId } });
 	}
 	async forkSession(sessionId, messageId) {
-		if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", {
-			url: "/session/{sessionID}/fork",
-			path: { sessionID: sessionId },
-			...messageId?.trim() ? { body: { messageID: messageId.trim() } } : {}
-		});
-		return unwrapSdkData(await this.client.session.fork({
+		return this.callScopedSdkMethod("session", "fork", { parameters: {
 			sessionID: sessionId,
 			...messageId?.trim() ? { messageID: messageId.trim() } : {}
-		}, SDK_OPTIONS));
+		} });
 	}
 	async getPath() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/path" });
-		return unwrapSdkData(await this.client.path.get(void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("path", "get", {});
 	}
 	async listLspStatuses(directory) {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", {
-			url: "/lsp",
-			...directory ? { query: { directory } } : {}
-		});
-		return unwrapSdkData(await this.client.lsp.status(directory ? { directory } : void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("lsp", "status", { parameters: directory ? { directory } : void 0 });
 	}
 	async listMcpStatuses(directory) {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", {
-			url: "/mcp",
-			...directory ? { query: { directory } } : {}
-		});
-		return unwrapSdkData(await this.client.mcp.status(directory ? { directory } : void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("mcp", "status", { parameters: directory ? { directory } : void 0 });
 	}
 	async getSessionStatuses() {
 		return this.loadSessionStatuses();
 	}
 	async listProjects() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/project" });
-		return unwrapSdkData(await this.client.project.list(void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("project", "list", {});
 	}
 	async listSessions() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/session" });
-		return unwrapSdkData(await this.client.session.list(void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("session", "list", {});
 	}
 	async getCurrentProject() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/project/current" });
-		return unwrapSdkData(await this.client.project.current(void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("project", "current", {});
 	}
 	async createSessionForDirectory(directory, title) {
-		if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", {
-			url: "/session",
-			query: { directory },
-			...title ? { body: { title } } : {}
-		});
-		return unwrapSdkData(await this.client.session.create(title ? {
+		return this.callScopedSdkMethod("session", "create", { parameters: title ? {
 			directory,
 			title
-		} : { directory }, SDK_OPTIONS));
+		} : { directory } });
 	}
 	async renameSession(sessionId, title) {
-		if (hasRawSdkMethod(this.client, "patch")) return this.requestRaw("patch", {
-			url: "/session/{sessionID}",
-			path: { sessionID: sessionId },
-			body: { title }
-		});
-		return unwrapSdkData(await this.client.session.update({
+		return this.callScopedSdkMethod("session", "update", { parameters: {
 			sessionID: sessionId,
 			title
-		}, SDK_OPTIONS));
+		} });
 	}
 	async listAgents() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/agent" });
-		return unwrapSdkData(await this.client.app.agents(void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("app", "agents", {});
 	}
 	async listPendingPermissions(directory) {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", {
-			url: "/permission",
-			...directory ? { query: { directory } } : {}
-		});
-		return unwrapSdkData(await this.client.permission.list(directory ? { directory } : void 0, SDK_OPTIONS));
-	}
-	async replyToPermission(requestId, reply, message) {
-		if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", {
-			url: "/permission/{requestID}/reply",
-			path: { requestID: requestId },
-			body: {
-				reply,
-				...message?.trim() ? { message: message.trim() } : {}
-			}
-		});
-		return unwrapSdkData(await this.client.permission.reply({
+		return this.callScopedSdkMethod("permission", "list", { parameters: directory ? { directory } : void 0 });
+	}
+	async replyToPermission(requestId, reply, message, _sessionId) {
+		return this.callScopedSdkMethod("permission", "reply", { parameters: {
 			requestID: requestId,
 			reply,
 			...message?.trim() ? { message: message.trim() } : {}
-		}, SDK_OPTIONS));
+		} });
 	}
 	async listModels() {
 		const now = Date.now();
@@ -405,9 +378,10 @@ var OpenCodeClient = class {
 			url: file.url
 		}))];
 		if (parts.length === 0) throw new Error("Prompt requires text or file attachments.");
-		const knownMessageIds = await this.captureKnownMessageIds(input.sessionId);
-		const initialData = await this.sendPromptRequest(input, parts);
-		return buildPromptSessionResult(await this.resolvePromptResponse(input, initialData, knownMessageIds, startedAt), {
+		throwIfAborted(input.signal);
+		const knownMessageIds = await this.captureKnownMessageIds(input.sessionId, input.signal);
+		await this.sendPromptRequest(input, parts);
+		return buildPromptSessionResult(await this.resolvePromptResponse(input, null, knownMessageIds, startedAt), {
 			emptyResponseText: EMPTY_RESPONSE_TEXT,
 			finishedAt: Date.now(),
 			startedAt,
@@ -416,7 +390,7 @@ var OpenCodeClient = class {
 	}
 	async resolvePromptResponse(input, data, knownMessageIds, startedAt) {
 		const structured = input.structured ?? false;
-		if (data && !shouldPollPromptMessage(data, structured)) return data;
+		if (data && shouldReturnPromptResponseImmediately(data, structured)) return data;
 		const messageId = data ? extractMessageId(data.info) : null;
 		const candidateOptions = {
 			initialMessageId: messageId,
@@ -426,145 +400,162 @@ var OpenCodeClient = class {
 			structured
 		};
 		let bestCandidate = selectPromptResponseCandidate(data ? [data] : [], candidateOptions);
-		const deadlineAt = Date.now() + this.promptRequestTimeouts.totalPollMs;
+		let lastProgressAt = Date.now();
+		let lastStatus = null;
+		const deadlineAt = startedAt + this.promptTimeoutPolicy.waitTimeoutMs;
 		let idleStatusSeen = false;
 		let attempt = 0;
 		while (true) {
+			throwIfAborted(input.signal);
+			const remainingWaitMs = deadlineAt - Date.now();
+			const remainingInactivityMs = this.promptTimeoutPolicy.recoveryInactivityTimeoutMs - (Date.now() - lastProgressAt);
+			if (remainingWaitMs <= 0 || remainingInactivityMs <= 0) break;
 			const delayMs = getPromptMessagePollDelayMs(attempt);
 			attempt += 1;
 			if (delayMs > 0) {
-				const remainingMs = deadlineAt - Date.now();
+				const remainingMs = Math.min(remainingWaitMs, remainingInactivityMs);
 				if (remainingMs <= 0) break;
-				await delay(Math.min(delayMs, remainingMs));
+				await delay(Math.min(delayMs, remainingMs), input.signal);
 			}
 			if (messageId) {
-				const next = await this.fetchPromptMessage(input.sessionId, messageId);
+				const next = await this.fetchPromptMessage(input.sessionId, messageId, input.signal);
 				if (next) {
 					const nextCandidate = selectPromptResponseCandidate([bestCandidate, next], candidateOptions);
-					if (nextCandidate) bestCandidate = nextCandidate;
-					if (bestCandidate && !shouldPollPromptMessage(bestCandidate, structured)) return bestCandidate;
+					if (nextCandidate) {
+						if (didPromptResponseAdvance(bestCandidate, nextCandidate, structured)) {
+							lastProgressAt = Date.now();
+							idleStatusSeen = false;
+						}
+						bestCandidate = nextCandidate;
+					}
+					if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && shouldReturnPromptResponseImmediately(bestCandidate, structured)) return bestCandidate;
 				}
 			}
-			const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "poll-messages");
+			const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "poll-messages", input.signal);
 			if (latest) {
 				const nextCandidate = selectPromptResponseCandidate([bestCandidate, latest], candidateOptions);
-				if (nextCandidate) bestCandidate = nextCandidate;
-				if (bestCandidate && !shouldPollPromptMessage(bestCandidate, structured)) return bestCandidate;
+				if (nextCandidate) {
+					if (didPromptResponseAdvance(bestCandidate, nextCandidate, structured)) {
+						lastProgressAt = Date.now();
+						idleStatusSeen = false;
+					}
+					bestCandidate = nextCandidate;
+				}
+				if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && shouldReturnPromptResponseImmediately(bestCandidate, structured)) return bestCandidate;
 			}
-			if ((await this.fetchPromptSessionStatus(input.sessionId))?.type === "idle") {
+			const status = await this.fetchPromptSessionStatus(input.sessionId, input.signal);
+			lastStatus = status;
+			if (status?.type === "busy" || status?.type === "retry") {
+				lastProgressAt = Date.now();
+				idleStatusSeen = false;
+			} else if (status?.type === "idle") {
 				if (idleStatusSeen) break;
 				idleStatusSeen = true;
 			}
+			if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && isCompletedEmptyPromptResponse(bestCandidate, structured) && status?.type !== "busy" && status?.type !== "retry") break;
 			if (Date.now() >= deadlineAt) break;
 		}
-		const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "final-scan");
+		const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "final-scan", input.signal);
 		const resolved = selectPromptResponseCandidate([bestCandidate, latest], candidateOptions);
-		if (!resolved || shouldPollPromptMessage(resolved, structured)) {
+		const requestScopedResolved = resolved && isPromptResponseForCurrentRequest(resolved, candidateOptions) ? resolved : null;
+		if (lastStatus?.type === "idle" && (!requestScopedResolved || shouldPollPromptMessage(requestScopedResolved, structured))) throw createMessageAbortedError();
+		if (!requestScopedResolved || shouldPollPromptMessage(requestScopedResolved, structured)) {
+			const timeoutReason = Date.now() >= deadlineAt ? "max-wait" : "recovery-inactivity";
+			const timeoutMs = timeoutReason === "max-wait" ? this.promptTimeoutPolicy.waitTimeoutMs : this.promptTimeoutPolicy.recoveryInactivityTimeoutMs;
 			const error = createOpenCodePromptTimeoutError({
 				sessionId: input.sessionId,
 				stage: "final-scan",
-				timeoutMs: this.promptRequestTimeouts.totalPollMs,
+				timeoutMs,
 				messageId: messageId ?? void 0
 			});
-			this.logPromptRequestFailure(error, {
+			this.logPromptRequest("warn", {
+				lastProgressAt,
+				messageId: messageId ?? void 0,
 				sessionId: input.sessionId,
 				stage: "final-scan",
-				timeoutMs: this.promptRequestTimeouts.totalPollMs,
-				messageId
-			});
+				timeoutMs,
+				timeoutReason
+			}, "OpenCode prompt recovery timed out");
 			throw error;
 		}
-		return resolved;
+		return requestScopedResolved;
 	}
-	async fetchPromptMessage(sessionId, messageId) {
+	async fetchPromptMessage(sessionId, messageId, signal) {
 		try {
 			return await this.runPromptRequestWithTimeout({
 				sessionId,
 				stage: "poll-message",
-				timeoutMs: this.promptRequestTimeouts.pollRequestMs,
+				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs,
 				messageId
-			}, async (signal) => {
-				if (hasRawSdkMethod(this.client, "get")) return normalizePromptResponse(await this.requestRaw("get", {
-					url: "/session/{sessionID}/message/{messageID}",
-					path: {
+			}, async (requestSignal) => {
+				return normalizePromptResponse(await this.callScopedSdkMethod("session", "message", {
+					parameters: {
 						sessionID: sessionId,
 						messageID: messageId
 					},
-					signal
+					signal: requestSignal
 				}));
-				if (typeof this.client.session.message !== "function") return null;
-				return normalizePromptResponse(unwrapSdkData(await this.client.session.message({
-					sessionID: sessionId,
-					messageID: messageId
-				}, {
-					...SDK_OPTIONS,
-					signal
-				})));
-			});
+			}, signal);
 		} catch (error) {
+			if (isPromptRequestAbort(error)) throw error;
 			this.logPromptRequestFailure(error, {
 				sessionId,
 				stage: "poll-message",
-				timeoutMs: this.promptRequestTimeouts.pollRequestMs,
+				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs,
 				messageId
 			});
 			return null;
 		}
 	}
-	async captureKnownMessageIds(sessionId) {
-		const messages = await this.fetchRecentPromptMessages(sessionId, "capture-known-messages");
+	async captureKnownMessageIds(sessionId, signal) {
+		const messages = await this.fetchRecentPromptMessages(sessionId, "capture-known-messages", signal);
 		if (!messages) return /* @__PURE__ */ new Set();
 		return new Set(messages.map((message) => extractMessageId(message.info)).filter((id) => typeof id === "string" && id.length > 0));
 	}
-	async fetchRecentPromptMessages(sessionId, stage) {
+	async fetchRecentPromptMessages(sessionId, stage, signal) {
 		try {
 			return await this.runPromptRequestWithTimeout({
 				sessionId,
 				stage,
-				timeoutMs: this.promptRequestTimeouts.pollRequestMs
-			}, async (signal) => {
-				if (hasRawSdkMethod(this.client, "get")) return normalizePromptResponses(await this.requestRaw("get", {
-					url: "/session/{sessionID}/message",
-					path: { sessionID: sessionId },
-					query: { limit: PROMPT_MESSAGE_POLL_LIMIT },
-					signal
+				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs
+			}, async (requestSignal) => {
+				return normalizePromptResponses(await this.callScopedSdkMethod("session", "messages", {
+					parameters: {
+						sessionID: sessionId,
+						limit: PROMPT_MESSAGE_POLL_LIMIT
+					},
+					signal: requestSignal
 				}));
-				if (typeof this.client.session.messages !== "function") return null;
-				return normalizePromptResponses(unwrapSdkData(await this.client.session.messages({
-					sessionID: sessionId,
-					limit: PROMPT_MESSAGE_POLL_LIMIT
-				}, {
-					...SDK_OPTIONS,
-					signal
-				})));
-			});
+			}, signal);
 		} catch (error) {
+			if (isPromptRequestAbort(error)) throw error;
 			this.logPromptRequestFailure(error, {
 				sessionId,
 				stage,
-				timeoutMs: this.promptRequestTimeouts.pollRequestMs
+				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs
 			});
 			return null;
 		}
 	}
-	async fetchPromptSessionStatus(sessionId) {
+	async fetchPromptSessionStatus(sessionId, signal) {
 		try {
 			return (await this.runPromptRequestWithTimeout({
 				sessionId,
 				stage: "poll-status",
-				timeoutMs: this.promptRequestTimeouts.pollRequestMs
-			}, async (signal) => this.loadSessionStatuses(signal)))[sessionId] ?? null;
+				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs
+			}, async (requestSignal) => this.loadSessionStatuses(requestSignal), signal))[sessionId] ?? null;
 		} catch (error) {
+			if (isPromptRequestAbort(error)) throw error;
 			this.logPromptRequestFailure(error, {
 				sessionId,
 				stage: "poll-status",
-				timeoutMs: this.promptRequestTimeouts.pollRequestMs
+				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs
 			});
 			return null;
 		}
 	}
-	async findLatestPromptResponse(sessionId, options, stage) {
-		const messages = await this.fetchRecentPromptMessages(sessionId, stage);
+	async findLatestPromptResponse(sessionId, options, stage, signal) {
+		const messages = await this.fetchRecentPromptMessages(sessionId, stage, signal);
 		if (!messages || messages.length === 0) return null;
 		return selectPromptResponseCandidate(messages, options);
 	}
@@ -580,12 +571,10 @@ var OpenCodeClient = class {
 		return models;
 	}
 	async loadConfig() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/config" });
-		return unwrapSdkData(await this.client.config.get(void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("config", "get", {});
 	}
 	async loadProviderCatalog() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/config/providers" });
-		return unwrapSdkData(await this.client.config.providers(void 0, SDK_OPTIONS));
+		return this.callScopedSdkMethod("config", "providers", {});
 	}
 	async sendPromptRequest(input, parts) {
 		const requestBody = {
@@ -604,62 +593,50 @@ var OpenCodeClient = class {
 				await this.runPromptRequestWithTimeout({
 					sessionId: input.sessionId,
 					stage: "send-prompt",
-					timeoutMs: this.promptRequestTimeouts.sendMs
+					timeoutMs: this.promptTimeoutPolicy.waitTimeoutMs
 				}, async (signal) => {
-					await this.client.session.promptAsync(requestParameters, {
-						...SDK_OPTIONS,
+					await this.callScopedSdkMethod("session", "promptAsync", {
+						parameters: requestParameters,
 						signal
 					});
-				});
-				return null;
+				}, input.signal);
+				return;
 			}
-			return await this.runPromptRequestWithTimeout({
-				sessionId: input.sessionId,
-				stage: "send-prompt",
-				timeoutMs: this.promptRequestTimeouts.sendMs
-			}, async (signal) => {
-				if (hasRawSdkMethod(this.client, "post")) return normalizePromptResponse(await this.requestRaw("post", {
-					url: "/session/{sessionID}/message",
-					path: { sessionID: input.sessionId },
-					body: requestBody,
-					signal
-				}));
-				return normalizePromptResponse(unwrapSdkData(await this.client.session.prompt(requestParameters, {
-					...SDK_OPTIONS,
-					signal
-				})));
-			});
 		} catch (error) {
 			this.logPromptRequestFailure(error, {
 				sessionId: input.sessionId,
 				stage: "send-prompt",
-				timeoutMs: this.promptRequestTimeouts.sendMs
+				timeoutMs: this.promptTimeoutPolicy.waitTimeoutMs
 			});
 			throw error;
 		}
-	}
-	async requestRaw(method, options) {
-		const handler = getRawSdkClient(this.client)?.[method];
-		if (typeof handler !== "function") throw new Error(`OpenCode SDK client does not expose a compatible raw ${method.toUpperCase()} method.`);
-		return unwrapSdkData(await handler({
-			...SDK_OPTIONS,
-			...options
-		}));
+		throw new Error("OpenCode SDK client does not expose session.promptAsync().");
 	}
 	async loadSessionStatuses(signal) {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", {
-			url: "/session/status",
-			...signal ? { signal } : {}
+		return this.callScopedSdkMethod("session", "status", {
+			signal,
+			parameters: void 0
 		});
-		return unwrapSdkData(await this.client.session.status(void 0, {
-			...SDK_OPTIONS,
-			...signal ? { signal } : {}
-		}));
 	}
-	async runPromptRequestWithTimeout(input, operation) {
+	async runPromptRequestWithTimeout(input, operation, signal) {
 		const startedAt = Date.now();
 		const controller = new AbortController();
+		const requestSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
 		let timeoutHandle = null;
+		let removeAbortListener = () => void 0;
+		const abortPromise = signal ? new Promise((_, reject) => {
+			const onAbort = () => {
+				reject(normalizeAbortReason(signal.reason));
+			};
+			if (signal.aborted) {
+				onAbort();
+				return;
+			}
+			signal.addEventListener("abort", onAbort, { once: true });
+			removeAbortListener = () => {
+				signal.removeEventListener("abort", onAbort);
+			};
+		}) : null;
 		const timeoutPromise = new Promise((_, reject) => {
 			timeoutHandle = setTimeout(() => {
 				reject(createOpenCodePromptTimeoutError({
@@ -673,14 +650,20 @@ var OpenCodeClient = class {
 			}, input.timeoutMs);
 		});
 		try {
-			return await Promise.race([operation(controller.signal), timeoutPromise]);
+			return await Promise.race([
+				operation(requestSignal),
+				timeoutPromise,
+				...abortPromise ? [abortPromise] : []
+			]);
 		} finally {
 			if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+			removeAbortListener();
 		}
 	}
 	logPromptRequestFailure(error, input) {
 		if (error instanceof OpenCodePromptTimeoutError) {
 			this.logPromptRequest("warn", {
+				endpointKind: resolvePromptEndpointKind(error.data.stage),
 				elapsedMs: error.data.elapsedMs,
 				messageId: error.data.messageId,
 				sessionId: error.data.sessionId,
@@ -690,6 +673,7 @@ var OpenCodeClient = class {
 			return;
 		}
 		this.logPromptRequest("warn", {
+			endpointKind: resolvePromptEndpointKind(input.stage),
 			error,
 			messageId: input.messageId ?? void 0,
 			sessionId: input.sessionId,
@@ -708,8 +692,8 @@ var OpenCodeClient = class {
 		}).catch(() => void 0);
 	}
 };
-function createOpenCodeClientFromSdkClient(client, fetchFn = fetch) {
-	return new OpenCodeClient(void 0, client, fetchFn);
+function createOpenCodeClientFromSdkClient(client, fetchFn = fetch, promptTimeoutPolicy = {}) {
+	return new OpenCodeClient(void 0, client, fetchFn, promptTimeoutPolicy);
 }
 function buildSelectableModels(config, providers, providerAvailability = /* @__PURE__ */ new Map()) {
 	const configuredProviders = config.provider ?? {};
@@ -816,7 +800,14 @@ function shouldPollPromptMessage(data, structured) {
 	const bodyMd = structured ? extractStructuredMarkdown(extractStructuredPayload(assistantInfo)) : null;
 	const hasText = extractTextFromParts(Array.isArray(data.parts) ? data.parts : []).length > 0;
 	const hasAssistantError = !!assistantInfo?.error;
-	return !hasText && !bodyMd && !hasAssistantError;
+	const isCompleted = isAssistantMessageCompleted(assistantInfo);
+	return !hasText && !bodyMd && !hasAssistantError && !isCompleted;
+}
+function shouldReturnPromptResponseImmediately(data, structured) {
+	return !shouldPollPromptMessage(data, structured) && !isCompletedEmptyPromptResponse(data, structured);
+}
+function isPromptResponseUsable(data, structured) {
+	return !shouldPollPromptMessage(data, structured) && !isCompletedEmptyPromptResponse(data, structured);
 }
 function normalizePromptResponse(response) {
 	return {
@@ -875,8 +866,26 @@ function extractMessageId(message) {
 	if (!isPlainRecord(message)) return null;
 	return typeof message.id === "string" && message.id.trim().length > 0 ? message.id : null;
 }
-function delay(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+function delay(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const handle = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(handle);
+			signal?.removeEventListener("abort", onAbort);
+			reject(normalizeAbortReason(signal?.reason));
+		};
+		if (signal?.aborted) {
+			onAbort();
+			return;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function didPromptResponseAdvance(previous, next, structured) {
+	return getPromptResponseProgressSignature(previous, structured) !== getPromptResponseProgressSignature(next, structured);
 }
 function createOpenCodePromptTimeoutError(input) {
 	return new OpenCodePromptTimeoutError({
@@ -885,6 +894,16 @@ function createOpenCodePromptTimeoutError(input) {
 		message: input.message ?? "The OpenCode host did not finish this request in time."
 	});
 }
+function resolvePromptEndpointKind(stage) {
+	switch (stage) {
+		case "capture-known-messages":
+		case "poll-messages":
+		case "final-scan": return "messages";
+		case "poll-message": return "message";
+		case "poll-status": return "status";
+		default: return "prompt";
+	}
+}
 function getPromptMessagePollDelayMs(attempt) {
 	return PROMPT_MESSAGE_POLL_INITIAL_DELAYS_MS[attempt] ?? PROMPT_MESSAGE_POLL_INTERVAL_MS;
 }
@@ -940,11 +959,12 @@ function unwrapSdkData(response) {
 	if (response && typeof response === "object" && "data" in response) return response.data;
 	return response;
 }
-function getRawSdkClient(client) {
-	return client.client ?? client._client ?? null;
-}
-function hasRawSdkMethod(client, method) {
-	return typeof getRawSdkClient(client)?.[method] === "function";
+function resolvePromptTimeoutPolicy(input) {
+	return {
+		pollRequestTimeoutMs: input.pollRequestTimeoutMs ?? DEFAULT_OPENCODE_PROMPT_TIMEOUT_POLICY.pollRequestTimeoutMs,
+		recoveryInactivityTimeoutMs: input.recoveryInactivityTimeoutMs ?? DEFAULT_OPENCODE_PROMPT_TIMEOUT_POLICY.recoveryInactivityTimeoutMs,
+		waitTimeoutMs: input.waitTimeoutMs ?? DEFAULT_OPENCODE_PROMPT_TIMEOUT_POLICY.waitTimeoutMs
+	};
 }
 function normalizeAssistantError(value) {
 	if (!isPlainRecord(value) || typeof value.name !== "string" || value.name.trim().length === 0) return;
@@ -954,6 +974,15 @@ function normalizeAssistantError(value) {
 		...isPlainRecord(value.data) ? { data: value.data } : {}
 	};
 }
+function isAssistantMessageCompleted(message) {
+	return !!message?.error || typeof message?.time?.completed === "number" || typeof message?.finish === "string" && message.finish.trim().length > 0;
+}
+function isCompletedEmptyPromptResponse(data, structured) {
+	const assistantInfo = toAssistantMessage(data.info);
+	const bodyMd = structured ? extractStructuredMarkdown(extractStructuredPayload(assistantInfo)) : null;
+	const hasText = extractTextFromParts(Array.isArray(data.parts) ? data.parts : []).length > 0;
+	return isAssistantMessageCompleted(assistantInfo) && !assistantInfo?.error && !hasText && !bodyMd;
+}
 function extractStructuredPayload(message) {
 	if (!isPlainRecord(message)) return null;
 	if ("structured" in message && message.structured !== void 0) return message.structured;
@@ -968,7 +997,7 @@ function selectPromptResponseCandidate(candidates, options) {
 function comparePromptResponseCandidates(left, right, options) {
 	const leftRank = getPromptResponseCandidateRank(left, options);
 	const rightRank = getPromptResponseCandidateRank(right, options);
-	return Number(rightRank.isUsable) - Number(leftRank.isUsable) || Number(rightRank.isInitial) - Number(leftRank.isInitial) || Number(rightRank.sharesParent) - Number(leftRank.sharesParent) || Number(rightRank.isNewSinceRequestStart) - Number(leftRank.isNewSinceRequestStart) || rightRank.createdAt - leftRank.createdAt;
+	return Number(rightRank.isInitial) - Number(leftRank.isInitial) || Number(rightRank.sharesParent) - Number(leftRank.sharesParent) || Number(rightRank.isNewSinceRequestStart) - Number(leftRank.isNewSinceRequestStart) || Number(rightRank.isUsable) - Number(leftRank.isUsable) || rightRank.createdAt - leftRank.createdAt;
 }
 function getPromptResponseCandidateRank(message, options) {
 	const assistant = toAssistantMessage(message.info);
@@ -978,25 +1007,57 @@ function getPromptResponseCandidateRank(message, options) {
 		createdAt,
 		isInitial: !!id && id === options.initialMessageId,
 		isNewSinceRequestStart: isPromptResponseNewSinceRequestStart(id, createdAt, options.knownMessageIds, options.requestStartedAt),
-		isUsable: !shouldPollPromptMessage(message, options.structured),
+		isUsable: isPromptResponseUsable(message, options.structured),
 		sharesParent: !!assistant?.parentID && assistant.parentID === options.initialParentId
 	};
 }
 function resolvePromptCandidateStartTime(startedAt, initialMessage) {
-	if (!initialMessage) return null;
+	if (!initialMessage) return startedAt;
 	const initialCreatedAt = coerceFiniteNumber(toAssistantMessage(initialMessage.info)?.time?.created);
 	if (initialCreatedAt === null) return startedAt;
 	return areComparablePromptTimestamps(startedAt, initialCreatedAt) ? startedAt : initialCreatedAt;
 }
+function getPromptResponseProgressSignature(response, structured) {
+	if (!response) return "null";
+	const assistant = toAssistantMessage(response.info);
+	const responseParts = Array.isArray(response.parts) ? response.parts : [];
+	return JSON.stringify({
+		assistantError: assistant?.error?.name ?? null,
+		bodyMd: structured ? extractStructuredMarkdown(extractStructuredPayload(assistant)) : null,
+		completedAt: assistant?.time?.completed ?? null,
+		finish: assistant?.finish ?? null,
+		id: assistant?.id ?? null,
+		partCount: responseParts.length,
+		text: extractTextFromParts(responseParts)
+	});
+}
 function isPromptResponseNewSinceRequestStart(messageId, createdAt, knownMessageIds, requestStartedAt) {
 	if (!messageId || knownMessageIds.has(messageId)) return false;
 	if (requestStartedAt === null) return true;
 	return createdAt >= requestStartedAt;
 }
+function isPromptResponseForCurrentRequest(response, options) {
+	const rank = getPromptResponseCandidateRank(response, options);
+	return rank.isInitial || rank.sharesParent || rank.isNewSinceRequestStart;
+}
 function areComparablePromptTimestamps(left, right) {
 	const epochThresholdMs = 0xe8d4a51000;
 	return left >= epochThresholdMs && right >= epochThresholdMs;
 }
+function isPromptRequestAbort(error) {
+	return error instanceof OpenCodeMessageAbortedError || error instanceof Error && error.name === "AbortError" || isNamedAbortError(error);
+}
+function isNamedAbortError(error) {
+	return !!error && typeof error === "object" && "name" in error && error.name === "MessageAbortedError";
+}
+function normalizeAbortReason(reason) {
+	if (reason instanceof Error || isNamedAbortError(reason)) return reason;
+	return createMessageAbortedError();
+}
+function throwIfAborted(signal) {
+	if (!signal?.aborted) return;
+	throw normalizeAbortReason(signal.reason);
+}
 function isPlainRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -1164,85 +1225,119 @@ function extractErrorMessage(error) {
 //#endregion
 //#region src/services/session-activity/foreground-session-tracker.ts
 var ForegroundSessionTracker = class {
-	chatStacks = /* @__PURE__ */ new Map();
-	counts = /* @__PURE__ */ new Map();
+	requests = /* @__PURE__ */ new Map();
 	sessionChats = /* @__PURE__ */ new Map();
+	acquire(chatId) {
+		if (this.requests.has(chatId)) return null;
+		const state = {
+			chatId,
+			controller: new AbortController(),
+			sessionId: null
+		};
+		this.requests.set(chatId, state);
+		return {
+			signal: state.controller.signal,
+			attachSession: (sessionId) => {
+				this.attachSession(chatId, sessionId);
+			},
+			dispose: () => {
+				this.release(chatId);
+			}
+		};
+	}
+	abort(chatId, reason = createMessageAbortedError()) {
+		const state = this.requests.get(chatId);
+		if (!state) return false;
+		if (!state.controller.signal.aborted) state.controller.abort(reason);
+		return true;
+	}
 	begin(chatId, sessionId) {
-		const currentCount = this.counts.get(sessionId) ?? 0;
-		this.counts.set(sessionId, currentCount + 1);
-		this.incrementChat(chatId, sessionId);
+		const lease = this.acquire(chatId);
+		if (!lease) return () => void 0;
+		lease.attachSession(sessionId);
 		return () => {
-			this.decrement(chatId, sessionId);
+			lease.dispose();
 		};
 	}
 	clear(sessionId) {
-		const wasForeground = this.counts.has(sessionId);
-		const chatCounts = this.sessionChats.get(sessionId);
-		this.counts.delete(sessionId);
-		this.sessionChats.delete(sessionId);
-		for (const chatId of chatCounts?.keys() ?? []) {
-			const stack = this.chatStacks.get(chatId);
-			if (!stack) continue;
-			const nextStack = stack.filter((trackedSessionId) => trackedSessionId !== sessionId);
-			if (nextStack.length === 0) {
-				this.chatStacks.delete(chatId);
-				continue;
-			}
-			this.chatStacks.set(chatId, nextStack);
+		const chatIds = this.listChatIds(sessionId);
+		if (chatIds.length === 0) return false;
+		for (const chatId of chatIds) {
+			const state = this.requests.get(chatId);
+			if (state?.sessionId === sessionId) state.sessionId = null;
 		}
-		return wasForeground;
+		this.sessionChats.delete(sessionId);
+		return true;
+	}
+	fail(sessionId, error) {
+		const chatIds = this.listChatIds(sessionId);
+		if (chatIds.length === 0) return false;
+		this.clear(sessionId);
+		for (const chatId of chatIds) this.abort(chatId, error);
+		return true;
 	}
 	getActiveSessionId(chatId) {
-		return this.chatStacks.get(chatId)?.at(-1) ?? null;
+		return this.requests.get(chatId)?.sessionId ?? null;
+	}
+	hasActiveRequest(chatId) {
+		return this.requests.has(chatId);
 	}
 	isForeground(sessionId) {
-		return this.counts.has(sessionId);
+		return this.sessionChats.has(sessionId);
 	}
 	listChatIds(sessionId) {
-		return [...this.sessionChats.get(sessionId)?.keys() ?? []];
-	}
-	decrement(chatId, sessionId) {
-		const currentCount = this.counts.get(sessionId);
-		if (!currentCount || currentCount <= 1) this.counts.delete(sessionId);
-		else this.counts.set(sessionId, currentCount - 1);
-		this.decrementChat(chatId, sessionId);
-	}
-	incrementChat(chatId, sessionId) {
-		const stack = this.chatStacks.get(chatId) ?? [];
-		stack.push(sessionId);
-		this.chatStacks.set(chatId, stack);
-		const chatCounts = this.sessionChats.get(sessionId) ?? /* @__PURE__ */ new Map();
-		const currentCount = chatCounts.get(chatId) ?? 0;
-		chatCounts.set(chatId, currentCount + 1);
-		this.sessionChats.set(sessionId, chatCounts);
-	}
-	decrementChat(chatId, sessionId) {
-		const stack = this.chatStacks.get(chatId);
-		if (stack) {
-			const index = stack.lastIndexOf(sessionId);
-			if (index >= 0) stack.splice(index, 1);
-			if (stack.length === 0) this.chatStacks.delete(chatId);
-			else this.chatStacks.set(chatId, stack);
+		return [...this.sessionChats.get(sessionId) ?? /* @__PURE__ */ new Set()];
+	}
+	attachSession(chatId, sessionId) {
+		const normalizedSessionId = sessionId.trim();
+		const state = this.requests.get(chatId);
+		if (!state || normalizedSessionId.length === 0) return;
+		if (state.sessionId === normalizedSessionId) return;
+		if (state.sessionId) this.detachChatFromSession(chatId, state.sessionId);
+		state.sessionId = normalizedSessionId;
+		const chatIds = this.sessionChats.get(normalizedSessionId) ?? /* @__PURE__ */ new Set();
+		chatIds.add(chatId);
+		this.sessionChats.set(normalizedSessionId, chatIds);
+	}
+	release(chatId) {
+		const state = this.requests.get(chatId);
+		if (!state) return;
+		if (state.sessionId) this.detachChatFromSession(chatId, state.sessionId);
+		this.requests.delete(chatId);
+	}
+	detachChatFromSession(chatId, sessionId) {
+		const chatIds = this.sessionChats.get(sessionId);
+		if (!chatIds) return;
+		chatIds.delete(chatId);
+		if (chatIds.size === 0) {
+			this.sessionChats.delete(sessionId);
+			return;
 		}
-		const chatCounts = this.sessionChats.get(sessionId);
-		if (!chatCounts) return;
-		const currentCount = chatCounts.get(chatId) ?? 0;
-		if (currentCount <= 1) chatCounts.delete(chatId);
-		else chatCounts.set(chatId, currentCount - 1);
-		if (chatCounts.size === 0) this.sessionChats.delete(sessionId);
-		else this.sessionChats.set(sessionId, chatCounts);
+		this.sessionChats.set(sessionId, chatIds);
 	}
 };
 var NOOP_FOREGROUND_SESSION_TRACKER = {
+	acquire() {
+		return null;
+	},
+	abort() {
+		return false;
+	},
 	begin() {
 		return () => void 0;
 	},
 	clear() {
 		return false;
 	},
+	fail() {
+		return false;
+	},
 	getActiveSessionId() {
 		return null;
 	},
+	hasActiveRequest() {
+		return false;
+	},
 	isForeground() {
 		return false;
 	},
@@ -1259,23 +1354,40 @@ var AbortPromptUseCase = class {
 		this.foregroundSessionTracker = foregroundSessionTracker;
 	}
 	async execute(input) {
+		const hasForegroundRequest = this.foregroundSessionTracker.hasActiveRequest(input.chatId);
 		const activeSessionId = this.foregroundSessionTracker.getActiveSessionId(input.chatId);
 		const binding = activeSessionId ? null : await this.sessionRepo.getByChatId(input.chatId);
 		const sessionId = activeSessionId ?? binding?.sessionId ?? null;
-		if (!sessionId) return {
+		if (!hasForegroundRequest && !sessionId) return {
 			sessionId: null,
 			status: "no_session",
 			sessionStatus: null
 		};
-		const sessionStatus = (await this.opencodeClient.getSessionStatuses())[sessionId] ?? null;
+		const sessionStatuses = sessionId ? await this.opencodeClient.getSessionStatuses() : {};
+		const sessionStatus = sessionId ? sessionStatuses[sessionId] ?? null : null;
+		if (hasForegroundRequest) {
+			if (sessionId && sessionStatus && sessionStatus.type !== "idle") await this.opencodeClient.abortSession(sessionId);
+			this.foregroundSessionTracker.abort(input.chatId, createMessageAbortedError());
+			return {
+				sessionId,
+				status: "aborted",
+				sessionStatus
+			};
+		}
 		if (!sessionStatus || sessionStatus.type === "idle") return {
 			sessionId,
 			status: "not_running",
 			sessionStatus
 		};
+		if (!sessionId) return {
+			sessionId: null,
+			status: "not_running",
+			sessionStatus
+		};
+		const runningSessionId = sessionId;
 		return {
-			sessionId,
-			status: await this.opencodeClient.abortSession(sessionId) ? "aborted" : "not_running",
+			sessionId: runningSessionId,
+			status: await this.opencodeClient.abortSession(runningSessionId) ? "aborted" : "not_running",
 			sessionStatus
 		};
 	}
@@ -1717,11 +1829,10 @@ var RenameSessionUseCase = class {
 //#endregion
 //#region src/use-cases/send-prompt.usecase.ts
 var SendPromptUseCase = class {
-	constructor(sessionRepo, opencodeClient, logger, foregroundSessionTracker = NOOP_FOREGROUND_SESSION_TRACKER) {
+	constructor(sessionRepo, opencodeClient, logger) {
 		this.sessionRepo = sessionRepo;
 		this.opencodeClient = opencodeClient;
 		this.logger = logger;
-		this.foregroundSessionTracker = foregroundSessionTracker;
 	}
 	async execute(input) {
 		const files = input.files ?? [];
@@ -1775,7 +1886,7 @@ var SendPromptUseCase = class {
 		}
 		const temporarySessionId = shouldIsolateImageTurn ? await this.createTemporaryImageSession(input.chatId, activeBinding.sessionId) : null;
 		const executionSessionId = temporarySessionId ?? activeBinding.sessionId;
-		const endForegroundSession = this.foregroundSessionTracker.begin(input.chatId, executionSessionId);
+		input.onExecutionSession?.(executionSessionId);
 		let result;
 		try {
 			result = await this.opencodeClient.promptSession({
@@ -1785,10 +1896,10 @@ var SendPromptUseCase = class {
 				...selectedAgent ? { agent: selectedAgent.name } : {},
 				structured: true,
 				...model ? { model } : {},
+				...input.signal ? { signal: input.signal } : {},
 				...activeBinding.modelVariant ? { variant: activeBinding.modelVariant } : {}
 			});
 		} finally {
-			endForegroundSession();
 			if (temporarySessionId) await this.cleanupTemporaryImageSession(input.chatId, activeBinding.sessionId, temporarySessionId);
 		}
 		await this.sessionRepo.touch(input.chatId);
@@ -2025,7 +2136,11 @@ function resolveExtension(mimeType) {
 //#region src/app/container.ts
 function createAppContainer(config, client) {
 	const logger = createOpenCodeAppLogger(client, { level: config.logLevel });
-	return createContainer(config, createOpenCodeClientFromSdkClient(client), logger);
+	return createContainer(config, createOpenCodeClientFromSdkClient(client, fetch, {
+		waitTimeoutMs: config.promptWaitTimeoutMs,
+		pollRequestTimeoutMs: config.promptPollRequestTimeoutMs,
+		recoveryInactivityTimeoutMs: config.promptRecoveryInactivityTimeoutMs
+	}), logger);
 }
 function createContainer(config, opencodeClient, logger) {
 	const stateStore = new JsonStateStore({
@@ -2052,7 +2167,7 @@ function createContainer(config, opencodeClient, logger) {
 	const getStatusUseCase = new GetStatusUseCase(getHealthUseCase, getPathUseCase, listLspUseCase, listMcpUseCase, listSessionsUseCase, sessionRepo);
 	const listModelsUseCase = new ListModelsUseCase(sessionRepo, opencodeClient);
 	const renameSessionUseCase = new RenameSessionUseCase(sessionRepo, opencodeClient, logger);
-	const sendPromptUseCase = new SendPromptUseCase(sessionRepo, opencodeClient, logger, foregroundSessionTracker);
+	const sendPromptUseCase = new SendPromptUseCase(sessionRepo, opencodeClient, logger);
 	const switchAgentUseCase = new SwitchAgentUseCase(sessionRepo, opencodeClient, logger);
 	const switchModelUseCase = new SwitchModelUseCase(sessionRepo, opencodeClient, logger);
 	const switchSessionUseCase = new SwitchSessionUseCase(sessionRepo, opencodeClient, logger);
@@ -2159,21 +2274,25 @@ function escapeMarkdownV2(value) {
 async function handleTelegramBotPluginEvent(runtime, event) {
 	switch (event.type) {
 		case "permission.asked":
-			await handlePermissionAsked(runtime, event.properties);
+			await handlePermissionAsked(runtime, event);
 			return;
 		case "permission.replied":
-			await handlePermissionReplied(runtime, event.properties.requestID, event.properties.reply);
+			await handlePermissionReplied(runtime, event);
 			return;
 		case "session.error":
-			await handleSessionError(runtime, event.properties.sessionID, event.properties.error);
+			await handleSessionError(runtime, event);
 			return;
 		case "session.idle":
-			await handleSessionIdle(runtime, event.properties.sessionID);
+			await handleSessionIdle(runtime, event);
+			return;
+		case "session.status":
+			await handleSessionStatus(runtime, event);
 			return;
 		default: return;
 	}
 }
-async function handlePermissionAsked(runtime, request) {
+async function handlePermissionAsked(runtime, event) {
+	const request = event.properties;
 	const bindings = await runtime.container.sessionRepo.listBySessionId(request.sessionID);
 	const chatIds = new Set([...bindings.map((binding) => binding.chatId), ...runtime.container.foregroundSessionTracker.listChatIds(request.sessionID)]);
 	const approvals = await runtime.container.permissionApprovalRepo.listByRequestId(request.id);
@@ -2202,7 +2321,9 @@ async function handlePermissionAsked(runtime, request) {
 		}
 	}
 }
-async function handlePermissionReplied(runtime, requestId, reply) {
+async function handlePermissionReplied(runtime, event) {
+	const requestId = event.properties.requestID;
+	const reply = event.properties.reply;
 	const approvals = await runtime.container.permissionApprovalRepo.listByRequestId(requestId);
 	await Promise.all(approvals.map(async (approval) => {
 		try {
@@ -2217,27 +2338,37 @@ async function handlePermissionReplied(runtime, requestId, reply) {
 		await runtime.container.permissionApprovalRepo.set(toResolvedApproval(approval, reply));
 	}));
 }
-async function handleSessionError(runtime, sessionId, error) {
+async function handleSessionError(runtime, event) {
+	const sessionId = event.properties.sessionID;
+	const error = event.properties.error;
 	if (!sessionId) {
 		runtime.container.logger.error({ error }, "session error received without a session id");
 		return;
 	}
-	if (runtime.container.foregroundSessionTracker.clear(sessionId)) {
+	if (runtime.container.foregroundSessionTracker.fail(sessionId, error ?? /* @__PURE__ */ new Error("Unknown session error."))) {
 		runtime.container.logger.warn({
 			error,
 			sessionId
 		}, "session error suppressed for foreground Telegram session");
 		return;
 	}
-	await notifyBoundChats(runtime, sessionId, `Session failed.\n\nSession: ${sessionId}\nError: ${error?.data?.message?.trim() || error?.name?.trim() || "Unknown session error."}`);
+	await notifyBoundChats(runtime, sessionId, `Session failed.\n\nSession: ${sessionId}\nError: ${(typeof error?.data?.message === "string" ? error.data.message.trim() : "") || error?.name?.trim() || "Unknown session error."}`);
 }
-async function handleSessionIdle(runtime, sessionId) {
+async function handleSessionIdle(runtime, event) {
+	const sessionId = event.properties.sessionID;
 	if (runtime.container.foregroundSessionTracker.clear(sessionId)) {
 		runtime.container.logger.info({ sessionId }, "session idle notification suppressed for foreground Telegram session");
 		return;
 	}
 	await notifyBoundChats(runtime, sessionId, `Session finished.\n\nSession: ${sessionId}`);
 }
+async function handleSessionStatus(runtime, event) {
+	if (event.properties.status.type !== "idle") return;
+	await handleSessionIdle(runtime, {
+		type: "session.idle",
+		properties: { sessionID: event.properties.sessionID }
+	});
+}
 async function notifyBoundChats(runtime, sessionId, text) {
 	const bindings = await runtime.container.sessionRepo.listBySessionId(sessionId);
 	const chatIds = [...new Set(bindings.map((binding) => binding.chatId))];
@@ -4478,8 +4609,8 @@ async function handlePermissionApprovalCallback(ctx, dependencies) {
 	const parsed = parsePermissionApprovalCallbackData(data);
 	if (!parsed) return;
 	try {
-		await dependencies.opencodeClient.replyToPermission(parsed.requestId, parsed.reply);
 		const approval = (await dependencies.permissionApprovalRepo.listByRequestId(parsed.requestId)).find((item) => item.chatId === ctx.chat?.id);
+		await dependencies.opencodeClient.replyToPermission(parsed.requestId, parsed.reply, void 0, approval?.sessionId);
 		if (approval) await dependencies.permissionApprovalRepo.set({
 			...approval,
 			status: parsed.reply,
@@ -4525,23 +4656,26 @@ function parseSessionActionTarget(data, prefix) {
 }
 //#endregion
 //#region src/bot/handlers/prompt.handler.ts
-var activePromptChats = /* @__PURE__ */ new Set();
 async function executePromptRequest(ctx, dependencies, resolvePrompt) {
 	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
-	if (activePromptChats.has(ctx.chat.id)) {
+	const foregroundRequest = dependencies.foregroundSessionTracker.acquire(ctx.chat.id);
+	if (!foregroundRequest) {
 		await ctx.reply(copy.status.alreadyProcessing);
 		return;
 	}
 	let processingMessage = null;
 	let sentTerminalReply = false;
 	try {
-		activePromptChats.add(ctx.chat.id);
 		processingMessage = await ctx.reply(copy.status.processing);
 		const promptInput = await resolvePrompt();
 		const telegramReply = buildTelegramPromptReply(normalizePromptReplyForDisplay((await dependencies.sendPromptUseCase.execute({
 			chatId: ctx.chat.id,
-			text: promptInput.text,
-			files: promptInput.files
+			files: promptInput.files,
+			onExecutionSession: (sessionId) => {
+				foregroundRequest.attachSession(sessionId);
+			},
+			signal: foregroundRequest.signal,
+			text: promptInput.text
 		})).assistantReply, copy, dependencies), copy);
 		try {
 			await ctx.reply(telegramReply.preferred.text, telegramReply.preferred.options);
@@ -4555,7 +4689,7 @@ async function executePromptRequest(ctx, dependencies, resolvePrompt) {
 		await ctx.reply(presentError(error, copy));
 		sentTerminalReply = true;
 	} finally {
-		activePromptChats.delete(ctx.chat.id);
+		foregroundRequest.dispose();
 		if (processingMessage && sentTerminalReply) try {
 			await ctx.api.deleteMessage(ctx.chat.id, processingMessage.message_id);
 		} catch (error) {