opencode-tbot 0.1.30 → 0.1.31

package/dist/plugin.js

@@ -1,83 +1,360 @@
-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 +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 {
@@ -1979,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");
 		}
@@ -1990,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");
@@ -2010,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,
@@ -2027,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);
 		}
@@ -2039,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");
@@ -2056,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");
@@ -2063,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");
@@ -2263,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,
@@ -2271,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
@@ -2285,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);
@@ -2294,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,
@@ -2327,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();
 		}
 	};
@@ -2431,6 +2840,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 +2865,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) {
+	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."))) {
-		runtime.container.logger.warn({
+		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 +2911,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 +2926,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");
 		}
 	}));
@@ -3284,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");
 }
@@ -3295,6 +3729,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 +3883,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 +4453,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 +4596,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 +4643,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 +4671,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 +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) {
@@ -4589,7 +5057,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 +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
@@ -4634,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
@@ -4900,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) {
@@ -5014,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) {
@@ -5059,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
@@ -5072,7 +5540,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 +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();
 	};
 }
@@ -5113,11 +5582,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 +5615,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 +5636,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 +5657,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 +5688,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 +5718,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 +5728,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 +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");
@@ -5317,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,