opencode-tbot 0.1.28 → 0.1.31

package/dist/plugin.js

@@ -1,73 +1,361 @@
-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 { i as OPENCODE_TBOT_VERSION, n as preparePluginConfiguration, o as loadAppConfig } from "./assets/plugin-config-jkAZYbFW.js";
+import { appendFile, mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import { parse, printParseErrorCode } from "jsonc-parser";
 import { z } from "zod";
-import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
 import { randomUUID } from "node:crypto";
+import { createOpencodeClient } from "@opencode-ai/sdk";
 import { run } from "@grammyjs/runner";
-import { Bot, InlineKeyboard } from "grammy";
+import { Bot, GrammyError, HttpError, InlineKeyboard } from "grammy";
 //#region src/infra/utils/redact.ts
-var REDACTED = "[REDACTED]";
-var DEFAULT_PREVIEW_LENGTH = 160;
+var REDACTED$1 = "[REDACTED]";
 var TELEGRAM_TOKEN_PATTERN = /\b\d{6,}:[A-Za-z0-9_-]{20,}\b/g;
 var BEARER_TOKEN_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/-]+=*\b/gi;
 var NAMED_SECRET_PATTERN = /\b(api[_\s-]?key|token|secret|password)\b(\s*[:=]\s*)([^\s,;]+)/gi;
 var API_KEY_LIKE_PATTERN = /\b(?:sk|pk)_[A-Za-z0-9_-]{10,}\b/g;
 function redactSensitiveText(input) {
-	return input.replace(BEARER_TOKEN_PATTERN, `Bearer ${REDACTED}`).replace(TELEGRAM_TOKEN_PATTERN, REDACTED).replace(NAMED_SECRET_PATTERN, (_, name, separator) => `${name}${separator}${REDACTED}`).replace(API_KEY_LIKE_PATTERN, REDACTED);
-}
-function createRedactedPreview(input, maxLength = DEFAULT_PREVIEW_LENGTH) {
-	const redacted = redactSensitiveText(input).replace(/\s+/g, " ").trim();
-	if (redacted.length <= maxLength) return redacted;
-	return `${redacted.slice(0, Math.max(0, maxLength - 3))}...`;
+	return input.replace(BEARER_TOKEN_PATTERN, `Bearer ${REDACTED$1}`).replace(TELEGRAM_TOKEN_PATTERN, REDACTED$1).replace(NAMED_SECRET_PATTERN, (_, name, separator) => `${name}${separator}${REDACTED$1}`).replace(API_KEY_LIKE_PATTERN, REDACTED$1);
 }
 //#endregion
 //#region src/infra/logger/index.ts
+var DEFAULT_COMPONENT = "app";
+var DEFAULT_EVENT = "log";
 var DEFAULT_SERVICE_NAME = "opencode-tbot";
+var DEFAULT_MAX_LOG_FILES = 30;
+var DEFAULT_MAX_TOTAL_LOG_BYTES = 314572800;
+var CONTENT_OMITTED = "[OMITTED]";
+var REDACTED = "[REDACTED]";
 var LEVEL_PRIORITY = {
 	debug: 10,
 	info: 20,
 	warn: 30,
 	error: 40
 };
+var RESERVED_EVENT_FIELDS = new Set([
+	"attempt",
+	"callbackData",
+	"chatId",
+	"command",
+	"component",
+	"correlationId",
+	"durationMs",
+	"error",
+	"event",
+	"operationId",
+	"projectId",
+	"requestId",
+	"runtimeId",
+	"sessionId",
+	"sizeBytes",
+	"status",
+	"updateId",
+	"worktree"
+]);
 function createOpenCodeAppLogger(client, options = {}) {
 	const service = normalizeServiceName(options.service);
 	const minimumLevel = normalizeLogLevel(options.level);
+	const runtimeId = normalizeString(options.runtimeId) ?? randomUUID();
+	const boundRootContext = {
+		component: DEFAULT_COMPONENT,
+		runtimeId,
+		...options.worktree ? { worktree: options.worktree } : {}
+	};
+	const sinks = createSinks(client, {
+		file: {
+			dir: options.file?.dir,
+			maxFiles: options.file?.retention?.maxFiles,
+			maxTotalBytes: options.file?.retention?.maxTotalBytes
+		},
+		runtimeId,
+		service,
+		sinks: options.sinks
+	});
 	let queue = Promise.resolve();
-	const enqueue = (level, input, message) => {
-		if (LEVEL_PRIORITY[level] < LEVEL_PRIORITY[minimumLevel]) return;
-		const { extra, text } = normalizeLogArguments(input, message);
-		const payload = {
-			service,
-			level,
-			message: text,
-			...extra ? { extra } : {}
-		};
+	const enqueue = (event) => {
+		if (LEVEL_PRIORITY[event.level] < LEVEL_PRIORITY[minimumLevel]) return;
+		const structuredEvent = buildStructuredLogEvent(event.level, event.input, event.message, service, event.context);
 		queue = queue.catch(() => void 0).then(async () => {
-			try {
-				await client.app.log(payload);
-			} catch {}
+			await Promise.allSettled(sinks.map((sink) => sink.write(structuredEvent)));
 		});
 	};
-	return {
+	const createLogger = (context) => ({
 		debug(input, message) {
-			enqueue("debug", input, message);
+			enqueue({
+				context,
+				input,
+				level: "debug",
+				message
+			});
 		},
 		info(input, message) {
-			enqueue("info", input, message);
+			enqueue({
+				context,
+				input,
+				level: "info",
+				message
+			});
 		},
 		warn(input, message) {
-			enqueue("warn", input, message);
+			enqueue({
+				context,
+				input,
+				level: "warn",
+				message
+			});
 		},
 		error(input, message) {
-			enqueue("error", input, message);
+			enqueue({
+				context,
+				input,
+				level: "error",
+				message
+			});
+		},
+		child(childContext) {
+			return createLogger({
+				...context,
+				...removeUndefinedFields(childContext)
+			});
 		},
 		async flush() {
 			await queue.catch(() => void 0);
+			await Promise.allSettled(sinks.map(async (sink) => {
+				await sink.flush?.();
+			}));
+		}
+	});
+	return createLogger(boundRootContext);
+}
+function logTelegramUpdate(logger, input, message) {
+	logger.info({
+		component: "telegram",
+		...input
+	}, message);
+}
+function logPromptLifecycle(logger, input, message) {
+	logger.info({
+		component: "prompt",
+		...input
+	}, message);
+}
+function logOpenCodeRequest(logger, input, message) {
+	logger.info({
+		component: "opencode",
+		...input
+	}, message);
+}
+function logPluginEvent(logger, input, message) {
+	logger.info({
+		component: "plugin-event",
+		...input
+	}, message);
+}
+function createSinks(client, options) {
+	const sinkOptions = options.sinks ?? {};
+	const sinks = [];
+	if (sinkOptions.host !== false) sinks.push(createHostSink(client, options.service));
+	if (sinkOptions.file !== false && options.file?.dir) sinks.push(createJsonlFileSink({
+		dir: options.file.dir,
+		maxFiles: options.file.maxFiles,
+		maxTotalBytes: options.file.maxTotalBytes,
+		runtimeId: options.runtimeId
+	}));
+	return sinks;
+}
+function createHostSink(client, service) {
+	return { async write(event) {
+		const payload = {
+			service,
+			level: event.level,
+			message: event.message,
+			extra: buildHostLogExtra(event)
+		};
+		if (client.app.log.length >= 2) {
+			await client.app.log(payload, {
+				responseStyle: "data",
+				throwOnError: true
+			});
+			return;
+		}
+		await client.app.log({
+			body: payload,
+			responseStyle: "data",
+			throwOnError: true
+		});
+	} };
+}
+function createJsonlFileSink(options) {
+	const maxFiles = options.maxFiles ?? DEFAULT_MAX_LOG_FILES;
+	const maxTotalBytes = options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_LOG_BYTES;
+	const runtimeSegment = sanitizeFileSegment(options.runtimeId);
+	const timestampSegment = (/* @__PURE__ */ new Date()).toISOString().replace(/:/gu, "-");
+	const filePath = join(options.dir, `${timestampSegment}.${process.pid}.${runtimeSegment}.jsonl`);
+	let initialized = false;
+	let writeCount = 0;
+	const initialize = async () => {
+		if (initialized) return;
+		await mkdir(options.dir, { recursive: true });
+		await cleanupLogDirectory(options.dir, maxFiles, maxTotalBytes);
+		initialized = true;
+	};
+	return { async write(event) {
+		await initialize();
+		await appendFile(filePath, `${JSON.stringify(event)}\n`, "utf8");
+		writeCount += 1;
+		if (writeCount === 1 || writeCount % 100 === 0) await cleanupLogDirectory(options.dir, maxFiles, maxTotalBytes);
+	} };
+}
+async function cleanupLogDirectory(directory, maxFiles, maxTotalBytes) {
+	let entries = [];
+	try {
+		const names = await readdir(directory);
+		entries = await Promise.all(names.filter((name) => name.endsWith(".jsonl")).map(async (name) => {
+			const entryPath = join(directory, name);
+			const entryStat = await stat(entryPath);
+			return {
+				path: entryPath,
+				size: entryStat.size,
+				time: entryStat.mtimeMs
+			};
+		}));
+	} catch {
+		return;
+	}
+	entries.sort((left, right) => right.time - left.time);
+	let totalBytes = 0;
+	const retained = [];
+	const deleted = [];
+	for (const entry of entries) {
+		const canKeepByCount = retained.length < maxFiles;
+		const canKeepBySize = retained.length === 0 || totalBytes + entry.size <= maxTotalBytes;
+		if (canKeepByCount && canKeepBySize) {
+			retained.push(entry);
+			totalBytes += entry.size;
+			continue;
+		}
+		deleted.push(entry);
+	}
+	await Promise.allSettled(deleted.map(async (entry) => {
+		await unlink(entry.path);
+	}));
+}
+function buildStructuredLogEvent(level, input, message, service, boundContext) {
+	const extracted = extractContextAndExtra(input);
+	const context = {
+		...removeUndefinedFields(boundContext),
+		...removeUndefinedFields(extracted.context)
+	};
+	const resolvedMessage = normalizeLogMessage(input, message);
+	return {
+		ts: (/* @__PURE__ */ new Date()).toISOString(),
+		level,
+		service,
+		component: normalizeComponent(context.component),
+		event: normalizeEventName(context.event),
+		message: redactSensitiveText(resolvedMessage),
+		runtimeId: context.runtimeId ?? null,
+		operationId: context.operationId ?? null,
+		correlationId: resolveCorrelationId(context),
+		...context.worktree ? { worktree: redactSensitiveText(context.worktree) } : {},
+		...typeof context.chatId === "number" ? { chatId: context.chatId } : {},
+		...context.sessionId ? { sessionId: context.sessionId } : {},
+		...context.projectId ? { projectId: context.projectId } : {},
+		...context.requestId ? { requestId: context.requestId } : {},
+		...typeof context.updateId === "number" ? { updateId: context.updateId } : {},
+		...context.command ? { command: context.command } : {},
+		...context.callbackData ? { callbackData: context.callbackData } : {},
+		...typeof context.durationMs === "number" ? { durationMs: context.durationMs } : {},
+		...typeof context.attempt === "number" ? { attempt: context.attempt } : {},
+		...context.status ? { status: context.status } : {},
+		...typeof context.sizeBytes === "number" ? { sizeBytes: context.sizeBytes } : {},
+		...context.error ? { error: context.error } : {},
+		...removeUndefinedFields(extracted.extra)
+	};
+}
+function buildHostLogExtra(event) {
+	const { service: _service, level: _level, message: _message, ...rest } = event;
+	return rest;
+}
+function extractContextAndExtra(input) {
+	if (input instanceof Error) return {
+		context: { error: serializeError(input) },
+		extra: {}
+	};
+	if (Array.isArray(input)) return {
+		context: {},
+		extra: { items: input.map((item) => sanitizeValue(item)) }
+	};
+	if (input === null || input === void 0) return {
+		context: {},
+		extra: {}
+	};
+	if (typeof input === "string") return {
+		context: {},
+		extra: {}
+	};
+	if (typeof input !== "object") return {
+		context: {},
+		extra: { value: sanitizeValue(input) }
+	};
+	const record = input;
+	const context = {};
+	const extra = {};
+	for (const [key, value] of Object.entries(record)) {
+		if (RESERVED_EVENT_FIELDS.has(key)) {
+			assignReservedField(context, key, value);
+			continue;
 		}
+		extra[key] = sanitizeFieldValue(key, value);
+	}
+	return {
+		context,
+		extra
 	};
 }
+function assignReservedField(context, key, value) {
+	switch (key) {
+		case "attempt":
+		case "durationMs":
+		case "sizeBytes":
+			if (typeof value === "number") context[key] = value;
+			return;
+		case "chatId":
+		case "updateId":
+			if (typeof value === "number") context[key] = value;
+			return;
+		case "callbackData":
+		case "command":
+		case "component":
+		case "event":
+		case "projectId":
+		case "requestId":
+		case "sessionId":
+		case "status":
+		case "worktree":
+			if (typeof value === "string" && value.trim().length > 0) context[key] = redactSensitiveText(value.trim());
+			return;
+		case "correlationId":
+		case "operationId":
+		case "runtimeId":
+			if (typeof value === "string" && value.trim().length > 0) context[key] = value.trim();
+			else if (value === null) context[key] = null;
+			return;
+		case "error":
+			if (value instanceof Error) context.error = serializeError(value);
+			else if (isPlainObject(value)) context.error = normalizeStructuredLogErrorRecord(value);
+			return;
+		default: return;
+	}
+}
+function normalizeLogMessage(input, message) {
+	if (typeof input === "string") {
+		const normalizedInput = input.trim();
+		return normalizedInput.length > 0 ? normalizedInput : "log";
+	}
+	if (message && message.trim().length > 0) return message.trim();
+	if (input instanceof Error) return input.message.trim() || input.name;
+	return "log";
+}
 function normalizeServiceName(value) {
 	const normalized = value?.trim();
 	return normalized && normalized.length > 0 ? normalized : DEFAULT_SERVICE_NAME;
@@ -80,59 +368,140 @@ function normalizeLogLevel(value) {
 		default: return "info";
 	}
 }
-function normalizeLogArguments(input, message) {
-	if (typeof input === "string") return { text: input };
-	if (message && message.trim().length > 0) {
-		const extra = serializeExtra(input);
-		return {
-			...extra ? { extra } : {},
-			text: message.trim()
-		};
-	}
-	if (input instanceof Error) return {
-		extra: serializeExtra(input) ?? void 0,
-		text: input.message.trim() || input.name
-	};
-	const extra = serializeExtra(input);
+function normalizeComponent(value) {
+	const normalized = value?.trim();
+	return normalized && normalized.length > 0 ? normalized : DEFAULT_COMPONENT;
+}
+function normalizeEventName(value) {
+	const normalized = value?.trim();
+	return normalized && normalized.length > 0 ? normalized : DEFAULT_EVENT;
+}
+function resolveCorrelationId(context) {
+	if (context.correlationId) return context.correlationId;
+	if (typeof context.updateId === "number") return String(context.updateId);
+	return context.operationId ?? null;
+}
+function serializeError(error) {
 	return {
-		...extra ? { extra } : {},
-		text: "log"
+		name: error.name,
+		message: redactSensitiveText(error.message),
+		...error.stack ? { stack: redactSensitiveText(error.stack) } : {},
+		..."data" in error && error.data && typeof error.data === "object" ? { data: sanitizeValue(error.data) } : {}
 	};
 }
-function serializeExtra(input) {
-	if (input === null || input === void 0) return null;
-	if (input instanceof Error) return { error: serializeError(input) };
-	if (Array.isArray(input)) return { items: input.map((item) => sanitizeValue(item)) };
-	if (typeof input !== "object") return { value: sanitizeValue(input) };
-	return sanitizeRecord(input);
+function sanitizePlainObject(value) {
+	return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, sanitizeFieldValue(key, entryValue)]));
 }
-function sanitizeRecord(record) {
-	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, isSensitiveKey(key) ? redactSensitiveFieldValue(value) : sanitizeValue(value)]));
+function sanitizeFieldValue(key, value) {
+	if (isSensitiveKey(key)) return redactSensitiveFieldValue(value);
+	if (isUrlLikeKey(key)) return summarizeUrlValue(value);
+	if (isTextContentKey(key)) return summarizeTextValue(value);
+	if (isAttachmentCollectionKey(key)) return summarizeAttachmentCollection(value);
+	return sanitizeValue(value);
 }
 function sanitizeValue(value) {
 	if (value instanceof Error) return serializeError(value);
-	if (Array.isArray(value)) return value.map((item) => sanitizeValue(item));
+	if (Array.isArray(value)) return value.map((entry) => sanitizeValue(entry));
 	if (typeof value === "string") return redactSensitiveText(value);
 	if (!value || typeof value !== "object") return value;
-	return sanitizeRecord(value);
+	return sanitizePlainObject(value);
 }
-function serializeError(error) {
+function summarizeTextValue(value) {
+	if (typeof value === "string") return {
+		omitted: CONTENT_OMITTED,
+		length: value.length
+	};
+	if (Array.isArray(value)) return {
+		omitted: CONTENT_OMITTED,
+		count: value.length
+	};
+	if (value && typeof value === "object") return {
+		omitted: CONTENT_OMITTED,
+		kind: "object"
+	};
+	return value;
+}
+function summarizeUrlValue(value) {
+	if (typeof value === "string" && value.trim().length > 0) return {
+		omitted: CONTENT_OMITTED,
+		kind: "url"
+	};
+	return sanitizeValue(value);
+}
+function summarizeAttachmentCollection(value) {
+	if (!Array.isArray(value)) return summarizeTextValue(value);
 	return {
-		name: error.name,
-		message: redactSensitiveText(error.message),
-		...error.stack ? { stack: redactSensitiveText(error.stack) } : {},
-		..."data" in error && error.data && typeof error.data === "object" ? { data: sanitizeValue(error.data) } : {}
+		count: value.length,
+		items: value.map((entry) => summarizeAttachmentValue(entry))
 	};
 }
+function summarizeAttachmentValue(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return summarizeTextValue(value);
+	const record = value;
+	return removeUndefinedFields({
+		filename: normalizeString(record.filename) ?? normalizeString(record.fileName) ?? void 0,
+		mime: normalizeString(record.mime) ?? normalizeString(record.mimeType) ?? void 0,
+		sizeBytes: pickNumericValue(record, [
+			"sizeBytes",
+			"size",
+			"fileSize"
+		]),
+		hasCaption: pickStringValue(record, ["caption"]) !== null,
+		textLength: pickStringValue(record, ["text", "prompt"])?.length,
+		type: normalizeString(record.type) ?? void 0
+	});
+}
 function isSensitiveKey(key) {
-	return /token|secret|api[-_]?key|authorization|password/iu.test(key);
+	return /token|secret|api[-_]?key|authorization|password|cookie/iu.test(key);
+}
+function isTextContentKey(key) {
+	return /(^|[-_])(text|prompt|caption|body|markdown|content|messageText|fallbackText|input|raw)$/iu.test(key) || /bodyMd|bodyText|messageText|fallbackText/iu.test(key);
+}
+function isUrlLikeKey(key) {
+	return /(^|[-_])(url|uri|href|filePath|downloadPath|downloadUrl|fileUrl)$/iu.test(key);
+}
+function isAttachmentCollectionKey(key) {
+	return /(^|[-_])(files|parts|attachments)$/iu.test(key);
 }
 function redactSensitiveFieldValue(value) {
-	if (typeof value === "string" && value.trim().length > 0) return "[REDACTED]";
-	if (Array.isArray(value)) return value.map(() => "[REDACTED]");
-	if (value && typeof value === "object") return "[REDACTED]";
+	if (typeof value === "string" && value.trim().length > 0) return REDACTED;
+	if (Array.isArray(value)) return value.map(() => REDACTED);
+	if (value && typeof value === "object") return REDACTED;
 	return value;
 }
+function removeUndefinedFields(record) {
+	return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
+}
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? redactSensitiveText(value.trim()) : null;
+}
+function pickNumericValue(record, keys) {
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "number") return value;
+	}
+}
+function pickStringValue(record, keys) {
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim().length > 0) return value.trim();
+	}
+	return null;
+}
+function sanitizeFileSegment(value) {
+	return value.replace(/[^a-z0-9._-]+/giu, "_");
+}
+function normalizeStructuredLogErrorRecord(value) {
+	return {
+		name: normalizeString(value.name) ?? "Error",
+		message: normalizeString(value.message) ?? "Unknown error",
+		...typeof value.stack === "string" ? { stack: redactSensitiveText(value.stack) } : {},
+		...value.data !== void 0 ? { data: sanitizeValue(value.data) } : {}
+	};
+}
 //#endregion
 //#region src/repositories/pending-action.repo.ts
 var FilePendingActionRepository = class {
@@ -292,7 +661,10 @@ var OpenCodeClient = class {
 			...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));
+		return unwrapSdkData(handler.length >= 2 ? await handler.call(target, input.legacyParameters, options) : await handler.call(target, input.parameters === void 0 ? options : {
+			...input.parameters,
+			...options
+		}));
 	}
 	async getHealth() {
 		try {
@@ -303,25 +675,43 @@ var OpenCodeClient = class {
 		}
 	}
 	async abortSession(sessionId) {
-		return this.callScopedSdkMethod("session", "abort", { parameters: { sessionID: sessionId } });
+		return this.callScopedSdkMethod("session", "abort", {
+			legacyParameters: { sessionID: sessionId },
+			parameters: { path: { id: sessionId } }
+		});
 	}
 	async deleteSession(sessionId) {
-		return this.callScopedSdkMethod("session", "delete", { parameters: { sessionID: sessionId } });
+		return this.callScopedSdkMethod("session", "delete", {
+			legacyParameters: { sessionID: sessionId },
+			parameters: { path: { id: sessionId } }
+		});
 	}
 	async forkSession(sessionId, messageId) {
-		return this.callScopedSdkMethod("session", "fork", { parameters: {
-			sessionID: sessionId,
-			...messageId?.trim() ? { messageID: messageId.trim() } : {}
-		} });
+		return this.callScopedSdkMethod("session", "fork", {
+			legacyParameters: {
+				sessionID: sessionId,
+				...messageId?.trim() ? { messageID: messageId.trim() } : {}
+			},
+			parameters: {
+				path: { id: sessionId },
+				...messageId?.trim() ? { body: { messageID: messageId.trim() } } : {}
+			}
+		});
 	}
 	async getPath() {
 		return this.callScopedSdkMethod("path", "get", {});
 	}
 	async listLspStatuses(directory) {
-		return this.callScopedSdkMethod("lsp", "status", { parameters: directory ? { directory } : void 0 });
+		return this.callScopedSdkMethod("lsp", "status", {
+			legacyParameters: directory ? { directory } : void 0,
+			parameters: directory ? { query: { directory } } : void 0
+		});
 	}
 	async listMcpStatuses(directory) {
-		return this.callScopedSdkMethod("mcp", "status", { parameters: directory ? { directory } : void 0 });
+		return this.callScopedSdkMethod("mcp", "status", {
+			legacyParameters: directory ? { directory } : void 0,
+			parameters: directory ? { query: { directory } } : void 0
+		});
 	}
 	async getSessionStatuses() {
 		return this.loadSessionStatuses();
@@ -336,29 +726,69 @@ var OpenCodeClient = class {
 		return this.callScopedSdkMethod("project", "current", {});
 	}
 	async createSessionForDirectory(directory, title) {
-		return this.callScopedSdkMethod("session", "create", { parameters: title ? {
-			directory,
-			title
-		} : { directory } });
+		return this.callScopedSdkMethod("session", "create", {
+			legacyParameters: title ? {
+				directory,
+				title
+			} : { directory },
+			parameters: {
+				query: { directory },
+				...title ? { body: { title } } : {}
+			}
+		});
 	}
 	async renameSession(sessionId, title) {
-		return this.callScopedSdkMethod("session", "update", { parameters: {
-			sessionID: sessionId,
-			title
-		} });
+		return this.callScopedSdkMethod("session", "update", {
+			legacyParameters: {
+				sessionID: sessionId,
+				title
+			},
+			parameters: {
+				path: { id: sessionId },
+				body: { title }
+			}
+		});
 	}
 	async listAgents() {
 		return this.callScopedSdkMethod("app", "agents", {});
 	}
 	async listPendingPermissions(directory) {
-		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() } : {}
-		} });
+		return (await this.callScopedSdkMethod("permission", "list", {
+			legacyParameters: directory ? { directory } : void 0,
+			parameters: directory ? { query: { directory } } : void 0
+		})).map(normalizePermissionRequest).filter((permission) => !!permission);
+	}
+	async replyToPermission(requestId, reply, message, sessionId) {
+		const normalizedMessage = message?.trim();
+		const rootPermissionHandler = this.client.postSessionIdPermissionsPermissionId;
+		if (sessionId && typeof rootPermissionHandler === "function") return unwrapSdkData(await rootPermissionHandler.call(this.client, {
+			...SDK_OPTIONS,
+			body: {
+				response: reply,
+				...normalizedMessage ? { message: normalizedMessage } : {}
+			},
+			path: {
+				id: sessionId,
+				permissionID: requestId
+			}
+		}));
+		return this.callScopedSdkMethod("permission", "reply", {
+			legacyParameters: {
+				requestID: requestId,
+				reply,
+				...normalizedMessage ? { message: normalizedMessage } : {}
+			},
+			parameters: sessionId ? {
+				body: {
+					response: reply,
+					...normalizedMessage ? { message: normalizedMessage } : {}
+				},
+				path: {
+					id: sessionId,
+					permissionID: requestId
+				}
+			} : void 0
+		});
 	}
 	async listModels() {
 		const now = Date.now();
@@ -494,10 +924,14 @@ var OpenCodeClient = class {
 				messageId
 			}, async (requestSignal) => {
 				return normalizePromptResponse(await this.callScopedSdkMethod("session", "message", {
-					parameters: {
+					legacyParameters: {
 						sessionID: sessionId,
 						messageID: messageId
 					},
+					parameters: { path: {
+						id: sessionId,
+						messageID: messageId
+					} },
 					signal: requestSignal
 				}));
 			}, signal);
@@ -525,10 +959,14 @@ var OpenCodeClient = class {
 				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs
 			}, async (requestSignal) => {
 				return normalizePromptResponses(await this.callScopedSdkMethod("session", "messages", {
-					parameters: {
+					legacyParameters: {
 						sessionID: sessionId,
 						limit: PROMPT_MESSAGE_POLL_LIMIT
 					},
+					parameters: {
+						path: { id: sessionId },
+						query: { limit: PROMPT_MESSAGE_POLL_LIMIT }
+					},
 					signal: requestSignal
 				}));
 			}, signal);
@@ -589,10 +1027,14 @@ var OpenCodeClient = class {
 			...input.variant ? { variant: input.variant } : {},
 			parts
 		};
-		const requestParameters = {
+		const legacyRequestParameters = {
 			sessionID: input.sessionId,
 			...requestBody
 		};
+		const requestParameters = {
+			body: requestBody,
+			path: { id: input.sessionId }
+		};
 		try {
 			if (typeof this.client.session?.promptAsync === "function") {
 				await this.runPromptRequestWithTimeout({
@@ -601,6 +1043,7 @@ var OpenCodeClient = class {
 					timeoutMs: this.promptTimeoutPolicy.waitTimeoutMs
 				}, async (signal) => {
 					await this.callScopedSdkMethod("session", "promptAsync", {
+						legacyParameters: legacyRequestParameters,
 						parameters: requestParameters,
 						signal
 					});
@@ -618,10 +1061,7 @@ var OpenCodeClient = class {
 		throw new Error("OpenCode SDK client does not expose session.promptAsync().");
 	}
 	async loadSessionStatuses(signal) {
-		return this.callScopedSdkMethod("session", "status", {
-			signal,
-			parameters: void 0
-		});
+		return this.callScopedSdkMethod("session", "status", { signal });
 	}
 	async callRawSdkGet(url, signal) {
 		const rawClient = getRawSdkRequestClient(this.client);
@@ -698,12 +1138,16 @@ var OpenCodeClient = class {
 	logPromptRequest(level, extra, message) {
 		const log = this.client.app?.log;
 		if (typeof log !== "function") return;
-		log.call(this.client.app, {
+		const payload = {
 			service: PROMPT_LOG_SERVICE,
 			level,
 			message,
 			extra
-		}).catch(() => void 0);
+		};
+		(log.length >= 2 ? log.call(this.client.app, payload, SDK_OPTIONS) : log.call(this.client.app, {
+			body: payload,
+			...SDK_OPTIONS
+		})).catch(() => void 0);
 	}
 };
 function createOpenCodeClientFromSdkClient(client, fetchFn = fetch, promptTimeoutPolicy = {}) {
@@ -825,7 +1269,7 @@ function isPromptResponseUsable(data, structured) {
 }
 function normalizePromptResponse(response) {
 	return {
-		info: isPlainRecord(response?.info) ? response.info : null,
+		info: isPlainRecord$1(response?.info) ? response.info : null,
 		parts: normalizePromptParts(response?.parts)
 	};
 }
@@ -849,7 +1293,7 @@ function toAssistantMessage(message) {
 	if ("mode" in message && typeof message.mode === "string" && message.mode.trim().length > 0) normalized.mode = message.mode;
 	if ("modelID" in message && typeof message.modelID === "string" && message.modelID.trim().length > 0) normalized.modelID = message.modelID;
 	if ("parentID" in message && typeof message.parentID === "string" && message.parentID.trim().length > 0) normalized.parentID = message.parentID;
-	if ("path" in message && isPlainRecord(message.path)) normalized.path = {
+	if ("path" in message && isPlainRecord$1(message.path)) normalized.path = {
 		...typeof message.path.cwd === "string" && message.path.cwd.trim().length > 0 ? { cwd: message.path.cwd } : {},
 		...typeof message.path.root === "string" && message.path.root.trim().length > 0 ? { root: message.path.root } : {}
 	};
@@ -859,16 +1303,16 @@ function toAssistantMessage(message) {
 	const structuredPayload = extractStructuredPayload(message);
 	if (structuredPayload !== null) normalized.structured = structuredPayload;
 	if ("summary" in message && typeof message.summary === "boolean") normalized.summary = message.summary;
-	if ("time" in message && isPlainRecord(message.time)) normalized.time = {
+	if ("time" in message && isPlainRecord$1(message.time)) normalized.time = {
 		...typeof message.time.created === "number" && Number.isFinite(message.time.created) ? { created: message.time.created } : {},
 		...typeof message.time.completed === "number" && Number.isFinite(message.time.completed) ? { completed: message.time.completed } : {}
 	};
-	if ("tokens" in message && isPlainRecord(message.tokens)) normalized.tokens = {
+	if ("tokens" in message && isPlainRecord$1(message.tokens)) normalized.tokens = {
 		...typeof message.tokens.input === "number" && Number.isFinite(message.tokens.input) ? { input: message.tokens.input } : {},
 		...typeof message.tokens.output === "number" && Number.isFinite(message.tokens.output) ? { output: message.tokens.output } : {},
 		...typeof message.tokens.reasoning === "number" && Number.isFinite(message.tokens.reasoning) ? { reasoning: message.tokens.reasoning } : {},
 		...typeof message.tokens.total === "number" && Number.isFinite(message.tokens.total) ? { total: message.tokens.total } : {},
-		...isPlainRecord(message.tokens.cache) ? { cache: {
+		...isPlainRecord$1(message.tokens.cache) ? { cache: {
 			...typeof message.tokens.cache.read === "number" && Number.isFinite(message.tokens.cache.read) ? { read: message.tokens.cache.read } : {},
 			...typeof message.tokens.cache.write === "number" && Number.isFinite(message.tokens.cache.write) ? { write: message.tokens.cache.write } : {}
 		} } : {}
@@ -877,7 +1321,7 @@ function toAssistantMessage(message) {
 	return normalized;
 }
 function extractMessageId(message) {
-	if (!isPlainRecord(message)) return null;
+	if (!isPlainRecord$1(message)) return null;
 	return typeof message.id === "string" && message.id.trim().length > 0 ? message.id : null;
 }
 function delay(ms, signal) {
@@ -973,6 +1417,27 @@ function unwrapSdkData(response) {
 	if (response && typeof response === "object" && "data" in response) return response.data;
 	return response;
 }
+function normalizePermissionRequest(permission) {
+	if (!isPlainRecord$1(permission)) return null;
+	const id = typeof permission.id === "string" && permission.id.trim().length > 0 ? permission.id : null;
+	const sessionID = typeof permission.sessionID === "string" && permission.sessionID.trim().length > 0 ? permission.sessionID : null;
+	const permissionName = typeof permission.permission === "string" && permission.permission.trim().length > 0 ? permission.permission : typeof permission.type === "string" && permission.type.trim().length > 0 ? permission.type : null;
+	if (!id || !sessionID || !permissionName) return null;
+	return {
+		always: Array.isArray(permission.always) ? permission.always.filter((value) => typeof value === "string") : [],
+		id,
+		metadata: isPlainRecord$1(permission.metadata) ? permission.metadata : {},
+		patterns: normalizePermissionPatterns$1(permission),
+		permission: permissionName,
+		sessionID
+	};
+}
+function normalizePermissionPatterns$1(permission) {
+	if (Array.isArray(permission.patterns)) return permission.patterns.filter((value) => typeof value === "string");
+	if (typeof permission.pattern === "string" && permission.pattern.trim().length > 0) return [permission.pattern];
+	if (Array.isArray(permission.pattern)) return permission.pattern.filter((value) => typeof value === "string");
+	return [];
+}
 function getRawSdkRequestClient(client) {
 	const compatibleClient = client;
 	return compatibleClient.client ?? compatibleClient._client ?? null;
@@ -988,11 +1453,11 @@ function resolvePromptTimeoutPolicy(input) {
 	};
 }
 function normalizeAssistantError(value) {
-	if (!isPlainRecord(value) || typeof value.name !== "string" || value.name.trim().length === 0) return;
+	if (!isPlainRecord$1(value) || typeof value.name !== "string" || value.name.trim().length === 0) return;
 	return {
 		...value,
 		name: value.name,
-		...isPlainRecord(value.data) ? { data: value.data } : {}
+		...isPlainRecord$1(value.data) ? { data: value.data } : {}
 	};
 }
 function isAssistantMessageCompleted(message) {
@@ -1005,7 +1470,7 @@ function isCompletedEmptyPromptResponse(data, structured) {
 	return isAssistantMessageCompleted(assistantInfo) && !assistantInfo?.error && !hasText && !bodyMd;
 }
 function extractStructuredPayload(message) {
-	if (!isPlainRecord(message)) return null;
+	if (!isPlainRecord$1(message)) return null;
 	if ("structured" in message && message.structured !== void 0) return message.structured;
 	if ("structured_output" in message && message.structured_output !== void 0) return message.structured_output;
 	return null;
@@ -1079,7 +1544,7 @@ function throwIfAborted(signal) {
 	if (!signal?.aborted) return;
 	throw normalizeAbortReason(signal.reason);
 }
-function isPlainRecord(value) {
+function isPlainRecord$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 async function resolveProviderAvailability(config, fetchFn) {
@@ -1872,10 +2337,11 @@ var SendPromptUseCase = class {
 				binding
 			});
 			binding = createdSession.binding;
-			this.logger.info({
+			logPromptLifecycle(this.logger, {
 				chatId: input.chatId,
-				sessionId: createdSession.session.id,
+				event: "prompt.session.created",
 				projectId: createdSession.session.projectID,
+				sessionId: createdSession.session.id,
 				directory: createdSession.session.directory
 			}, "session created");
 		}
@@ -1883,11 +2349,15 @@ var SendPromptUseCase = class {
 			const selectedModel = (await this.opencodeClient.listModels()).find((model) => model.providerID === binding?.modelProviderId && model.id === binding?.modelId);
 			if (!selectedModel) {
 				binding = await clearStoredModelSelection(this.sessionRepo, binding);
-				this.logger.warn?.({ chatId: input.chatId }, "selected model is no longer available, falling back to OpenCode default");
+				this.logger.warn?.({
+					chatId: input.chatId,
+					event: "prompt.model.unavailable"
+				}, "selected model is no longer available, falling back to OpenCode default");
 			} else if (binding.modelVariant && !(binding.modelVariant in selectedModel.variants)) {
 				binding = await clearStoredModelVariant(this.sessionRepo, binding);
 				this.logger.warn?.({
 					chatId: input.chatId,
+					event: "prompt.model.variant_unavailable",
 					providerId: selectedModel.providerID,
 					modelId: selectedModel.id
 				}, "selected model variant is no longer available, falling back to default variant");
@@ -1903,13 +2373,24 @@ var SendPromptUseCase = class {
 		const selectedAgent = resolveSelectedAgent(await this.opencodeClient.listAgents(), activeBinding.agentName);
 		if (activeBinding.agentName && selectedAgent?.name !== activeBinding.agentName) {
 			activeBinding = await clearStoredAgentSelection(this.sessionRepo, activeBinding);
-			this.logger.warn?.({ chatId: input.chatId }, "selected agent is no longer available, falling back to OpenCode default");
+			this.logger.warn?.({
+				chatId: input.chatId,
+				event: "prompt.agent.unavailable"
+			}, "selected agent is no longer available, falling back to OpenCode default");
 		}
 		const temporarySessionId = shouldIsolateImageTurn ? await this.createTemporaryImageSession(input.chatId, activeBinding.sessionId) : null;
 		const executionSessionId = temporarySessionId ?? activeBinding.sessionId;
 		input.onExecutionSession?.(executionSessionId);
 		let result;
 		try {
+			logOpenCodeRequest(this.logger, {
+				chatId: input.chatId,
+				event: "opencode.prompt.submit",
+				projectId: activeBinding.projectId,
+				sessionId: executionSessionId,
+				fileCount: files.length,
+				status: "started"
+			}, "submitting OpenCode prompt");
 			result = await this.opencodeClient.promptSession({
 				sessionId: executionSessionId,
 				prompt: promptText,
@@ -1920,6 +2401,13 @@ var SendPromptUseCase = class {
 				...input.signal ? { signal: input.signal } : {},
 				...activeBinding.modelVariant ? { variant: activeBinding.modelVariant } : {}
 			});
+			logPromptLifecycle(this.logger, {
+				chatId: input.chatId,
+				event: "prompt.completed",
+				projectId: activeBinding.projectId,
+				sessionId: executionSessionId,
+				status: "completed"
+			}, "prompt completed");
 		} finally {
 			if (temporarySessionId) await this.cleanupTemporaryImageSession(input.chatId, activeBinding.sessionId, temporarySessionId);
 		}
@@ -1932,14 +2420,18 @@ var SendPromptUseCase = class {
 	}
 	async clearInvalidSessionContext(chatId, binding, reason) {
 		const nextBinding = await clearStoredSessionContext(this.sessionRepo, binding);
-		this.logger.warn?.({ chatId }, `${reason}, falling back to the current OpenCode project`);
+		this.logger.warn?.({
+			chatId,
+			event: "prompt.session.invalid_context"
+		}, `${reason}, falling back to the current OpenCode project`);
 		return nextBinding;
 	}
 	async createTemporaryImageSession(chatId, sessionId) {
 		const temporarySession = await this.opencodeClient.forkSession(sessionId);
 		if (!temporarySession.id || temporarySession.id === sessionId) throw new Error("OpenCode did not return a distinct temporary session for the image turn.");
-		this.logger.info?.({
+		logPromptLifecycle(this.logger, {
 			chatId,
+			event: "prompt.temporary_session.created",
 			parentSessionId: sessionId,
 			sessionId: temporarySession.id
 		}, "created temporary image session");
@@ -1949,6 +2441,7 @@ var SendPromptUseCase = class {
 		try {
 			if (!await this.opencodeClient.deleteSession(sessionId)) this.logger.warn?.({
 				chatId,
+				event: "prompt.temporary_session.cleanup_failed",
 				parentSessionId,
 				sessionId
 			}, "failed to delete temporary image session");
@@ -1956,6 +2449,7 @@ var SendPromptUseCase = class {
 			this.logger.warn?.({
 				error,
 				chatId,
+				event: "prompt.temporary_session.cleanup_failed",
 				parentSessionId,
 				sessionId
 			}, "failed to delete temporary image session");
@@ -2156,7 +2650,23 @@ function resolveExtension(mimeType) {
 //#endregion
 //#region src/app/container.ts
 function createAppContainer(config, client) {
-	const logger = createOpenCodeAppLogger(client, { level: config.logLevel });
+	const runtimeId = randomUUID();
+	const logger = createOpenCodeAppLogger(client, {
+		file: {
+			dir: config.loggingFileDir,
+			retention: {
+				maxFiles: config.loggingRetentionMaxFiles,
+				maxTotalBytes: config.loggingRetentionMaxTotalBytes
+			}
+		},
+		level: config.loggingLevel,
+		runtimeId,
+		sinks: {
+			file: config.loggingFileSinkEnabled,
+			host: config.loggingHostSinkEnabled
+		},
+		worktree: config.worktreePath
+	});
 	return createContainer(config, createOpenCodeClientFromSdkClient(client, fetch, {
 		waitTimeoutMs: config.promptWaitTimeoutMs,
 		pollRequestTimeoutMs: config.promptPollRequestTimeoutMs,
@@ -2164,6 +2674,9 @@ function createAppContainer(config, client) {
 	}), logger);
 }
 function createContainer(config, opencodeClient, logger) {
+	const storageLogger = logger.child({ component: "storage" });
+	const opencodeLogger = logger.child({ component: "opencode" });
+	const promptLogger = logger.child({ component: "prompt" });
 	const stateStore = new JsonStateStore({
 		filePath: config.stateFilePath,
 		createDefaultState: createDefaultOpencodeTbotState
@@ -2178,7 +2691,7 @@ function createContainer(config, opencodeClient, logger) {
 	});
 	const uploadFileUseCase = new UploadFileUseCase(telegramFileClient);
 	const abortPromptUseCase = new AbortPromptUseCase(sessionRepo, opencodeClient, foregroundSessionTracker);
-	const createSessionUseCase = new CreateSessionUseCase(sessionRepo, opencodeClient, logger);
+	const createSessionUseCase = new CreateSessionUseCase(sessionRepo, opencodeClient, opencodeLogger);
 	const getHealthUseCase = new GetHealthUseCase(opencodeClient);
 	const getPathUseCase = new GetPathUseCase(opencodeClient);
 	const listAgentsUseCase = new ListAgentsUseCase(sessionRepo, opencodeClient);
@@ -2187,11 +2700,11 @@ function createContainer(config, opencodeClient, logger) {
 	const listSessionsUseCase = new ListSessionsUseCase(sessionRepo, opencodeClient);
 	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);
-	const switchAgentUseCase = new SwitchAgentUseCase(sessionRepo, opencodeClient, logger);
-	const switchModelUseCase = new SwitchModelUseCase(sessionRepo, opencodeClient, logger);
-	const switchSessionUseCase = new SwitchSessionUseCase(sessionRepo, opencodeClient, logger);
+	const renameSessionUseCase = new RenameSessionUseCase(sessionRepo, opencodeClient, opencodeLogger);
+	const sendPromptUseCase = new SendPromptUseCase(sessionRepo, opencodeClient, promptLogger);
+	const switchAgentUseCase = new SwitchAgentUseCase(sessionRepo, opencodeClient, opencodeLogger);
+	const switchModelUseCase = new SwitchModelUseCase(sessionRepo, opencodeClient, opencodeLogger);
+	const switchSessionUseCase = new SwitchSessionUseCase(sessionRepo, opencodeClient, opencodeLogger);
 	let disposed = false;
 	return {
 		abortPromptUseCase,
@@ -2220,7 +2733,10 @@ function createContainer(config, opencodeClient, logger) {
 		async dispose() {
 			if (disposed) return;
 			disposed = true;
-			logger.info({ filePath: config.stateFilePath }, "disposing telegram bot container");
+			storageLogger.info({
+				event: "storage.container.disposed",
+				filePath: config.stateFilePath
+			}, "disposing telegram bot container");
 			await logger.flush();
 		}
 	};
@@ -2295,25 +2811,40 @@ function escapeMarkdownV2(value) {
 async function handleTelegramBotPluginEvent(runtime, event) {
 	switch (event.type) {
 		case "permission.asked":
-			await handlePermissionAsked(runtime, event);
+		case "permission.updated": {
+			const request = normalizePermissionRequestEvent(event.properties);
+			if (request) await handlePermissionAsked(runtime, request);
 			return;
-		case "permission.replied":
-			await handlePermissionReplied(runtime, event);
+		}
+		case "permission.replied": {
+			const replyEvent = normalizePermissionReplyEvent(event.properties);
+			if (replyEvent) await handlePermissionReplied(runtime, replyEvent);
 			return;
-		case "session.error":
-			await handleSessionError(runtime, event);
+		}
+		case "session.error": {
+			const sessionError = normalizeSessionErrorEvent(event.properties);
+			if (sessionError) await handleSessionError(runtime, sessionError);
 			return;
-		case "session.idle":
-			await handleSessionIdle(runtime, event);
+		}
+		case "session.idle": {
+			const sessionIdle = normalizeSessionIdleEvent(event.properties);
+			if (sessionIdle) await handleSessionIdle(runtime, sessionIdle);
 			return;
-		case "session.status":
-			await handleSessionStatus(runtime, event);
+		}
+		case "session.status": {
+			const sessionStatus = normalizeSessionStatusEvent(event.properties);
+			if (sessionStatus) await handleSessionStatus(runtime, sessionStatus);
 			return;
+		}
 		default: return;
 	}
 }
-async function handlePermissionAsked(runtime, event) {
-	const request = event.properties;
+async function handlePermissionAsked(runtime, request) {
+	const logger = runtime.container.logger.child({
+		component: "plugin-event",
+		requestId: request.id,
+		sessionId: request.sessionID
+	});
 	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);
@@ -2334,73 +2865,81 @@ async function handlePermissionAsked(runtime, event) {
 				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 			});
 		} catch (error) {
-			runtime.container.logger.error({
+			logger.error({
 				error,
 				chatId,
+				event: "plugin-event.permission.ask.delivery_failed",
 				requestId: request.id
 			}, "failed to deliver permission request to Telegram");
 		}
 	}
 }
 async function handlePermissionReplied(runtime, event) {
-	const requestId = event.properties.requestID;
-	const reply = event.properties.reply;
-	const approvals = await runtime.container.permissionApprovalRepo.listByRequestId(requestId);
+	const logger = runtime.container.logger.child({
+		component: "plugin-event",
+		event: "plugin-event.permission.replied",
+		requestId: event.requestId,
+		sessionId: event.sessionId
+	});
+	const approvals = await runtime.container.permissionApprovalRepo.listByRequestId(event.requestId);
 	await Promise.all(approvals.map(async (approval) => {
 		try {
-			await runtime.bot.api.editMessageText(approval.chatId, approval.messageId, buildPermissionApprovalResolvedMessage(requestId, reply));
+			await runtime.bot.api.editMessageText(approval.chatId, approval.messageId, buildPermissionApprovalResolvedMessage(event.requestId, event.reply));
 		} catch (error) {
-			runtime.container.logger.warn({
+			logger.warn({
 				error,
 				chatId: approval.chatId,
-				requestId
+				event: "plugin-event.permission.reply_message_failed"
 			}, "failed to update Telegram permission message");
 		}
-		await runtime.container.permissionApprovalRepo.set(toResolvedApproval(approval, reply));
+		await runtime.container.permissionApprovalRepo.set(toResolvedApproval(approval, event.reply));
 	}));
 }
 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.fail(sessionId, error ?? /* @__PURE__ */ new Error("Unknown session error."))) {
-		runtime.container.logger.warn({
-			error,
-			sessionId
+	const logger = runtime.container.logger.child({
+		component: "plugin-event",
+		sessionId: event.sessionId
+	});
+	if (runtime.container.foregroundSessionTracker.fail(event.sessionId, event.error instanceof Error ? event.error : /* @__PURE__ */ new Error("Unknown session error."))) {
+		logger.warn({
+			error: event.error,
+			event: "plugin-event.session.error.foreground_suppressed"
 		}, "session error suppressed for foreground Telegram session");
 		return;
 	}
-	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."}`);
+	const message = extractSessionErrorMessage(event.error) ?? "Unknown session error.";
+	await notifyBoundChats(runtime, event.sessionId, `Session failed.\n\nSession: ${event.sessionId}\nError: ${message}`);
 }
 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");
+	const logger = runtime.container.logger.child({
+		component: "plugin-event",
+		sessionId: event.sessionId
+	});
+	if (runtime.container.foregroundSessionTracker.clear(event.sessionId)) {
+		logPluginEvent(logger, { event: "plugin-event.session.idle.foreground_suppressed" }, "session idle notification suppressed for foreground Telegram session");
 		return;
 	}
-	await notifyBoundChats(runtime, sessionId, `Session finished.\n\nSession: ${sessionId}`);
+	await notifyBoundChats(runtime, event.sessionId, `Session finished.\n\nSession: ${event.sessionId}`);
 }
 async function handleSessionStatus(runtime, event) {
-	if (event.properties.status.type !== "idle") return;
-	await handleSessionIdle(runtime, {
-		type: "session.idle",
-		properties: { sessionID: event.properties.sessionID }
-	});
+	if (event.statusType !== "idle") return;
+	await handleSessionIdle(runtime, event);
 }
 async function notifyBoundChats(runtime, sessionId, text) {
+	const logger = runtime.container.logger.child({
+		component: "plugin-event",
+		sessionId
+	});
 	const bindings = await runtime.container.sessionRepo.listBySessionId(sessionId);
 	const chatIds = [...new Set(bindings.map((binding) => binding.chatId))];
 	await Promise.all(chatIds.map(async (chatId) => {
 		try {
 			await runtime.bot.api.sendMessage(chatId, text);
 		} catch (error) {
-			runtime.container.logger.warn({
+			logger.warn({
 				error,
 				chatId,
-				sessionId
+				event: "plugin-event.session.notify_failed"
 			}, "failed to notify Telegram chat about session event");
 		}
 	}));
@@ -2412,6 +2951,79 @@ function toResolvedApproval(approval, reply) {
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
 }
+function normalizePermissionRequestEvent(properties) {
+	if (!isPlainRecord(properties)) return null;
+	const id = asNonEmptyString(properties.id);
+	const sessionID = asNonEmptyString(properties.sessionID);
+	const permission = asNonEmptyString(properties.permission) ?? asNonEmptyString(properties.type);
+	if (!id || !sessionID || !permission) return null;
+	return {
+		always: Array.isArray(properties.always) ? properties.always.filter((value) => typeof value === "string") : [],
+		id,
+		metadata: isPlainRecord(properties.metadata) ? properties.metadata : {},
+		patterns: normalizePermissionPatterns(properties),
+		permission,
+		sessionID
+	};
+}
+function normalizePermissionReplyEvent(properties) {
+	if (!isPlainRecord(properties)) return null;
+	const requestId = asNonEmptyString(properties.requestID) ?? asNonEmptyString(properties.permissionID);
+	const reply = normalizePermissionReply(asNonEmptyString(properties.reply) ?? asNonEmptyString(properties.response));
+	const sessionId = asNonEmptyString(properties.sessionID);
+	if (!requestId || !reply || !sessionId) return null;
+	return {
+		reply,
+		requestId,
+		sessionId
+	};
+}
+function normalizeSessionErrorEvent(properties) {
+	if (!isPlainRecord(properties)) return null;
+	const sessionId = asNonEmptyString(properties.sessionID);
+	if (!sessionId) return null;
+	return {
+		error: properties.error,
+		sessionId
+	};
+}
+function normalizeSessionIdleEvent(properties) {
+	if (!isPlainRecord(properties)) return null;
+	const sessionId = asNonEmptyString(properties.sessionID);
+	return sessionId ? { sessionId } : null;
+}
+function normalizeSessionStatusEvent(properties) {
+	if (!isPlainRecord(properties) || !isPlainRecord(properties.status)) return null;
+	const sessionId = asNonEmptyString(properties.sessionID);
+	const statusType = asNonEmptyString(properties.status.type);
+	if (!sessionId || !statusType) return null;
+	return {
+		sessionId,
+		statusType
+	};
+}
+function normalizePermissionPatterns(properties) {
+	if (Array.isArray(properties.patterns)) return properties.patterns.filter((value) => typeof value === "string");
+	if (typeof properties.pattern === "string" && properties.pattern.trim().length > 0) return [properties.pattern];
+	if (Array.isArray(properties.pattern)) return properties.pattern.filter((value) => typeof value === "string");
+	return [];
+}
+function normalizePermissionReply(value) {
+	if (value === "once" || value === "always" || value === "reject") return value;
+	return null;
+}
+function extractSessionErrorMessage(error) {
+	if (error instanceof Error && error.message.trim().length > 0) return error.message.trim();
+	if (!isPlainRecord(error)) return null;
+	if (isPlainRecord(error.data) && typeof error.data.message === "string" && error.data.message.trim().length > 0) return error.data.message.trim();
+	return asNonEmptyString(error.name);
+}
+function asNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function isPlainRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 var SUPPORTED_BOT_LANGUAGES = [
 	"en",
 	"zh-CN",
@@ -3104,7 +3716,9 @@ var TELEGRAM_COMMAND_SYNC_SCOPES = [{ type: "default" }, { type: "all_private_ch
 async function syncTelegramCommands(bot, logger) {
 	await Promise.all(TELEGRAM_COMMAND_SYNC_SCOPES.map((scope) => bot.api.setMyCommands(TELEGRAM_COMMANDS, { scope })));
 	logger.info({
+		component: "runtime",
 		commands: TELEGRAM_COMMANDS.map((command) => command.command),
+		event: "runtime.commands.synced",
 		scopes: TELEGRAM_COMMAND_SYNC_SCOPES.map((scope) => scope.type)
 	}, "telegram commands synced");
 }
@@ -3115,109 +3729,42 @@ async function syncTelegramCommandsForChat(api, chatId, language) {
 	} });
 }
 //#endregion
-//#region src/bot/i18n.ts
-async function getChatLanguage(sessionRepo, chatId) {
-	if (!chatId) return "en";
-	return normalizeBotLanguage((await sessionRepo.getByChatId(chatId))?.language);
-}
-async function getChatCopy(sessionRepo, chatId) {
-	return getBotCopy(await getChatLanguage(sessionRepo, chatId));
-}
-async function setChatLanguage(sessionRepo, chatId, language) {
-	const binding = await sessionRepo.getByChatId(chatId);
-	await sessionRepo.setCurrent({
-		chatId,
-		sessionId: binding?.sessionId ?? null,
-		projectId: binding?.projectId ?? null,
-		directory: binding?.directory ?? null,
-		agentName: binding?.agentName ?? null,
-		modelProviderId: binding?.modelProviderId ?? null,
-		modelId: binding?.modelId ?? null,
-		modelVariant: binding?.modelVariant ?? null,
-		language,
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	});
-}
-var NUMBERED_BUTTONS_PER_ROW = 5;
-function buildModelsKeyboard(models, requestedPage, copy = BOT_COPY) {
-	const page = getModelsPage(models, requestedPage);
-	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (_, index) => `model:pick:${page.startIndex + index + 1}`);
-	appendPaginationButtons(keyboard, page.page, page.totalPages, "model:page", copy);
+//#region src/bot/logger-context.ts
+function buildTelegramLoggerContext(ctx, component = "telegram") {
+	const updateId = typeof ctx.update?.update_id === "number" ? ctx.update.update_id : void 0;
+	const command = extractTelegramCommand(resolveMessageText(ctx));
+	const callbackData = normalizeTelegramString(ctx.callbackQuery?.data);
+	const operationId = typeof updateId === "number" ? `telegram-${updateId}` : null;
 	return {
-		keyboard,
-		page
+		component,
+		...typeof ctx.chat?.id === "number" ? { chatId: ctx.chat.id } : {},
+		...typeof updateId === "number" ? { updateId } : {},
+		...command ? { command } : {},
+		...callbackData ? { callbackData } : {},
+		correlationId: typeof updateId === "number" ? String(updateId) : operationId,
+		operationId
 	};
 }
-function buildAgentsKeyboard(agents, requestedPage, copy = BOT_COPY) {
-	const page = getAgentsPage(agents, requestedPage);
-	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (_, index) => `agents:select:${page.startIndex + index + 1}`);
-	appendPaginationButtons(keyboard, page.page, page.totalPages, "agents:page", copy);
-	return {
-		keyboard,
-		page
-	};
+function scopeLoggerToTelegramContext(logger, ctx, component = "telegram") {
+	return logger.child(buildTelegramLoggerContext(ctx, component));
 }
-function buildSessionsKeyboard(sessions, requestedPage, copy = BOT_COPY) {
-	const page = getSessionsPage(sessions, requestedPage);
-	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (session) => `sessions:pick:${page.page}:${session.id}`);
-	appendPaginationButtons(keyboard, page.page, page.totalPages, "sessions:page", copy);
+function scopeDependenciesToTelegramContext(dependencies, ctx, component = "telegram") {
 	return {
-		keyboard,
-		page
+		...dependencies,
+		logger: scopeLoggerToTelegramContext(dependencies.logger, ctx, component)
 	};
 }
-function buildSessionActionKeyboard(sessionId, page, copy = BOT_COPY) {
-	return new InlineKeyboard().text(copy.sessions.switchAction, `sessions:switch:${page}:${sessionId}`).text(copy.sessions.renameAction, `sessions:rename:${page}:${sessionId}`).row().text(copy.sessions.backToList, `sessions:back:${page}`);
-}
-function buildModelVariantsKeyboard(variants, modelIndex) {
-	return buildNumberedKeyboard(variants, 0, (_, index) => `model:variant:${modelIndex}:${index + 1}`);
-}
-function buildLanguageKeyboard(currentLanguage, copy = BOT_COPY) {
-	const keyboard = new InlineKeyboard();
-	SUPPORTED_BOT_LANGUAGES.forEach((language, index) => {
-		const label = currentLanguage === language ? `[${getLanguageLabel(language, copy)}]` : getLanguageLabel(language, copy);
-		keyboard.text(label, `language:select:${language}`);
-		if (index !== SUPPORTED_BOT_LANGUAGES.length - 1) keyboard.row();
-	});
-	return keyboard;
+function resolveMessageText(ctx) {
+	return normalizeTelegramString(ctx.message?.text) ?? normalizeTelegramString(ctx.msg?.text);
 }
-function getModelsPage(models, requestedPage) {
-	return getPagedItems(models, requestedPage, 10);
+function extractTelegramCommand(value) {
+	if (!value || !value.startsWith("/")) return null;
+	const token = value.split(/\s+/u, 1)[0]?.trim();
+	if (!token) return null;
+	return token.replace(/^\/+/u, "").split("@", 1)[0] ?? null;
 }
-function getAgentsPage(agents, requestedPage) {
-	return getPagedItems(agents, requestedPage, 10);
-}
-function getSessionsPage(sessions, requestedPage) {
-	return getPagedItems(sessions, requestedPage, 10);
-}
-function buildNumberedKeyboard(items, startIndex, buildCallbackData) {
-	const keyboard = new InlineKeyboard();
-	items.forEach((item, index) => {
-		const displayIndex = startIndex + index + 1;
-		keyboard.text(`${displayIndex}`, buildCallbackData(item, index));
-		if (index !== items.length - 1 && (index + 1) % NUMBERED_BUTTONS_PER_ROW === 0) keyboard.row();
-	});
-	return keyboard;
-}
-function appendPaginationButtons(keyboard, page, totalPages, prefix, copy) {
-	if (totalPages <= 1) return;
-	if (page > 0) keyboard.text(copy.common.previousPage, `${prefix}:${page - 1}`);
-	if (page < totalPages - 1) keyboard.text(copy.common.nextPage, `${prefix}:${page + 1}`);
-}
-function getPagedItems(items, requestedPage, pageSize) {
-	const totalPages = Math.max(1, Math.ceil(items.length / pageSize));
-	const page = clampPage(requestedPage, totalPages);
-	const startIndex = page * pageSize;
-	return {
-		items: items.slice(startIndex, startIndex + pageSize),
-		page,
-		startIndex,
-		totalPages
-	};
-}
-function clampPage(page, totalPages) {
-	if (!Number.isInteger(page) || page < 0) return 0;
-	return Math.min(page, totalPages - 1);
+function normalizeTelegramString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
 //#endregion
 //#region src/bot/presenters/error.presenter.ts
@@ -3334,6 +3881,179 @@ function stringifyUnknown(value) {
 	}
 }
 //#endregion
+//#region src/bot/error-boundary.ts
+function extractTelegramUpdateContext(ctx) {
+	return buildTelegramLoggerContext({
+		callbackQuery: { data: getNestedString(ctx, ["callbackQuery", "data"]) },
+		chat: { id: getNestedNumber(ctx, ["chat", "id"]) ?? void 0 },
+		message: { text: getNestedString(ctx, ["message", "text"]) },
+		update: { update_id: getNestedNumber(ctx, ["update", "update_id"]) ?? void 0 }
+	});
+}
+async function replyWithDefaultTelegramError(ctx, logger, error) {
+	const text = presentError(error, BOT_COPY);
+	const editMessageText = getFunction(ctx, "editMessageText");
+	const reply = getFunction(ctx, "reply");
+	const callbackData = getNestedString(ctx, ["callbackQuery", "data"]);
+	try {
+		if (typeof callbackData === "string" && editMessageText) {
+			await editMessageText.call(ctx, text);
+			return;
+		}
+		if (reply) await reply.call(ctx, text);
+	} catch (replyError) {
+		logger.warn?.({
+			...extractTelegramUpdateContext(ctx),
+			error: replyError
+		}, "failed to deliver fallback Telegram error message");
+	}
+}
+function getFunction(value, key) {
+	if (!(key in value)) return null;
+	const candidate = value[key];
+	return typeof candidate === "function" ? candidate : null;
+}
+function getNestedNumber(value, path) {
+	const candidate = getNestedValue(value, path);
+	return typeof candidate === "number" ? candidate : null;
+}
+function getNestedString(value, path) {
+	const candidate = getNestedValue(value, path);
+	return typeof candidate === "string" ? candidate : null;
+}
+function getNestedValue(value, path) {
+	let current = value;
+	for (const segment of path) {
+		if (!current || typeof current !== "object" || !(segment in current)) return null;
+		current = current[segment];
+	}
+	return current;
+}
+//#endregion
+//#region src/bot/i18n.ts
+async function getChatLanguage(sessionRepo, chatId) {
+	if (!chatId) return "en";
+	return normalizeBotLanguage((await sessionRepo.getByChatId(chatId))?.language);
+}
+async function getSafeChatLanguage(sessionRepo, chatId, logger) {
+	try {
+		return await getChatLanguage(sessionRepo, chatId);
+	} catch (error) {
+		logger?.warn?.({
+			error,
+			chatId: chatId ?? void 0
+		}, "failed to resolve Telegram chat language; falling back to the default locale");
+		return "en";
+	}
+}
+async function getSafeChatCopy(sessionRepo, chatId, logger) {
+	try {
+		return getBotCopy(await getSafeChatLanguage(sessionRepo, chatId, logger));
+	} catch (error) {
+		logger?.warn?.({
+			error,
+			chatId: chatId ?? void 0
+		}, "failed to resolve Telegram copy; falling back to the default locale");
+		return BOT_COPY;
+	}
+}
+async function setChatLanguage(sessionRepo, chatId, language) {
+	const binding = await sessionRepo.getByChatId(chatId);
+	await sessionRepo.setCurrent({
+		chatId,
+		sessionId: binding?.sessionId ?? null,
+		projectId: binding?.projectId ?? null,
+		directory: binding?.directory ?? null,
+		agentName: binding?.agentName ?? null,
+		modelProviderId: binding?.modelProviderId ?? null,
+		modelId: binding?.modelId ?? null,
+		modelVariant: binding?.modelVariant ?? null,
+		language,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+var NUMBERED_BUTTONS_PER_ROW = 5;
+function buildModelsKeyboard(models, requestedPage, copy = BOT_COPY) {
+	const page = getModelsPage(models, requestedPage);
+	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (_, index) => `model:pick:${page.startIndex + index + 1}`);
+	appendPaginationButtons(keyboard, page.page, page.totalPages, "model:page", copy);
+	return {
+		keyboard,
+		page
+	};
+}
+function buildAgentsKeyboard(agents, requestedPage, copy = BOT_COPY) {
+	const page = getAgentsPage(agents, requestedPage);
+	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (_, index) => `agents:select:${page.startIndex + index + 1}`);
+	appendPaginationButtons(keyboard, page.page, page.totalPages, "agents:page", copy);
+	return {
+		keyboard,
+		page
+	};
+}
+function buildSessionsKeyboard(sessions, requestedPage, copy = BOT_COPY) {
+	const page = getSessionsPage(sessions, requestedPage);
+	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (session) => `sessions:pick:${page.page}:${session.id}`);
+	appendPaginationButtons(keyboard, page.page, page.totalPages, "sessions:page", copy);
+	return {
+		keyboard,
+		page
+	};
+}
+function buildSessionActionKeyboard(sessionId, page, copy = BOT_COPY) {
+	return new InlineKeyboard().text(copy.sessions.switchAction, `sessions:switch:${page}:${sessionId}`).text(copy.sessions.renameAction, `sessions:rename:${page}:${sessionId}`).row().text(copy.sessions.backToList, `sessions:back:${page}`);
+}
+function buildModelVariantsKeyboard(variants, modelIndex) {
+	return buildNumberedKeyboard(variants, 0, (_, index) => `model:variant:${modelIndex}:${index + 1}`);
+}
+function buildLanguageKeyboard(currentLanguage, copy = BOT_COPY) {
+	const keyboard = new InlineKeyboard();
+	SUPPORTED_BOT_LANGUAGES.forEach((language, index) => {
+		const label = currentLanguage === language ? `[${getLanguageLabel(language, copy)}]` : getLanguageLabel(language, copy);
+		keyboard.text(label, `language:select:${language}`);
+		if (index !== SUPPORTED_BOT_LANGUAGES.length - 1) keyboard.row();
+	});
+	return keyboard;
+}
+function getModelsPage(models, requestedPage) {
+	return getPagedItems(models, requestedPage, 10);
+}
+function getAgentsPage(agents, requestedPage) {
+	return getPagedItems(agents, requestedPage, 10);
+}
+function getSessionsPage(sessions, requestedPage) {
+	return getPagedItems(sessions, requestedPage, 10);
+}
+function buildNumberedKeyboard(items, startIndex, buildCallbackData) {
+	const keyboard = new InlineKeyboard();
+	items.forEach((item, index) => {
+		const displayIndex = startIndex + index + 1;
+		keyboard.text(`${displayIndex}`, buildCallbackData(item, index));
+		if (index !== items.length - 1 && (index + 1) % NUMBERED_BUTTONS_PER_ROW === 0) keyboard.row();
+	});
+	return keyboard;
+}
+function appendPaginationButtons(keyboard, page, totalPages, prefix, copy) {
+	if (totalPages <= 1) return;
+	if (page > 0) keyboard.text(copy.common.previousPage, `${prefix}:${page - 1}`);
+	if (page < totalPages - 1) keyboard.text(copy.common.nextPage, `${prefix}:${page + 1}`);
+}
+function getPagedItems(items, requestedPage, pageSize) {
+	const totalPages = Math.max(1, Math.ceil(items.length / pageSize));
+	const page = clampPage(requestedPage, totalPages);
+	const startIndex = page * pageSize;
+	return {
+		items: items.slice(startIndex, startIndex + pageSize),
+		page,
+		startIndex,
+		totalPages
+	};
+}
+function clampPage(page, totalPages) {
+	if (!Number.isInteger(page) || page < 0) return 0;
+	return Math.min(page, totalPages - 1);
+}
+//#endregion
 //#region src/bot/presenters/message.presenter.ts
 var VARIANT_ORDER = [
 	"minimal",
@@ -3713,7 +4433,7 @@ function formatSessionLabel(session) {
 //#endregion
 //#region src/bot/commands/agents.ts
 async function handleAgentsCommand(ctx, dependencies) {
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		const result = await dependencies.listAgentsUseCase.execute({ chatId: ctx.chat.id });
 		if (result.agents.length === 0) {
@@ -3733,13 +4453,13 @@ async function handleAgentsCommand(ctx, dependencies) {
 }
 function registerAgentsCommand(bot, dependencies) {
 	bot.command(["agents", "agent"], async (ctx) => {
-		await handleAgentsCommand(ctx, dependencies);
+		await handleAgentsCommand(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
 //#region src/bot/sessions-menu.ts
 async function buildSessionsListView(chatId, requestedPage, dependencies) {
-	const copy = await getChatCopy(dependencies.sessionRepo, chatId);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, chatId, dependencies.logger);
 	const result = await dependencies.listSessionsUseCase.execute({ chatId });
 	if (result.sessions.length === 0) return {
 		copy,
@@ -3798,14 +4518,14 @@ async function getPendingSessionRenameAction(dependencies, chatId) {
 }
 async function replyIfSessionRenamePending(ctx, dependencies) {
 	if (!await getPendingSessionRenameAction(dependencies, ctx.chat.id)) return false;
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	await ctx.reply(copy.sessions.renamePendingInput);
 	return true;
 }
 async function handlePendingSessionRenameText(ctx, dependencies) {
 	const pendingAction = await getPendingSessionRenameAction(dependencies, ctx.chat.id);
 	if (!pendingAction) return false;
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	const title = ctx.message.text?.trim() ?? "";
 	if (title.startsWith("/")) {
 		await ctx.reply(copy.sessions.renamePendingInput);
@@ -3837,7 +4557,7 @@ async function handlePendingSessionRenameText(ctx, dependencies) {
 async function cancelPendingSessionRename(ctx, dependencies) {
 	const pendingAction = await getPendingSessionRenameAction(dependencies, ctx.chat.id);
 	if (!pendingAction) return false;
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	await dependencies.pendingActionRepo.clear(ctx.chat.id);
 	await bestEffortRestoreSessionsList(ctx.api, pendingAction, dependencies);
 	await ctx.reply(copy.sessions.renameCancelled);
@@ -3856,7 +4576,7 @@ function isSessionRenamePendingAction(action) {
 //#endregion
 //#region src/bot/commands/cancel.ts
 async function handleCancelCommand(ctx, dependencies) {
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		if (await cancelPendingSessionRename(ctx, dependencies)) return;
 		const result = await dependencies.abortPromptUseCase.execute({ chatId: ctx.chat.id });
@@ -3876,14 +4596,14 @@ async function handleCancelCommand(ctx, dependencies) {
 }
 function registerCancelCommand(bot, dependencies) {
 	bot.command("cancel", async (ctx) => {
-		await handleCancelCommand(ctx, dependencies);
+		await handleCancelCommand(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
 //#region src/bot/commands/language.ts
 async function handleLanguageCommand(ctx, dependencies) {
-	const language = await getChatLanguage(dependencies.sessionRepo, ctx.chat.id);
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const language = await getSafeChatLanguage(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		await syncTelegramCommandsForChat(ctx.api, ctx.chat.id, language);
 		await ctx.reply(presentLanguageMessage(language, copy), { reply_markup: buildLanguageKeyboard(language, copy) });
@@ -3893,7 +4613,7 @@ async function handleLanguageCommand(ctx, dependencies) {
 	}
 }
 async function switchLanguageForChat(api, chatId, language, dependencies) {
-	const currentCopy = await getChatCopy(dependencies.sessionRepo, chatId);
+	const currentCopy = await getSafeChatCopy(dependencies.sessionRepo, chatId, dependencies.logger);
 	if (!isBotLanguage(language)) return {
 		found: false,
 		copy: currentCopy
@@ -3902,7 +4622,7 @@ async function switchLanguageForChat(api, chatId, language, dependencies) {
 	await syncTelegramCommandsForChat(api, chatId, language);
 	return {
 		found: true,
-		copy: await getChatCopy(dependencies.sessionRepo, chatId),
+		copy: await getSafeChatCopy(dependencies.sessionRepo, chatId, dependencies.logger),
 		language
 	};
 }
@@ -3912,7 +4632,7 @@ async function presentLanguageSwitchForChat(chatId, api, language, dependencies)
 		found: false,
 		copy: result.copy,
 		text: result.copy.language.expired,
-		keyboard: buildLanguageKeyboard(await getChatLanguage(dependencies.sessionRepo, chatId), result.copy)
+		keyboard: buildLanguageKeyboard(await getSafeChatLanguage(dependencies.sessionRepo, chatId, dependencies.logger), result.copy)
 	};
 	return {
 		found: true,
@@ -3923,13 +4643,13 @@ async function presentLanguageSwitchForChat(chatId, api, language, dependencies)
 }
 function registerLanguageCommand(bot, dependencies) {
 	bot.command("language", async (ctx) => {
-		await handleLanguageCommand(ctx, dependencies);
+		await handleLanguageCommand(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
 //#region src/bot/commands/models.ts
 async function handleModelsCommand(ctx, dependencies) {
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		const result = await dependencies.listModelsUseCase.execute({ chatId: ctx.chat.id });
 		if (result.models.length === 0) {
@@ -3951,13 +4671,13 @@ async function handleModelsCommand(ctx, dependencies) {
 }
 function registerModelsCommand(bot, dependencies) {
 	bot.command(["model", "models"], async (ctx) => {
-		await handleModelsCommand(ctx, dependencies);
+		await handleModelsCommand(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
 //#region src/bot/commands/new.ts
 async function handleNewCommand(ctx, dependencies) {
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		const title = extractSessionTitle(ctx);
 		const result = await dependencies.createSessionUseCase.execute({
@@ -3972,7 +4692,7 @@ async function handleNewCommand(ctx, dependencies) {
 }
 function registerNewCommand(bot, dependencies) {
 	bot.command("new", async (ctx) => {
-		await handleNewCommand(ctx, dependencies);
+		await handleNewCommand(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 function extractSessionTitle(ctx) {
@@ -4321,7 +5041,7 @@ function escapeLinkDestination(url) {
 //#endregion
 //#region src/bot/commands/status.ts
 async function handleStatusCommand(ctx, dependencies) {
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat?.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat?.id, dependencies.logger);
 	try {
 		const result = await dependencies.getStatusUseCase.execute({ chatId: ctx.chat?.id ?? 0 });
 		const renderedMarkdown = renderMarkdownToTelegramMarkdownV2(presentStatusMarkdownMessage(result, copy));
@@ -4337,13 +5057,13 @@ async function handleStatusCommand(ctx, dependencies) {
 }
 function registerStatusCommand(bot, dependencies) {
 	bot.command("status", async (ctx) => {
-		await handleStatusCommand(ctx, dependencies);
+		await handleStatusCommand(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
 //#region src/bot/commands/sessions.ts
 async function handleSessionsCommand(ctx, dependencies) {
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		await dependencies.pendingActionRepo.clear(ctx.chat.id);
 		const view = await buildSessionsListView(ctx.chat.id, 0, dependencies);
@@ -4355,7 +5075,7 @@ async function handleSessionsCommand(ctx, dependencies) {
 }
 function registerSessionsCommand(bot, dependencies) {
 	bot.command("sessions", async (ctx) => {
-		await handleSessionsCommand(ctx, dependencies);
+		await handleSessionsCommand(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
@@ -4366,7 +5086,7 @@ function presentStartMarkdownMessage(copy = BOT_COPY) {
 //#endregion
 //#region src/bot/commands/start.ts
 async function handleStartCommand(ctx, dependencies) {
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat?.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat?.id, dependencies.logger);
 	const reply = buildTelegramStaticReply(presentStartMarkdownMessage(copy));
 	try {
 		await ctx.reply(reply.preferred.text, reply.preferred.options);
@@ -4382,7 +5102,7 @@ async function handleStartCommand(ctx, dependencies) {
 }
 function registerStartCommand(bot, dependencies) {
 	bot.command("start", async (ctx) => {
-		await handleStartCommand(ctx, dependencies);
+		await handleStartCommand(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
@@ -4404,7 +5124,7 @@ async function handleAgentsCallback(ctx, dependencies) {
 	if (!data.startsWith("agents:")) return;
 	await ctx.answerCallbackQuery();
 	if (!ctx.chat) return;
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		if (data.startsWith(AGENTS_PAGE_PREFIX)) {
 			const requestedPage = Number(data.slice(12));
@@ -4448,7 +5168,7 @@ async function handleModelsCallback(ctx, dependencies) {
 	if (!data.startsWith("model:")) return;
 	await ctx.answerCallbackQuery();
 	if (!ctx.chat) return;
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		if (data.startsWith(MODEL_PAGE_PREFIX)) {
 			const requestedPage = Number(data.slice(11));
@@ -4527,7 +5247,7 @@ async function handleSessionsCallback(ctx, dependencies) {
 	if (!data.startsWith("sessions:")) return;
 	await ctx.answerCallbackQuery();
 	if (!ctx.chat) return;
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		if (data.startsWith(SESSIONS_PAGE_PREFIX)) {
 			const requestedPage = Number(data.slice(14));
@@ -4608,10 +5328,10 @@ async function handleLanguageCallback(ctx, dependencies) {
 	if (!data.startsWith("language:")) return;
 	await ctx.answerCallbackQuery();
 	if (!ctx.chat || !ctx.api) return;
-	const currentCopy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const currentCopy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	try {
 		if (!data.startsWith(LANGUAGE_SELECT_PREFIX)) {
-			await ctx.editMessageText(presentLanguageMessage(await getChatLanguage(dependencies.sessionRepo, ctx.chat.id), currentCopy), { reply_markup: buildLanguageKeyboard(await getChatLanguage(dependencies.sessionRepo, ctx.chat.id), currentCopy) });
+			await ctx.editMessageText(presentLanguageMessage(await getSafeChatLanguage(dependencies.sessionRepo, ctx.chat.id, dependencies.logger), currentCopy), { reply_markup: buildLanguageKeyboard(await getSafeChatLanguage(dependencies.sessionRepo, ctx.chat.id, dependencies.logger), currentCopy) });
 			return;
 		}
 		const selectedLanguage = data.slice(16);
@@ -4648,19 +5368,19 @@ async function handlePermissionApprovalCallback(ctx, dependencies) {
 }
 function registerCallbackHandler(bot, dependencies) {
 	bot.callbackQuery(/^agents:/, async (ctx) => {
-		await handleAgentsCallback(ctx, dependencies);
+		await handleAgentsCallback(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 	bot.callbackQuery(/^sessions:/, async (ctx) => {
-		await handleSessionsCallback(ctx, dependencies);
+		await handleSessionsCallback(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 	bot.callbackQuery(/^model:/, async (ctx) => {
-		await handleModelsCallback(ctx, dependencies);
+		await handleModelsCallback(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 	bot.callbackQuery(/^language:/, async (ctx) => {
-		await handleLanguageCallback(ctx, dependencies);
+		await handleLanguageCallback(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 	bot.callbackQuery(/^permission:/, async (ctx) => {
-		await handlePermissionApprovalCallback(ctx, dependencies);
+		await handlePermissionApprovalCallback(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 function parseSessionActionTarget(data, prefix) {
@@ -4678,7 +5398,7 @@ function parseSessionActionTarget(data, prefix) {
 //#endregion
 //#region src/bot/handlers/prompt.handler.ts
 async function executePromptRequest(ctx, dependencies, resolvePrompt) {
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	const foregroundRequest = dependencies.foregroundSessionTracker.acquire(ctx.chat.id);
 	if (!foregroundRequest) {
 		await ctx.reply(copy.status.alreadyProcessing);
@@ -4762,10 +5482,10 @@ async function handleImageMessage(ctx, dependencies) {
 }
 function registerFileHandler(bot, dependencies) {
 	bot.on("message:photo", async (ctx) => {
-		await handleImageMessage(ctx, dependencies);
+		await handleImageMessage(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 	bot.on("message:document", async (ctx) => {
-		await handleImageMessage(ctx, dependencies);
+		await handleImageMessage(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 function resolveTelegramImage(message) {
@@ -4807,7 +5527,7 @@ async function handleTextMessage(ctx, dependencies) {
 }
 function registerMessageHandler(bot, dependencies) {
 	bot.on("message:text", async (ctx) => {
-		await handleTextMessage(ctx, dependencies);
+		await handleTextMessage(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
@@ -4815,12 +5535,12 @@ function registerMessageHandler(bot, dependencies) {
 async function handleVoiceMessage(ctx, dependencies) {
 	if (!ctx.message.voice) return;
 	if (await replyIfSessionRenamePending(ctx, dependencies)) return;
-	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getSafeChatCopy(dependencies.sessionRepo, ctx.chat.id, dependencies.logger);
 	await ctx.reply(copy.errors.voiceUnsupported);
 }
 function registerVoiceHandler(bot, dependencies) {
 	bot.on("message:voice", async (ctx) => {
-		await handleVoiceMessage(ctx, dependencies);
+		await handleVoiceMessage(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
@@ -4841,17 +5561,18 @@ function createAuthMiddleware(allowedChatIds) {
 function buildIncomingUpdateLogFields(ctx) {
 	const messageText = ctx.msg && "text" in ctx.msg ? ctx.msg.text : void 0;
 	return {
+		...buildTelegramLoggerContext(ctx),
+		event: "telegram.update.received",
 		updateId: ctx.update.update_id,
 		chatId: ctx.chat?.id,
 		fromId: ctx.from?.id,
 		hasText: typeof messageText === "string" && messageText.length > 0,
-		textLength: typeof messageText === "string" ? messageText.length : 0,
-		textPreview: typeof messageText === "string" && messageText.length > 0 ? createRedactedPreview(messageText) : void 0
+		textLength: typeof messageText === "string" ? messageText.length : 0
 	};
 }
 function createLoggingMiddleware(logger) {
 	return async (ctx, next) => {
-		logger.info(buildIncomingUpdateLogFields(ctx), "incoming update");
+		logTelegramUpdate(logger, { ...buildIncomingUpdateLogFields(ctx) }, "incoming update");
 		return next();
 	};
 }
@@ -4860,45 +5581,133 @@ function createLoggingMiddleware(logger) {
 function registerBot(bot, container, options) {
 	bot.use(createLoggingMiddleware(container.logger));
 	bot.use(createAuthMiddleware(options.telegramAllowedChatIds));
-	registerStartCommand(bot, container);
-	registerStatusCommand(bot, container);
-	registerNewCommand(bot, container);
-	registerAgentsCommand(bot, container);
-	registerSessionsCommand(bot, container);
-	registerCancelCommand(bot, container);
-	registerModelsCommand(bot, container);
-	registerLanguageCommand(bot, container);
-	registerCallbackHandler(bot, container);
-	registerFileHandler(bot, container);
-	registerMessageHandler(bot, container);
-	registerVoiceHandler(bot, container);
+	const safeBot = bot.errorBoundary(async (error) => {
+		const scopedLogger = scopeLoggerToTelegramContext(container.logger, error.ctx, "telegram");
+		scopedLogger.error({
+			...extractTelegramUpdateContext(error.ctx),
+			event: "telegram.middleware.failed",
+			error: error.error
+		}, "telegram middleware failed");
+		await replyWithDefaultTelegramError(error.ctx, scopedLogger, error.error);
+	});
+	registerStartCommand(safeBot, container);
+	registerStatusCommand(safeBot, container);
+	registerNewCommand(safeBot, container);
+	registerAgentsCommand(safeBot, container);
+	registerSessionsCommand(safeBot, container);
+	registerCancelCommand(safeBot, container);
+	registerModelsCommand(safeBot, container);
+	registerLanguageCommand(safeBot, container);
+	registerCallbackHandler(safeBot, container);
+	registerFileHandler(safeBot, container);
+	registerMessageHandler(safeBot, container);
+	registerVoiceHandler(safeBot, container);
 }
 //#endregion
 //#region src/app/runtime.ts
+var TELEGRAM_RUNNER_OPTIONS = { runner: {
+	fetch: { timeout: 30 },
+	maxRetryTime: 900 * 1e3,
+	retryInterval: "exponential",
+	silent: true
+} };
 async function startTelegramBotRuntime(input) {
-	const bot = new Bot(input.config.telegramBotToken, { client: { apiRoot: input.config.telegramApiRoot } });
-	registerBot(bot, input.container, { telegramAllowedChatIds: input.config.telegramAllowedChatIds });
+	const runtimeKey = buildTelegramRuntimeKey(input.config);
+	const registry = getTelegramBotRuntimeRegistry();
+	const existingRuntime = registry.activeByKey.get(runtimeKey);
+	const runtimeLogger = input.container.logger.child({ component: "runtime" });
+	if (existingRuntime) {
+		runtimeLogger.warn({
+			event: "runtime.reused",
+			runtimeKey,
+			telegramApiRoot: input.config.telegramApiRoot
+		}, "telegram runtime already active in this process; reusing the existing runner");
+		await input.container.dispose();
+		return existingRuntime;
+	}
+	const runtimePromise = startTelegramBotRuntimeInternal(input, runtimeKey, () => {
+		if (registry.activeByKey.get(runtimeKey) === runtimePromise) registry.activeByKey.delete(runtimeKey);
+	}).catch((error) => {
+		if (registry.activeByKey.get(runtimeKey) === runtimePromise) registry.activeByKey.delete(runtimeKey);
+		throw error;
+	});
+	registry.activeByKey.set(runtimeKey, runtimePromise);
+	return runtimePromise;
+}
+async function startTelegramBotRuntimeInternal(input, runtimeKey, releaseRuntime) {
+	const bot = (input.botFactory ?? ((token, options) => new Bot(token, options)))(input.config.telegramBotToken, { client: { apiRoot: input.config.telegramApiRoot } });
+	const runtimeLogger = input.container.logger.child({ component: "runtime" });
+	wrapTelegramGetUpdates(bot, input.container);
+	(input.registerBotHandlers ?? registerBot)(bot, input.container, { telegramAllowedChatIds: input.config.telegramAllowedChatIds });
 	bot.catch((error) => {
-		input.container.logger.error({
-			error: error.error,
-			update: error.ctx.update
+		const metadata = extractTelegramUpdateContext(error.ctx);
+		const telegramLogger = input.container.logger.child({
+			component: "telegram",
+			...metadata
+		});
+		if (error.error instanceof GrammyError) {
+			telegramLogger.error({
+				event: "telegram.api.error",
+				errorCode: error.error.error_code,
+				description: error.error.description,
+				method: error.error.method,
+				parameters: error.error.parameters,
+				payload: error.error.payload
+			}, "telegram bot api request failed");
+			return;
+		}
+		if (error.error instanceof HttpError) {
+			telegramLogger.error({
+				event: "telegram.http.error",
+				error: error.error.error,
+				message: error.error.message
+			}, "telegram bot network request failed");
+			return;
+		}
+		telegramLogger.error({
+			event: "telegram.update.failed",
+			error: error.error
 		}, "telegram bot update failed");
 	});
-	input.container.logger.info("bot starting...");
-	if (input.syncCommands ?? true) await syncTelegramCommands(bot, input.container.logger);
-	const runner = run(bot);
+	runtimeLogger.info({
+		event: "runtime.polling.starting",
+		runtimeKey
+	}, "telegram bot polling starting");
+	const runner = (input.runBot ?? run)(bot, TELEGRAM_RUNNER_OPTIONS);
 	let stopped = false;
 	let disposed = false;
-	const stop = () => {
+	if (input.syncCommands ?? true) (input.syncCommandsHandler ?? syncTelegramCommands)(bot, input.container.logger).catch((error) => {
+		runtimeLogger.warn({
+			event: "runtime.commands.sync_failed",
+			error,
+			runtimeKey
+		}, "failed to sync telegram commands; polling continues without command registration updates");
+	});
+	let stopPromise = null;
+	const requestStop = async () => {
 		if (stopped) return;
 		stopped = true;
-		runner.stop();
+		stopPromise = runner.stop().catch((error) => {
+			runtimeLogger.warn({
+				event: "runtime.stop.failed",
+				error,
+				runtimeKey
+			}, "failed to stop telegram runner cleanly");
+		});
+		await stopPromise;
+	};
+	const stop = () => {
+		requestStop();
 	};
 	const dispose = async () => {
 		if (disposed) return;
 		disposed = true;
-		stop();
-		await input.container.dispose();
+		try {
+			await requestStop();
+			await input.container.dispose();
+		} finally {
+			releaseRuntime();
+		}
 	};
 	return {
 		bot,
@@ -4907,39 +5716,71 @@ async function startTelegramBotRuntime(input) {
 		dispose
 	};
 }
+function wrapTelegramGetUpdates(bot, container) {
+	const originalGetUpdates = bot.api.getUpdates.bind(bot.api);
+	const runtimeLogger = container.logger.child({ component: "runtime" });
+	bot.api.getUpdates = async (options, signal) => {
+		const requestOptions = options ?? {
+			limit: 100,
+			offset: 0,
+			timeout: 30
+		};
+		try {
+			return await originalGetUpdates(requestOptions, signal);
+		} catch (error) {
+			runtimeLogger.warn({
+				event: "runtime.telegram.get_updates_failed",
+				error,
+				limit: requestOptions.limit,
+				offset: requestOptions.offset,
+				timeout: requestOptions.timeout
+			}, "telegram getUpdates failed");
+			throw error;
+		}
+	};
+}
+function buildTelegramRuntimeKey(config) {
+	return `${config.telegramApiRoot}::${config.telegramBotToken}`;
+}
+function getTelegramBotRuntimeRegistry() {
+	const globalScope = globalThis;
+	globalScope.__opencodeTbotTelegramRuntimeRegistry__ ??= { activeByKey: /* @__PURE__ */ new Map() };
+	return globalScope.__opencodeTbotTelegramRuntimeRegistry__;
+}
 //#endregion
 //#region src/plugin.ts
-var runtimeState = null;
 async function ensureTelegramBotPluginRuntime(options) {
+	const runtimeStateHolder = getTelegramBotPluginRuntimeStateHolder();
 	const cwd = resolvePluginRuntimeCwd(options.context);
-	if (runtimeState && runtimeState.cwd !== cwd) {
-		const activeState = runtimeState;
-		runtimeState = null;
+	if (runtimeStateHolder.state && runtimeStateHolder.state.cwd !== cwd) {
+		const activeState = runtimeStateHolder.state;
+		runtimeStateHolder.state = null;
 		await disposeTelegramBotPluginRuntimeState(activeState);
 	}
-	if (!runtimeState) {
+	if (!runtimeStateHolder.state) {
 		const runtimePromise = startPluginRuntime(options, cwd).then((runtime) => {
-			if (runtimeState?.runtimePromise === runtimePromise) runtimeState.runtime = runtime;
+			if (runtimeStateHolder.state?.runtimePromise === runtimePromise) runtimeStateHolder.state.runtime = runtime;
 			return runtime;
 		}).catch((error) => {
-			if (runtimeState?.runtimePromise === runtimePromise) runtimeState = null;
+			if (runtimeStateHolder.state?.runtimePromise === runtimePromise) runtimeStateHolder.state = null;
 			throw error;
 		});
-		runtimeState = {
+		runtimeStateHolder.state = {
 			cwd,
 			runtime: null,
 			runtimePromise
 		};
 	}
-	return runtimeState.runtimePromise;
+	return runtimeStateHolder.state.runtimePromise;
 }
 var TelegramBotPlugin = async (context) => {
 	return createHooks(await ensureTelegramBotPluginRuntime({ context }));
 };
 async function resetTelegramBotPluginRuntimeForTests() {
-	if (!runtimeState) return;
-	const activeState = runtimeState;
-	runtimeState = null;
+	const runtimeStateHolder = getTelegramBotPluginRuntimeStateHolder();
+	if (!runtimeStateHolder.state) return;
+	const activeState = runtimeStateHolder.state;
+	runtimeStateHolder.state = null;
 	await disposeTelegramBotPluginRuntimeState(activeState);
 }
 async function startPluginRuntime(options, cwd) {
@@ -4952,8 +5793,9 @@ async function startPluginRuntime(options, cwd) {
 	});
 	const { config, container } = bootstrapApp(options.context.client, preparedConfiguration.config, { cwd: preparedConfiguration.cwd });
 	try {
-		if (preparedConfiguration.ignoredProjectConfigFilePath) container.logger.warn({
+		if (preparedConfiguration.ignoredProjectConfigFilePath) container.logger.child({ component: "runtime" }).warn({
 			cwd: preparedConfiguration.cwd,
+			event: "runtime.config.legacy_worktree_ignored",
 			ignoredProjectConfigFilePath: preparedConfiguration.ignoredProjectConfigFilePath,
 			globalConfigFilePath: preparedConfiguration.globalConfigFilePath
 		}, "legacy worktree plugin config is ignored; migrate settings to the global opencode-tbot config");
@@ -4961,8 +5803,9 @@ async function startPluginRuntime(options, cwd) {
 			config,
 			container
 		});
-		container.logger.info({
+		container.logger.child({ component: "runtime" }).info({
 			cwd: preparedConfiguration.cwd,
+			event: "runtime.plugin.started",
 			globalConfigFilePath: preparedConfiguration.globalConfigFilePath,
 			ignoredProjectConfigFilePath: preparedConfiguration.ignoredProjectConfigFilePath,
 			configFilePath: preparedConfiguration.configFilePath,
@@ -4992,6 +5835,11 @@ function createHooks(runtime) {
 		}
 	};
 }
+function getTelegramBotPluginRuntimeStateHolder() {
+	const globalScope = globalThis;
+	globalScope.__opencodeTbotPluginRuntimeState__ ??= { state: null };
+	return globalScope.__opencodeTbotPluginRuntimeState__;
+}
 //#endregion
 export { TelegramBotPlugin, TelegramBotPlugin as default, ensureTelegramBotPluginRuntime, resetTelegramBotPluginRuntimeForTests };