im-code-agent 0.0.0-alpha.1

package/dist/src-CcW-Vja8.mjs

@@ -0,0 +1,3452 @@
+import { access, copyFile, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import lark from "@larksuiteoapi/node-sdk";
+//#region src/agent/agent-adapter.ts
+function resolveAgentCommand(config, agentType) {
+	const command = config.agents[agentType];
+	if (!command) throw new Error(`Agent not configured: ${agentType}`);
+	return command;
+}
+//#endregion
+//#region src/agent/agent-process.ts
+const ACP_TOOL_CALL_STANDARD_FIELDS = [
+	"toolCallId",
+	"kind",
+	"status",
+	"title",
+	"content",
+	"content[].type",
+	"locations",
+	"locations[].path",
+	"locations[].line",
+	"rawInput",
+	"rawOutput",
+	"_meta"
+];
+const ACP_REQUEST_PERMISSION_STANDARD_FIELDS = [
+	"sessionId",
+	"toolCall",
+	"toolCall.toolCallId",
+	"toolCall.kind",
+	"toolCall.status",
+	"toolCall.title",
+	"toolCall.content",
+	"toolCall.locations",
+	"toolCall.rawInput",
+	"toolCall.rawOutput",
+	"toolCall._meta",
+	"options",
+	"options[].optionId",
+	"options[].name",
+	"options[].kind",
+	"options[]._meta",
+	"_meta"
+];
+function collectFieldPaths(value, basePath = "") {
+	const paths = /* @__PURE__ */ new Set();
+	const walk = (node, path) => {
+		if (node === null || node === void 0) return;
+		if (Array.isArray(node)) {
+			if (path) paths.add(`${path}[]`);
+			for (const item of node) walk(item, path ? `${path}[]` : "[]");
+			return;
+		}
+		if (typeof node !== "object") return;
+		for (const [key, child] of Object.entries(node)) {
+			const nextPath = path ? `${path}.${key}` : key;
+			paths.add(nextPath);
+			walk(child, nextPath);
+		}
+	};
+	walk(value, basePath);
+	return Array.from(paths).sort();
+}
+function summarizePermissionRequest(params, rawParams) {
+	return {
+		topLevelKeys: rawParams && typeof rawParams === "object" ? Object.keys(rawParams) : [],
+		fieldPaths: collectFieldPaths(rawParams),
+		standardFields: ACP_REQUEST_PERMISSION_STANDARD_FIELDS,
+		sessionId: params.sessionId,
+		optionsCount: params.options.length,
+		options: params.options.map((item) => ({
+			optionId: item.id,
+			name: item.name,
+			kind: item.kind
+		}))
+	};
+}
+function normalizePermissionParams(raw) {
+	if (!raw || typeof raw !== "object") return {};
+	const obj = raw;
+	const sessionId = typeof obj.sessionId === "string" ? obj.sessionId : void 0;
+	const toolCall = obj.toolCall;
+	const options = ((Array.isArray(obj.options) ? obj.options : void 0) ?? []).map((item) => {
+		if (!item || typeof item !== "object") return;
+		const opt = item;
+		const optionId = typeof opt.optionId === "string" ? opt.optionId : void 0;
+		const name = typeof opt.name === "string" ? opt.name : void 0;
+		const kind = typeof opt.kind === "string" ? opt.kind : void 0;
+		if (!optionId || !name || !kind) return;
+		return {
+			id: optionId,
+			name,
+			kind
+		};
+	}).filter((item) => Boolean(item));
+	if (!sessionId || !toolCall) return {};
+	return { params: {
+		sessionId,
+		toolCall,
+		options
+	} };
+}
+var AgentProcessError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "AgentProcessError";
+	}
+};
+var AgentProcess = class {
+	#children = /* @__PURE__ */ new Map();
+	#defaultRequestTimeoutMs = 3e4;
+	#promptIdleTimeoutMs = 12e4;
+	#toolUpdateLogDedup = /* @__PURE__ */ new Set();
+	constructor(config, logger, onEvent, onPermissionRequest) {
+		this.config = config;
+		this.logger = logger;
+		this.onEvent = onEvent;
+		this.onPermissionRequest = onPermissionRequest;
+	}
+	async checkHealth(agent) {
+		const command = resolveAgentCommand(this.config, agent);
+		const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const notes = [];
+		const commandAvailable = await this.isCommandAvailable(command.command);
+		if (!commandAvailable) notes.push(`Command is not accessible: ${command.command}`);
+		let cliVersion;
+		if (agent === "codex") {
+			const result = spawnSync("codex", ["--version"], { encoding: "utf8" });
+			if (result.status === 0) cliVersion = result.stdout.trim();
+			else notes.push("codex CLI is installed but `codex --version` did not exit cleanly");
+		}
+		const hasStoredAuth = spawnSync("test", ["-f", `${process.env.HOME}/.codex/auth.json`], { stdio: "ignore" }).status === 0;
+		if (!hasStoredAuth) notes.push("No ~/.codex/auth.json detected");
+		let status = "ready";
+		if (!commandAvailable) status = "unavailable";
+		else if (!hasStoredAuth) status = "degraded";
+		return {
+			agent,
+			status,
+			commandAvailable,
+			cliVersion,
+			hasStoredAuth,
+			notes,
+			checkedAt
+		};
+	}
+	async start(options) {
+		if (this.#children.has(options.taskId)) throw new Error(`Task is already running: ${options.taskId}`);
+		const command = resolveAgentCommand(this.config, options.agent);
+		const spawnArgs = [...command.args ?? [], ...options.runtimeArgs ?? []];
+		const health = await this.checkHealth(options.agent);
+		if (!health.commandAvailable) throw new AgentProcessError("agent_command_unavailable", health.notes.join("; "));
+		const child = spawn(command.command, spawnArgs, {
+			cwd: options.cwd,
+			env: {
+				...process.env,
+				...command.env
+			},
+			stdio: "pipe"
+		});
+		const agentChild = {
+			child,
+			nextRequestId: 1,
+			pendingRequests: /* @__PURE__ */ new Map(),
+			stdoutBuffer: "",
+			stderrChunks: []
+		};
+		this.#children.set(options.taskId, agentChild);
+		child.stdout.on("data", (chunk) => {
+			this.handleStdout(options.taskId, chunk.toString());
+		});
+		child.stderr.on("data", (chunk) => {
+			agentChild.stderrChunks.push(chunk.toString());
+			this.logger.warn("agent stderr", {
+				taskId: options.taskId,
+				chunk: chunk.toString()
+			});
+		});
+		child.on("spawn", () => {
+			this.logger.info("agent process spawned", {
+				taskId: options.taskId,
+				agent: options.agent,
+				command: command.command,
+				args: spawnArgs,
+				cwd: options.cwd
+			});
+		});
+		child.on("error", (error) => {
+			this.rejectAllPendingRequests(options.taskId, `agent process spawn failed: ${error.message}`);
+			this.#children.delete(options.taskId);
+			this.clearToolUpdateLogCache(options.taskId);
+			this.logger.error("agent process error", {
+				taskId: options.taskId,
+				error: error.message
+			});
+		});
+		child.on("exit", (code, signal) => {
+			this.rejectAllPendingRequests(options.taskId, "agent process exited");
+			this.#children.delete(options.taskId);
+			this.clearToolUpdateLogCache(options.taskId);
+			this.logger.info("agent process exited", {
+				taskId: options.taskId,
+				code,
+				signal
+			});
+		});
+		const initialization = await this.initialize(options.taskId);
+		agentChild.initialization = initialization;
+		let sessionId;
+		let loadResult;
+		if (options.resumeSessionId) try {
+			loadResult = await this.loadSession(options.taskId, options.resumeSessionId, options.cwd);
+			sessionId = options.resumeSessionId;
+			this.logger.info("agent session resumed", {
+				taskId: options.taskId,
+				sessionId,
+				cwd: options.cwd
+			});
+		} catch (error) {
+			this.logger.warn("agent session resume failed, fallback to new session", {
+				taskId: options.taskId,
+				resumeSessionId: options.resumeSessionId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			const session = await this.newSession(options.taskId, options.cwd);
+			loadResult = session;
+			sessionId = session.sessionId;
+		}
+		else {
+			const session = await this.newSession(options.taskId, options.cwd);
+			loadResult = session;
+			sessionId = session.sessionId;
+		}
+		agentChild.sessionId = sessionId;
+		this.logger.info("agent initialized", {
+			taskId: options.taskId,
+			protocolVersion: initialization.protocolVersion,
+			agentName: initialization.agentInfo?.name,
+			agentVersion: initialization.agentInfo?.version,
+			sessionId
+		});
+		return {
+			initialization,
+			sessionId,
+			models: loadResult.models
+		};
+	}
+	async isCommandAvailable(command) {
+		if (command.includes("/")) try {
+			await access(command);
+			return true;
+		} catch {
+			return false;
+		}
+		return spawnSync("which", [command], { stdio: "ignore" }).status === 0;
+	}
+	async stop(taskId) {
+		const agentChild = this.#children.get(taskId);
+		if (!agentChild) return;
+		this.rejectAllPendingRequests(taskId, "agent process stopped");
+		agentChild.child.kill("SIGTERM");
+		this.#children.delete(taskId);
+		this.clearToolUpdateLogCache(taskId);
+	}
+	async initialize(taskId) {
+		return this.sendRequest(taskId, "initialize", {
+			protocolVersion: 1,
+			clientCapabilities: {
+				fs: {
+					readTextFile: false,
+					writeTextFile: false
+				},
+				terminal: false
+			}
+		});
+	}
+	async prompt(taskId, promptText) {
+		const agentChild = this.getChild(taskId);
+		if (!agentChild.sessionId) throw new Error(`Agent session not initialized for task: ${taskId}`);
+		const params = {
+			sessionId: agentChild.sessionId,
+			prompt: [{
+				type: "text",
+				text: promptText
+			}]
+		};
+		return this.sendRequest(taskId, "session/prompt", params);
+	}
+	async setSessionModel(taskId, modelId) {
+		const agentChild = this.getChild(taskId);
+		if (!agentChild.sessionId) throw new Error(`Agent session not initialized for task: ${taskId}`);
+		const params = {
+			sessionId: agentChild.sessionId,
+			modelId
+		};
+		await this.sendRequest(taskId, "session/set_model", params);
+	}
+	async newSession(taskId, cwd) {
+		const params = {
+			cwd,
+			mcpServers: []
+		};
+		try {
+			return await this.sendRequest(taskId, "session/new", params);
+		} catch (error) {
+			throw this.mapRequestError(taskId, "session/new", error);
+		}
+	}
+	async loadSession(taskId, sessionId, cwd) {
+		const params = {
+			sessionId,
+			cwd,
+			mcpServers: []
+		};
+		try {
+			return await this.sendRequest(taskId, "session/load", params);
+		} catch (error) {
+			throw this.mapRequestError(taskId, "session/load", error);
+		}
+	}
+	async sendRequest(taskId, method, params) {
+		const agentChild = this.getChild(taskId);
+		const id = agentChild.nextRequestId++;
+		const payload = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			...params === void 0 ? {} : { params }
+		};
+		return new Promise((resolve, reject) => {
+			const timeoutMs = method === "session/prompt" ? this.#promptIdleTimeoutMs : this.#defaultRequestTimeoutMs;
+			const timer = this.createRequestTimer(taskId, id, method, timeoutMs);
+			agentChild.pendingRequests.set(id, {
+				method,
+				timer,
+				timeoutMs,
+				resolve: (value) => resolve(value),
+				reject
+			});
+			this.writeMessage(taskId, payload);
+		});
+	}
+	writeMessage(taskId, message) {
+		this.getChild(taskId).child.stdin.write(`${JSON.stringify(message)}\n`);
+		this.logger.info("agent request sent", {
+			taskId,
+			method: message.method,
+			hasId: "id" in message
+		});
+	}
+	handleStdout(taskId, chunk) {
+		const agentChild = this.getChild(taskId);
+		agentChild.stdoutBuffer += chunk;
+		const lines = agentChild.stdoutBuffer.split("\n");
+		agentChild.stdoutBuffer = lines.pop() ?? "";
+		for (const rawLine of lines) {
+			const line = rawLine.trim();
+			if (!line) continue;
+			this.handleMessage(taskId, line).catch((error) => {
+				this.logger.warn("agent message handling failed", {
+					taskId,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			});
+		}
+	}
+	async handleMessage(taskId, line) {
+		let message;
+		try {
+			message = JSON.parse(line);
+		} catch (error) {
+			this.logger.warn("agent emitted non-json stdout", {
+				taskId,
+				line,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			return;
+		}
+		if ("id" in message && "result" in message) {
+			this.handleSuccess(taskId, message);
+			return;
+		}
+		if ("id" in message && "error" in message) {
+			this.handleFailure(taskId, message);
+			return;
+		}
+		if ("id" in message && "method" in message && !("result" in message) && !("error" in message)) {
+			await this.handleInboundRequest(taskId, message);
+			return;
+		}
+		if ("method" in message && message.method === "session/update") {
+			this.handleSessionUpdate(taskId, message);
+			return;
+		}
+		this.logger.info("agent notification received", {
+			taskId,
+			method: message.method
+		});
+	}
+	async handleInboundRequest(taskId, message) {
+		if (message.method !== "request_permission" && message.method !== "session/request_permission") {
+			this.logger.warn("agent inbound request is not supported", {
+				taskId,
+				method: message.method,
+				id: message.id
+			});
+			this.writeSuccess(taskId, message.id, { outcome: { outcome: "cancelled" } });
+			return;
+		}
+		if (!this.onPermissionRequest) {
+			this.logger.warn("permission request handler is not configured", {
+				taskId,
+				id: message.id
+			});
+			this.writeSuccess(taskId, message.id, { outcome: { outcome: "cancelled" } });
+			return;
+		}
+		const params = normalizePermissionParams(message.params).params;
+		if (!params) {
+			this.logger.warn("permission request params missing", {
+				taskId,
+				id: message.id,
+				rawFieldPaths: collectFieldPaths(message.params)
+			});
+			this.writeSuccess(taskId, message.id, { outcome: { outcome: "cancelled" } });
+			return;
+		}
+		this.logger.info("permission request payload", {
+			taskId,
+			id: message.id,
+			method: message.method,
+			permission: summarizePermissionRequest(params, message.params),
+			toolCallFieldPaths: collectFieldPaths(params.toolCall),
+			toolCallStandardFields: ACP_TOOL_CALL_STANDARD_FIELDS
+		});
+		let outcome;
+		try {
+			outcome = await this.onPermissionRequest({
+				taskId,
+				params,
+				emitApprovalRequested: (request) => {
+					this.onEvent?.({
+						type: "agent.approval_requested",
+						taskId,
+						request
+					});
+				}
+			});
+		} catch (error) {
+			this.logger.error("permission request handler failed", {
+				taskId,
+				id: message.id,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			this.writeSuccess(taskId, message.id, { outcome: { outcome: "cancelled" } });
+			return;
+		}
+		if (outcome.decision) this.onEvent?.({
+			type: "agent.approval_resolved",
+			taskId,
+			decision: outcome.decision
+		});
+		if (outcome.status !== "approved") {
+			if (outcome.optionId) this.writeSuccess(taskId, message.id, { outcome: {
+				outcome: "selected",
+				optionId: outcome.optionId
+			} });
+			else this.writeSuccess(taskId, message.id, { outcome: { outcome: "cancelled" } });
+			return;
+		}
+		this.writeSuccess(taskId, message.id, { outcome: {
+			outcome: "selected",
+			optionId: outcome.optionId
+		} });
+	}
+	writeSuccess(taskId, id, result) {
+		const agentChild = this.#children.get(taskId);
+		if (!agentChild) {
+			this.logger.warn("agent response dropped: task is no longer running", {
+				taskId,
+				id
+			});
+			return;
+		}
+		const response = {
+			jsonrpc: "2.0",
+			id,
+			result
+		};
+		agentChild.child.stdin.write(`${JSON.stringify(response)}\n`);
+		this.logger.info("agent response sent", {
+			taskId,
+			id
+		});
+	}
+	handleSuccess(taskId, message) {
+		const agentChild = this.getChild(taskId);
+		const pending = agentChild.pendingRequests.get(message.id);
+		if (!pending) {
+			this.logger.warn("agent response without pending request", {
+				taskId,
+				id: message.id
+			});
+			return;
+		}
+		agentChild.pendingRequests.delete(message.id);
+		clearTimeout(pending.timer);
+		pending.resolve(message.result);
+	}
+	handleFailure(taskId, message) {
+		const agentChild = this.getChild(taskId);
+		if (message.id === null) {
+			this.logger.error("agent emitted rpc error without request id", {
+				taskId,
+				code: message.error.code,
+				message: message.error.message
+			});
+			return;
+		}
+		const pending = agentChild.pendingRequests.get(message.id);
+		if (!pending) {
+			this.logger.warn("agent error without pending request", {
+				taskId,
+				id: message.id,
+				code: message.error.code,
+				message: message.error.message
+			});
+			return;
+		}
+		agentChild.pendingRequests.delete(message.id);
+		clearTimeout(pending.timer);
+		pending.reject(new AgentProcessError("agent_protocol_error", `ACP request failed for ${pending.method}: ${message.error.message} (${message.error.code})`));
+	}
+	handleSessionUpdate(taskId, message) {
+		this.refreshPromptTimeout(taskId);
+		const update = message.params?.update;
+		if (update?.sessionUpdate === "agent_message_chunk" && update.content?.type === "text") this.onEvent?.({
+			type: "agent.output",
+			taskId,
+			text: update.content.text
+		});
+		const processText = this.formatProcessUpdate(update);
+		if (processText) this.onEvent?.({
+			type: "agent.output",
+			taskId,
+			text: processText
+		});
+		if (update?.sessionUpdate?.includes("tool")) {
+			const toolUpdate = this.toToolInvocation(update);
+			this.onEvent?.({
+				type: "agent.tool_update",
+				taskId,
+				update: toolUpdate
+			});
+			if (this.shouldLogToolUpdate(taskId, toolUpdate)) this.logger.info("agent tool update", {
+				taskId,
+				sessionId: message.params?.sessionId,
+				updateType: update.sessionUpdate,
+				tool: {
+					toolCallId: toolUpdate.toolCallId,
+					toolName: toolUpdate.toolName,
+					toolNameSource: toolUpdate.toolNameSource,
+					kind: toolUpdate.kind,
+					status: toolUpdate.status
+				},
+				fieldPaths: toolUpdate.fieldPaths,
+				standardFields: ACP_TOOL_CALL_STANDARD_FIELDS
+			});
+		}
+		if (update?.sessionUpdate && update.sessionUpdate !== "agent_message_chunk" && update.sessionUpdate !== "usage_update") this.logger.info("agent session update received", {
+			taskId,
+			sessionId: message.params?.sessionId,
+			updateType: update.sessionUpdate,
+			contentType: update?.content?.type
+		});
+	}
+	formatProcessUpdate(update) {
+		if (!update) return;
+		if (update.sessionUpdate === "agent_message_chunk") return;
+		if (update.sessionUpdate === "usage_update") return;
+		if (update.sessionUpdate === "available_commands_update") return;
+		if (update.sessionUpdate.includes("tool")) return this.formatToolUpdate(update);
+		const summary = this.summarizeUpdate(update);
+		return `\n[${update.sessionUpdate}]${summary ? ` ${summary}` : ""}\n`;
+	}
+	formatToolUpdate(update) {
+		const summary = this.toToolInvocation(update);
+		const toolName = summary.toolName ?? "工具调用";
+		const status = this.readStringField(update, [
+			"status",
+			"state",
+			"phase"
+		]);
+		const command = summary.command;
+		const path = summary.path;
+		const error = this.readStringField(update, ["error", "message"]);
+		const query = summary.query;
+		const url = summary.url;
+		const lines = [`\n[tool] ${toolName}${status ? ` (${status})` : ""}`];
+		if (query) lines.push(`query: ${this.truncate(query, 160)}`);
+		if (url) lines.push(`url: ${this.truncate(url, 200)}`);
+		if (command) lines.push(`cmd: ${this.truncate(command, 160)}`);
+		if (path) lines.push(`path: ${this.truncate(path, 120)}`);
+		if (error) lines.push(`error: ${this.truncate(error, 160)}`);
+		lines.push("");
+		return lines.join("\n");
+	}
+	toToolInvocation(update) {
+		const command = this.readStringField(update, [
+			"command",
+			"cmd",
+			"shellCommand"
+		]) ?? this.findStringByKeyPattern(update, /(cmd|command|shell)/i);
+		const path = this.readStringField(update, [
+			"path",
+			"cwd",
+			"targetPath"
+		]) ?? this.findStringByKeyPattern(update, /(cwd|path|target)/i);
+		const query = this.readStringField(update, [
+			"query",
+			"q",
+			"searchQuery",
+			"keyword"
+		]) ?? this.findStringByKeyPattern(update, /(query|keyword)\b/i);
+		const url = this.readStringField(update, [
+			"url",
+			"uri",
+			"link"
+		]) ?? this.findStringByKeyPattern(update, /(url|uri|link)\b/i);
+		const toolNameResult = this.extractToolName(update);
+		const status = this.readStringField(update, [
+			"status",
+			"state",
+			"phase"
+		]);
+		const id = this.readStringField(update, [
+			"id",
+			"toolCallId",
+			"tool_call_id"
+		]) ?? this.findStringByKeyPattern(update, /\b(id|tool.*id|call.*id)\b/i);
+		const title = this.readStringField(update, ["title"]);
+		const kind = this.readStringField(update, ["kind"]);
+		const error = this.readStringField(update, ["error", "message"]);
+		return {
+			updateType: update.sessionUpdate,
+			toolCallId: id ?? "unknown",
+			toolName: toolNameResult.name,
+			toolNameSource: toolNameResult.source,
+			kind: kind ?? "unknown",
+			title,
+			status: status ?? "unknown",
+			command,
+			path,
+			query,
+			url,
+			error,
+			fieldPaths: collectFieldPaths(update)
+		};
+	}
+	extractToolName(update) {
+		const fromActionType = this.extractToolNameFromActionType(update);
+		if (fromActionType) return {
+			name: fromActionType,
+			source: "action_type"
+		};
+		const fromTitle = this.extractToolNameFromTitle(update);
+		if (fromTitle) return {
+			name: fromTitle,
+			source: "title"
+		};
+		const direct = this.readStringField(update, [
+			"toolName",
+			"tool_name",
+			"tool",
+			"method",
+			"function"
+		]) ?? this.findStringByKeyPattern(update, /(tool.*name|tool|method|function|action)/i);
+		if (direct && !this.isGenericToolValue(direct)) return {
+			name: direct,
+			source: "direct_field"
+		};
+		const knownTool = this.findKnownToolName(update);
+		if (knownTool) return {
+			name: knownTool,
+			source: "known_pattern"
+		};
+		const command = this.readStringField(update, [
+			"command",
+			"cmd",
+			"shellCommand"
+		]) ?? this.findStringByKeyPattern(update, /(cmd|command|shell)/i);
+		if (command) return {
+			name: command.split(/\s+/)[0] ?? "unknown",
+			source: "command"
+		};
+		return {
+			name: "unknown",
+			source: "fallback"
+		};
+	}
+	extractToolNameFromActionType(update) {
+		const actionType = this.readStringField(update, ["actionType", "action_type"]) ?? this.findStringByKeyPattern(update, /action.*type/i);
+		if (!actionType) return;
+		const normalized = actionType.trim().toLowerCase();
+		if (normalized === "search") return "web.search_query";
+		if (normalized === "open_page") return "web.open";
+		if (normalized === "find_text") return "web.find";
+		if (normalized === "screenshot") return "web.screenshot";
+		return `web.${normalized}`;
+	}
+	extractToolNameFromTitle(update) {
+		const title = this.readStringField(update, ["title"]);
+		if (!title) return;
+		const normalized = title.toLowerCase();
+		if (normalized.includes("searching the web") || normalized.includes("searching for:")) return "web.search_query";
+		if (normalized.includes("opening:") || normalized === "open page") return "web.open";
+		if (normalized.startsWith("finding:")) return "web.find";
+	}
+	summarizeUpdate(update) {
+		const content = update.content;
+		if (content?.type === "text") return content.text;
+		if (content?.type === "image") return `[image:${content.mimeType}]`;
+		const { sessionUpdate: _sessionUpdate, content: _content, availableCommands: _availableCommands, used: _used, size: _size, ...compact } = update;
+		const text = JSON.stringify(compact);
+		if (!text || text === "{}") return "";
+		return text.length > 300 ? `${text.slice(0, 300)}...` : text;
+	}
+	readStringField(update, keys) {
+		const dict = update;
+		for (const key of keys) {
+			const value = dict[key];
+			if (typeof value === "string" && value.trim()) return value.trim();
+			if (typeof value === "number" || typeof value === "boolean") return String(value);
+			if (value && typeof value === "object") {
+				const nested = value;
+				for (const nestedKey of [
+					"name",
+					"text",
+					"command",
+					"path",
+					"message"
+				]) {
+					const nestedValue = nested[nestedKey];
+					if (typeof nestedValue === "string" && nestedValue.trim()) return nestedValue.trim();
+				}
+			}
+		}
+	}
+	findStringByKeyPattern(value, pattern, depth = 0) {
+		if (depth > 6) return;
+		for (const [key, item] of Object.entries(value)) {
+			if (typeof item === "string" && item.trim() && pattern.test(key)) return item.trim();
+			if (item && typeof item === "object") {
+				if (Array.isArray(item)) {
+					for (const entry of item) if (entry && typeof entry === "object") {
+						const nested = this.findStringByKeyPattern(entry, pattern, depth + 1);
+						if (nested) return nested;
+					}
+					continue;
+				}
+				const nested = this.findStringByKeyPattern(item, pattern, depth + 1);
+				if (nested) return nested;
+			}
+		}
+	}
+	isGenericToolValue(value) {
+		const normalized = value.trim().toLowerCase();
+		return /^ws_[a-z0-9]+$/.test(normalized) || normalized === "tool" || normalized === "tools" || normalized === "in_progress" || normalized === "completed" || normalized === "running" || normalized === "status";
+	}
+	findKnownToolName(value, depth = 0) {
+		if (depth > 6) return;
+		const known = [
+			"search_query",
+			"web_search",
+			"image_query",
+			"open",
+			"click",
+			"find",
+			"screenshot",
+			"finance",
+			"weather",
+			"sports",
+			"time"
+		];
+		for (const item of Object.values(value)) {
+			if (typeof item === "string") {
+				const normalized = item.trim().toLowerCase();
+				if (known.includes(normalized)) return normalized;
+			}
+			if (item && typeof item === "object") {
+				if (Array.isArray(item)) {
+					for (const entry of item) if (entry && typeof entry === "object") {
+						const nested = this.findKnownToolName(entry, depth + 1);
+						if (nested) return nested;
+					}
+					continue;
+				}
+				const nested = this.findKnownToolName(item, depth + 1);
+				if (nested) return nested;
+			}
+		}
+	}
+	shouldLogToolUpdate(taskId, update) {
+		const key = `${taskId}:${update.toolCallId}:${update.status}:${update.updateType}`;
+		if (this.#toolUpdateLogDedup.has(key)) return false;
+		this.#toolUpdateLogDedup.add(key);
+		return true;
+	}
+	clearToolUpdateLogCache(taskId) {
+		for (const key of this.#toolUpdateLogDedup) if (key.startsWith(`${taskId}:`)) this.#toolUpdateLogDedup.delete(key);
+	}
+	truncate(text, maxLen) {
+		return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
+	}
+	getChild(taskId) {
+		const agentChild = this.#children.get(taskId);
+		if (!agentChild) throw new Error(`Agent process not found for task: ${taskId}`);
+		return agentChild;
+	}
+	createRequestTimer(taskId, requestId, method, timeoutMs) {
+		return setTimeout(() => {
+			const agentChild = this.#children.get(taskId);
+			const pending = agentChild?.pendingRequests.get(requestId);
+			if (!pending) return;
+			agentChild?.pendingRequests.delete(requestId);
+			pending.reject(new AgentProcessError("agent_session_timeout", `ACP request timed out for ${method} after ${timeoutMs}ms`));
+		}, timeoutMs);
+	}
+	refreshPromptTimeout(taskId) {
+		const agentChild = this.#children.get(taskId);
+		if (!agentChild) return;
+		for (const [requestId, pending] of agentChild.pendingRequests.entries()) {
+			if (pending.method !== "session/prompt") continue;
+			clearTimeout(pending.timer);
+			pending.timer = this.createRequestTimer(taskId, requestId, pending.method, pending.timeoutMs);
+		}
+	}
+	rejectAllPendingRequests(taskId, reason) {
+		const agentChild = this.#children.get(taskId);
+		if (!agentChild) return;
+		for (const [id, pending] of agentChild.pendingRequests.entries()) {
+			clearTimeout(pending.timer);
+			pending.reject(new AgentProcessError("agent_session_start_failed", `ACP request interrupted for ${pending.method}: ${reason}`));
+			agentChild.pendingRequests.delete(id);
+		}
+	}
+	mapRequestError(taskId, method, error) {
+		if (error instanceof AgentProcessError) {
+			if (error.code === "agent_session_timeout") {
+				const stderr = this.getChild(taskId).stderrChunks.join("\n");
+				if (!(spawnSync("test", ["-f", `${process.env.HOME}/.codex/auth.json`], { stdio: "ignore" }).status === 0)) return new AgentProcessError("agent_auth_missing", "Codex authentication is missing. Please complete local Codex login first.");
+				return new AgentProcessError("agent_session_timeout", stderr ? `codex-acp did not finish ${method} within timeout. stderr: ${stderr}` : `codex-acp did not finish ${method} within timeout`);
+			}
+			return error;
+		}
+		return new AgentProcessError("agent_session_start_failed", error instanceof Error ? error.message : String(error));
+	}
+};
+//#endregion
+//#region src/approval/approval-store.ts
+var ApprovalStore = class {
+	#snapshots = /* @__PURE__ */ new Map();
+	#waiters = /* @__PURE__ */ new Map();
+	set(request) {
+		this.#snapshots.set(request.id, {
+			request,
+			status: "pending"
+		});
+	}
+	get(requestId) {
+		return this.#snapshots.get(requestId);
+	}
+	delete(requestId) {
+		const waiter = this.#waiters.get(requestId);
+		if (waiter) {
+			clearTimeout(waiter.timer);
+			this.#waiters.delete(requestId);
+		}
+		this.#snapshots.delete(requestId);
+	}
+	awaitDecision(requestId, timeoutMs) {
+		const snapshot = this.#snapshots.get(requestId);
+		if (!snapshot) return Promise.reject(/* @__PURE__ */ new Error(`Approval request not found: ${requestId}`));
+		if (snapshot.status === "approved" && snapshot.decision) return Promise.resolve({
+			status: "approved",
+			request: snapshot.request,
+			decision: snapshot.decision
+		});
+		if (snapshot.status === "rejected") return Promise.resolve({
+			status: "rejected",
+			request: snapshot.request,
+			decision: snapshot.decision
+		});
+		if (snapshot.status === "expired") return Promise.resolve({
+			status: "expired",
+			request: snapshot.request
+		});
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				const current = this.#snapshots.get(requestId);
+				if (!current || current.status !== "pending") return;
+				current.status = "expired";
+				current.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+				this.#snapshots.set(requestId, current);
+				this.#waiters.delete(requestId);
+				resolve({
+					status: "expired",
+					request: current.request
+				});
+			}, timeoutMs);
+			this.#waiters.set(requestId, {
+				resolve,
+				timer
+			});
+		});
+	}
+	resolve(decision) {
+		const snapshot = this.#snapshots.get(decision.requestId);
+		if (!snapshot) return { accepted: false };
+		if (snapshot.status !== "pending") return {
+			accepted: false,
+			snapshot
+		};
+		snapshot.status = decision.decision === "approved" ? "approved" : "rejected";
+		snapshot.decision = decision;
+		snapshot.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.#snapshots.set(decision.requestId, snapshot);
+		const waiter = this.#waiters.get(decision.requestId);
+		if (waiter) {
+			clearTimeout(waiter.timer);
+			this.#waiters.delete(decision.requestId);
+			waiter.resolve(snapshot.status === "approved" ? {
+				status: "approved",
+				request: snapshot.request,
+				decision
+			} : {
+				status: "rejected",
+				request: snapshot.request,
+				decision
+			});
+		}
+		return {
+			accepted: true,
+			snapshot
+		};
+	}
+};
+//#endregion
+//#region src/approval/approval-gateway.ts
+var ApprovalGateway = class {
+	#resolutionListeners = /* @__PURE__ */ new Set();
+	#sessionAllowAll = /* @__PURE__ */ new Set();
+	constructor(store, logger) {
+		this.store = store;
+		this.logger = logger;
+	}
+	request(request) {
+		this.store.set(request);
+		this.logger.info("approval request stored", {
+			requestId: request.id,
+			taskId: request.taskId,
+			kind: request.kind
+		});
+	}
+	async requestAndWait(request, timeoutMs) {
+		this.request(request);
+		const result = await this.store.awaitDecision(request.id, timeoutMs);
+		if (result.status === "expired") {
+			const snapshot = this.store.get(request.id);
+			if (snapshot) {
+				this.emitResolution(snapshot);
+				this.store.delete(request.id);
+			}
+		}
+		return result;
+	}
+	resolve(decision) {
+		const result = this.store.resolve(decision);
+		if (!result.snapshot) {
+			this.logger.warn("approval request not found", {
+				requestId: decision.requestId,
+				taskId: decision.taskId
+			});
+			return;
+		}
+		if (!result.accepted) {
+			this.logger.info("approval request resolve ignored", {
+				requestId: decision.requestId,
+				taskId: decision.taskId,
+				decision: decision.decision,
+				status: result.snapshot.status
+			});
+			return result.snapshot;
+		}
+		if (decision.decision === "approved" && decision.comment === "approved-for-session") this.#sessionAllowAll.add(decision.taskId);
+		this.logger.info("approval request resolved", {
+			requestId: decision.requestId,
+			taskId: decision.taskId,
+			decision: decision.decision
+		});
+		this.emitResolution(result.snapshot);
+		this.store.delete(decision.requestId);
+		return result.snapshot;
+	}
+	isSessionAllowAll(taskId) {
+		return this.#sessionAllowAll.has(taskId);
+	}
+	onResolved(listener) {
+		this.#resolutionListeners.add(listener);
+		return () => {
+			this.#resolutionListeners.delete(listener);
+		};
+	}
+	emitResolution(snapshot) {
+		for (const listener of this.#resolutionListeners) listener(snapshot);
+	}
+};
+//#endregion
+//#region src/policy/policy-engine.ts
+function evaluatePolicy(input) {
+	const { kind, hasSessionAllowAll } = input;
+	if (hasSessionAllowAll) return { type: "allow" };
+	return {
+		type: "ask",
+		reason: `Approval required for ${kind}`
+	};
+}
+//#endregion
+//#region src/approval/permission-handler.ts
+const APPROVAL_TIMEOUT_MS = 12e4;
+function findWorkspaceByTask(taskId, taskRunner, workspaces) {
+	const task = taskRunner.getTask(taskId);
+	if (!task) return workspaces[0];
+	return workspaces.find((item) => item.id === task.workspaceId) ?? workspaces[0];
+}
+function extractTargetPath(params) {
+	const fromLocation = params.toolCall.locations?.[0]?.path;
+	if (fromLocation) return fromLocation;
+	const rawInput = params.toolCall.rawInput;
+	if (rawInput && typeof rawInput === "object") {
+		const candidate = rawInput.path;
+		if (typeof candidate === "string" && candidate.trim()) return candidate;
+	}
+}
+function extractCommand(params) {
+	const rawInput = params.toolCall.rawInput;
+	if (typeof rawInput === "string" && rawInput.trim()) return rawInput.trim();
+	if (rawInput && typeof rawInput === "object") for (const key of [
+		"command",
+		"cmd",
+		"shellCommand",
+		"input",
+		"prompt"
+	]) {
+		const value = rawInput[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+	}
+	const content = params.toolCall.content;
+	if (content && content.length > 0) {
+		for (const item of content) if (item.type === "text" && typeof item.text === "string" && item.text.trim()) return item.text.trim();
+	}
+}
+function inferApprovalKind(params) {
+	const kind = (params.toolCall.kind ?? "").toLowerCase();
+	const title = (params.toolCall.title ?? "").toLowerCase();
+	const cmd = (extractCommand(params) ?? "").toLowerCase();
+	if (/network|http|https|curl|wget/.test(kind) || /network|http|https|curl|wget/.test(title) || /curl|wget/.test(cmd)) return "network";
+	if (/edit|patch|write|file/.test(kind) || /edit|patch|write|apply/.test(title)) return "write";
+	if (/read|view|list/.test(kind) || /read|view|list/.test(title)) return "read";
+	if (/cat\s|ls\s|find\s|rg\s/.test(cmd)) return "read";
+	return "exec";
+}
+function chooseAllowOption(options, preferSession) {
+	if (options.length === 0) return;
+	if (preferSession) {
+		const sessionOption = options.find((item) => {
+			const id = item.id.toLowerCase();
+			return id === "approved-for-session" || id === "approve-for-session" || id === "always";
+		});
+		if (sessionOption) return sessionOption.id;
+	}
+	const explicitApproved = options.find((item) => {
+		const id = item.id.toLowerCase();
+		return id === "approved" || id === "approve" || id === "allow" || id === "yes";
+	});
+	if (explicitApproved) return explicitApproved.id;
+	const allow = options.find((item) => item.kind.toLowerCase().startsWith("allow"));
+	if (allow) return allow.id;
+	return options[0]?.id;
+}
+function chooseRejectOption(options) {
+	for (const candidate of [
+		"abort",
+		"rejected",
+		"reject",
+		"cancel"
+	]) {
+		const hit = options.find((item) => item.id === candidate);
+		if (hit) return hit.id;
+	}
+	return options.find((item) => item.kind.startsWith("reject"))?.id;
+}
+function buildApprovalRequest(taskId, kind, workspace, params) {
+	const now = /* @__PURE__ */ new Date();
+	const command = extractCommand(params);
+	const target = extractTargetPath(params);
+	const title = params.toolCall.title ?? `Permission required: ${kind}`;
+	return {
+		id: randomUUID(),
+		taskId,
+		kind,
+		title,
+		cwd: workspace.cwd,
+		target,
+		command,
+		reason: title,
+		riskLevel: kind === "read" ? "low" : kind === "write" ? "medium" : "high",
+		createdAt: now.toISOString(),
+		expiresAt: new Date(now.getTime() + APPROVAL_TIMEOUT_MS).toISOString()
+	};
+}
+function buildDeniedWorkspaceOutcome(taskId, params) {
+	const fallbackRequest = {
+		id: randomUUID(),
+		taskId,
+		kind: "exec",
+		title: "Permission denied: workspace not found",
+		cwd: process.cwd(),
+		reason: "workspace_not_found",
+		riskLevel: "high",
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		expiresAt: new Date(Date.now() + APPROVAL_TIMEOUT_MS).toISOString()
+	};
+	return {
+		status: "denied",
+		optionId: chooseRejectOption(params.options),
+		approvalRequest: fallbackRequest,
+		decision: {
+			requestId: fallbackRequest.id,
+			taskId,
+			decision: "rejected",
+			comment: "workspace_not_found",
+			decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			decidedBy: "policy-engine"
+		}
+	};
+}
+function createPermissionRequestHandler(args) {
+	const { workspaces, approvalGateway, getTaskRunner } = args;
+	return async ({ taskId, params, emitApprovalRequested }) => {
+		const taskRunner = getTaskRunner();
+		const workspace = findWorkspaceByTask(taskId, taskRunner, workspaces);
+		if (!workspace) return buildDeniedWorkspaceOutcome(taskId, params);
+		const kind = inferApprovalKind(params);
+		const request = buildApprovalRequest(taskId, kind, workspace, params);
+		const policy = evaluatePolicy({
+			kind,
+			workspace,
+			hasSessionAllowAll: approvalGateway.isSessionAllowAll(taskId) || taskRunner.isTaskFullAccess(taskId)
+		});
+		if (policy.type === "allow") {
+			const optionId = chooseAllowOption(params.options, true);
+			if (!optionId) return {
+				status: "denied",
+				optionId: chooseRejectOption(params.options),
+				approvalRequest: request,
+				decision: {
+					requestId: request.id,
+					taskId,
+					decision: "rejected",
+					comment: "allow_option_not_found",
+					decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					decidedBy: "policy-engine"
+				}
+			};
+			return {
+				status: "approved",
+				optionId,
+				approvalRequest: request,
+				decision: {
+					requestId: request.id,
+					taskId,
+					decision: "approved",
+					decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					decidedBy: "policy-engine",
+					comment: optionId === "approved-for-session" ? "approved-for-session" : "auto-allow"
+				}
+			};
+		}
+		if (policy.type === "deny") return {
+			status: "denied",
+			optionId: chooseRejectOption(params.options),
+			approvalRequest: request,
+			decision: {
+				requestId: request.id,
+				taskId,
+				decision: "rejected",
+				comment: policy.reason,
+				decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				decidedBy: "policy-engine"
+			}
+		};
+		emitApprovalRequested(request);
+		const awaited = await approvalGateway.requestAndWait(request, APPROVAL_TIMEOUT_MS);
+		if (awaited.status === "approved") {
+			const optionId = chooseAllowOption(params.options, awaited.decision.comment === "approved-for-session");
+			if (!optionId) return {
+				status: "denied",
+				optionId: chooseRejectOption(params.options),
+				approvalRequest: request,
+				decision: {
+					requestId: request.id,
+					taskId,
+					decision: "rejected",
+					comment: "allow_option_not_found",
+					decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					decidedBy: "bridge"
+				}
+			};
+			return {
+				status: "approved",
+				optionId,
+				approvalRequest: request,
+				decision: awaited.decision
+			};
+		}
+		if (awaited.status === "rejected") return {
+			status: "rejected",
+			optionId: chooseRejectOption(params.options),
+			approvalRequest: request,
+			decision: awaited.decision
+		};
+		return {
+			status: "expired",
+			optionId: chooseRejectOption(params.options),
+			approvalRequest: request,
+			decision: {
+				requestId: request.id,
+				taskId,
+				decision: "rejected",
+				comment: "approval_timeout",
+				decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				decidedBy: "system-timeout"
+			}
+		};
+	};
+}
+//#endregion
+//#region src/config/load-config.ts
+const CODEX_ACP_BIN = fileURLToPath(import.meta.resolve("@zed-industries/codex-acp/bin/codex-acp.js"));
+const DEFAULT_CONFIG_ENV_PATH = resolve(homedir(), ".im-code-agent", "config.env");
+const DEFAULT_CONFIG_ENV_CONTENT = `# Bridge 基础配置
+
+# 飞书应用凭据
+FEISHU_APP_ID=
+FEISHU_APP_SECRET=
+
+# 可选：true 时默认 Full Access
+YOLO_MODE=false
+
+# 可选：默认工作目录，不填则使用 bridge 启动目录
+WORKSPACE_DEFAULT_CWD=
+`;
+function parseEnvFile(content) {
+	const result = {};
+	for (const rawLine of content.split("\n")) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith("#")) continue;
+		const equalIndex = line.indexOf("=");
+		if (equalIndex <= 0) continue;
+		const key = line.slice(0, equalIndex).trim();
+		let value = line.slice(equalIndex + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		result[key] = value;
+	}
+	return result;
+}
+function stringifyEnvValue(value) {
+	return /[\s#"'`]/.test(value) ? JSON.stringify(value) : value;
+}
+function upsertEnvValue(content, key, value) {
+	const lines = content.split("\n");
+	const rendered = `${key}=${stringifyEnvValue(value)}`;
+	const lineIndex = lines.findIndex((line) => line.trimStart().startsWith(`${key}=`));
+	if (lineIndex >= 0) lines[lineIndex] = rendered;
+	else {
+		if (lines.length > 0 && lines.at(-1) !== "") lines.push("");
+		lines.push(rendered);
+	}
+	return lines.join("\n");
+}
+function normalizeCredential(value) {
+	const trimmed = value?.trim();
+	if (!trimmed) return;
+	if (trimmed === "cli_xxx" || trimmed === "xxx") return;
+	return trimmed;
+}
+async function resolveNodeCommand() {
+	if (await fileExists(process.execPath)) return process.execPath;
+	return "node";
+}
+async function isDirectory(dirPath) {
+	try {
+		return (await stat(dirPath)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function loadBridgeEnvFile() {
+	await ensureDefaultConfigEnvFile(resolveBridgeEnvPath());
+	const configuredPath = process.env.BRIDGE_ENV_PATH;
+	const envPaths = configuredPath ? [resolve(configuredPath)] : [
+		DEFAULT_CONFIG_ENV_PATH,
+		resolve(process.cwd(), "bridge.env"),
+		resolve(process.cwd(), ".env")
+	];
+	for (const envPath of envPaths) try {
+		return parseEnvFile(await readFile(envPath, "utf8"));
+	} catch {
+		continue;
+	}
+	return {};
+}
+function resolveBridgeEnvPath() {
+	const configuredPath = process.env.BRIDGE_ENV_PATH;
+	return configuredPath ? resolve(configuredPath) : DEFAULT_CONFIG_ENV_PATH;
+}
+async function fileExists(filePath) {
+	try {
+		await access(filePath, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function ensureDefaultConfigEnvFile(configEnvPath) {
+	await createConfigEnvIfMissing(configEnvPath, process.cwd());
+}
+async function createConfigEnvIfMissing(targetPath, baseDir) {
+	if (await fileExists(targetPath)) return;
+	await mkdir(dirname(targetPath), { recursive: true });
+	const configTemplatePath = resolve(baseDir, "config.env.example");
+	if (await fileExists(configTemplatePath)) {
+		await copyFile(configTemplatePath, targetPath);
+		return;
+	}
+	await writeFile(targetPath, DEFAULT_CONFIG_ENV_CONTENT, "utf8");
+}
+async function promptForFeishuCredentials(envPath) {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error(`未检测到飞书配置，请在 ${envPath} 中填写 FEISHU_APP_ID 和 FEISHU_APP_SECRET，或通过环境变量注入后再启动。`);
+	console.warn([
+		"未检测到有效的飞书配置。",
+		`将引导你写入 ${envPath}。`,
+		"直接回车可跳过，但当前启动会直接退出。"
+	].join(" "));
+	const readline = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const appId = normalizeCredential(await readline.question("请输入飞书 App ID: "));
+		const appSecret = normalizeCredential(await readline.question("请输入飞书 App Secret: "));
+		if (!appId || !appSecret) throw new Error("缺少飞书配置，启动已取消。请填写 FEISHU_APP_ID 和 FEISHU_APP_SECRET 后重试。");
+		const nextContent = upsertEnvValue(upsertEnvValue(await readFile(envPath, "utf8").catch(() => DEFAULT_CONFIG_ENV_CONTENT), "FEISHU_APP_ID", appId), "FEISHU_APP_SECRET", appSecret);
+		await writeFile(envPath, nextContent.endsWith("\n") ? nextContent : `${nextContent}\n`, "utf8");
+		process.env.FEISHU_APP_ID = appId;
+		process.env.FEISHU_APP_SECRET = appSecret;
+		console.warn(`飞书配置已写入 ${envPath}。`);
+	} finally {
+		readline.close();
+	}
+}
+async function loadConfig() {
+	const nodeCommand = await resolveNodeCommand();
+	const envPath = resolveBridgeEnvPath();
+	let fileEnv = await loadBridgeEnvFile();
+	const getValue = (key) => process.env[key] ?? fileEnv[key];
+	let appId = normalizeCredential(getValue("FEISHU_APP_ID"));
+	let appSecret = normalizeCredential(getValue("FEISHU_APP_SECRET"));
+	if (!appId || !appSecret) {
+		await promptForFeishuCredentials(envPath);
+		fileEnv = await loadBridgeEnvFile();
+		appId = normalizeCredential(process.env.FEISHU_APP_ID ?? fileEnv.FEISHU_APP_ID);
+		appSecret = normalizeCredential(process.env.FEISHU_APP_SECRET ?? fileEnv.FEISHU_APP_SECRET);
+	}
+	if (!appId || !appSecret) throw new Error(`缺少飞书配置，请在 ${envPath} 中填写 FEISHU_APP_ID 和 FEISHU_APP_SECRET 后重试。`);
+	const yoloMode = getValue("YOLO_MODE")?.trim().toLowerCase() === "true";
+	const workspaceDefaultCwd = getValue("WORKSPACE_DEFAULT_CWD")?.trim();
+	const resolvedDefaultCwd = workspaceDefaultCwd ? resolve(workspaceDefaultCwd) : process.cwd();
+	const defaultCwd = await isDirectory(resolvedDefaultCwd) ? resolvedDefaultCwd : process.cwd();
+	return {
+		feishu: {
+			appId,
+			appSecret
+		},
+		yoloMode,
+		agents: { codex: {
+			command: nodeCommand,
+			args: [CODEX_ACP_BIN]
+		} },
+		workspaces: [{
+			id: "local-default",
+			name: "Local Default",
+			cwd: defaultCwd
+		}]
+	};
+}
+//#endregion
+//#region src/feishu/approval-card-policy.ts
+function shouldPatchApprovalSummary(decision) {
+	return decision.comment !== "approval_timeout";
+}
+//#endregion
+//#region src/feishu/command-router.ts
+function parseContent(content) {
+	try {
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+async function parseUserCommand(rawPrompt, currentCwd) {
+	if (rawPrompt === "/help") return { type: "help" };
+	if (rawPrompt === "/status") return { type: "status" };
+	if (rawPrompt === "/stop" || rawPrompt === "/interrupt") return { type: "stop" };
+	if (rawPrompt === "/perm") return { type: "show-access" };
+	if (rawPrompt === "/model") return { type: "model" };
+	if (rawPrompt.startsWith("/model ")) return {
+		type: "model",
+		model: rawPrompt.slice(7).trim() || void 0
+	};
+	if (rawPrompt === "/new") return { type: "new" };
+	if (rawPrompt.startsWith("/new ")) {
+		const inputPath = rawPrompt.slice(5).trim();
+		if (!inputPath) return { type: "new" };
+		return {
+			type: "new",
+			cwd: await resolveValidatedCwd(inputPath, currentCwd)
+		};
+	}
+	return {
+		type: "prompt",
+		prompt: rawPrompt
+	};
+}
+function parseCardActionValue(data) {
+	const payload = data.action?.value ?? data.event?.action?.value;
+	if (!payload) return null;
+	let value = payload;
+	if (typeof value === "string") try {
+		value = JSON.parse(value);
+	} catch {
+		return null;
+	}
+	if (!value || typeof value !== "object") return null;
+	const item = value;
+	if (item.type === "access" && typeof item.cardId === "string" && typeof item.chatId === "string" && (item.action === "set" || item.action === "clear")) {
+		if (item.action === "clear") return {
+			type: "access",
+			cardId: item.cardId,
+			chatId: item.chatId,
+			action: "clear"
+		};
+		if (item.mode === "standard" || item.mode === "full-access") return {
+			type: "access",
+			cardId: item.cardId,
+			chatId: item.chatId,
+			action: "set",
+			mode: item.mode
+		};
+		return null;
+	}
+	if (item.type === "model" && typeof item.cardId === "string" && typeof item.chatId === "string" && typeof item.model === "string") return {
+		type: "model",
+		cardId: item.cardId,
+		chatId: item.chatId,
+		model: item.model
+	};
+	if (typeof item.requestId === "string" && typeof item.taskId === "string" && (item.decision === "approved" || item.decision === "rejected")) return {
+		type: "approval",
+		requestId: item.requestId,
+		taskId: item.taskId,
+		decision: item.decision,
+		comment: typeof item.comment === "string" ? item.comment : void 0
+	};
+	return null;
+}
+async function resolveValidatedCwd(inputPath, baseCwd) {
+	const candidate = isAbsolute(inputPath) ? inputPath : resolve(baseCwd, inputPath);
+	const dirStat = await stat(candidate).catch(() => void 0);
+	if (!dirStat || !dirStat.isDirectory()) throw new Error(`路径不存在或不是目录：${candidate}`);
+	return resolve(candidate);
+}
+//#endregion
+//#region src/feishu/card-renderer.ts
+var TaskCardStreamer = class {
+	#segments = [];
+	#tools = /* @__PURE__ */ new Map();
+	#status = "running";
+	#summary = "执行中";
+	#lastPatchedAt = 0;
+	#pendingPatchTimer;
+	#pendingPatchResolvers = [];
+	#patchQueue = Promise.resolve();
+	#cardMessageId;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	handleOutputChunk(chunk) {
+		const toolUpdate = this.deps.renderer.parseToolChunk(chunk);
+		if (toolUpdate) {
+			this.upsertTool(toolUpdate);
+			this.enqueuePatch(false);
+			return;
+		}
+		const last = this.#segments[this.#segments.length - 1];
+		if (last?.type === "text") last.content += chunk;
+		else this.#segments.push({
+			type: "text",
+			content: chunk
+		});
+		this.enqueuePatch(false);
+	}
+	handleToolUpdate(update) {
+		const toolUpdate = this.deps.renderer.toToolView(update);
+		if (!toolUpdate) return;
+		this.upsertTool(toolUpdate);
+		this.enqueuePatch(false);
+	}
+	markFailed(error) {
+		this.#status = "failed";
+		this.#summary = error;
+		this.enqueuePatch(true);
+	}
+	markCompleted(summary) {
+		this.#status = "completed";
+		this.#summary = summary ?? "执行完成";
+		this.enqueuePatch(true);
+	}
+	async finalize() {
+		this.enqueuePatch(true);
+		if (this.#pendingPatchTimer) await new Promise((resolve) => {
+			this.#pendingPatchResolvers.push(resolve);
+		});
+		await this.#patchQueue;
+		if (!this.#cardMessageId) await this.ensureCardMessage();
+	}
+	upsertTool(toolUpdate) {
+		const prev = this.#tools.get(toolUpdate.id) ?? { id: toolUpdate.id };
+		this.#tools.set(toolUpdate.id, {
+			...prev,
+			...toolUpdate
+		});
+		if (!this.#segments.some((segment) => segment.type === "tool" && segment.id === toolUpdate.id)) this.#segments.push({
+			type: "tool",
+			id: toolUpdate.id
+		});
+	}
+	enqueuePatch(force) {
+		const now = Date.now();
+		const wait = force ? 0 : Math.max(0, this.deps.patchMinIntervalMs - (now - this.#lastPatchedAt));
+		if (!force && this.#pendingPatchTimer) return;
+		if (this.#pendingPatchTimer) {
+			clearTimeout(this.#pendingPatchTimer);
+			this.#pendingPatchTimer = void 0;
+		}
+		this.#pendingPatchTimer = setTimeout(() => {
+			this.#pendingPatchTimer = void 0;
+			this.#lastPatchedAt = Date.now();
+			while (this.#pendingPatchResolvers.length > 0) this.#pendingPatchResolvers.shift()?.();
+			this.#patchQueue = this.#patchQueue.then(async () => {
+				const messageId = await this.ensureCardMessage();
+				if (!messageId) return;
+				await this.deps.patchCard(messageId, this.deps.renderer.buildTaskCard({
+					status: this.#status,
+					segments: this.#segments,
+					tools: this.#tools,
+					summary: this.#summary
+				}));
+			}).catch((error) => {
+				this.deps.logger.warn("feishu patch card failed", { error: error instanceof Error ? error.message : String(error) });
+			});
+		}, wait);
+	}
+	async ensureCardMessage() {
+		if (this.#cardMessageId) return this.#cardMessageId;
+		if (this.#status === "running" && this.#segments.length === 0) return;
+		this.#cardMessageId = await this.deps.sendCard(this.deps.chatId, this.deps.renderer.buildTaskCard({
+			status: this.#status,
+			segments: this.#segments,
+			tools: this.#tools,
+			summary: this.#summary
+		}));
+		return this.#cardMessageId;
+	}
+};
+var FeishuCardRenderer = class {
+	buildTaskCard(params) {
+		const footerElement = params.status === "running" ? {
+			tag: "markdown",
+			content: " ",
+			icon: {
+				tag: "custom_icon",
+				img_key: "img_v3_02vb_496bec09-4b43-4773-ad6b-0cdd103cd2bg",
+				size: "16px 16px"
+			},
+			element_id: "loading_icon"
+		} : params.status === "completed" ? {
+			tag: "div",
+			text: {
+				tag: "plain_text",
+				content: "已完成",
+				text_size: "cus-0"
+			}
+		} : {
+			tag: "div",
+			text: {
+				tag: "plain_text",
+				content: `执行失败：${params.summary}`,
+				text_size: "cus-0"
+			}
+		};
+		const elements = this.buildContentElements(params.segments, params.tools);
+		if (elements.length === 0) elements.push({
+			tag: "markdown",
+			content: " "
+		});
+		elements.push(footerElement);
+		return {
+			schema: "2.0",
+			config: {
+				update_multi: true,
+				width_mode: "fill",
+				streaming_mode: true,
+				style: {
+					text_size: {
+						"cus-0": {
+							default: "notation",
+							pc: "notation",
+							mobile: "notation"
+						},
+						"cus-1": {
+							default: "small",
+							pc: "small",
+							mobile: "small"
+						}
+					},
+					color: {
+						foot_gray: {
+							light_mode: "rgba(100,106,115,1)",
+							dark_mode: "rgba(182,188,196,1)"
+						},
+						tool_meta_gray: {
+							light_mode: "rgba(100,106,115,1)",
+							dark_mode: "rgba(182,188,196,1)"
+						}
+					}
+				},
+				summary: { content: params.status === "running" ? "生成中" : params.status === "completed" ? "已完成" : `执行失败：${params.summary}` }
+			},
+			body: {
+				direction: "vertical",
+				vertical_spacing: "6px",
+				padding: "10px 12px 10px 12px",
+				elements
+			}
+		};
+	}
+	buildApprovalSummaryCard(title, decision) {
+		return {
+			schema: "2.0",
+			config: { update_multi: true },
+			body: {
+				direction: "vertical",
+				padding: "10px 12px 10px 12px",
+				elements: [
+					{
+						tag: "markdown",
+						content: `**${this.escapeCardMarkdown(title)}**`
+					},
+					{
+						tag: "markdown",
+						content: `request: ${this.escapeCardMarkdown(decision.requestId)}`
+					},
+					{
+						tag: "markdown",
+						content: `时间: ${this.escapeCardMarkdown(decision.decidedAt)}`
+					},
+					{
+						tag: "markdown",
+						content: `操作者: ${this.escapeCardMarkdown(decision.decidedBy)}`
+					}
+				]
+			}
+		};
+	}
+	buildAccessModeCard(params) {
+		const currentMode = params.overrideMode ?? params.defaultMode;
+		const overrideText = params.overrideMode ? this.formatAccessMode(params.overrideMode) : "继承默认";
+		const sourceText = params.overrideMode ? "会话临时覆盖" : "全局默认";
+		const fullActive = currentMode === "full-access";
+		const standardActive = currentMode === "standard" && Boolean(params.overrideMode);
+		const inheritActive = !params.overrideMode;
+		return {
+			schema: "2.0",
+			config: {
+				update_multi: true,
+				width_mode: "fill",
+				style: {
+					text_size: { "cus-0": {
+						default: "notation",
+						pc: "notation",
+						mobile: "notation"
+					} },
+					color: { foot_gray: {
+						light_mode: "rgba(100,106,115,1)",
+						dark_mode: "rgba(182,188,196,1)"
+					} }
+				}
+			},
+			body: {
+				direction: "vertical",
+				padding: "10px 12px 10px 12px",
+				elements: [
+					{
+						tag: "markdown",
+						content: "**权限模式**"
+					},
+					{
+						tag: "markdown",
+						content: `全局默认: ${this.escapeCardMarkdown(this.formatAccessMode(params.defaultMode))}`
+					},
+					{
+						tag: "markdown",
+						content: `本会话覆盖: ${this.escapeCardMarkdown(overrideText)}${inheritActive ? " ✅" : ""}`
+					},
+					{
+						tag: "markdown",
+						content: `当前生效: ${this.escapeCardMarkdown(this.formatAccessMode(currentMode))}（${this.escapeCardMarkdown(sourceText)}） ✅`
+					},
+					...params.readonly ? [{
+						tag: "markdown",
+						content: params.readonlyReason ?? "本卡已应用变更，按钮已锁定。"
+					}] : [{
+						tag: "column_set",
+						columns: [
+							this.buildActionButton(fullActive ? "本会话 Full Access（当前）" : "本会话 Full Access", fullActive ? "primary" : "default", {
+								type: "access",
+								cardId: params.cardId,
+								chatId: params.chatId,
+								action: "set",
+								mode: "full-access"
+							}),
+							this.buildActionButton(standardActive ? "本会话 Standard（当前）" : "本会话 Standard", standardActive ? "primary" : "default", {
+								type: "access",
+								cardId: params.cardId,
+								chatId: params.chatId,
+								action: "set",
+								mode: "standard"
+							}),
+							this.buildActionButton(inheritActive ? "恢复默认（当前）" : "恢复默认", inheritActive ? "primary" : "default", {
+								type: "access",
+								cardId: params.cardId,
+								chatId: params.chatId,
+								action: "clear"
+							})
+						]
+					}],
+					{
+						tag: "div",
+						text: {
+							tag: "plain_text",
+							content: "提示：会话覆盖仅当前会话有效，切换/重置会话后恢复默认。",
+							text_size: "cus-0"
+						}
+					}
+				]
+			}
+		};
+	}
+	buildModelCard(params) {
+		const modelRows = [];
+		for (let index = 0; index < params.models.length; index += 3) {
+			const items = params.models.slice(index, index + 3);
+			modelRows.push({
+				tag: "column_set",
+				columns: items.map((model) => this.buildActionButton(model.id === params.currentModel ? `${model.name}（当前）` : model.name, model.id === params.currentModel ? "primary" : "default", {
+					type: "model",
+					cardId: params.cardId,
+					chatId: params.chatId,
+					model: model.id
+				}))
+			});
+		}
+		return {
+			schema: "2.0",
+			config: {
+				update_multi: true,
+				width_mode: "fill"
+			},
+			body: {
+				direction: "vertical",
+				padding: "10px 12px 10px 12px",
+				elements: [
+					{
+						tag: "markdown",
+						content: "**模型切换**"
+					},
+					{
+						tag: "markdown",
+						content: `当前模型: ${this.escapeCardMarkdown(params.currentModel ?? "未设置")}`
+					},
+					{
+						tag: "markdown",
+						content: `可选模型: ${this.escapeCardMarkdown(params.models.map((item) => item.id).join(", "))}`
+					},
+					...params.readonly ? [{
+						tag: "markdown",
+						content: params.readonlyReason ?? "本卡已应用变更，按钮已锁定。"
+					}] : [...modelRows],
+					{
+						tag: "div",
+						text: {
+							tag: "plain_text",
+							content: "提示：切换模型会重置当前会话，后续消息使用新模型。",
+							text_size: "cus-0"
+						}
+					}
+				]
+			}
+		};
+	}
+	buildApprovalCard(request, status, decision) {
+		const statusText = status === "pending" ? "待审批" : status === "approved" ? "已批准" : status === "rejected" ? "已拒绝" : "已超时";
+		const elements = [
+			{
+				tag: "markdown",
+				content: `**状态：${this.escapeCardMarkdown(statusText)}**`
+			},
+			{
+				tag: "markdown",
+				content: `类型: ${this.escapeCardMarkdown(request.kind)} | 风险: ${this.escapeCardMarkdown(request.riskLevel)}`
+			},
+			{
+				tag: "markdown",
+				content: `标题: ${this.escapeCardMarkdown(request.title)}`
+			},
+			{
+				tag: "markdown",
+				content: `工作目录: ${this.escapeCardMarkdown(request.cwd)}`
+			}
+		];
+		if (request.command) elements.push({
+			tag: "markdown",
+			content: `命令: \`${this.escapeCardMarkdown(this.shorten(request.command, 140))}\``
+		});
+		if (request.target) elements.push({
+			tag: "markdown",
+			content: `目标: ${this.escapeCardMarkdown(request.target)}`
+		});
+		if (status === "pending") elements.push({
+			tag: "column_set",
+			columns: [
+				this.buildApprovalButton("批准", "primary", {
+					requestId: request.id,
+					taskId: request.taskId,
+					decision: "approved"
+				}),
+				this.buildApprovalButton("本会话允许", "default", {
+					requestId: request.id,
+					taskId: request.taskId,
+					decision: "approved",
+					comment: "approved-for-session"
+				}),
+				this.buildApprovalButton("拒绝", "danger", {
+					requestId: request.id,
+					taskId: request.taskId,
+					decision: "rejected"
+				})
+			]
+		});
+		else if (decision) elements.push({
+			tag: "markdown",
+			content: `操作人: ${this.escapeCardMarkdown(decision.decidedBy)}\\n时间: ${this.escapeCardMarkdown(decision.decidedAt)}`
+		});
+		return {
+			schema: "2.0",
+			config: {
+				update_multi: true,
+				width_mode: "fill"
+			},
+			body: {
+				direction: "vertical",
+				padding: "10px 12px 10px 12px",
+				elements
+			}
+		};
+	}
+	parseToolChunk(chunk) {
+		const lines = chunk.split("\n").map((line) => line.trim()).filter(Boolean);
+		if (lines.length === 0 || !lines[0]?.startsWith("[tool]")) return;
+		const headMatch = lines[0].match(/^\[tool\]\s+(.+?)(?:\s+\(([^)]+)\))?$/);
+		if (!headMatch?.[1]) return;
+		const tool = {
+			id: headMatch[1].trim(),
+			status: headMatch[2]?.trim()
+		};
+		for (const line of lines.slice(1)) {
+			if (line.startsWith("cmd:")) {
+				tool.cmd = line.slice(4).trim();
+				continue;
+			}
+			if (line.startsWith("path:")) {
+				tool.path = line.slice(5).trim();
+				continue;
+			}
+			if (line.startsWith("error:")) tool.error = line.slice(6).trim();
+		}
+		return tool;
+	}
+	toToolView(update) {
+		if (!update.toolCallId) return;
+		const cmd = update.command ?? update.query ?? update.url ?? update.title ?? update.toolName;
+		return {
+			id: update.toolCallId,
+			name: update.toolName,
+			status: update.status,
+			cmd,
+			query: update.query,
+			url: update.url,
+			path: update.path,
+			error: update.error
+		};
+	}
+	buildContentElements(segments, tools) {
+		const elements = [];
+		const maxToolCards = 12;
+		let renderedToolCards = 0;
+		let hiddenToolCards = 0;
+		let lastToolPath;
+		let lastToolSignature;
+		let index = 0;
+		while (index < segments.length) {
+			const segment = segments[index];
+			if (!segment) break;
+			if (segment.type === "text") {
+				if (!segment.content) {
+					index += 1;
+					continue;
+				}
+				elements.push({
+					tag: "markdown",
+					content: this.escapeCardMarkdown(segment.content)
+				});
+				index += 1;
+				continue;
+			}
+			const toolCards = [];
+			while (index < segments.length && segments[index]?.type === "tool") {
+				const current = segments[index];
+				const tool = tools.get(current.id);
+				if (!tool) {
+					index += 1;
+					continue;
+				}
+				const statusText = this.formatToolStatus(tool.status);
+				const statusBadge = this.getToolStatusBadge(tool.status);
+				const cmdText = tool.cmd ? this.shorten(tool.cmd, 140) : "（无命令）";
+				const pathText = tool.path ? this.shorten(tool.path, 90) : void 0;
+				const errorText = tool.error ? this.shorten(tool.error, 160) : void 0;
+				const title = tool.name ?? this.getToolDisplayTitle(tool.cmd);
+				const signature = `${statusText}|${cmdText}|${pathText ?? ""}|${errorText ?? ""}`;
+				if (signature === lastToolSignature) {
+					index += 1;
+					continue;
+				}
+				lastToolSignature = signature;
+				if (renderedToolCards >= maxToolCards) {
+					hiddenToolCards += 1;
+					index += 1;
+					continue;
+				}
+				const cardElements = [
+					{
+						tag: "div",
+						text: {
+							tag: "plain_text",
+							content: `${statusBadge} ${title}`
+						}
+					},
+					{
+						tag: "div",
+						text: {
+							tag: "plain_text",
+							content: cmdText
+						}
+					},
+					{
+						tag: "markdown",
+						content: `<font color='grey'>状态：${this.escapeCardMarkdown(statusText)}</font>`
+					}
+				];
+				if (pathText && pathText !== lastToolPath) {
+					cardElements.push({
+						tag: "markdown",
+						content: `<font color='grey'>↳ ${this.escapeCardMarkdown(pathText)}</font>`
+					});
+					lastToolPath = pathText;
+				}
+				if (errorText) cardElements.push({
+					tag: "div",
+					text: {
+						tag: "plain_text",
+						content: `❗ ${errorText}`,
+						text_size: "cus-1"
+					}
+				});
+				toolCards.push({
+					tag: "interactive_container",
+					has_border: true,
+					corner_radius: "10px",
+					padding: "8px 10px 8px 10px",
+					margin: "4px 0 4px 0",
+					elements: cardElements
+				});
+				renderedToolCards += 1;
+				index += 1;
+			}
+			if (toolCards.length > 0) elements.push({
+				tag: "collapsible_panel",
+				header: { title: {
+					tag: "plain_text",
+					content: `🛠️ 工具调用（${toolCards.length}）`
+				} },
+				elements: toolCards
+			});
+		}
+		if (hiddenToolCards > 0) elements.push({
+			tag: "markdown",
+			content: `…已折叠 ${hiddenToolCards} 条工具调用`
+		});
+		return elements;
+	}
+	buildApprovalButton(label, type, value) {
+		return {
+			tag: "column",
+			width: "weighted",
+			weight: 1,
+			elements: [{
+				tag: "button",
+				type,
+				text: {
+					tag: "plain_text",
+					content: label
+				},
+				behaviors: [{
+					type: "callback",
+					value
+				}]
+			}]
+		};
+	}
+	buildActionButton(label, type, value) {
+		return {
+			tag: "column",
+			width: "weighted",
+			weight: 1,
+			elements: [{
+				tag: "button",
+				type,
+				text: {
+					tag: "plain_text",
+					content: label
+				},
+				behaviors: [{
+					type: "callback",
+					value
+				}]
+			}]
+		};
+	}
+	formatToolStatus(status) {
+		if (!status) return "处理中";
+		if (status === "in_progress") return "进行中";
+		if (status === "completed") return "已完成";
+		if (status === "failed") return "失败";
+		return status;
+	}
+	getToolStatusBadge(_status) {
+		return "🛠️";
+	}
+	getToolDisplayTitle(cmd) {
+		if (!cmd) return "步骤";
+		const head = cmd.trim().split(/\s+/, 1)[0]?.toLowerCase();
+		if (!head) return "步骤";
+		if (head === "cat" || head === "sed" || head === "head" || head === "tail") return "读取";
+		if (head === "ls" || head === "find" || head === "rg" || head === "grep") return "检索";
+		if (head === "git") return "Git";
+		if (head === "npm" || head === "pnpm" || head === "vp") return "命令";
+		return "步骤";
+	}
+	formatAccessMode(mode) {
+		return mode === "full-access" ? "Full Access" : "Standard";
+	}
+	shorten(text, maxLen) {
+		if (text.length <= maxLen) return text;
+		return `${text.slice(0, maxLen)}...`;
+	}
+	escapeCardMarkdown(text) {
+		return text.replace(/\r/g, "").replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+	}
+};
+//#endregion
+//#region src/feishu/command-handler.ts
+var FeishuCommandHandler = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handle(params) {
+		const { chatId, workspace, command } = params;
+		if (command.type === "prompt") return {
+			type: "prompt",
+			prompt: command.prompt
+		};
+		if (command.type === "help") {
+			await this.deps.messageClient.sendText(chatId, [
+				"支持指令：",
+				"/help - 展示指令说明",
+				"/new [path] - 新建会话，可选切换工作目录",
+				"/model - 查看并切换当前模型",
+				"/model <name> - 直接切换到指定模型",
+				"/status - 查看当前会话状态",
+				"/stop - 打断当前执行中的任务",
+				"/perm - 查看并切换权限模式"
+			].join("\n"));
+			return { type: "handled" };
+		}
+		if (command.type === "new") {
+			const next = await this.deps.sessionController.startNewConversation({
+				chatId,
+				workspace,
+				agent: "codex",
+				cwd: command.cwd
+			}, this.deps.taskRunner);
+			await this.deps.messageClient.sendText(chatId, `已切换到新会话，session_id: ${next.sessionId}\n工作目录：${next.workspace.cwd}`);
+			return { type: "handled" };
+		}
+		if (command.type === "status") {
+			await this.deps.messageClient.sendText(chatId, [
+				`session_id: ${this.deps.sessionController.getBridgeSessionId(chatId) ?? "未创建"}`,
+				`codex_session_id: ${this.deps.sessionController.getResumeSessionId(chatId) ?? "未创建"}`,
+				`工具目录（cwd）: ${workspace.cwd}`,
+				`当前模型: ${this.deps.sessionController.getModel(chatId) ?? "未设置"}`,
+				`权限模式: ${this.deps.sessionController.getAccessMode(chatId)}`
+			].join("\n"));
+			return { type: "handled" };
+		}
+		if (command.type === "stop") {
+			const interrupted = await this.deps.sessionController.interrupt(chatId, this.deps.taskRunner);
+			await this.deps.messageClient.sendText(chatId, interrupted ? "已打断当前任务。" : "当前没有执行中的任务。");
+			return { type: "handled" };
+		}
+		if (command.type === "show-access") {
+			await this.deps.cardActionHandler.sendPermissionCard(chatId);
+			return { type: "handled" };
+		}
+		if (command.type === "model") {
+			if (!command.model) {
+				if (this.deps.sessionController.getAvailableModels(chatId).length === 0) await this.deps.sessionController.startNewConversation({
+					chatId,
+					workspace,
+					agent: "codex"
+				}, this.deps.taskRunner);
+				await this.deps.cardActionHandler.sendModelCard(chatId);
+				return { type: "handled" };
+			}
+			if (this.deps.sessionController.getAvailableModels(chatId).length === 0) await this.deps.sessionController.startNewConversation({
+				chatId,
+				workspace,
+				agent: "codex"
+			}, this.deps.taskRunner);
+			const resolvedModels = this.deps.sessionController.getAvailableModels(chatId);
+			if (!resolvedModels.some((item) => item.id === command.model)) {
+				await this.deps.messageClient.sendText(chatId, `不支持的模型：${command.model}\n可用模型：${resolvedModels.map((item) => item.id).join(", ")}`);
+				return { type: "handled" };
+			}
+			const changed = await this.deps.sessionController.setModel(chatId, command.model, this.deps.taskRunner);
+			await this.deps.messageClient.sendText(chatId, changed ? `已切换模型：${this.deps.sessionController.getModel(chatId)}` : `当前模型已是：${this.deps.sessionController.getModel(chatId)}`);
+			return { type: "handled" };
+		}
+		return { type: "handled" };
+	}
+};
+//#endregion
+//#region src/feishu/feishu-event-dispatcher.ts
+function buildFeishuEventDispatcher(deps) {
+	const dispatcher = new lark.EventDispatcher({}).register({ "im.message.receive_v1": async (data) => {
+		await deps.onMessageReceived(data);
+	} });
+	registerLoosely(dispatcher, { "card.action.trigger": async (data) => {
+		return await deps.onCardAction(data) ?? {};
+	} });
+	return dispatcher;
+}
+function registerLoosely(dispatcher, handles) {
+	dispatcher.register(handles);
+}
+//#endregion
+//#region src/feishu/message-entry-queue.ts
+var MessageEntryQueue = class {
+	#processingMessageIds = /* @__PURE__ */ new Set();
+	#handledMessageIds = /* @__PURE__ */ new Map();
+	#chatQueues = /* @__PURE__ */ new Map();
+	constructor(dedupeTtlMs = 600 * 1e3) {
+		this.dedupeTtlMs = dedupeTtlMs;
+	}
+	gcHandledMessageIds() {
+		const now = Date.now();
+		for (const [messageId, timestamp] of this.#handledMessageIds.entries()) if (now - timestamp > this.dedupeTtlMs) this.#handledMessageIds.delete(messageId);
+	}
+	tryBegin(messageId) {
+		if (this.#handledMessageIds.has(messageId) || this.#processingMessageIds.has(messageId)) return false;
+		this.#processingMessageIds.add(messageId);
+		return true;
+	}
+	runInChatQueue(chatId, messageId, task) {
+		if (!this.tryBegin(messageId)) return;
+		const queue = (this.#chatQueues.get(chatId) ?? Promise.resolve()).catch(() => {}).then(async () => {
+			await task();
+		});
+		this.#chatQueues.set(chatId, queue);
+		queue.finally(() => {
+			this.complete(messageId);
+			if (this.#chatQueues.get(chatId) === queue) this.#chatQueues.delete(chatId);
+		}).catch(() => void 0);
+		return queue;
+	}
+	complete(messageId) {
+		this.#processingMessageIds.delete(messageId);
+		this.#handledMessageIds.set(messageId, Date.now());
+	}
+};
+//#endregion
+//#region src/feishu/feishu-card-action-handler.ts
+var FeishuCardActionHandler = class {
+	#permissionCardMessages = /* @__PURE__ */ new Map();
+	#permissionCardRevisions = /* @__PURE__ */ new Map();
+	#permissionCardUpdatedAt = /* @__PURE__ */ new Map();
+	#handledPermissionCardIds = /* @__PURE__ */ new Map();
+	#modelCardMessages = /* @__PURE__ */ new Map();
+	#modelCardUpdatedAt = /* @__PURE__ */ new Map();
+	#handledModelCardIds = /* @__PURE__ */ new Map();
+	#handledCardActionEventIds = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async sendPermissionCard(chatId) {
+		this.gcPermissionCardState();
+		const cardId = randomUUID();
+		const version = 1;
+		this.#permissionCardRevisions.set(cardId, version);
+		const card = this.deps.cardRenderer.buildAccessModeCard({
+			cardId,
+			chatId,
+			defaultMode: this.deps.sessionController.getDefaultAccessMode(),
+			overrideMode: this.deps.sessionController.getAccessOverride(chatId),
+			readonly: false
+		});
+		const messageId = await this.deps.messageClient.sendCard(chatId, card);
+		this.#permissionCardMessages.set(cardId, messageId);
+		this.#permissionCardUpdatedAt.set(cardId, Date.now());
+		this.deps.logger.info("permission card sent", {
+			chatId,
+			cardId,
+			version,
+			messageId,
+			defaultMode: this.deps.sessionController.getDefaultAccessMode(),
+			overrideMode: this.deps.sessionController.getAccessOverride(chatId),
+			effectiveMode: this.deps.sessionController.getAccessMode(chatId)
+		});
+	}
+	async sendModelCard(chatId) {
+		this.gcModelCardState();
+		const cardId = randomUUID();
+		const card = this.deps.cardRenderer.buildModelCard({
+			cardId,
+			chatId,
+			currentModel: this.deps.sessionController.getModel(chatId),
+			models: this.deps.sessionController.getAvailableModels(chatId),
+			readonly: false
+		});
+		const messageId = await this.deps.messageClient.sendCard(chatId, card);
+		this.#modelCardMessages.set(cardId, messageId);
+		this.#modelCardUpdatedAt.set(cardId, Date.now());
+		this.deps.logger.info("model card sent", {
+			chatId,
+			cardId,
+			messageId,
+			currentModel: this.deps.sessionController.getModel(chatId),
+			models: this.deps.sessionController.getAvailableModels(chatId).map((item) => item.id)
+		});
+	}
+	async handleCardAction(data) {
+		this.deps.logger.info("card action received", {
+			topLevelKeys: Object.keys(data),
+			eventId: this.extractCardActionEventId(data),
+			actionMessageId: this.extractActionMessageId(data)
+		});
+		this.gcHandledCardActionEventIds();
+		const eventId = this.extractCardActionEventId(data);
+		if (eventId && this.#handledCardActionEventIds.has(eventId)) {
+			this.deps.logger.info("card action ignored: duplicated event", { eventId });
+			return;
+		}
+		if (eventId) this.#handledCardActionEventIds.set(eventId, Date.now());
+		const action = parseCardActionValue(data);
+		if (!action) {
+			this.deps.logger.warn("card action ignored: invalid payload");
+			return;
+		}
+		if (action.type === "access") return this.handleAccessAction(action, data);
+		if (action.type === "model") return this.handleModelAction(action, data);
+		const decision = {
+			requestId: action.requestId,
+			taskId: action.taskId,
+			decision: action.decision,
+			comment: action.comment,
+			decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			decidedBy: this.extractOperatorId(data)
+		};
+		this.deps.approvalGateway.resolve(decision);
+		this.deps.onApprovalResolved(decision);
+	}
+	async handleModelAction(action, data) {
+		this.gcHandledModelCardIds();
+		const chatId = action.chatId;
+		const actionMessageId = this.extractActionMessageId(data);
+		const availableModels = this.deps.sessionController.getAvailableModels(chatId);
+		if (availableModels.length > 0 && !availableModels.some((item) => item.id === action.model)) {
+			this.deps.logger.warn("model card action ignored: unsupported model", {
+				chatId,
+				cardId: action.cardId,
+				model: action.model
+			});
+			return;
+		}
+		if (this.#handledModelCardIds.has(action.cardId)) {
+			this.deps.logger.info("model card action ignored: card already locked", {
+				chatId,
+				cardId: action.cardId,
+				messageId: actionMessageId
+			});
+			return;
+		}
+		this.#handledModelCardIds.set(action.cardId, Date.now());
+		try {
+			await this.deps.sessionController.setModel(chatId, action.model, this.deps.taskRunner);
+			this.deps.logger.info("model card action applied", {
+				chatId,
+				cardId: action.cardId,
+				model: action.model
+			});
+		} catch (error) {
+			this.#handledModelCardIds.delete(action.cardId);
+			this.deps.logger.warn("model card action failed, unlock card", {
+				chatId,
+				cardId: action.cardId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+		const card = await this.updateModelCard(chatId, actionMessageId, action.cardId, true, false);
+		if (!card) return;
+		return { card: {
+			type: "raw",
+			data: card
+		} };
+	}
+	async handleAccessAction(action, data) {
+		this.gcHandledPermissionCardIds();
+		const chatId = action.chatId;
+		const actionMessageId = this.extractActionMessageId(data);
+		this.deps.logger.info("permission card action parsed", {
+			chatId,
+			cardId: action.cardId,
+			action: action.action,
+			mode: action.action === "set" ? action.mode : void 0,
+			actionMessageId
+		});
+		if (this.#handledPermissionCardIds.has(action.cardId)) {
+			this.deps.logger.info("permission card action ignored: card already locked", {
+				chatId,
+				messageId: actionMessageId,
+				cardId: action.cardId
+			});
+			return;
+		}
+		this.#handledPermissionCardIds.set(action.cardId, Date.now());
+		try {
+			if (action.action === "clear") await this.deps.sessionController.clearAccessOverride(chatId, this.deps.taskRunner);
+			else await this.deps.sessionController.setAccessMode(chatId, action.mode, this.deps.taskRunner);
+			this.deps.logger.info("permission card action applied", {
+				chatId,
+				cardId: action.cardId,
+				effectiveMode: this.deps.sessionController.getAccessMode(chatId)
+			});
+		} catch (error) {
+			this.#handledPermissionCardIds.delete(action.cardId);
+			this.deps.logger.warn("permission card action failed, unlock card", {
+				chatId,
+				cardId: action.cardId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+		const card = await this.updatePermissionCard(chatId, actionMessageId, action.cardId, true, void 0, false);
+		if (!card) {
+			this.deps.logger.warn("permission card action applied but card update skipped", {
+				chatId,
+				cardId: action.cardId,
+				actionMessageId
+			});
+			return;
+		}
+		return { card: {
+			type: "raw",
+			data: card
+		} };
+	}
+	async updatePermissionCard(chatId, messageId, cardId, lockAfterPatch = false, readonlyReason, patch = true) {
+		this.gcPermissionCardState();
+		const resolvedCardId = cardId ?? randomUUID();
+		const nextRevision = (this.#permissionCardRevisions.get(resolvedCardId) ?? 1) + 1;
+		this.#permissionCardRevisions.set(resolvedCardId, nextRevision);
+		this.#permissionCardUpdatedAt.set(resolvedCardId, Date.now());
+		const card = this.deps.cardRenderer.buildAccessModeCard({
+			cardId: resolvedCardId,
+			chatId,
+			defaultMode: this.deps.sessionController.getDefaultAccessMode(),
+			overrideMode: this.deps.sessionController.getAccessOverride(chatId),
+			readonly: lockAfterPatch,
+			readonlyReason
+		});
+		const fromActionMessageId = messageId;
+		const fromCardMap = this.#permissionCardMessages.get(resolvedCardId);
+		const targetMessageId = fromActionMessageId ?? fromCardMap;
+		if (!targetMessageId) {
+			this.deps.logger.warn("permission card update skipped: message id not found", {
+				chatId,
+				cardId: resolvedCardId
+			});
+			return;
+		}
+		this.deps.logger.info("permission card patch start", {
+			chatId,
+			cardId: resolvedCardId,
+			version: nextRevision,
+			targetMessageId,
+			targetSource: fromActionMessageId ? "action-message-id" : "card-id-map",
+			lockAfterPatch,
+			overrideMode: this.deps.sessionController.getAccessOverride(chatId),
+			effectiveMode: this.deps.sessionController.getAccessMode(chatId)
+		});
+		try {
+			this.#permissionCardMessages.set(resolvedCardId, targetMessageId);
+			if (patch) {
+				await this.deps.messageClient.patchCard(targetMessageId, card);
+				this.deps.logger.info("permission card patch done", {
+					chatId,
+					cardId: resolvedCardId,
+					version: nextRevision,
+					targetMessageId,
+					lockAfterPatch
+				});
+			} else this.deps.logger.info("permission card patch skipped: callback response mode", {
+				chatId,
+				cardId: resolvedCardId,
+				version: nextRevision,
+				targetMessageId,
+				lockAfterPatch
+			});
+			return card;
+		} catch (error) {
+			this.deps.logger.warn("patch permission card failed", {
+				chatId,
+				messageId: targetMessageId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			return;
+		}
+	}
+	async updateModelCard(chatId, messageId, cardId, lockAfterPatch = false, patch = true) {
+		this.gcModelCardState();
+		const resolvedCardId = cardId ?? randomUUID();
+		this.#modelCardUpdatedAt.set(resolvedCardId, Date.now());
+		const card = this.deps.cardRenderer.buildModelCard({
+			cardId: resolvedCardId,
+			chatId,
+			currentModel: this.deps.sessionController.getModel(chatId),
+			models: this.deps.sessionController.getAvailableModels(chatId),
+			readonly: lockAfterPatch
+		});
+		const targetMessageId = messageId ?? this.#modelCardMessages.get(resolvedCardId);
+		if (!targetMessageId) {
+			this.deps.logger.warn("model card update skipped: message id not found", {
+				chatId,
+				cardId: resolvedCardId
+			});
+			return;
+		}
+		try {
+			this.#modelCardMessages.set(resolvedCardId, targetMessageId);
+			if (patch) await this.deps.messageClient.patchCard(targetMessageId, card);
+			return card;
+		} catch (error) {
+			this.deps.logger.warn("patch model card failed", {
+				chatId,
+				messageId: targetMessageId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			return;
+		}
+	}
+	extractOperatorId(data) {
+		const operator = data.operator && typeof data.operator === "object" ? data.operator : void 0;
+		const operatorId = operator?.operator_id && typeof operator.operator_id === "object" ? operator.operator_id : void 0;
+		if (typeof operatorId?.open_id === "string") return operatorId.open_id;
+		if (typeof operatorId?.user_id === "string") return operatorId.user_id;
+		return "feishu-user";
+	}
+	extractActionMessageId(data) {
+		const topLevel = typeof data.open_message_id === "string" ? data.open_message_id : void 0;
+		if (topLevel) return topLevel;
+		const eventObj = data.event && typeof data.event === "object" ? data.event : void 0;
+		if (eventObj) {
+			if (typeof eventObj.open_message_id === "string") return eventObj.open_message_id;
+			const contextObj = eventObj.context && typeof eventObj.context === "object" ? eventObj.context : void 0;
+			if (contextObj && typeof contextObj.open_message_id === "string") return contextObj.open_message_id;
+			const messageObj = eventObj.message && typeof eventObj.message === "object" ? eventObj.message : void 0;
+			if (messageObj && typeof messageObj.message_id === "string") return messageObj.message_id;
+		}
+		const messageObj = data.message && typeof data.message === "object" ? data.message : void 0;
+		if (messageObj && typeof messageObj.message_id === "string") return messageObj.message_id;
+	}
+	extractCardActionEventId(data) {
+		if (typeof data.event_id === "string") return data.event_id;
+		const headerObj = data.header && typeof data.header === "object" ? data.header : void 0;
+		if (headerObj && typeof headerObj.event_id === "string") return headerObj.event_id;
+		const eventObj = data.event && typeof data.event === "object" ? data.event : void 0;
+		if (eventObj && typeof eventObj.event_id === "string") return eventObj.event_id;
+	}
+	gcHandledCardActionEventIds() {
+		const expireMs = 6e4;
+		const now = Date.now();
+		for (const [eventId, ts] of this.#handledCardActionEventIds.entries()) if (now - ts > expireMs) this.#handledCardActionEventIds.delete(eventId);
+	}
+	gcHandledPermissionCardIds() {
+		const expireMs = 10 * 6e4;
+		const now = Date.now();
+		for (const [cardId, ts] of this.#handledPermissionCardIds.entries()) if (now - ts > expireMs) this.#handledPermissionCardIds.delete(cardId);
+	}
+	gcHandledModelCardIds() {
+		const expireMs = 10 * 6e4;
+		const now = Date.now();
+		for (const [cardId, ts] of this.#handledModelCardIds.entries()) if (now - ts > expireMs) this.#handledModelCardIds.delete(cardId);
+	}
+	gcPermissionCardState() {
+		const expireMs = 1440 * 60 * 1e3;
+		const now = Date.now();
+		for (const [cardId, ts] of this.#permissionCardUpdatedAt.entries()) if (now - ts > expireMs) {
+			this.#permissionCardUpdatedAt.delete(cardId);
+			this.#permissionCardRevisions.delete(cardId);
+			this.#permissionCardMessages.delete(cardId);
+		}
+	}
+	gcModelCardState() {
+		const expireMs = 1440 * 60 * 1e3;
+		const now = Date.now();
+		for (const [cardId, ts] of this.#modelCardUpdatedAt.entries()) if (now - ts > expireMs) {
+			this.#modelCardUpdatedAt.delete(cardId);
+			this.#modelCardMessages.delete(cardId);
+		}
+	}
+};
+//#endregion
+//#region src/feishu/feishu-message-client.ts
+var FeishuMessageClient = class {
+	constructor(client, logger) {
+		this.client = client;
+		this.logger = logger;
+	}
+	async sendText(chatId, text) {
+		await this.client.im.v1.message.create({
+			params: { receive_id_type: "chat_id" },
+			data: {
+				receive_id: chatId,
+				msg_type: "text",
+				content: JSON.stringify({ text })
+			}
+		});
+	}
+	async sendCard(chatId, card) {
+		const messageId = (await this.client.im.v1.message.create({
+			params: { receive_id_type: "chat_id" },
+			data: {
+				receive_id: chatId,
+				msg_type: "interactive",
+				content: JSON.stringify(card)
+			}
+		})).data?.message_id;
+		if (!messageId) throw new Error("failed to create card message: missing message_id");
+		return messageId;
+	}
+	async patchCard(messageId, card) {
+		await this.client.im.v1.message.patch({
+			path: { message_id: messageId },
+			data: { content: JSON.stringify(card) }
+		});
+	}
+	async addTypingReaction(messageId) {
+		try {
+			return (await this.client.im.v1.messageReaction.create({
+				path: { message_id: messageId },
+				data: { reaction_type: { emoji_type: "Typing" } }
+			})).data?.reaction_id;
+		} catch (error) {
+			this.logger.warn("add typing reaction failed", {
+				messageId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			return;
+		}
+	}
+	async removeTypingReaction(messageId, reactionId) {
+		await this.client.im.v1.messageReaction.delete({ path: {
+			message_id: messageId,
+			reaction_id: reactionId
+		} });
+	}
+};
+//#endregion
+//#region src/session/session-state-store.ts
+var FileSessionStateStore = class {
+	constructor(filePath = resolve(homedir(), ".im-code-agent", "chat-state.json")) {
+		this.filePath = filePath;
+	}
+	async loadState() {
+		const raw = await readFile(this.filePath, "utf8").catch(() => void 0);
+		if (!raw) return {
+			chatCwds: /* @__PURE__ */ new Map(),
+			chatBridgeSessionIds: /* @__PURE__ */ new Map(),
+			chatSessionIds: /* @__PURE__ */ new Map()
+		};
+		const parsed = JSON.parse(raw);
+		return {
+			chatCwds: new Map(Object.entries(parsed.chatCwds ?? {})),
+			chatBridgeSessionIds: new Map(Object.entries(parsed.chatBridgeSessionIds ?? {})),
+			chatSessionIds: new Map(Object.entries(parsed.chatSessionIds ?? {}))
+		};
+	}
+	async saveState(state) {
+		const payload = {
+			chatCwds: Object.fromEntries(state.chatCwds.entries()),
+			chatBridgeSessionIds: Object.fromEntries(state.chatBridgeSessionIds.entries()),
+			chatSessionIds: Object.fromEntries(state.chatSessionIds.entries())
+		};
+		await mkdir(dirname(this.filePath), { recursive: true });
+		const tmpPath = `${this.filePath}.tmp`;
+		await writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf8");
+		await rename(tmpPath, this.filePath);
+	}
+};
+//#endregion
+//#region src/session/session-manager.ts
+var SessionManager = class {
+	#tasks = /* @__PURE__ */ new Map();
+	createTask(input, workspace) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const task = {
+			id: crypto.randomUUID(),
+			workspaceId: workspace.id,
+			agent: input.agent,
+			prompt: input.prompt,
+			cwd: workspace.cwd,
+			status: "pending",
+			createdAt: now
+		};
+		this.#tasks.set(task.id, task);
+		return task;
+	}
+	getTask(taskId) {
+		return this.#tasks.get(taskId);
+	}
+	updateTaskStatus(taskId, status) {
+		const task = this.#tasks.get(taskId);
+		if (!task) return;
+		const updatedTask = {
+			...task,
+			status,
+			startedAt: status === "running" ? (/* @__PURE__ */ new Date()).toISOString() : task.startedAt,
+			endedAt: status === "completed" || status === "failed" || status === "cancelled" ? (/* @__PURE__ */ new Date()).toISOString() : task.endedAt
+		};
+		this.#tasks.set(taskId, updatedTask);
+		return updatedTask;
+	}
+};
+//#endregion
+//#region src/session/task-runner.ts
+function sameRuntimeArgs(left, right) {
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
+	return true;
+}
+var TaskRunner = class {
+	#eventLog = /* @__PURE__ */ new Map();
+	#eventListeners = /* @__PURE__ */ new Map();
+	#conversations = /* @__PURE__ */ new Map();
+	#runningConversations = /* @__PURE__ */ new Set();
+	#taskRuntimeArgs = /* @__PURE__ */ new Map();
+	constructor(sessionManager, agentProcess, logger) {
+		this.sessionManager = sessionManager;
+		this.agentProcess = agentProcess;
+		this.logger = logger;
+	}
+	async startTask(input, workspace, options) {
+		const task = this.sessionManager.createTask(input, workspace);
+		this.#taskRuntimeArgs.set(task.id, options?.runtimeArgs ?? []);
+		this.#eventLog.set(task.id, []);
+		if (options?.onEvent) this.#eventListeners.set(task.id, options.onEvent);
+		this.sessionManager.updateTaskStatus(task.id, "running");
+		try {
+			const { initialization, sessionId } = await this.agentProcess.start({
+				taskId: task.id,
+				agent: task.agent,
+				cwd: task.cwd,
+				runtimeArgs: options?.runtimeArgs
+			});
+			this.recordEvent(task.id, {
+				type: "task.started",
+				taskId: task.id,
+				workspaceId: task.workspaceId,
+				agent: task.agent,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			const promptResult = await this.agentProcess.prompt(task.id, task.prompt);
+			this.logger.info("task started", {
+				taskId: task.id,
+				workspaceId: task.workspaceId,
+				agent: task.agent,
+				protocolVersion: initialization.protocolVersion,
+				sessionId,
+				stopReason: promptResult.stopReason
+			});
+			this.recordEvent(task.id, {
+				type: "task.completed",
+				taskId: task.id,
+				summary: promptResult.stopReason,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return {
+				taskId: task.id,
+				events: this.flushEvents(task.id)
+			};
+		} catch (error) {
+			const taskError = error instanceof AgentProcessError ? error : new AgentProcessError("agent_session_start_failed", error instanceof Error ? error.message : String(error));
+			this.sessionManager.updateTaskStatus(task.id, "failed");
+			this.logger.error("task failed before prompt completed", {
+				taskId: task.id,
+				code: taskError.code,
+				error: taskError.message
+			});
+			this.recordEvent(task.id, {
+				type: "task.failed",
+				taskId: task.id,
+				code: taskError.code,
+				error: taskError.message,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return {
+				taskId: task.id,
+				events: this.flushEvents(task.id)
+			};
+		}
+	}
+	async startConversationTask(conversationId, input, workspace, options) {
+		const state = await this.ensureConversation(conversationId, workspace, input.agent, {
+			resumeSessionId: options?.resumeSessionId,
+			runtimeArgs: options?.runtimeArgs
+		}, input.prompt);
+		return this.runConversationPrompt(conversationId, state, input.prompt, options);
+	}
+	async ensureConversation(conversationId, workspace, agent, options, promptForTask) {
+		let state = this.#conversations.get(conversationId);
+		if (state && (state.workspaceId !== workspace.id || state.agent !== agent || state.cwd !== workspace.cwd || !sameRuntimeArgs(state.runtimeArgs, options?.runtimeArgs ?? []))) {
+			await this.resetConversation(conversationId);
+			state = void 0;
+		}
+		if (state) return state;
+		const task = this.sessionManager.createTask({
+			workspaceId: workspace.id,
+			agent,
+			prompt: promptForTask ?? ""
+		}, workspace);
+		const started = await this.agentProcess.start({
+			taskId: task.id,
+			agent,
+			cwd: workspace.cwd,
+			resumeSessionId: options?.resumeSessionId,
+			runtimeArgs: options?.runtimeArgs
+		});
+		state = {
+			taskId: task.id,
+			workspaceId: workspace.id,
+			agent,
+			cwd: workspace.cwd,
+			sessionId: started.sessionId,
+			runtimeArgs: options?.runtimeArgs ?? [],
+			models: started.models
+		};
+		this.#taskRuntimeArgs.set(task.id, state.runtimeArgs);
+		this.#conversations.set(conversationId, state);
+		this.logger.info("conversation created", {
+			conversationId,
+			taskId: state.taskId,
+			workspaceId: state.workspaceId,
+			agent: state.agent,
+			sessionId: started.sessionId,
+			resumed: Boolean(options?.resumeSessionId && started.sessionId === options.resumeSessionId)
+		});
+		return state;
+	}
+	async runConversationPrompt(conversationId, state, prompt, options) {
+		this.#runningConversations.add(conversationId);
+		const result = await this.runPrompt(state.taskId, state.workspaceId, state.agent, prompt, options).finally(() => {
+			this.#runningConversations.delete(conversationId);
+		});
+		if (result.events.some((event) => event.type === "task.failed")) await this.resetConversation(conversationId);
+		return {
+			...result,
+			sessionId: state.sessionId,
+			models: state.models
+		};
+	}
+	async resetConversation(conversationId) {
+		const state = this.#conversations.get(conversationId);
+		if (!state) return false;
+		this.#conversations.delete(conversationId);
+		this.#taskRuntimeArgs.delete(state.taskId);
+		this.sessionManager.updateTaskStatus(state.taskId, "cancelled");
+		await this.agentProcess.stop(state.taskId);
+		this.logger.info("conversation reset", {
+			conversationId,
+			taskId: state.taskId
+		});
+		return true;
+	}
+	isConversationRunning(conversationId) {
+		return this.#runningConversations.has(conversationId);
+	}
+	hasConversation(conversationId) {
+		return this.#conversations.has(conversationId);
+	}
+	async setConversationModel(conversationId, modelId) {
+		const state = this.#conversations.get(conversationId);
+		if (!state) return false;
+		await this.agentProcess.setSessionModel(state.taskId, modelId);
+		if (state.models) state.models = {
+			...state.models,
+			currentModelId: modelId
+		};
+		return true;
+	}
+	getConversationModels(conversationId) {
+		return this.#conversations.get(conversationId)?.models;
+	}
+	getTask(taskId) {
+		return this.sessionManager.getTask(taskId);
+	}
+	isTaskFullAccess(taskId) {
+		const args = this.#taskRuntimeArgs.get(taskId) ?? [];
+		return this.hasApprovalPolicyNever(args);
+	}
+	handleAgentEvent(event) {
+		if (event.type === "agent.output") {
+			const bridgeEvent = {
+				type: "task.output",
+				taskId: event.taskId,
+				stream: "agent",
+				chunk: event.text,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.recordEvent(event.taskId, bridgeEvent);
+			return bridgeEvent;
+		}
+		if (event.type === "agent.approval_requested") {
+			const bridgeEvent = {
+				type: "task.approval_requested",
+				taskId: event.taskId,
+				request: event.request,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.recordEvent(event.taskId, bridgeEvent);
+			return bridgeEvent;
+		}
+		if (event.type === "agent.approval_resolved") {
+			const bridgeEvent = {
+				type: "task.approval_resolved",
+				taskId: event.taskId,
+				decision: event.decision,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.recordEvent(event.taskId, bridgeEvent);
+			return bridgeEvent;
+		}
+		if (event.type === "agent.tool_update") {
+			const bridgeEvent = {
+				type: "task.tool_update",
+				taskId: event.taskId,
+				update: event.update,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.recordEvent(event.taskId, bridgeEvent);
+			return bridgeEvent;
+		}
+	}
+	recordEvent(taskId, event) {
+		const events = this.#eventLog.get(taskId);
+		if (!events) this.#eventLog.set(taskId, [event]);
+		else events.push(event);
+		const listener = this.#eventListeners.get(taskId);
+		if (listener) listener(event);
+	}
+	async runPrompt(taskId, workspaceId, agent, prompt, options) {
+		this.#eventLog.set(taskId, []);
+		if (options?.onEvent) this.#eventListeners.set(taskId, options.onEvent);
+		this.sessionManager.updateTaskStatus(taskId, "running");
+		this.recordEvent(taskId, {
+			type: "task.started",
+			taskId,
+			workspaceId,
+			agent,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		try {
+			const promptResult = await this.agentProcess.prompt(taskId, prompt);
+			this.recordEvent(taskId, {
+				type: "task.completed",
+				taskId,
+				summary: promptResult.stopReason,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		} catch (error) {
+			const taskError = error instanceof AgentProcessError ? error : new AgentProcessError("agent_session_start_failed", error instanceof Error ? error.message : String(error));
+			this.sessionManager.updateTaskStatus(taskId, "failed");
+			this.logger.error("task failed before prompt completed", {
+				taskId,
+				code: taskError.code,
+				error: taskError.message
+			});
+			this.recordEvent(taskId, {
+				type: "task.failed",
+				taskId,
+				code: taskError.code,
+				error: taskError.message,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+		return {
+			taskId,
+			events: this.flushEvents(taskId)
+		};
+	}
+	flushEvents(taskId) {
+		const events = this.#eventLog.get(taskId) ?? [];
+		this.#eventLog.delete(taskId);
+		this.#eventListeners.delete(taskId);
+		return events;
+	}
+	hasApprovalPolicyNever(args) {
+		for (let index = 0; index < args.length - 1; index += 1) if (args[index] === "-c" && args[index + 1] === "approval_policy=\"never\"") return true;
+		return false;
+	}
+};
+//#endregion
+//#region src/feishu/session-controller.ts
+var FeishuSessionController = class {
+	#chatCwds = /* @__PURE__ */ new Map();
+	#chatBridgeSessionIds = /* @__PURE__ */ new Map();
+	#chatSessionIds = /* @__PURE__ */ new Map();
+	#chatAccessModes = /* @__PURE__ */ new Map();
+	#chatCurrentModelIds = /* @__PURE__ */ new Map();
+	#chatAvailableModels = /* @__PURE__ */ new Map();
+	#defaultAccessMode;
+	constructor(workspaces, defaultAccessMode, stateStore = new FileSessionStateStore()) {
+		this.workspaces = workspaces;
+		this.stateStore = stateStore;
+		this.#defaultAccessMode = defaultAccessMode;
+	}
+	async restore() {
+		const persisted = await this.stateStore.loadState();
+		let sanitized = false;
+		const fallbackCwd = this.workspaces[0]?.cwd;
+		for (const [chatId, cwd] of persisted.chatCwds.entries()) if (await this.isDirectory(cwd)) this.#chatCwds.set(chatId, cwd);
+		else if (fallbackCwd) {
+			this.#chatCwds.set(chatId, fallbackCwd);
+			sanitized = true;
+		}
+		for (const [chatId, bridgeSessionId] of persisted.chatBridgeSessionIds.entries()) this.#chatBridgeSessionIds.set(chatId, bridgeSessionId);
+		for (const [chatId, sessionId] of persisted.chatSessionIds.entries()) this.#chatSessionIds.set(chatId, sessionId);
+		if (sanitized) await this.persist();
+		return {
+			persistedChats: this.#chatCwds.size,
+			persistedSessions: this.#chatSessionIds.size
+		};
+	}
+	async resolveValidatedWorkspace(chatId) {
+		const workspace = this.resolveWorkspace(chatId);
+		if (!workspace) return;
+		if (await this.isDirectory(workspace.cwd)) return workspace;
+		const fallback = this.workspaces[0];
+		if (!fallback) return workspace;
+		await this.setChatCwd(chatId, fallback.cwd);
+		await this.clearSession(chatId);
+		return {
+			...fallback,
+			cwd: fallback.cwd
+		};
+	}
+	getResumeSessionId(chatId) {
+		return this.#chatSessionIds.get(chatId);
+	}
+	getBridgeSessionId(chatId) {
+		return this.#chatBridgeSessionIds.get(chatId);
+	}
+	async setSessionId(chatId, sessionId) {
+		if (!sessionId) {
+			this.#chatBridgeSessionIds.delete(chatId);
+			this.#chatSessionIds.delete(chatId);
+		} else {
+			this.#chatBridgeSessionIds.set(chatId, randomUUID());
+			this.#chatSessionIds.set(chatId, sessionId);
+		}
+		await this.persist();
+	}
+	async clearSession(chatId) {
+		this.#chatBridgeSessionIds.delete(chatId);
+		this.#chatSessionIds.delete(chatId);
+		this.#chatCurrentModelIds.delete(chatId);
+		this.#chatAvailableModels.delete(chatId);
+		await this.persist();
+	}
+	getAccessMode(chatId) {
+		return this.#chatAccessModes.get(chatId) ?? this.#defaultAccessMode;
+	}
+	getDefaultAccessMode() {
+		return this.#defaultAccessMode;
+	}
+	getAccessOverride(chatId) {
+		return this.#chatAccessModes.get(chatId);
+	}
+	getModel(chatId) {
+		return this.#chatCurrentModelIds.get(chatId);
+	}
+	async setModel(chatId, model, taskRunner) {
+		if (!taskRunner.hasConversation(chatId)) return false;
+		if (this.getModel(chatId) === model) return false;
+		if (!await taskRunner.setConversationModel(chatId, model)) return false;
+		const models = taskRunner.getConversationModels(chatId);
+		this.updateModelState(chatId, models);
+		return true;
+	}
+	getAvailableModels(chatId) {
+		return this.#chatAvailableModels.get(chatId) ?? [];
+	}
+	updateModelState(chatId, state) {
+		if (!state) return;
+		this.#chatCurrentModelIds.set(chatId, state.currentModelId);
+		this.#chatAvailableModels.set(chatId, state.availableModels);
+	}
+	async setAccessMode(chatId, mode, taskRunner) {
+		if (this.getAccessMode(chatId) === mode) return false;
+		if (mode === this.#defaultAccessMode) this.#chatAccessModes.delete(chatId);
+		else this.#chatAccessModes.set(chatId, mode);
+		await this.resetConversation(chatId, taskRunner, { keepAccessOverride: true });
+		return true;
+	}
+	async clearAccessOverride(chatId, taskRunner) {
+		if (!this.#chatAccessModes.has(chatId)) return false;
+		this.#chatAccessModes.delete(chatId);
+		await this.resetConversation(chatId, taskRunner);
+		return true;
+	}
+	async interrupt(chatId, taskRunner) {
+		if (!taskRunner.isConversationRunning(chatId)) return false;
+		await this.resetConversation(chatId, taskRunner, { keepAccessOverride: true });
+		return true;
+	}
+	async resetConversation(chatId, taskRunner, options) {
+		await taskRunner.resetConversation(chatId);
+		this.#chatBridgeSessionIds.delete(chatId);
+		this.#chatSessionIds.delete(chatId);
+		this.#chatCurrentModelIds.delete(chatId);
+		this.#chatAvailableModels.delete(chatId);
+		if (!options?.keepAccessOverride) this.#chatAccessModes.delete(chatId);
+		await this.persist();
+	}
+	async startNewConversation(options, taskRunner) {
+		await this.resetConversation(options.chatId, taskRunner);
+		if (options.cwd) await this.setChatCwd(options.chatId, options.cwd);
+		else await this.setChatCwd(options.chatId, options.workspace.cwd);
+		const nextWorkspace = {
+			...options.workspace,
+			cwd: options.cwd ?? options.workspace.cwd
+		};
+		const conversation = await taskRunner.ensureConversation(options.chatId, nextWorkspace, options.agent);
+		this.updateModelState(options.chatId, conversation.models);
+		this.#chatBridgeSessionIds.set(options.chatId, randomUUID());
+		this.#chatSessionIds.set(options.chatId, conversation.sessionId);
+		await this.persist();
+		return {
+			sessionId: conversation.sessionId,
+			workspace: nextWorkspace
+		};
+	}
+	resolveWorkspace(chatId) {
+		const baseWorkspace = this.workspaces[0];
+		if (!baseWorkspace) return;
+		const cwd = this.#chatCwds.get(chatId) ?? baseWorkspace.cwd;
+		return {
+			...baseWorkspace,
+			cwd
+		};
+	}
+	async setChatCwd(chatId, cwd) {
+		this.#chatCwds.set(chatId, cwd);
+		await this.persist();
+	}
+	async isDirectory(path) {
+		const dirStat = await stat(path).catch(() => void 0);
+		return Boolean(dirStat?.isDirectory());
+	}
+	async persist() {
+		await this.stateStore.saveState({
+			chatCwds: this.#chatCwds,
+			chatBridgeSessionIds: this.#chatBridgeSessionIds,
+			chatSessionIds: this.#chatSessionIds
+		});
+	}
+};
+//#endregion
+//#region src/feishu/feishu-gateway.ts
+function buildCodexRuntimeArgs(mode) {
+	const args = [];
+	if (mode === "full-access") args.push("-c", "approval_policy=\"never\"", "-c", "sandbox_mode=\"danger-full-access\"");
+	return args;
+}
+var FeishuGateway = class {
+	#wsClient;
+	#eventDispatcher;
+	#messageQueue = new MessageEntryQueue();
+	#sessionController;
+	#cardRenderer = new FeishuCardRenderer();
+	#messageClient;
+	#cardActionHandler;
+	#commandHandler;
+	#approvalCards = /* @__PURE__ */ new Map();
+	#patchMinIntervalMs = 280;
+	constructor(config, workspaces, taskRunner, approvalGateway, logger, yoloMode = false) {
+		this.taskRunner = taskRunner;
+		this.approvalGateway = approvalGateway;
+		this.logger = logger;
+		this.#sessionController = new FeishuSessionController(workspaces, yoloMode ? "full-access" : "standard");
+		this.#messageClient = new FeishuMessageClient(new lark.Client({
+			appId: config.appId,
+			appSecret: config.appSecret
+		}), this.logger);
+		this.#cardActionHandler = new FeishuCardActionHandler({
+			sessionController: this.#sessionController,
+			taskRunner: this.taskRunner,
+			approvalGateway: this.approvalGateway,
+			messageClient: this.#messageClient,
+			cardRenderer: this.#cardRenderer,
+			logger: this.logger,
+			onApprovalResolved: (decision) => {
+				this.patchApprovalCardByDecision(decision);
+			}
+		});
+		this.#commandHandler = new FeishuCommandHandler({
+			sessionController: this.#sessionController,
+			cardActionHandler: this.#cardActionHandler,
+			messageClient: this.#messageClient,
+			taskRunner: this.taskRunner
+		});
+		this.#wsClient = new lark.WSClient({
+			appId: config.appId,
+			appSecret: config.appSecret,
+			loggerLevel: lark.LoggerLevel.info
+		});
+		this.#eventDispatcher = buildFeishuEventDispatcher({
+			onMessageReceived: async (data) => {
+				await this.handleIncomingMessage(data);
+			},
+			onCardAction: async (data) => {
+				return this.#cardActionHandler.handleCardAction(data ?? {});
+			}
+		});
+		this.approvalGateway.onResolved((snapshot) => {
+			this.patchApprovalCard(snapshot);
+		});
+	}
+	async start() {
+		const restored = await this.#sessionController.restore();
+		await this.#wsClient.start({ eventDispatcher: this.#eventDispatcher });
+		this.logger.info("feishu gateway started", restored);
+	}
+	async handleIncomingMessage(data) {
+		this.#messageQueue.gcHandledMessageIds();
+		const messageId = data.message.message_id;
+		const queue = this.#messageQueue.runInChatQueue(data.message.chat_id, messageId, async () => {
+			await this.processMessage(data);
+		});
+		if (!queue) {
+			this.logger.info("feishu duplicate message ignored", { messageId });
+			return;
+		}
+		queue.catch((error) => {
+			this.logger.error("feishu message process failed", {
+				messageId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		});
+	}
+	async processMessage(data) {
+		if (data.sender.sender_type !== "user") return;
+		const chatId = data.message.chat_id;
+		if (data.message.message_type !== "text") {
+			await this.#messageClient.sendText(chatId, "只支持文本消息。");
+			return;
+		}
+		const workspace = await this.#sessionController.resolveValidatedWorkspace(chatId);
+		if (!workspace) {
+			await this.#messageClient.sendText(chatId, "未配置可用工作区。");
+			return;
+		}
+		const rawPrompt = (parseContent(data.message.content).text ?? "").trim();
+		if (!rawPrompt) {
+			await this.#messageClient.sendText(chatId, "消息内容为空。");
+			return;
+		}
+		let command;
+		try {
+			command = await parseUserCommand(rawPrompt, workspace.cwd);
+		} catch (error) {
+			await this.#messageClient.sendText(chatId, `命令解析失败：${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		const result = await this.#commandHandler.handle({
+			chatId,
+			workspace,
+			command
+		});
+		if (result.type === "handled") return;
+		await this.runConversationTask({
+			chatId,
+			messageId: data.message.message_id,
+			workspace,
+			prompt: result.prompt
+		});
+	}
+	async runConversationTask(params) {
+		const streamer = new TaskCardStreamer({
+			chatId: params.chatId,
+			logger: this.logger,
+			renderer: this.#cardRenderer,
+			sendCard: async (chatId, card) => this.#messageClient.sendCard(chatId, card),
+			patchCard: async (messageId, card) => this.#messageClient.patchCard(messageId, card),
+			patchMinIntervalMs: this.#patchMinIntervalMs
+		});
+		let typingReactionId;
+		try {
+			typingReactionId = await this.#messageClient.addTypingReaction(params.messageId);
+			const result = await this.taskRunner.startConversationTask(params.chatId, {
+				workspaceId: params.workspace.id,
+				agent: "codex",
+				prompt: params.prompt
+			}, params.workspace, {
+				runtimeArgs: buildCodexRuntimeArgs(this.#sessionController.getAccessMode(params.chatId)),
+				resumeSessionId: this.#sessionController.getResumeSessionId(params.chatId),
+				onEvent: (event) => {
+					this.onTaskEvent(params.chatId, event, streamer);
+				}
+			});
+			if (result.sessionId && this.#sessionController.getResumeSessionId(params.chatId) !== result.sessionId) await this.#sessionController.setSessionId(params.chatId, result.sessionId);
+			this.#sessionController.updateModelState(params.chatId, result.models);
+			const failed = result.events.find((event) => event.type === "task.failed");
+			const completed = result.events.find((event) => event.type === "task.completed");
+			if (failed) streamer.markFailed(failed.error);
+			else if (completed) streamer.markCompleted(completed.summary);
+			await streamer.finalize();
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.logger.error("run conversation task failed", {
+				chatId: params.chatId,
+				messageId: params.messageId,
+				error: errorMessage
+			});
+			streamer.markFailed(errorMessage);
+			await streamer.finalize().catch((finalizeError) => {
+				this.logger.error("finalize failed after task error", {
+					chatId: params.chatId,
+					messageId: params.messageId,
+					error: finalizeError instanceof Error ? finalizeError.message : String(finalizeError)
+				});
+			});
+		} finally {
+			if (typingReactionId) await this.#messageClient.removeTypingReaction(params.messageId, typingReactionId).catch(() => {});
+		}
+	}
+	onTaskEvent(chatId, event, streamer) {
+		if (event.type === "task.output") {
+			streamer.handleOutputChunk(event.chunk);
+			return;
+		}
+		if (event.type === "task.tool_update") {
+			streamer.handleToolUpdate(event.update);
+			return;
+		}
+		if (event.type === "task.approval_requested") {
+			this.sendApprovalCard(chatId, event.request).catch((error) => {
+				this.logger.error("send approval card failed", {
+					taskId: event.taskId,
+					requestId: event.request.id,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			});
+			return;
+		}
+		if (event.type === "task.approval_resolved") {
+			if (shouldPatchApprovalSummary(event.decision)) this.patchApprovalCardByDecision(event.decision);
+			return;
+		}
+		if (event.type === "task.failed") {
+			streamer.markFailed(event.error);
+			return;
+		}
+		if (event.type === "task.completed") streamer.markCompleted(event.summary);
+	}
+	async sendApprovalCard(chatId, request) {
+		this.gcApprovalCards();
+		const messageId = await this.#messageClient.sendCard(chatId, this.#cardRenderer.buildApprovalCard(request, "pending"));
+		this.#approvalCards.set(request.id, {
+			chatId,
+			messageId,
+			updatedAtMs: Date.now()
+		});
+	}
+	async patchApprovalCard(snapshot) {
+		this.gcApprovalCards();
+		const binding = this.#approvalCards.get(snapshot.request.id);
+		if (!binding) return;
+		binding.updatedAtMs = Date.now();
+		await this.#messageClient.patchCard(binding.messageId, this.#cardRenderer.buildApprovalCard(snapshot.request, snapshot.status, snapshot.decision)).catch((error) => {
+			this.logger.warn("patch approval card failed", {
+				requestId: snapshot.request.id,
+				messageId: binding.messageId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		});
+	}
+	async patchApprovalCardByDecision(decision) {
+		this.gcApprovalCards();
+		const binding = this.#approvalCards.get(decision.requestId);
+		if (!binding) return;
+		binding.updatedAtMs = Date.now();
+		const title = decision.decision === "approved" ? "已批准" : "已拒绝";
+		await this.#messageClient.patchCard(binding.messageId, this.#cardRenderer.buildApprovalSummaryCard(title, decision)).catch((error) => {
+			this.logger.warn("patch approval card failed", {
+				requestId: decision.requestId,
+				messageId: binding.messageId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		});
+	}
+	gcApprovalCards() {
+		const ttlMs = 1440 * 60 * 1e3;
+		const now = Date.now();
+		for (const [requestId, binding] of this.#approvalCards.entries()) if (now - binding.updatedAtMs > ttlMs) this.#approvalCards.delete(requestId);
+	}
+};
+//#endregion
+//#region src/utils/logger.ts
+function log(level, message, context) {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const levelLabel = level.toUpperCase();
+	const contextText = context ? ` ${formatContext(context)}` : "";
+	console.log(`[${timestamp}] ${levelLabel} ${message}${contextText}`);
+}
+function formatContext(context) {
+	return Object.entries(context).map(([key, value]) => `${key}=${stringifyValue(value)}`).join(" ");
+}
+function stringifyValue(value) {
+	if (typeof value === "string") return value;
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "[unserializable]";
+	}
+}
+function createLogger() {
+	return {
+		info: (message, context) => log("info", message, context),
+		warn: (message, context) => log("warn", message, context),
+		error: (message, context) => log("error", message, context)
+	};
+}
+//#endregion
+//#region src/index.ts
+async function startBridge() {
+	const config = await loadConfig();
+	const logger = createLogger();
+	const approvalGateway = new ApprovalGateway(new ApprovalStore(), logger);
+	const sessionManager = new SessionManager();
+	let taskRunner;
+	taskRunner = new TaskRunner(sessionManager, new AgentProcess(config, logger, (event) => {
+		const bridgeEvent = taskRunner.handleAgentEvent(event);
+		if (!bridgeEvent) return;
+		logger.info("bridge event emitted", bridgeEvent);
+	}, createPermissionRequestHandler({
+		workspaces: config.workspaces,
+		approvalGateway,
+		getTaskRunner: () => taskRunner
+	})), logger);
+	const feishuGateway = config.feishu ? new FeishuGateway(config.feishu, config.workspaces, taskRunner, approvalGateway, logger, config.yoloMode) : void 0;
+	if (feishuGateway) await feishuGateway.start();
+	logger.info("bridge started", {
+		workspaceCount: config.workspaces.length,
+		feishuEnabled: Boolean(feishuGateway),
+		yoloMode: config.yoloMode
+	});
+}
+//#endregion
+export { startBridge as t };