opencode-tbot 0.1.30 → 0.1.32

package/dist/plugin.js

@@ -1,83 +1,359 @@
-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";
 import { randomUUID } from "node:crypto";
+import { createOpencodeClient } from "@opencode-ai/sdk";
 import { run } from "@grammyjs/runner";
 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 {
-				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
-				});
-			} 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();
@@ -91,59 +367,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 {
@@ -213,6 +570,139 @@ var FileSessionRepository = class {
 	}
 };
 //#endregion
+//#region src/infra/utils/markdown-text.ts
+var HTML_TAG_PATTERN = /<\/?[A-Za-z][^>]*>/g;
+function stripMarkdownToPlainText(markdown) {
+	const lines = preprocessMarkdownForPlainText(markdown).split("\n");
+	const rendered = [];
+	for (let index = 0; index < lines.length; index += 1) {
+		const tableBlock = consumeMarkdownTable$1(lines, index);
+		if (tableBlock) {
+			rendered.push(renderTableAsPlainText(tableBlock.rows));
+			index = tableBlock.nextIndex - 1;
+			continue;
+		}
+		rendered.push(lines[index] ?? "");
+	}
+	return rendered.join("\n").replace(/```[A-Za-z0-9_-]*\n?/g, "").replace(/```/g, "").replace(/^#{1,6}\s+/gm, "").replace(/^\s*>\s?/gm, "").replace(/^(\s*)[-+*]\s+/gm, "$1- ").replace(/^(\s*)(\d+)[.)]\s+/gm, "$1$2. ").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)").replace(/(\*\*|__)(.*?)\1/g, "$2").replace(/(\*|_)(.*?)\1/g, "$2").replace(/`([^`]+)`/g, "$1").replace(HTML_TAG_PATTERN, "").trim();
+}
+function preprocessMarkdownForPlainText(markdown) {
+	const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+	const processed = [];
+	let activeFence = null;
+	for (const line of lines) {
+		const fenceMatch = line.match(/^```([A-Za-z0-9_-]+)?\s*$/);
+		if (fenceMatch) {
+			const language = (fenceMatch[1] ?? "").toLowerCase();
+			if (activeFence === "markdown") {
+				activeFence = null;
+				continue;
+			}
+			if (activeFence === "plain") {
+				processed.push(line);
+				activeFence = null;
+				continue;
+			}
+			if (language === "md" || language === "markdown") {
+				activeFence = "markdown";
+				continue;
+			}
+			activeFence = "plain";
+			processed.push(line);
+			continue;
+		}
+		processed.push(line);
+	}
+	return processed.join("\n");
+}
+function consumeMarkdownTable$1(lines, startIndex) {
+	if (startIndex + 1 >= lines.length) return null;
+	const headerCells = parseMarkdownTableRow$1(lines[startIndex] ?? "");
+	const separatorCells = parseMarkdownTableSeparator$1(lines[startIndex + 1] ?? "");
+	if (!headerCells || !separatorCells || headerCells.length !== separatorCells.length) return null;
+	const rows = [headerCells];
+	let index = startIndex + 2;
+	while (index < lines.length) {
+		const rowCells = parseMarkdownTableRow$1(lines[index] ?? "");
+		if (!rowCells || rowCells.length !== headerCells.length) break;
+		rows.push(rowCells);
+		index += 1;
+	}
+	return {
+		rows,
+		nextIndex: index
+	};
+}
+function parseMarkdownTableRow$1(line) {
+	const trimmed = line.trim();
+	if (!trimmed.includes("|")) return null;
+	const cells = splitMarkdownTableCells$1(trimmed).map((cell) => normalizeTableCell$1(cell));
+	return cells.length >= 2 ? cells : null;
+}
+function parseMarkdownTableSeparator$1(line) {
+	const cells = splitMarkdownTableCells$1(line.trim());
+	if (cells.length < 2) return null;
+	return cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim())) ? cells : null;
+}
+function splitMarkdownTableCells$1(line) {
+	const content = line.replace(/^\|/, "").replace(/\|$/, "");
+	const cells = [];
+	let current = "";
+	let escaped = false;
+	for (const char of content) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			current += char;
+			continue;
+		}
+		if (char === "|") {
+			cells.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	cells.push(current);
+	return cells;
+}
+function normalizeTableCell$1(cell) {
+	return cell.trim().replace(/\\\|/g, "|").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)").replace(/(\*\*|__)(.*?)\1/g, "$2").replace(/(\*|_)(.*?)\1/g, "$2").replace(/`([^`]+)`/g, "$1").replace(HTML_TAG_PATTERN, "");
+}
+function renderTableAsPlainText(rows) {
+	return buildAlignedTableLines$1(rows).join("\n");
+}
+function buildAlignedTableLines$1(rows) {
+	const columnWidths = calculateTableColumnWidths$1(rows);
+	return [
+		formatTableRow$1(rows[0] ?? [], columnWidths),
+		columnWidths.map((width) => "-".repeat(Math.max(3, width))).join("-+-"),
+		...rows.slice(1).map((row) => formatTableRow$1(row, columnWidths))
+	];
+}
+function calculateTableColumnWidths$1(rows) {
+	return (rows[0] ?? []).map((_, columnIndex) => rows.reduce((maxWidth, row) => Math.max(maxWidth, getDisplayWidth$1(row[columnIndex] ?? "")), 0));
+}
+function formatTableRow$1(row, columnWidths) {
+	return row.map((cell, index) => padDisplayWidth$1(cell, columnWidths[index] ?? 0)).join(" | ");
+}
+function padDisplayWidth$1(value, targetWidth) {
+	const padding = Math.max(0, targetWidth - getDisplayWidth$1(value));
+	return `${value}${" ".repeat(padding)}`;
+}
+function getDisplayWidth$1(value) {
+	let width = 0;
+	for (const char of value) width += isWideCharacter$1(char.codePointAt(0) ?? 0) ? 2 : 1;
+	return width;
+}
+function isWideCharacter$1(codePoint) {
+	return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510);
+}
+//#endregion
 //#region src/services/opencode/opencode.client.ts
 function buildOpenCodeSdkConfig(options) {
 	const apiKey = options.apiKey?.trim();
@@ -256,24 +746,11 @@ var DEFAULT_OPENCODE_PROMPT_TIMEOUT_POLICY = {
 	recoveryInactivityTimeoutMs: 12e4,
 	waitTimeoutMs: 18e5
 };
-var STRUCTURED_REPLY_SCHEMA = {
-	type: "json_schema",
-	retryCount: 2,
-	schema: {
-		type: "object",
-		additionalProperties: false,
-		required: ["body_md"],
-		properties: { body_md: {
-			type: "string",
-			description: "Markdown body only. Do not include duration, token usage, or any footer. Do not wrap the whole answer in ```md or ```markdown fences. Use Markdown formatting directly unless the user explicitly asks for raw Markdown source."
-		} }
-	}
-};
 var SDK_OPTIONS = {
 	responseStyle: "data",
 	throwOnError: true
 };
-var StructuredReplySchema = z.object({ body_md: z.string() });
+var TEXT_OUTPUT_FORMAT = { type: "text" };
 var OpenCodeClient = class {
 	client;
 	fetchFn;
@@ -461,20 +938,17 @@ var OpenCodeClient = class {
 		return buildPromptSessionResult(await this.resolvePromptResponse(input, null, knownMessageIds, startedAt), {
 			emptyResponseText: EMPTY_RESPONSE_TEXT,
 			finishedAt: Date.now(),
-			startedAt,
-			structured: input.structured ?? false
+			startedAt
 		});
 	}
 	async resolvePromptResponse(input, data, knownMessageIds, startedAt) {
-		const structured = input.structured ?? false;
-		if (data && shouldReturnPromptResponseImmediately(data, structured)) return data;
+		if (data && shouldReturnPromptResponseImmediately(data)) return data;
 		const messageId = data ? extractMessageId(data.info) : null;
 		const candidateOptions = {
 			initialMessageId: messageId,
 			initialParentId: data ? toAssistantMessage(data.info)?.parentID ?? null : null,
 			knownMessageIds,
-			requestStartedAt: resolvePromptCandidateStartTime(startedAt, data),
-			structured
+			requestStartedAt: resolvePromptCandidateStartTime(startedAt, data)
 		};
 		let bestCandidate = selectPromptResponseCandidate(data ? [data] : [], candidateOptions);
 		let lastProgressAt = Date.now();
@@ -499,26 +973,26 @@ var OpenCodeClient = class {
 				if (next) {
 					const nextCandidate = selectPromptResponseCandidate([bestCandidate, next], candidateOptions);
 					if (nextCandidate) {
-						if (didPromptResponseAdvance(bestCandidate, nextCandidate, structured)) {
+						if (didPromptResponseAdvance(bestCandidate, nextCandidate)) {
 							lastProgressAt = Date.now();
 							idleStatusSeen = false;
 						}
 						bestCandidate = nextCandidate;
 					}
-					if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && shouldReturnPromptResponseImmediately(bestCandidate, structured)) return bestCandidate;
+					if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && shouldReturnPromptResponseImmediately(bestCandidate)) return bestCandidate;
 				}
 			}
 			const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "poll-messages", input.signal);
 			if (latest) {
 				const nextCandidate = selectPromptResponseCandidate([bestCandidate, latest], candidateOptions);
 				if (nextCandidate) {
-					if (didPromptResponseAdvance(bestCandidate, nextCandidate, structured)) {
+					if (didPromptResponseAdvance(bestCandidate, nextCandidate)) {
 						lastProgressAt = Date.now();
 						idleStatusSeen = false;
 					}
 					bestCandidate = nextCandidate;
 				}
-				if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && shouldReturnPromptResponseImmediately(bestCandidate, structured)) return bestCandidate;
+				if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && shouldReturnPromptResponseImmediately(bestCandidate)) return bestCandidate;
 			}
 			const status = await this.fetchPromptSessionStatus(input.sessionId, input.signal);
 			lastStatus = status;
@@ -529,14 +1003,14 @@ var OpenCodeClient = class {
 				if (idleStatusSeen) break;
 				idleStatusSeen = true;
 			}
-			if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && isCompletedEmptyPromptResponse(bestCandidate, structured) && status?.type !== "busy" && status?.type !== "retry") break;
+			if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && isCompletedEmptyPromptResponse(bestCandidate) && status?.type !== "busy" && status?.type !== "retry") break;
 			if (Date.now() >= deadlineAt) break;
 		}
 		const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "final-scan", input.signal);
 		const resolved = selectPromptResponseCandidate([bestCandidate, latest], candidateOptions);
 		const requestScopedResolved = resolved && isPromptResponseForCurrentRequest(resolved, candidateOptions) ? resolved : null;
-		if (lastStatus?.type === "idle" && (!requestScopedResolved || shouldPollPromptMessage(requestScopedResolved, structured))) throw createMessageAbortedError();
-		if (!requestScopedResolved || shouldPollPromptMessage(requestScopedResolved, structured)) {
+		if (lastStatus?.type === "idle" && (!requestScopedResolved || shouldPollPromptMessage(requestScopedResolved))) throw createMessageAbortedError();
+		if (!requestScopedResolved || shouldPollPromptMessage(requestScopedResolved)) {
 			const timeoutReason = Date.now() >= deadlineAt ? "max-wait" : "recovery-inactivity";
 			const timeoutMs = timeoutReason === "max-wait" ? this.promptTimeoutPolicy.waitTimeoutMs : this.promptTimeoutPolicy.recoveryInactivityTimeoutMs;
 			const error = createOpenCodePromptTimeoutError({
@@ -662,9 +1136,10 @@ var OpenCodeClient = class {
 		return this.callScopedSdkMethod("config", "providers", {});
 	}
 	async sendPromptRequest(input, parts) {
+		const format = input.format ?? TEXT_OUTPUT_FORMAT;
 		const requestBody = {
 			...input.agent ? { agent: input.agent } : {},
-			...input.structured ? { format: STRUCTURED_REPLY_SCHEMA } : {},
+			format,
 			...input.model ? { model: input.model } : {},
 			...input.variant ? { variant: input.variant } : {},
 			parts
@@ -881,10 +1356,9 @@ function extractTextFromParts(parts) {
 }
 function buildPromptSessionResult(data, options) {
 	const assistantInfo = toAssistantMessage(data.info);
-	const structuredPayload = extractStructuredPayload(assistantInfo);
-	const bodyMd = options.structured ? extractStructuredMarkdown(structuredPayload) : null;
 	const responseParts = Array.isArray(data.parts) ? data.parts : [];
-	const fallbackText = extractTextFromParts(responseParts) || bodyMd || options.emptyResponseText;
+	const bodyMd = extractTextFromParts(responseParts) || null;
+	const fallbackText = bodyMd ? stripMarkdownToPlainText(bodyMd) || bodyMd : options.emptyResponseText;
 	return {
 		assistantError: assistantInfo?.error ?? null,
 		bodyMd,
@@ -892,22 +1366,21 @@ function buildPromptSessionResult(data, options) {
 		info: assistantInfo,
 		metrics: extractPromptMetrics(assistantInfo, options.startedAt, options.finishedAt),
 		parts: responseParts,
-		structured: structuredPayload ?? null
+		structured: null
 	};
 }
-function shouldPollPromptMessage(data, structured) {
+function shouldPollPromptMessage(data) {
 	const assistantInfo = toAssistantMessage(data.info);
-	const bodyMd = structured ? extractStructuredMarkdown(extractStructuredPayload(assistantInfo)) : null;
 	const hasText = extractTextFromParts(Array.isArray(data.parts) ? data.parts : []).length > 0;
 	const hasAssistantError = !!assistantInfo?.error;
 	const isCompleted = isAssistantMessageCompleted(assistantInfo);
-	return !hasText && !bodyMd && !hasAssistantError && !isCompleted;
+	return !hasText && !hasAssistantError && !isCompleted;
 }
-function shouldReturnPromptResponseImmediately(data, structured) {
-	return !shouldPollPromptMessage(data, structured) && !isCompletedEmptyPromptResponse(data, structured);
+function shouldReturnPromptResponseImmediately(data) {
+	return !shouldPollPromptMessage(data) && !isCompletedEmptyPromptResponse(data);
 }
-function isPromptResponseUsable(data, structured) {
-	return !shouldPollPromptMessage(data, structured) && !isCompletedEmptyPromptResponse(data, structured);
+function isPromptResponseUsable(data) {
+	return !shouldPollPromptMessage(data) && !isCompletedEmptyPromptResponse(data);
 }
 function normalizePromptResponse(response) {
 	return {
@@ -942,8 +1415,6 @@ function toAssistantMessage(message) {
 	if ("providerID" in message && typeof message.providerID === "string" && message.providerID.trim().length > 0) normalized.providerID = message.providerID;
 	if ("role" in message && message.role === "assistant") normalized.role = "assistant";
 	if ("sessionID" in message && typeof message.sessionID === "string" && message.sessionID.trim().length > 0) normalized.sessionID = message.sessionID;
-	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$1(message.time)) normalized.time = {
 		...typeof message.time.created === "number" && Number.isFinite(message.time.created) ? { created: message.time.created } : {},
@@ -984,8 +1455,8 @@ function delay(ms, signal) {
 		signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
-function didPromptResponseAdvance(previous, next, structured) {
-	return getPromptResponseProgressSignature(previous, structured) !== getPromptResponseProgressSignature(next, structured);
+function didPromptResponseAdvance(previous, next) {
+	return getPromptResponseProgressSignature(previous) !== getPromptResponseProgressSignature(next);
 }
 function createOpenCodePromptTimeoutError(input) {
 	return new OpenCodePromptTimeoutError({
@@ -1007,12 +1478,6 @@ function resolvePromptEndpointKind(stage) {
 function getPromptMessagePollDelayMs(attempt) {
 	return PROMPT_MESSAGE_POLL_INITIAL_DELAYS_MS[attempt] ?? PROMPT_MESSAGE_POLL_INTERVAL_MS;
 }
-function extractStructuredMarkdown(structured) {
-	const parsed = StructuredReplySchema.safeParse(structured);
-	if (!parsed.success) return null;
-	const bodyMd = parsed.data.body_md.replace(/\r\n?/g, "\n").trim();
-	return bodyMd.length > 0 ? bodyMd : null;
-}
 function extractPromptMetrics(info, startedAt, finishedAt) {
 	const createdAt = typeof info?.time?.created === "number" && Number.isFinite(info.time.created) ? info.time.created : null;
 	const completedAt = typeof info?.time?.completed === "number" && Number.isFinite(info.time.completed) ? info.time.completed : null;
@@ -1105,17 +1570,10 @@ function normalizeAssistantError(value) {
 function isAssistantMessageCompleted(message) {
 	return !!message?.error || typeof message?.time?.completed === "number" || typeof message?.finish === "string" && message.finish.trim().length > 0;
 }
-function isCompletedEmptyPromptResponse(data, structured) {
+function isCompletedEmptyPromptResponse(data) {
 	const assistantInfo = toAssistantMessage(data.info);
-	const bodyMd = structured ? extractStructuredMarkdown(extractStructuredPayload(assistantInfo)) : null;
 	const hasText = extractTextFromParts(Array.isArray(data.parts) ? data.parts : []).length > 0;
-	return isAssistantMessageCompleted(assistantInfo) && !assistantInfo?.error && !hasText && !bodyMd;
-}
-function extractStructuredPayload(message) {
-	if (!isPlainRecord$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;
+	return isAssistantMessageCompleted(assistantInfo) && !assistantInfo?.error && !hasText;
 }
 function selectPromptResponseCandidate(candidates, options) {
 	const availableCandidates = candidates.filter((candidate) => !!candidate).filter((candidate) => toAssistantMessage(candidate.info) !== null);
@@ -1135,7 +1593,7 @@ function getPromptResponseCandidateRank(message, options) {
 		createdAt,
 		isInitial: !!id && id === options.initialMessageId,
 		isNewSinceRequestStart: isPromptResponseNewSinceRequestStart(id, createdAt, options.knownMessageIds, options.requestStartedAt),
-		isUsable: isPromptResponseUsable(message, options.structured),
+		isUsable: isPromptResponseUsable(message),
 		sharesParent: !!assistant?.parentID && assistant.parentID === options.initialParentId
 	};
 }
@@ -1145,13 +1603,13 @@ function resolvePromptCandidateStartTime(startedAt, initialMessage) {
 	if (initialCreatedAt === null) return startedAt;
 	return areComparablePromptTimestamps(startedAt, initialCreatedAt) ? startedAt : initialCreatedAt;
 }
-function getPromptResponseProgressSignature(response, structured) {
+function getPromptResponseProgressSignature(response) {
 	if (!response) return "null";
 	const assistant = toAssistantMessage(response.info);
 	const responseParts = Array.isArray(response.parts) ? response.parts : [];
 	return JSON.stringify({
 		assistantError: assistant?.error?.name ?? null,
-		bodyMd: structured ? extractStructuredMarkdown(extractStructuredPayload(assistant)) : null,
+		bodyMd: extractTextFromParts(responseParts) || null,
 		completedAt: assistant?.time?.completed ?? null,
 		finish: assistant?.finish ?? null,
 		id: assistant?.id ?? null,
@@ -1979,10 +2437,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");
 		}
@@ -1990,11 +2449,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");
@@ -2010,23 +2473,41 @@ 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,
 				...files.length > 0 ? { files } : {},
 				...selectedAgent ? { agent: selectedAgent.name } : {},
-				structured: true,
+				format: { type: "text" },
 				...model ? { model } : {},
 				...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);
 		}
@@ -2039,14 +2520,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");
@@ -2056,6 +2541,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");
@@ -2063,6 +2549,7 @@ var SendPromptUseCase = class {
 			this.logger.warn?.({
 				error,
 				chatId,
+				event: "prompt.temporary_session.cleanup_failed",
 				parentSessionId,
 				sessionId
 			}, "failed to delete temporary image session");
@@ -2263,7 +2750,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,
@@ -2271,6 +2774,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
@@ -2285,7 +2791,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);
@@ -2294,11 +2800,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,
@@ -2327,7 +2833,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();
 		}
 	};
@@ -2431,6 +2940,11 @@ async function handleTelegramBotPluginEvent(runtime, event) {
 	}
 }
 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);
@@ -2451,35 +2965,45 @@ async function handlePermissionAsked(runtime, request) {
 				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 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(event.requestId, event.reply));
 		} catch (error) {
-			runtime.container.logger.warn({
+			logger.warn({
 				error,
 				chatId: approval.chatId,
-				requestId: event.requestId,
-				sessionId: event.sessionId
+				event: "plugin-event.permission.reply_message_failed"
 			}, "failed to update Telegram permission message");
 		}
 		await runtime.container.permissionApprovalRepo.set(toResolvedApproval(approval, event.reply));
 	}));
 }
 async function handleSessionError(runtime, event) {
-	if (runtime.container.foregroundSessionTracker.fail(event.sessionId, event.error instanceof Error ? event.error : /* @__PURE__ */ new Error("Unknown session error."))) {
-		runtime.container.logger.warn({
+	const logger = runtime.container.logger.child({
+		component: "plugin-event",
+		sessionId: event.sessionId
+	});
+	if (runtime.container.foregroundSessionTracker.fail(event.sessionId, normalizeForegroundSessionError(event.error))) {
+		logger.warn({
 			error: event.error,
-			sessionId: event.sessionId
+			event: "plugin-event.session.error.foreground_suppressed"
 		}, "session error suppressed for foreground Telegram session");
 		return;
 	}
@@ -2487,8 +3011,12 @@ async function handleSessionError(runtime, event) {
 	await notifyBoundChats(runtime, event.sessionId, `Session failed.\n\nSession: ${event.sessionId}\nError: ${message}`);
 }
 async function handleSessionIdle(runtime, event) {
+	const logger = runtime.container.logger.child({
+		component: "plugin-event",
+		sessionId: event.sessionId
+	});
 	if (runtime.container.foregroundSessionTracker.clear(event.sessionId)) {
-		runtime.container.logger.info({ sessionId: event.sessionId }, "session idle notification suppressed for foreground Telegram session");
+		logPluginEvent(logger, { event: "plugin-event.session.idle.foreground_suppressed" }, "session idle notification suppressed for foreground Telegram session");
 		return;
 	}
 	await notifyBoundChats(runtime, event.sessionId, `Session finished.\n\nSession: ${event.sessionId}`);
@@ -2498,16 +3026,20 @@ async function handleSessionStatus(runtime, event) {
 	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");
 		}
 	}));
@@ -2586,6 +3118,16 @@ function extractSessionErrorMessage(error) {
 	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 normalizeForegroundSessionError(error) {
+	if (error instanceof Error) return error;
+	if (isPlainRecord(error) && typeof error.name === "string" && error.name.trim().length > 0) {
+		const normalized = new Error(extractSessionErrorMessage(error) ?? "Unknown session error.");
+		normalized.name = error.name.trim();
+		if (isPlainRecord(error.data)) normalized.data = error.data;
+		return normalized;
+	}
+	return /* @__PURE__ */ new Error("Unknown session error.");
+}
 function asNonEmptyString(value) {
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -3284,7 +3826,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");
 }
@@ -3295,6 +3839,44 @@ async function syncTelegramCommandsForChat(api, chatId, language) {
 	} });
 }
 //#endregion
+//#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 {
+		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 scopeLoggerToTelegramContext(logger, ctx, component = "telegram") {
+	return logger.child(buildTelegramLoggerContext(ctx, component));
+}
+function scopeDependenciesToTelegramContext(dependencies, ctx, component = "telegram") {
+	return {
+		...dependencies,
+		logger: scopeLoggerToTelegramContext(dependencies.logger, ctx, component)
+	};
+}
+function resolveMessageText(ctx) {
+	return normalizeTelegramString(ctx.message?.text) ?? normalizeTelegramString(ctx.msg?.text);
+}
+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 normalizeTelegramString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+//#endregion
 //#region src/bot/presenters/error.presenter.ts
 function presentError(error, copy = BOT_COPY) {
 	const presented = normalizeError(error, copy);
@@ -3411,16 +3993,12 @@ function stringifyUnknown(value) {
 //#endregion
 //#region src/bot/error-boundary.ts
 function extractTelegramUpdateContext(ctx) {
-	const updateId = getNestedNumber(ctx, ["update", "update_id"]);
-	const chatId = getNestedNumber(ctx, ["chat", "id"]);
-	const messageText = getNestedString(ctx, ["message", "text"]);
-	const callbackData = getNestedString(ctx, ["callbackQuery", "data"]);
-	return {
-		...typeof updateId === "number" ? { updateId } : {},
-		...typeof chatId === "number" ? { chatId } : {},
-		...typeof messageText === "string" && messageText.trim().length > 0 ? { messageText } : {},
-		...typeof callbackData === "string" && callbackData.trim().length > 0 ? { callbackData } : {}
-	};
+	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);
@@ -3985,7 +4563,7 @@ 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
@@ -4128,7 +4706,7 @@ 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
@@ -4175,7 +4753,7 @@ 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
@@ -4203,7 +4781,7 @@ 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
@@ -4224,7 +4802,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) {
@@ -4245,7 +4823,7 @@ var MARKDOWN_SPECIAL_CHARACTERS = /([_*\[\]()~`>#+\-=|{}.!\\])/g;
 function buildTelegramPromptReply(result, copy = BOT_COPY) {
 	const renderedMarkdown = result.bodyMd ? renderMarkdownToTelegramMarkdownV2(result.bodyMd) : null;
 	const footerPlain = formatPlainMetricsFooter(result.metrics, copy);
-	const fallback = { text: joinBodyAndFooter(truncatePlainBody(normalizePlainBody(result, renderedMarkdown !== null, copy), footerPlain), footerPlain) };
+	const fallback = { text: joinBodyAndFooter(truncatePlainBody(normalizePlainBody(result, copy), footerPlain), footerPlain) };
 	if (!renderedMarkdown) return {
 		preferred: fallback,
 		fallback
@@ -4349,24 +4927,10 @@ function renderMarkdownToTelegramMarkdownV2(markdown) {
 	if (inCodeBlock) return null;
 	return rendered.join("\n");
 }
-function stripMarkdownToPlainText(markdown) {
-	const lines = preprocessMarkdownForTelegram(markdown).split("\n");
-	const rendered = [];
-	for (let index = 0; index < lines.length; index += 1) {
-		const tableBlock = consumeMarkdownTable(lines, index);
-		if (tableBlock) {
-			rendered.push(renderTableAsPlainText(tableBlock.rows));
-			index = tableBlock.nextIndex - 1;
-			continue;
-		}
-		rendered.push(lines[index]);
-	}
-	return rendered.join("\n").replace(/```[A-Za-z0-9_-]*\n?/g, "").replace(/```/g, "").replace(/^#{1,6}\s+/gm, "").replace(/^\s*>\s?/gm, "").replace(/^(\s*)[-+*]\s+/gm, "$1- ").replace(/^(\s*)(\d+)[.)]\s+/gm, "$1$2. ").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)").replace(/(\*\*|__)(.*?)\1/g, "$2").replace(/(\*|_)(.*?)\1/g, "$2").replace(/`([^`]+)`/g, "$1").trim();
-}
-function normalizePlainBody(result, preferStructured, copy) {
+function normalizePlainBody(result, copy) {
 	const fromStructured = result.bodyMd ? stripMarkdownToPlainText(result.bodyMd) : "";
 	const fromFallback = result.fallbackText.trim();
-	return (preferStructured ? fromStructured || fromFallback : fromFallback || fromStructured).trim() || result.fallbackText || copy.prompt.emptyResponse;
+	return (fromStructured || fromFallback).trim() || result.fallbackText || copy.prompt.emptyResponse;
 }
 function truncatePlainBody(body, footer) {
 	const reservedLength = footer.length + 2;
@@ -4490,9 +5054,6 @@ function renderTableAsTelegramCodeBlock(rows) {
 		"```"
 	].join("\n");
 }
-function renderTableAsPlainText(rows) {
-	return buildAlignedTableLines(rows).join("\n");
-}
 function buildAlignedTableLines(rows) {
 	const columnWidths = calculateTableColumnWidths(rows);
 	return [
@@ -4589,7 +5150,7 @@ 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
@@ -4607,7 +5168,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
@@ -4634,7 +5195,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
@@ -4900,19 +5461,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) {
@@ -4949,7 +5510,7 @@ async function executePromptRequest(ctx, dependencies, resolvePrompt) {
 			},
 			signal: foregroundRequest.signal,
 			text: promptInput.text
-		})).assistantReply, copy, dependencies), copy);
+		})).assistantReply, copy), copy);
 		try {
 			await ctx.reply(telegramReply.preferred.text, telegramReply.preferred.options);
 		} catch (replyError) {
@@ -4970,26 +5531,14 @@ async function executePromptRequest(ctx, dependencies, resolvePrompt) {
 		}
 	}
 }
-function normalizePromptReplyForDisplay(promptReply, copy, dependencies) {
+function normalizePromptReplyForDisplay(promptReply, copy) {
 	if (!promptReply.assistantError) return promptReply;
-	if (isRecoverableStructuredOutputError(promptReply)) {
-		dependencies.logger.warn?.({ error: promptReply.assistantError }, "structured output validation failed, falling back to assistant text reply");
-		return {
-			...promptReply,
-			assistantError: null
-		};
-	}
 	return {
 		...promptReply,
 		bodyMd: null,
 		fallbackText: presentError(promptReply.assistantError, copy)
 	};
 }
-function isRecoverableStructuredOutputError(promptReply) {
-	if (promptReply.assistantError?.name !== "StructuredOutputError") return false;
-	if (promptReply.bodyMd?.trim()) return true;
-	return promptReply.parts.some((part) => part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0);
-}
 //#endregion
 //#region src/bot/handlers/file.handler.ts
 var TELEGRAM_MAX_DOWNLOAD_BYTES = 20 * 1024 * 1024;
@@ -5014,10 +5563,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) {
@@ -5059,7 +5608,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
@@ -5072,7 +5621,7 @@ async function handleVoiceMessage(ctx, dependencies) {
 }
 function registerVoiceHandler(bot, dependencies) {
 	bot.on("message:voice", async (ctx) => {
-		await handleVoiceMessage(ctx, dependencies);
+		await handleVoiceMessage(ctx, scopeDependenciesToTelegramContext(dependencies, ctx, "telegram"));
 	});
 }
 //#endregion
@@ -5093,17 +5642,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();
 	};
 }
@@ -5113,11 +5663,13 @@ function registerBot(bot, container, options) {
 	bot.use(createLoggingMiddleware(container.logger));
 	bot.use(createAuthMiddleware(options.telegramAllowedChatIds));
 	const safeBot = bot.errorBoundary(async (error) => {
-		container.logger.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, container.logger, error.error);
+		await replyWithDefaultTelegramError(error.ctx, scopedLogger, error.error);
 	});
 	registerStartCommand(safeBot, container);
 	registerStatusCommand(safeBot, container);
@@ -5144,8 +5696,10 @@ async function startTelegramBotRuntime(input) {
 	const runtimeKey = buildTelegramRuntimeKey(input.config);
 	const registry = getTelegramBotRuntimeRegistry();
 	const existingRuntime = registry.activeByKey.get(runtimeKey);
+	const runtimeLogger = input.container.logger.child({ component: "runtime" });
 	if (existingRuntime) {
-		input.container.logger.warn({
+		runtimeLogger.warn({
+			event: "runtime.reused",
 			runtimeKey,
 			telegramApiRoot: input.config.telegramApiRoot
 		}, "telegram runtime already active in this process; reusing the existing runner");
@@ -5163,13 +5717,18 @@ async function startTelegramBotRuntime(input) {
 }
 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) => {
 		const metadata = extractTelegramUpdateContext(error.ctx);
+		const telegramLogger = input.container.logger.child({
+			component: "telegram",
+			...metadata
+		});
 		if (error.error instanceof GrammyError) {
-			input.container.logger.error({
-				...metadata,
+			telegramLogger.error({
+				event: "telegram.api.error",
 				errorCode: error.error.error_code,
 				description: error.error.description,
 				method: error.error.method,
@@ -5179,24 +5738,28 @@ async function startTelegramBotRuntimeInternal(input, runtimeKey, releaseRuntime
 			return;
 		}
 		if (error.error instanceof HttpError) {
-			input.container.logger.error({
-				...metadata,
+			telegramLogger.error({
+				event: "telegram.http.error",
 				error: error.error.error,
 				message: error.error.message
 			}, "telegram bot network request failed");
 			return;
 		}
-		input.container.logger.error({
-			...metadata,
+		telegramLogger.error({
+			event: "telegram.update.failed",
 			error: error.error
 		}, "telegram bot update failed");
 	});
-	input.container.logger.info({ runtimeKey }, "telegram bot polling starting");
+	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;
 	if (input.syncCommands ?? true) (input.syncCommandsHandler ?? syncTelegramCommands)(bot, input.container.logger).catch((error) => {
-		input.container.logger.warn({
+		runtimeLogger.warn({
+			event: "runtime.commands.sync_failed",
 			error,
 			runtimeKey
 		}, "failed to sync telegram commands; polling continues without command registration updates");
@@ -5206,7 +5769,8 @@ async function startTelegramBotRuntimeInternal(input, runtimeKey, releaseRuntime
 		if (stopped) return;
 		stopped = true;
 		stopPromise = runner.stop().catch((error) => {
-			input.container.logger.warn({
+			runtimeLogger.warn({
+				event: "runtime.stop.failed",
 				error,
 				runtimeKey
 			}, "failed to stop telegram runner cleanly");
@@ -5235,6 +5799,7 @@ async function startTelegramBotRuntimeInternal(input, runtimeKey, releaseRuntime
 }
 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,
@@ -5244,7 +5809,8 @@ function wrapTelegramGetUpdates(bot, container) {
 		try {
 			return await originalGetUpdates(requestOptions, signal);
 		} catch (error) {
-			container.logger.warn({
+			runtimeLogger.warn({
+				event: "runtime.telegram.get_updates_failed",
 				error,
 				limit: requestOptions.limit,
 				offset: requestOptions.offset,
@@ -5308,8 +5874,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");
@@ -5317,8 +5884,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,