@wemind/cli 0.0.0-stage → 1.0.0

package/dist/cli.js

@@ -0,0 +1,4382 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import crypto, { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+import os from "node:os";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+//#region ../wechat-ilink-core/dist/config.js
+/**
+* iLink 应用标识。
+* 原 fork 从 package.json 的 ilink_appid 字段读取（向上查找）；拆为 workspace 多包后，
+* 该耦合不再可靠（mcp-server 打包后会找到错误的 package.json），固化为常量，并允许 env 覆盖。
+*/
+const ILINK_APP_ID = process.env.ILINK_APP_ID?.trim() || "bot";
+//#endregion
+//#region ../wechat-ilink-core/dist/api/types.js
+/**
+* iLink Bot API 协议类型（镜像服务端 proto：GetUpdatesReq/Resp、WeixinMessage、SendMessageReq 等）。
+*
+* 来源与依据：
+*  - 字段与 proto 含义对照官方 Tencent/openclaw-weixin `src/api/types.ts` 整理（社区/官方最权威的公开实现）。
+*  - 错误码（ret / errcode）语义见 `error-codes.ts`。
+*  - 标 `[实测]` 的注释为 WeMind 在真机使用中验证/纠正的结论（详见笔记「迭代记录与待办」）。
+*
+* 约定：
+*  - 全部走 JSON over HTTP；proto 里的 bytes 字段在 JSON 中是 **base64 字符串**。
+*  - 协议字段绝大多数可选（服务端按场景下发），故统一用 `?`；本地自有类型（AccountData/ServerState/QrLoginState）按实际必填。
+*/
+/** 消息方向（proto: MessageType）。USER=入站(用户发来)，BOT=出站(机器人发出)。 */
+const MessageType = {
+	NONE: 0,
+	USER: 1,
+	BOT: 2
+};
+/** 消息项类型（proto: MessageItemType）。一条消息的 item_list 里每项是其中一种。 */
+const MessageItemType = {
+	NONE: 0,
+	TEXT: 1,
+	IMAGE: 2,
+	VOICE: 3,
+	FILE: 4,
+	VIDEO: 5
+};
+/**
+* 消息状态（proto: MessageState）。
+* - NEW=0：新消息。
+* - GENERATING=1：生成中（流式/进行中）。
+* - FINISH=2：本回合结束。
+* [实测] 关键：发送进度/中间消息用 **GENERATING**，仅最终答案用 **FINISH**——
+*   FINISH 会结束当前回合（关闭该 context 的发送窗口），若进度也用 FINISH 会提前关掉会话。
+*   详见笔记里程碑 21/23 与 README「进度提示与连续发送上限」。
+*/
+const MessageState = {
+	NEW: 0,
+	GENERATING: 1,
+	FINISH: 2
+};
+/** 上传媒体类型（proto: UploadMediaType）。getUploadUrl 的 media_type 取值。 */
+const UploadMediaType = {
+	IMAGE: 1,
+	VIDEO: 2,
+	FILE: 3,
+	VOICE: 4
+};
+//#endregion
+//#region ../wechat-ilink-core/dist/api/error-codes.js
+/**
+* iLink Bot API 错误码定义与分类。
+*
+* 权威来源：逆向自官方 Tencent/openclaw-weixin 的「iLink Bot API 协议参考」
+* （corespeed-io/wechatbot `docs/protocol.md` 的 Error Codes 表，社区逆向、目前最权威的公开文档）。
+*
+* 两个字段，语义不同：
+*  - `ret`    ：发送/上传等 RPC 的返回码（sendmessage / getuploadurl 等响应体）。
+*  - `errcode`：长轮询/会话类接口的错误码（getupdates 等）。
+*
+* 已知错误码（截至文档）：
+*  | 码            | 字段     | 含义                         | 处理                                   |
+*  |---------------|----------|------------------------------|----------------------------------------|
+*  | 0             | ret      | 成功                          | —                                      |
+*  | -2            | ret      | 参数错误 (Parameter error)    | 检查请求参数                            |
+*  | -14           | errcode  | 会话过期 (Session expired)    | 重新登录（本项目对该账号冷却 1 小时）   |
+*
+* ⚠️ 重要澄清（避免重蹈覆辙）：
+*  - `ret = -2` 官方定义是**参数错误**，**不是**"context_token 按时间过期"。
+*    常见诱因：context_token 失效/与当前会话不匹配、必填字段缺失/格式不对。
+*  - context_token 官方说明：按 `(accountId, userId)` **缓存、持久化、重用**，
+*    **仅在会话过期(-14)/重新登录时清除**——**没有**文档化的时间 TTL。
+*  - 真正"按时间/会话过期"的是 `errcode = -14`（会话级），与 -2 无关。
+*/
+/** 发送/上传 RPC 的 `ret` 码。 */
+const ILINK_RET = {
+	OK: 0,
+	/** 参数错误：检查请求（最常见为 context_token 失效/不匹配；也可能被复用为发送限流——短时连续发送过多，见 README「连续发送上限」）。 */
+	PARAM_ERROR: -2
+};
+/** 长轮询/会话类接口的 `errcode` 码。 */
+const ILINK_ERRCODE = { 
+/** 会话过期，需重新登录。 */
+SESSION_EXPIRED: -14 };
+/** 把一个 ret/errcode 数值分类。 */
+function classifyILinkCode(code) {
+	if (code === void 0 || code === null || code === 0) return "ok";
+	if (code === ILINK_ERRCODE.SESSION_EXPIRED) return "session_expired";
+	if (code === ILINK_RET.PARAM_ERROR) return "param_error";
+	return "unknown";
+}
+/** 返回可读标签 + 处理建议，用于日志与提示。 */
+function describeILinkCode(code) {
+	switch (classifyILinkCode(code)) {
+		case "ok": return {
+			kind: "ok",
+			label: `ok(${code ?? 0})`,
+			hint: ""
+		};
+		case "session_expired": return {
+			kind: "session_expired",
+			label: "会话过期(-14)",
+			hint: "需重新登录"
+		};
+		case "param_error": return {
+			kind: "param_error",
+			label: "参数错误(-2)",
+			hint: "检查请求参数（最常见：context_token 失效/不匹配；或发送限流——短时连续发送过多）"
+		};
+		default: return {
+			kind: "unknown",
+			label: `未知错误码(${code})`,
+			hint: "对照 iLink 协议文档排查"
+		};
+	}
+}
+/** iLink 接口返回非 0 ret/errcode 时抛出的结构化错误，携带原始码与分类，便于上层按类型处理。 */
+var ILinkError = class extends Error {
+	code;
+	kind;
+	constructor(op, code, errmsg) {
+		const { kind, label, hint } = describeILinkCode(code);
+		super(`${op} failed: ${label}${hint ? ` — ${hint}` : ""}${errmsg ? ` (${errmsg})` : ""}`);
+		this.name = "ILinkError";
+		this.code = code;
+		this.kind = kind;
+	}
+};
+//#endregion
+//#region ../wechat-ilink-core/dist/api/client.js
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35e3;
+const DEFAULT_API_TIMEOUT_MS = 15e3;
+const QR_LONG_POLL_TIMEOUT_MS = 35e3;
+const ILINK_CLIENT_VERSION = process.env.ILINK_CLIENT_VERSION?.trim() || "2.4.3";
+const CHANNEL_VERSION = ILINK_CLIENT_VERSION;
+/**
+* iLink-App-ClientVersion: uint32 编码 0x00MMNNPP（major<<16 | minor<<8 | patch）。
+* 编码方式借鉴自官方 Tencent/openclaw-weixin（MIT）。
+*/
+function buildClientVersion(version) {
+	const [major = 0, minor = 0, patch = 0] = version.split(".").map((p) => parseInt(p, 10) || 0);
+	return (major & 255) << 16 | (minor & 255) << 8 | patch & 255;
+}
+const ILINK_APP_CLIENT_VERSION = String(buildClientVersion(ILINK_CLIENT_VERSION));
+/** iLink 公共请求头：所有 GET/POST 都需携带，缺失会导致服务端拒绝连接。 */
+function buildCommonHeaders() {
+	return {
+		"iLink-App-Id": ILINK_APP_ID,
+		"iLink-App-ClientVersion": ILINK_APP_CLIENT_VERSION
+	};
+}
+function ensureTrailingSlash(url) {
+	return url.endsWith("/") ? url : `${url}/`;
+}
+function randomWechatUin() {
+	const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+	return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+function buildHeaders(opts) {
+	const headers = {
+		"Content-Type": "application/json",
+		AuthorizationType: "ilink_bot_token",
+		"Content-Length": String(Buffer.byteLength(opts.body, "utf-8")),
+		"X-WECHAT-UIN": randomWechatUin(),
+		...buildCommonHeaders()
+	};
+	if (opts.token?.trim()) headers.Authorization = `Bearer ${opts.token.trim()}`;
+	return headers;
+}
+async function apiFetch(params) {
+	const base = ensureTrailingSlash(params.baseUrl);
+	const url = new URL(params.endpoint, base);
+	const hdrs = buildHeaders({
+		token: params.token,
+		body: params.body
+	});
+	const controller = new AbortController();
+	const t = setTimeout(() => controller.abort(), params.timeoutMs);
+	try {
+		const res = await fetch(url.toString(), {
+			method: "POST",
+			headers: hdrs,
+			body: params.body,
+			signal: controller.signal
+		});
+		const rawText = await res.text();
+		clearTimeout(t);
+		if (!res.ok) throw new Error(`${params.label} ${res.status}: ${rawText}`);
+		return rawText;
+	} catch (err) {
+		clearTimeout(t);
+		throw err;
+	}
+}
+/** 防御性解析 API JSON 响应：失败抛带 label 与响应片段的清晰错误，而非裸 SyntaxError（畸形/代理 HTML/截断响应不致以晦涩错误打断调用方）。 */
+function parseJsonResp(raw, label) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new Error(`${label}: response not JSON (${raw.slice(0, 120)})`);
+	}
+}
+function buildBaseInfo() {
+	return { channel_version: CHANNEL_VERSION };
+}
+async function getUpdates(params) {
+	const timeout = params.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+	try {
+		return parseJsonResp(await apiFetch({
+			baseUrl: params.baseUrl,
+			endpoint: "ilink/bot/getupdates",
+			body: JSON.stringify({
+				get_updates_buf: params.updatesBuf ?? "",
+				base_info: buildBaseInfo()
+			}),
+			token: params.token,
+			timeoutMs: timeout,
+			label: "getUpdates"
+		}), "getUpdates");
+	} catch (err) {
+		if (err instanceof Error && err.name === "AbortError") return {
+			ret: 0,
+			msgs: [],
+			get_updates_buf: params.updatesBuf
+		};
+		throw err;
+	}
+}
+async function sendMessage(params) {
+	const raw = await apiFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/sendmessage",
+		body: JSON.stringify({
+			...params.body,
+			base_info: buildBaseInfo()
+		}),
+		token: params.token,
+		timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+		label: "sendMessage"
+	});
+	let code;
+	let errmsg;
+	try {
+		const resp = raw ? JSON.parse(raw) : null;
+		code = resp?.ret ?? resp?.errcode;
+		errmsg = resp?.errmsg;
+	} catch {}
+	if (code !== void 0 && code !== 0) throw new ILinkError("sendMessage", code, errmsg);
+}
+/** 取 CDN 上传地址（发图/发文件用）。返回 upload_full_url 或 upload_param。 */
+async function getUploadUrl(params) {
+	return parseJsonResp(await apiFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/getuploadurl",
+		body: JSON.stringify({
+			filekey: params.filekey,
+			media_type: params.media_type,
+			to_user_id: params.to_user_id,
+			rawsize: params.rawsize,
+			rawfilemd5: params.rawfilemd5,
+			filesize: params.filesize,
+			no_need_thumb: params.no_need_thumb,
+			aeskey: params.aeskey,
+			base_info: buildBaseInfo()
+		}),
+		token: params.token,
+		timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+		label: "getUploadUrl"
+	}), "getUploadUrl");
+}
+async function fetchQRCode(apiBaseUrl) {
+	return parseJsonResp(await apiFetch({
+		baseUrl: apiBaseUrl,
+		endpoint: "ilink/bot/get_bot_qrcode?bot_type=3",
+		body: JSON.stringify({ local_token_list: [] }),
+		timeoutMs: DEFAULT_API_TIMEOUT_MS,
+		label: "fetchQRCode"
+	}), "fetchQRCode");
+}
+async function pollQRStatus(apiBaseUrl, qrcode) {
+	const base = ensureTrailingSlash(apiBaseUrl);
+	const url = new URL(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, base);
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), QR_LONG_POLL_TIMEOUT_MS);
+	try {
+		const response = await fetch(url.toString(), {
+			headers: buildCommonHeaders(),
+			signal: controller.signal
+		});
+		if (!response.ok) {
+			const body = await response.text().catch(() => "(unreadable)");
+			clearTimeout(timer);
+			throw new Error(`Failed to poll QR status: ${response.status} ${response.statusText} ${body}`);
+		}
+		const text = await response.text();
+		clearTimeout(timer);
+		return parseJsonResp(text, "pollQRStatus");
+	} catch (err) {
+		clearTimeout(timer);
+		if (err instanceof Error && err.name === "AbortError") return { status: "wait" };
+		throw err;
+	}
+}
+function generateId(prefix) {
+	return `${prefix}:${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+}
+const DEFAULT_CONFIG_TIMEOUT_MS = 15e3;
+async function getConfig(params) {
+	return parseJsonResp(await apiFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/getconfig",
+		body: JSON.stringify({
+			ilink_user_id: params.ilinkUserId,
+			context_token: params.contextToken,
+			base_info: buildBaseInfo()
+		}),
+		token: params.token,
+		timeoutMs: DEFAULT_CONFIG_TIMEOUT_MS,
+		label: "getConfig"
+	}), "getConfig");
+}
+async function sendTyping(params) {
+	await apiFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/sendtyping",
+		body: JSON.stringify({
+			...params.body,
+			base_info: buildBaseInfo()
+		}),
+		token: params.token,
+		timeoutMs: DEFAULT_CONFIG_TIMEOUT_MS,
+		label: "sendTyping"
+	});
+}
+/** 通知服务端该 bot 客户端上线（best-effort，失败不阻断）。 */
+async function notifyStart(params) {
+	try {
+		await apiFetch({
+			baseUrl: params.baseUrl,
+			endpoint: "ilink/bot/msg/notifystart",
+			body: JSON.stringify({ base_info: buildBaseInfo() }),
+			token: params.token,
+			timeoutMs: DEFAULT_CONFIG_TIMEOUT_MS,
+			label: "notifyStart"
+		});
+	} catch (err) {
+		console.error(`[wemind/wechat-ilink-core/ilink] notifyStart failed (ignored, best-effort): ${String(err)}`);
+	}
+}
+/** 通知服务端该 bot 客户端下线（best-effort，失败不阻断）。 */
+async function notifyStop(params) {
+	try {
+		await apiFetch({
+			baseUrl: params.baseUrl,
+			endpoint: "ilink/bot/msg/notifystop",
+			body: JSON.stringify({ base_info: buildBaseInfo() }),
+			token: params.token,
+			timeoutMs: DEFAULT_CONFIG_TIMEOUT_MS,
+			label: "notifyStop"
+		});
+	} catch (err) {
+		console.error(`[wemind/wechat-ilink-core/ilink] notifyStop failed (ignored, best-effort): ${String(err)}`);
+	}
+}
+//#endregion
+//#region ../wechat-ilink-core/dist/api/transport-errors.js
+/**
+* 传输层错误分类：把 fetch/网络层抛出的错误归类，判定是否可重试。
+* 与 error-codes.ts（iLink 业务 ret/errcode）正交——这里只管「网络传输」层面的失败。
+* 借鉴 wxclawbot-cli（MIT）client.ts 的 classifyTransportError 思路。
+*/
+/** 归类一个传输层错误。timeout（AbortError）一律可重试。 */
+function classifyTransportError(err) {
+	if (err instanceof Error && err.name === "AbortError") return {
+		kind: "timeout",
+		retryable: true,
+		message: err.message || "request timeout"
+	};
+	const message = err instanceof Error ? err.message : String(err);
+	const code = err && typeof err === "object" && "code" in err && typeof err.code === "string" ? err.code : void 0;
+	const cause = err instanceof Error && err.cause != null ? String(err.cause) : void 0;
+	const s = `${message} ${code ?? ""} ${cause ?? ""}`.toLowerCase();
+	if (s.includes("enotfound") || s.includes("dns")) return {
+		kind: "dns",
+		retryable: true,
+		message,
+		code
+	};
+	if (s.includes("econnreset") || s.includes("socket hang up")) return {
+		kind: "connection",
+		retryable: true,
+		message,
+		code
+	};
+	if (s.includes("cert") || s.includes("tls") || s.includes("ssl")) return {
+		kind: "tls",
+		retryable: false,
+		message,
+		code
+	};
+	if (s.includes("econnrefused") || s.includes("ehostunreach") || s.includes("enetunreach") || s.includes("etimedout") || s.includes("network") || s.includes("fetch failed")) return {
+		kind: "network",
+		retryable: true,
+		message,
+		code
+	};
+	return {
+		kind: "unknown",
+		retryable: false,
+		message,
+		code
+	};
+}
+//#endregion
+//#region ../wechat-ilink-core/dist/api/session-guard.js
+const PAUSE_MS = 3600 * 1e3;
+const pauseUntil = /* @__PURE__ */ new Map();
+/** 命中 -14 后暂停该账号一小时。 */
+function pauseSession(accountId) {
+	pauseUntil.set(accountId, Date.now() + PAUSE_MS);
+}
+/** 距离冷却结束的剩余毫秒数（未暂停时为 0）。 */
+function getRemainingPauseMs(accountId) {
+	const until = pauseUntil.get(accountId);
+	if (until === void 0) return 0;
+	const remaining = until - Date.now();
+	if (remaining <= 0) {
+		pauseUntil.delete(accountId);
+		return 0;
+	}
+	return remaining;
+}
+function isSessionPaused(accountId) {
+	return getRemainingPauseMs(accountId) > 0;
+}
+/** 重新登录成功后清除冷却。 */
+function clearSessionPause(accountId) {
+	pauseUntil.delete(accountId);
+}
+//#endregion
+//#region ../wechat-ilink-core/dist/store/accounts.js
+/**
+* 账号注册表：管理 ~/.wemind 下的多账号清单。
+* - 每个账号一个独立子目录（key = 由 botId 派生的唯一标识，见 deriveAccountKey）。
+* - accounts.json 记录 key → 元数据（botId/userId/baseUrl/label/addedAt）与默认账号。
+* label 为人类可读别名（默认等于 key，可改），folder/key 始终唯一且由微信 botId 派生。
+*/
+/** WeMind 根目录（所有账号子目录与注册表的父目录）。可用 WEMIND_HOME 覆盖。 */
+const WEMIND_ROOT = process.env.WEMIND_HOME?.trim() || path.join(os.homedir(), ".wemind");
+const REGISTRY_FILE = path.join(WEMIND_ROOT, "accounts.json");
+/** 把 botId（如 feead781eb44@im.bot）净化成可作目录名的唯一 key（feead781eb44）。 */
+function deriveAccountKey(botId) {
+	return ((botId || "").split("@")[0] || botId || "").replace(/[^a-zA-Z0-9_-]/g, "").trim() || "account";
+}
+/** 某账号的状态目录：~/.wemind/<key>。 */
+function accountDir(key) {
+	return path.join(WEMIND_ROOT, key);
+}
+function loadRegistry() {
+	let raw;
+	try {
+		raw = fs.readFileSync(REGISTRY_FILE, "utf-8");
+	} catch {
+		return { accounts: {} };
+	}
+	try {
+		const j = JSON.parse(raw);
+		if (j && typeof j === "object" && j.accounts) return j;
+		throw new Error("registry shape invalid");
+	} catch (e) {
+		console.error(`[wemind/wechat-ilink-core/accounts] ${REGISTRY_FILE} parse failed, backing up: ${String(e)}`);
+		try {
+			fs.renameSync(REGISTRY_FILE, `${REGISTRY_FILE}.corrupt-${Date.now()}`);
+		} catch {}
+		return { accounts: {} };
+	}
+}
+/** 原子写注册表：临时文件 + rename，避免写途崩溃/并发损坏。 */
+function saveRegistry(reg) {
+	fs.mkdirSync(WEMIND_ROOT, { recursive: true });
+	const tmp = `${REGISTRY_FILE}.tmp-${process.pid}-${Date.now()}`;
+	fs.writeFileSync(tmp, JSON.stringify(reg, null, 2), "utf-8");
+	fs.renameSync(tmp, REGISTRY_FILE);
+}
+function listAccounts() {
+	const reg = loadRegistry();
+	return Object.values(reg.accounts).sort((a, b) => a.addedAt - b.addedAt);
+}
+function getDefaultKey() {
+	const reg = loadRegistry();
+	if (reg.default && reg.accounts[reg.default]) return reg.default;
+	const keys = Object.keys(reg.accounts);
+	return keys.length ? keys[0] : void 0;
+}
+function setDefaultKey(key) {
+	const reg = loadRegistry();
+	if (!reg.accounts[key]) throw new Error(`account not found: ${key}`);
+	reg.default = key;
+	saveRegistry(reg);
+}
+/** 登记/更新一个账号；首个账号自动设为默认。 */
+function registerAccount(meta) {
+	const reg = loadRegistry();
+	const existing = reg.accounts[meta.key];
+	const full = {
+		key: meta.key,
+		botId: meta.botId,
+		userId: meta.userId,
+		baseUrl: meta.baseUrl,
+		label: meta.label || existing?.label || meta.key,
+		addedAt: existing?.addedAt ?? meta.addedAt ?? Date.now()
+	};
+	reg.accounts[meta.key] = full;
+	if (!reg.default) reg.default = meta.key;
+	saveRegistry(reg);
+	return full;
+}
+/** 移除注册表中的账号条目（不删除磁盘目录，由调用方决定）。 */
+function unregisterAccount(key) {
+	const reg = loadRegistry();
+	delete reg.accounts[key];
+	if (reg.default === key) {
+		const rest = Object.keys(reg.accounts);
+		reg.default = rest.length ? rest[0] : void 0;
+	}
+	saveRegistry(reg);
+}
+/** 设置/修改某账号的人类可读别名。 */
+function setLabel(key, label) {
+	const reg = loadRegistry();
+	if (!reg.accounts[key]) throw new Error(`account not found: ${key}`);
+	reg.accounts[key].label = label;
+	saveRegistry(reg);
+}
+//#endregion
+//#region ../wechat-ilink-core/dist/store/account.js
+/**
+* 数据目录解析（按优先级）：
+*  1. WECHAT_DATA_DIR：显式指定完整路径（最高优先级，便于任意自定义/多账号）。
+*  2. 否则 ~/.wemind/<account>，其中 <account> 取自 WECHAT_ACCOUNT，默认 "default"。
+* account.json / state.json / brain-sessions.json / brain-mcps.json / brain-home 等都落在此目录下。
+* 多账号即「不同 WECHAT_ACCOUNT（或 WECHAT_DATA_DIR）→ 不同目录 → 互相隔离」。
+*/
+const ACCOUNT_KEY = process.env.WECHAT_ACCOUNT?.trim() || "default";
+const DATA_DIR = process.env.WECHAT_DATA_DIR?.trim() || path.join(WEMIND_ROOT, ACCOUNT_KEY);
+function ensureDir(dir) {
+	fs.mkdirSync(dir, { recursive: true });
+}
+function readJson$2(filePath) {
+	let raw;
+	try {
+		raw = fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (e) {
+		console.error(`[wemind/wechat-ilink-core/store] ${filePath} parse failed, backing up and treating as empty: ${String(e)}`);
+		try {
+			fs.renameSync(filePath, `${filePath}.corrupt-${Date.now()}`);
+		} catch {}
+		return null;
+	}
+}
+/** 原子写：先写临时文件再 rename 覆盖（同盘 rename 原子），避免写途崩溃/并发产生半截损坏文件。 */
+function writeJson(filePath, data) {
+	ensureDir(path.dirname(filePath));
+	const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+	fs.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+	fs.renameSync(tmp, filePath);
+}
+function loadAccount() {
+	return readJson$2(path.join(DATA_DIR, "account.json"));
+}
+function loadState() {
+	return readJson$2(path.join(DATA_DIR, "state.json")) ?? {
+		updatesBuf: "",
+		contextTokens: {},
+		lastMessageId: 0
+	};
+}
+function saveState(state) {
+	writeJson(path.join(DATA_DIR, "state.json"), state);
+}
+function saveQrState(state) {
+	writeJson(path.join(DATA_DIR, "qr_login.json"), state);
+}
+//#endregion
+//#region ../wechat-ilink-core/dist/store/allow-from.js
+function filePath(dir = DATA_DIR) {
+	return path.join(dir, "allowFrom.json");
+}
+function readAllowFrom(dir = DATA_DIR) {
+	let raw;
+	try {
+		raw = fs.readFileSync(filePath(dir), "utf-8");
+	} catch {
+		return [];
+	}
+	try {
+		const j = JSON.parse(raw);
+		return Array.isArray(j.allowFrom) ? j.allowFrom.filter((x) => typeof x === "string" && !!x) : [];
+	} catch (e) {
+		console.error(`[wemind/wechat-ilink-core/allow-from] ${filePath(dir)} parse failed, backing up: ${String(e)}`);
+		try {
+			fs.renameSync(filePath(dir), `${filePath(dir)}.corrupt-${Date.now()}`);
+		} catch {}
+		return [];
+	}
+}
+/** 原子写：临时文件 + rename，避免写途崩溃/并发损坏这个安全闸文件。 */
+function writeAllowFrom(list, dir = DATA_DIR) {
+	fs.mkdirSync(dir, { recursive: true });
+	const uniq = [...new Set(list.filter((x) => typeof x === "string" && !!x))];
+	const fp = filePath(dir);
+	const tmp = `${fp}.tmp-${process.pid}-${Date.now()}`;
+	fs.writeFileSync(tmp, JSON.stringify({
+		version: 1,
+		allowFrom: uniq
+	}, null, 2), "utf-8");
+	fs.renameSync(tmp, fp);
+}
+/** 加入授权用户（去重）。返回更新后的清单。 */
+function addAllowFrom(userId, dir = DATA_DIR) {
+	const list = readAllowFrom(dir);
+	if (userId && !list.includes(userId)) list.push(userId);
+	writeAllowFrom(list, dir);
+	return list;
+}
+/** 移除授权用户。返回更新后的清单。 */
+function removeAllowFrom(userId, dir = DATA_DIR) {
+	const list = readAllowFrom(dir).filter((x) => x !== userId);
+	writeAllowFrom(list, dir);
+	return list;
+}
+/** 该 userId 是否被授权。 */
+function isAllowed(userId, dir = DATA_DIR) {
+	return !!userId && readAllowFrom(dir).includes(userId);
+}
+//#endregion
+//#region ../wechat-ilink-core/dist/cdn/image.js
+/**
+* 收图：从 iLink CDN 下载并 AES-128-ECB 解密图片。
+* 机制借鉴官方 Tencent/openclaw-weixin（MIT）的 cdn/pic-decrypt + cdn-url。
+*/
+const CDN_BASE_URL = process.env.WECHAT_CDN_BASE_URL?.trim() || "https://novac2c.cdn.weixin.qq.com/c2c";
+function decryptAesEcb(ciphertext, key) {
+	const d = createDecipheriv("aes-128-ecb", key, null);
+	return Buffer.concat([d.update(ciphertext), d.final()]);
+}
+/** 解析图片 AES key → 16 字节。aeskey 为 hex；media.aes_key 为 base64（可能是 base64(hex 字符串)）。 */
+function resolveKey$1(img) {
+	if (img.aeskey && /^[0-9a-fA-F]{32}$/.test(img.aeskey)) return Buffer.from(img.aeskey, "hex");
+	const b64 = img.media?.aes_key;
+	if (b64) {
+		const decoded = Buffer.from(b64, "base64");
+		if (decoded.length === 16) return decoded;
+		if (decoded.length === 32 && /^[0-9a-fA-F]{32}$/.test(decoded.toString("ascii"))) return Buffer.from(decoded.toString("ascii"), "hex");
+	}
+	return null;
+}
+/** 下载并解密一张图片，返回明文 Buffer（失败抛错）。 */
+async function downloadImage(img) {
+	const url = img.media?.full_url || (img.media?.encrypt_query_param ? `${CDN_BASE_URL}/download?encrypted_query_param=${encodeURIComponent(img.media.encrypt_query_param)}` : "");
+	if (!url) throw new Error("image: 无 full_url/encrypt_query_param");
+	const key = resolveKey$1(img);
+	if (!key) throw new Error("image: 无法解析 aes key");
+	const res = await fetch(url, { signal: AbortSignal.timeout(2e4) });
+	if (!res.ok) throw new Error(`image: CDN 下载失败 ${res.status}`);
+	return decryptAesEcb(Buffer.from(await res.arrayBuffer()), key);
+}
+/** AES-128-ECB 加密（PKCS7 默认）。 */
+function encryptAesEcb(plaintext, key) {
+	const c = createCipheriv("aes-128-ecb", key, null);
+	return Buffer.concat([c.update(plaintext), c.final()]);
+}
+/** AES-128-ECB 密文大小（PKCS7 补齐到 16 字节边界）。 */
+function aesEcbPaddedSize(plaintextSize) {
+	return Math.ceil((plaintextSize + 1) / 16) * 16;
+}
+/** 加密并上传一段 buffer 到 CDN，返回下载用的 encrypt_query_param（响应头 x-encrypted-param）。 */
+async function uploadBufferToCdn(params) {
+	const { buf, aeskey, filekey, uploadFullUrl, uploadParam } = params;
+	const ciphertext = encryptAesEcb(buf, aeskey);
+	const url = uploadFullUrl?.trim() || (uploadParam ? `${CDN_BASE_URL}/upload?encrypted_query_param=${encodeURIComponent(uploadParam)}&filekey=${encodeURIComponent(filekey)}` : "");
+	if (!url) throw new Error("upload: 无 upload_full_url/upload_param");
+	let lastErr;
+	for (let attempt = 1; attempt <= 3; attempt++) try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/octet-stream" },
+			body: new Uint8Array(ciphertext),
+			signal: AbortSignal.timeout(3e4)
+		});
+		if (res.status >= 400 && res.status < 500) throw new Error(`CDN 上传客户端错误 ${res.status}`);
+		if (res.status !== 200) throw new Error(`CDN 上传服务端错误 ${res.status}`);
+		const dp = res.headers.get("x-encrypted-param");
+		if (!dp) throw new Error("CDN 上传响应缺 x-encrypted-param");
+		return dp;
+	} catch (e) {
+		lastErr = e;
+		if (e instanceof Error && e.message.includes("客户端错误")) throw e;
+		if (attempt < 3) continue;
+	}
+	throw lastErr instanceof Error ? lastErr : /* @__PURE__ */ new Error("CDN 上传失败");
+}
+/** getUploadUrl + 加密上传，返回媒体引用所需信息。media_type 见 UploadMediaType。 */
+async function uploadMediaBytes(params) {
+	const { baseUrl, token, to, data, mediaType } = params;
+	const rawsize = data.length;
+	const rawfilemd5 = createHash("md5").update(data).digest("hex");
+	const filesize = aesEcbPaddedSize(rawsize);
+	const filekey = randomBytes(16).toString("hex");
+	const aeskey = randomBytes(16);
+	const up = await getUploadUrl({
+		baseUrl,
+		token,
+		filekey,
+		media_type: mediaType,
+		to_user_id: to,
+		rawsize,
+		rawfilemd5,
+		filesize,
+		no_need_thumb: true,
+		aeskey: aeskey.toString("hex")
+	});
+	const code = up.ret ?? up.errcode;
+	if (code !== void 0 && code !== 0) throw new ILinkError("getUploadUrl", code, up.errmsg);
+	return {
+		downloadParam: await uploadBufferToCdn({
+			buf: data,
+			aeskey,
+			filekey,
+			uploadFullUrl: up.upload_full_url,
+			uploadParam: up.upload_param
+		}),
+		aeskeyHex: aeskey.toString("hex"),
+		filesize,
+		rawsize
+	};
+}
+/** 拼 CDN media 引用（消息里给接收方下载+解密用）。 */
+function buildMediaRef(downloadParam, aeskeyHex) {
+	return {
+		encrypt_query_param: downloadParam,
+		aes_key: Buffer.from(aeskeyHex).toString("base64"),
+		encrypt_type: 1
+	};
+}
+const IMAGE_EXTS = /* @__PURE__ */ new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".bmp"
+]);
+const VIDEO_EXTS = /* @__PURE__ */ new Set([
+	".mp4",
+	".mov",
+	".webm",
+	".mkv",
+	".avi"
+]);
+/** 按文件名扩展名判定媒体类别（借鉴 wxclawbot media.ts classifyMedia）。其余一律按文件发送。 */
+function classifyMediaByName(name) {
+	const i = name.lastIndexOf(".");
+	const ext = i >= 0 ? name.slice(i).toLowerCase() : "";
+	if (IMAGE_EXTS.has(ext)) return "image";
+	if (VIDEO_EXTS.has(ext)) return "video";
+	return "file";
+}
+const UPLOAD_TYPE_BY_KIND = {
+	image: UploadMediaType.IMAGE,
+	video: UploadMediaType.VIDEO,
+	file: UploadMediaType.FILE
+};
+/** 主动发一张图片给用户（需 context_token，与发文本相同）。image 为图片明文 buffer。 */
+async function sendImage(params) {
+	const { baseUrl, token, to, image, contextToken } = params;
+	const { downloadParam, aeskeyHex, filesize } = await uploadMediaBytes({
+		baseUrl,
+		token,
+		to,
+		data: image,
+		mediaType: UploadMediaType.IMAGE
+	});
+	await sendMessage({
+		baseUrl,
+		token,
+		body: { msg: {
+			from_user_id: "",
+			to_user_id: to,
+			client_id: generateId("img"),
+			message_type: MessageType.BOT,
+			message_state: MessageState.FINISH,
+			item_list: [{
+				type: MessageItemType.IMAGE,
+				image_item: {
+					media: buildMediaRef(downloadParam, aeskeyHex),
+					mid_size: filesize
+				}
+			}],
+			context_token: contextToken
+		} }
+	});
+}
+/**
+* 主动发一个文件/视频/图片给用户（需 context_token）。
+* 类别按 fileName 扩展名自动判定（image/video/file），也可用 kind 显式指定。
+* 借鉴 wxclawbot media.ts 的类型识别与 item 组装；上传链路复用 WeMind 自有实现。
+*/
+async function sendFile(params) {
+	const { baseUrl, token, to, data, fileName, contextToken } = params;
+	const kind = params.kind ?? classifyMediaByName(fileName);
+	const { downloadParam, aeskeyHex, filesize, rawsize } = await uploadMediaBytes({
+		baseUrl,
+		token,
+		to,
+		data,
+		mediaType: UPLOAD_TYPE_BY_KIND[kind]
+	});
+	const media = buildMediaRef(downloadParam, aeskeyHex);
+	let item;
+	if (kind === "image") item = {
+		type: MessageItemType.IMAGE,
+		image_item: {
+			media,
+			mid_size: filesize
+		}
+	};
+	else if (kind === "video") item = {
+		type: MessageItemType.VIDEO,
+		video_item: {
+			media,
+			video_size: filesize
+		}
+	};
+	else item = {
+		type: MessageItemType.FILE,
+		file_item: {
+			media,
+			file_name: fileName,
+			len: String(rawsize)
+		}
+	};
+	await sendMessage({
+		baseUrl,
+		token,
+		body: { msg: {
+			from_user_id: "",
+			to_user_id: to,
+			client_id: generateId("media"),
+			message_type: MessageType.BOT,
+			message_state: MessageState.FINISH,
+			item_list: [item],
+			context_token: contextToken
+		} }
+	});
+}
+//#endregion
+//#region src/brain-agents.ts
+/**
+* 已知 ACP agent 预设。
+* - `kiro` 为默认且**已实测**。
+* - 其余均为**示例（未实测）**：参数/包名以各自官方为准，接入前请核对（见 docs/接入其它-ACP-Agent.md）。
+* - 区别两类：① **原生 ACP**（CLI 自带 ACP 模式，直接起，如 kiro、gemini）；
+*   ② **需适配器**（CLI 本身不说 ACP，要起一个适配器进程，如 Claude Code、Codex）。
+*/
+const ACP_AGENT_PRESETS = {
+	kiro: {
+		name: "kiro",
+		bin: "kiro-cli",
+		binWin: "kiro-cli.exe",
+		args: ["acp", "--trust-all-tools"],
+		homeEnvVar: "KIRO_HOME",
+		realHome: path.join(os.homedir(), ".kiro"),
+		inheritDirs: [
+			"steering",
+			"memories",
+			"skills",
+			"agents",
+			"powers",
+			"tasks",
+			"extensions"
+		]
+	},
+	gemini: {
+		name: "gemini",
+		bin: "gemini",
+		binWin: "gemini.cmd",
+		args: ["--experimental-acp"],
+		homeEnvVar: "GEMINI_CLI_HOME",
+		shell: true
+	},
+	opencode: {
+		name: "opencode",
+		bin: "opencode",
+		binWin: "opencode",
+		args: ["acp"],
+		shell: true,
+		homeEnvVar: "XDG_CONFIG_HOME",
+		realHome: path.join(os.homedir(), ".config", "opencode"),
+		inheritDirs: [
+			"skills",
+			"agents",
+			"commands"
+		],
+		inheritFiles: ["AGENTS.md"],
+		configSubdir: "opencode",
+		mcpFormat: "opencode",
+		mcpConfigFile: "opencode.json",
+		catalogFile: "opencode.json",
+		env: { OPENCODE_DISABLE_PROJECT_CONFIG: "1" }
+	},
+	deepseek: {
+		name: "deepseek",
+		bin: "dsh",
+		binWin: "dsh.cmd",
+		args: ["--profile", "acp"],
+		shell: true,
+		homeEnvVar: "DSH_HOME",
+		realHome: path.join(os.homedir(), ".dsh"),
+		inheritDirs: ["skills"],
+		inheritFiles: ["AGENTS.md"],
+		credentialFile: ".credentials.yaml",
+		restore: "resume",
+		firstFrameMs: 6e4,
+		heartbeatMs: 6e4,
+		images: false,
+		model: "[\"deepseek-account\",\"deepseek-flash\"]",
+		mcpViaAcp: true
+	},
+	"claude-code": {
+		name: "claude-code",
+		bin: "npx",
+		binWin: "npx.cmd",
+		args: ["-y", "@zed-industries/claude-code-acp"],
+		shell: true
+	},
+	codex: {
+		name: "codex",
+		bin: "codex-acp",
+		binWin: "codex-acp.exe",
+		args: []
+	}
+};
+function onPath(exe) {
+	for (const dir of (process.env.PATH ?? "").split(path.delimiter)) if (dir && fs.existsSync(path.join(dir, exe))) return path.join(dir, exe);
+	return null;
+}
+/**
+* `auto` 的探测顺序：按序取第一个「二进制能在 PATH 上解析到」的预设。
+* 只收纳**原生 ACP 且二进制可直接判定**的预设——适配器类（`claude-code` 走 `npx`、
+* `codex` 走 `codex-acp`）不参与自动探测（`npx` 几乎总在 PATH 上，会把它们误选出来）。
+*/
+const AUTO_PROBE_ORDER = [
+	"kiro",
+	"opencode",
+	"gemini",
+	"deepseek"
+];
+/** 预设在该平台的「可执行文件名」（用于 PATH 探测）。 */
+function presetExe(preset) {
+	return process.platform === "win32" ? preset.binWin ?? `${preset.bin}.exe` : preset.bin;
+}
+/** 预设的二进制是否能在 PATH 上解析到（只判定、不启动）。 */
+function presetAvailable(key) {
+	const preset = ACP_AGENT_PRESETS[key];
+	return !!preset && onPath(presetExe(preset)) !== null;
+}
+/**
+* 解析一个 bin 说明（绝对/相对路径，或 PATH 上的裸名）到实际文件；解析不到返回 null。
+* 裸名在 Windows 上会补试 `.exe`/`.cmd`，覆盖 npm shim 的常见布局。
+*/
+function locateBin(bin) {
+	if (!bin) return null;
+	if (bin.includes("/") || bin.includes(path.sep)) return fs.existsSync(bin) ? bin : null;
+	const candidates = [bin];
+	if (process.platform === "win32" && !/\.[A-Za-z0-9]+$/.test(bin)) candidates.push(`${bin}.exe`, `${bin}.cmd`);
+	for (const c of candidates) {
+		const hit = onPath(c);
+		if (hit) return hit;
+	}
+	return null;
+}
+/** 解析当前要用的 ACP agent：环境变量 > 账号 brain.json > auto。 */
+function resolveAgent(cfg) {
+	const envKey = process.env.WEMIND_BRAIN?.trim();
+	const fileKey = cfg?.agent?.trim();
+	const requestedKey = (envKey || fileKey || "auto").toLowerCase();
+	const source = envKey ? "env" : fileKey ? "file" : "auto";
+	let known = true;
+	let key = requestedKey;
+	if (key === "auto") key = AUTO_PROBE_ORDER.find((k) => presetAvailable(k)) ?? "kiro";
+	else if (!ACP_AGENT_PRESETS[key]) {
+		known = false;
+		key = "kiro";
+	}
+	const preset = ACP_AGENT_PRESETS[key];
+	const shellEnv = process.env.WEMIND_BRAIN_SHELL?.trim();
+	const shell = shellEnv !== void 0 && shellEnv !== "" ? shellEnv === "1" || shellEnv.toLowerCase() === "true" : cfg?.shell ?? preset.shell ?? false;
+	const explicitBin = process.env.WEMIND_BRAIN_BIN?.trim() || (preset.name === "kiro" ? process.env.KIRO_CLI_BIN?.trim() : void 0) || cfg?.bin?.trim() || "";
+	const exe = presetExe(preset);
+	const binPath = explicitBin ? locateBin(explicitBin) : onPath(exe);
+	const bin = explicitBin || (shell ? process.platform === "win32" ? exe : preset.bin : binPath || preset.bin);
+	const available = known && binPath !== null;
+	const argsOverride = process.env.WEMIND_BRAIN_ARGS?.trim();
+	const args = argsOverride ? argsOverride.split(/\s+/) : cfg?.args && cfg.args.length ? cfg.args : preset.args;
+	const homeEnvVar = process.env.WEMIND_BRAIN_HOME_ENV?.trim() || cfg?.homeEnvVar?.trim() || preset.homeEnvVar;
+	const inherit = (process.env.WEMIND_BRAIN_INHERIT ?? process.env.WECHAT_BRAIN_INHERIT ?? "1") !== "0";
+	const realHome = process.env.WEMIND_BRAIN_REAL_HOME?.trim() || process.env.WECHAT_REAL_KIRO_HOME?.trim() || preset.realHome;
+	const dirsEnv = process.env.WEMIND_BRAIN_INHERIT_DIRS?.trim();
+	const inheritDirs = dirsEnv ? dirsEnv.split(/[,\s]+/).filter(Boolean) : preset.inheritDirs ?? [];
+	return {
+		name: preset.name,
+		bin,
+		args,
+		homeEnvVar,
+		shell,
+		inherit,
+		realHome,
+		inheritDirs,
+		inheritFiles: preset.inheritFiles ?? [],
+		configSubdir: preset.configSubdir ?? "",
+		mcpFormat: preset.mcpFormat ?? "kiro",
+		mcpConfigFile: preset.mcpConfigFile ?? "settings/mcp.json",
+		catalogFile: preset.catalogFile ?? "settings/mcp.json",
+		env: preset.env ?? {},
+		restore: preset.restore,
+		firstFrameMs: preset.firstFrameMs,
+		heartbeatMs: preset.heartbeatMs,
+		images: preset.images ?? true,
+		credentialFile: preset.credentialFile,
+		model: preset.model,
+		mcpViaAcp: preset.mcpViaAcp ?? false,
+		requestedKey,
+		source,
+		known,
+		available,
+		binPath
+	};
+}
+/**
+* 校验解析后的大脑是否可用：可用返回 null，否则返回一句面向用户的说明。
+* 供 daemon 启动校验（早失败、说人话）与 `wemind brain` / `wemind brain check` 复用。
+*/
+function agentProblem(ag) {
+	if (!ag.known) return `未知大脑预设「${ag.requestedKey}」。可选：${Object.keys(ACP_AGENT_PRESETS).join("、")}（自定义二进制可用 WEMIND_BRAIN_BIN 或 brain set --bin 指定）`;
+	if (ag.requestedKey === "auto" && !ag.available) return `自动探测未找到可用的大脑（已试：${AUTO_PROBE_ORDER.join("、")}）。请安装其中之一，或运行 \`wemind brain set <预设>\``;
+	if (!ag.available) return ag.name === "deepseek" ? `找不到 DeepSeek 的「${ag.bin}」。桌面端通常有 dsh.cmd；把它的绝对路径传给 \`wemind brain set deepseek --bin "<...>\\dsh.cmd"\`` : `找不到大脑「${ag.name}」的二进制「${ag.bin}」。安装它，或运行 \`wemind brain set <预设>\` 切换`;
+	return null;
+}
+//#endregion
+//#region src/brain-config.ts
+/** brain.json 的完整路径（默认当前账号数据目录）。 */
+function brainConfigPath(dir = DATA_DIR) {
+	return path.join(dir, "brain.json");
+}
+/**
+* 读取账号的大脑配置；缺失/损坏/无有效 agent 一律返回 null（幂等、不抛）。
+* 字段做了宽松归一化：args 允许字符串（空格分隔）或数组；未知字段忽略。
+*/
+function loadBrainConfig(dir = DATA_DIR) {
+	let j;
+	try {
+		j = JSON.parse(fs.readFileSync(brainConfigPath(dir), "utf-8"));
+	} catch {
+		return null;
+	}
+	if (!j || typeof j !== "object" || Array.isArray(j)) return null;
+	const agent = typeof j.agent === "string" ? j.agent.trim() : "";
+	if (!agent) return null;
+	const cfg = { agent };
+	if (typeof j.bin === "string" && j.bin.trim()) cfg.bin = j.bin.trim();
+	if (Array.isArray(j.args)) cfg.args = j.args.filter((x) => typeof x === "string");
+	else if (typeof j.args === "string" && j.args.trim()) cfg.args = j.args.trim().split(/\s+/);
+	if (typeof j.shell === "boolean") cfg.shell = j.shell;
+	if (typeof j.homeEnvVar === "string" && j.homeEnvVar.trim()) cfg.homeEnvVar = j.homeEnvVar.trim();
+	return cfg;
+}
+/** 原子写入账号的大脑配置（临时文件 + rename，避免读到半截）。 */
+function saveBrainConfig(cfg, dir = DATA_DIR) {
+	fs.mkdirSync(dir, { recursive: true });
+	const fp = brainConfigPath(dir);
+	const tmp = `${fp}.tmp`;
+	fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+	fs.renameSync(tmp, fp);
+}
+/** 清除账号的大脑配置（回到自动探测/默认）；返回是否确有文件被删。 */
+function clearBrainConfig(dir = DATA_DIR) {
+	try {
+		fs.unlinkSync(brainConfigPath(dir));
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/agent-mcp.ts
+function isObj(v) {
+	return !!v && typeof v === "object" && !Array.isArray(v);
+}
+/** 从配置对象读出 server 定义表（按格式）；缺失/异常一律返回空表。 */
+function readMcpServers(obj, format) {
+	if (!isObj(obj)) return {};
+	const servers = format === "opencode" ? isObj(obj.mcp) ? obj.mcp.servers : void 0 : obj.mcpServers;
+	return isObj(servers) ? servers : {};
+}
+/** 把 server 定义表写回配置对象（按格式），返回**新对象**（不改原对象），并保留其它键（如 opencode 的 model）。 */
+function withMcpServers(obj, servers, format) {
+	const base = isObj(obj) ? { ...obj } : {};
+	if (format === "opencode") {
+		const mcp = isObj(base.mcp) ? { ...base.mcp } : {};
+		mcp.servers = servers;
+		base.mcp = mcp;
+	} else base.mcpServers = servers;
+	return base;
+}
+/**
+* 宽松解析 JSONC（去 // 与块注释、去尾随逗号）。仅用于把用户可能带注释的
+* opencode.jsonc 读成对象；失败返回 null（调用方按「无配置」处理，不抛）。
+*/
+function parseJsonc(text) {
+	try {
+		return JSON.parse(text);
+	} catch {}
+	try {
+		const cleaned = text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/,(\s*[}\]])/g, "$1");
+		const parsed = JSON.parse(cleaned);
+		return isObj(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function envEntries(map) {
+	if (!isObj(map)) return [];
+	return Object.entries(map).filter(([, v]) => v !== void 0 && v !== null).map(([name, v]) => ({
+		name,
+		value: String(v)
+	}));
+}
+/**
+* 把 catalog 的 server 定义表转成 ACP `mcpServers`（stdio / HTTP）。
+* - kiro `{ command, args, env }` → stdio；
+* - opencode `{ type:"local", command:[...], environment }` → stdio（拆 command[0]/args）；
+* - `{ url }`（kiro 远程 / opencode remote）→ HTTP（SSE 不被 ACP 支持，无法从定义识别，由服务端拒绝）。
+* 返回转换结果与**被跳过的名字**（结构不认识/明显残缺）——调用方记日志，避免坏条目把整个 session 拖挂。
+*/
+function toAcpMcpServers(servers, opts = {}) {
+	const exclude = new Set(opts.exclude ?? []);
+	const out = [];
+	const skipped = [];
+	for (const [name, entry] of Object.entries(servers)) {
+		if (exclude.has(name)) continue;
+		if (!isObj(entry)) {
+			skipped.push(name);
+			continue;
+		}
+		if (Array.isArray(entry.command)) {
+			const cmd = entry.command[0];
+			if (typeof cmd !== "string" || !cmd) {
+				skipped.push(name);
+				continue;
+			}
+			out.push({
+				name,
+				command: cmd,
+				args: entry.command.slice(1).map(String),
+				env: envEntries(entry.environment ?? entry.env)
+			});
+			continue;
+		}
+		if (typeof entry.command === "string" && entry.command) {
+			out.push({
+				name,
+				command: entry.command,
+				args: Array.isArray(entry.args) ? entry.args.map(String) : [],
+				env: envEntries(entry.env)
+			});
+			continue;
+		}
+		if (typeof entry.url === "string" && entry.url) {
+			const rawHeaders = entry.headers;
+			const headers = isObj(rawHeaders) ? envEntries(rawHeaders) : Array.isArray(rawHeaders) ? rawHeaders.filter((h) => isObj(h) && typeof h.name === "string").map((h) => ({
+				name: String(h.name),
+				value: String(h.value ?? "")
+			})) : [];
+			out.push({
+				name,
+				type: "http",
+				url: entry.url,
+				headers
+			});
+			continue;
+		}
+		skipped.push(name);
+	}
+	return {
+		servers: out,
+		skipped
+	};
+}
+//#endregion
+//#region src/mcp-sandbox.ts
+/**
+* brain 的 MCP 沙箱：brain 跑在独立配置目录下，默认不加载任何 MCP。
+* 通过对话指令（加载/卸载/列出）动态调整「激活集」，从全局 MCP 目录取定义写入沙箱。
+* DATA_DIR 从 core 导入（支持 WECHAT_DATA_DIR 覆盖，便于多账号隔离）。
+*
+* 按 agent 适配（见 brain-agents.ts 预设与 docs/接入-OpenCode.md）：
+* - 配置目录：kiro = 沙箱根（KIRO_HOME）；opencode = <沙箱>/opencode（XDG_CONFIG_HOME）。
+* - MCP 文件：kiro = settings/mcp.json（{mcpServers}）；opencode = opencode.json（mcp.servers）。
+* kiro 行为与改造前完全一致（默认值即 kiro 约定）。
+*/
+const AG$1 = resolveAgent(loadBrainConfig());
+/** brain 专用沙箱根目录（由 agent 的 homeEnvVar 指向它）。 */
+const BRAIN_HOME = process.env.WECHAT_BRAIN_HOME?.trim() || path.join(DATA_DIR, "brain-home");
+/** 该 agent 在沙箱里的「配置目录」（kiro=沙箱根；opencode=<沙箱>/opencode）。 */
+const BRAIN_CONFIG_DIR = path.join(BRAIN_HOME, AG$1.configSubdir);
+/** MCP 配置文件（相对配置目录，按 agent 的 mcpConfigFile）。 */
+const BRAIN_MCP_JSON = path.join(BRAIN_CONFIG_DIR, AG$1.mcpConfigFile);
+/** 激活集持久化文件。 */
+const ACTIVE_FILE = path.join(DATA_DIR, "brain-mcps.json");
+/** 「目录」：可选 MCP 的定义来源。默认取所用 agent 真实配置目录（realHome）下的
+*  catalogFile（kiro: settings/mcp.json / opencode: opencode.json）；可用
+*  `WEMIND_MCP_CATALOG` / `WECHAT_MCP_CATALOG` 覆盖为任意路径。 */
+const CATALOG$1 = process.env.WEMIND_MCP_CATALOG?.trim() || process.env.WECHAT_MCP_CATALOG?.trim() || path.join(AG$1.realHome || path.join(os.homedir(), ".kiro"), AG$1.catalogFile);
+/** 永不允许 brain 加载（防回环）。 */
+const FORBIDDEN = /* @__PURE__ */ new Set(["wechat"]);
+/**
+* 让 brain 继承所用 agent 真实配置目录的「知识/记忆/技能」：
+* - 目录式（inheritDirs，如 kiro 的 steering/memories/skills、opencode 的 skills/agents/commands）用
+*   目录 junction（Windows）/ symlink 指向真实目录；
+* - 单文件式（inheritFiles，如 opencode 的 AGENTS.md）直接拷入配置目录。
+* 使微信里的大脑和你日常使用读到同样的记忆、规则、技能。
+* **MCP（settings/opencode.json 的 mcp 段）与 brain 自有会话（sessions）不镜像**：MCP 必须走沙箱（排除 wechat 防回环），会话不能混。
+*/
+function mirrorRealKiro$1() {
+	if (!AG$1.inherit || !AG$1.realHome) return;
+	if (path.resolve(BRAIN_HOME) === path.resolve(AG$1.realHome)) return;
+	try {
+		fs.mkdirSync(BRAIN_CONFIG_DIR, { recursive: true });
+	} catch {}
+	for (const d of AG$1.inheritDirs) {
+		const target = path.join(AG$1.realHome, d);
+		const link = path.join(BRAIN_CONFIG_DIR, d);
+		if (!fs.existsSync(target)) continue;
+		let present = false;
+		try {
+			fs.lstatSync(link);
+			present = true;
+		} catch {}
+		if (present) try {
+			const st = fs.lstatSync(link);
+			if (st.isSymbolicLink()) continue;
+			if (st.isDirectory()) if (fs.readdirSync(link).length === 0) fs.rmdirSync(link);
+			else {
+				for (const f of fs.readdirSync(target)) {
+					const dst = path.join(link, f);
+					const src = path.join(target, f);
+					try {
+						if (!fs.existsSync(dst) && fs.statSync(src).isFile()) fs.copyFileSync(src, dst);
+					} catch {}
+				}
+				continue;
+			}
+			else continue;
+		} catch {
+			continue;
+		}
+		try {
+			fs.symlinkSync(target, link, process.platform === "win32" ? "junction" : "dir");
+		} catch {}
+	}
+	for (const f of AG$1.inheritFiles) {
+		const src = path.join(AG$1.realHome, f);
+		const dst = path.join(BRAIN_CONFIG_DIR, f);
+		try {
+			if (fs.existsSync(src) && !fs.existsSync(dst)) fs.copyFileSync(src, dst);
+		} catch {}
+	}
+}
+function readJson$1(file) {
+	try {
+		return JSON.parse(fs.readFileSync(file, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/**
+* 把 agent 的凭据文件同步进沙箱（如 DSH 的 `.credentials.yaml`）。
+* 新者胜：首次复制；真实 home 的 token 刷新后覆盖沙箱；沙箱自己刷新过则保留沙箱版本。
+* 这是敏感文件，仅放在账号沙箱内；Windows 无 POSIX 600，建议专用账号 + 目录 ACL。
+*/
+function syncCredentialFile$1() {
+	if (!AG$1.credentialFile || !AG$1.realHome) return;
+	const src = path.join(AG$1.realHome, AG$1.credentialFile);
+	const dst = path.join(BRAIN_CONFIG_DIR, AG$1.credentialFile);
+	try {
+		if (!fs.existsSync(src)) return;
+		fs.mkdirSync(path.dirname(dst), { recursive: true });
+		const s = fs.statSync(src);
+		const d = fs.existsSync(dst) ? fs.statSync(dst) : null;
+		if (!d || s.mtimeMs > d.mtimeMs + 1e3) fs.copyFileSync(src, dst);
+	} catch {}
+}
+function loadCatalog$1() {
+	return readMcpServers(readJson$1(CATALOG$1), AG$1.mcpFormat);
+}
+/** 目录中可选的 server 名（排除禁用项）。 */
+function catalogNames() {
+	return Object.keys(loadCatalog$1()).filter((n) => !FORBIDDEN.has(n));
+}
+function loadActive() {
+	const a = readJson$1(ACTIVE_FILE)?.active;
+	return Array.isArray(a) ? a.filter((x) => typeof x === "string") : [];
+}
+function saveActive(list) {
+	fs.mkdirSync(DATA_DIR, { recursive: true });
+	fs.writeFileSync(ACTIVE_FILE, JSON.stringify({ active: list }, null, 2), "utf-8");
+}
+/** 按激活集从目录取定义，写入沙箱 MCP 配置（默认空）。保留配置里其它键（如 opencode 的 model）。
+*  `mcpViaAcp` 预设（DSH）不写文件——激活集经 activeMcpServers() 转成 ACP mcpServers 随 session 下发。 */
+function applySandbox() {
+	if (AG$1.mcpViaAcp) return;
+	const cat = loadCatalog$1();
+	const active = loadActive().filter((n) => cat[n] && !FORBIDDEN.has(n));
+	const servers = {};
+	for (const n of active) servers[n] = cat[n];
+	const next = withMcpServers(readJson$1(BRAIN_MCP_JSON) ?? {}, servers, AG$1.mcpFormat);
+	fs.mkdirSync(path.dirname(BRAIN_MCP_JSON), { recursive: true });
+	fs.writeFileSync(BRAIN_MCP_JSON, JSON.stringify(next, null, 2), "utf-8");
+}
+/** brain 当前应挂载的 ACP mcpServers（mcpViaAcp 预设用）：激活集 → catalog 定义 → ACP 声明。
+*  跳过不可转换的坏条目并记日志——官方 DSH 的 session/new 遇到起不来的 MCP 会回滚整个会话。 */
+function activeMcpServers() {
+	const cat = loadCatalog$1();
+	const active = loadActive().filter((n) => cat[n] && !FORBIDDEN.has(n));
+	const picked = {};
+	for (const n of active) picked[n] = cat[n];
+	const { servers, skipped } = toAcpMcpServers(picked, { exclude: FORBIDDEN });
+	if (skipped.length) console.error(`[wemind/wechat-daemon/mcp] 跳过无法转换的 MCP：${skipped.join(", ")}`);
+	return servers;
+}
+/** kiro：继承真实 settings/ 下除 mcp.json 外的文件（cli.json 含模型/免确认等），让大脑与日常使用同款配置。 */
+function syncKiroSettings$1() {
+	const realSettings = path.join(AG$1.realHome, "settings");
+	const brainSettings = path.join(BRAIN_CONFIG_DIR, "settings");
+	if (!fs.existsSync(realSettings)) return;
+	try {
+		fs.mkdirSync(brainSettings, { recursive: true });
+	} catch {}
+	let names = [];
+	try {
+		names = fs.readdirSync(realSettings);
+	} catch {
+		return;
+	}
+	for (const f of names) {
+		if (f === "mcp.json") continue;
+		try {
+			const src = path.join(realSettings, f);
+			if (fs.statSync(src).isFile()) fs.copyFileSync(src, path.join(brainSettings, f));
+		} catch {}
+	}
+}
+/** opencode：把用户全局 opencode.json(c)（去掉 mcp 段）作为基底写进沙箱，继承 model 等设置；mcp 仍由 applySandbox 权威覆盖。 */
+function syncOpencodeBase$1() {
+	const src = ["opencode.json", "opencode.jsonc"].map((f) => path.join(AG$1.realHome, f)).find((f) => fs.existsSync(f));
+	if (!src) return;
+	let parsed = null;
+	try {
+		const raw = fs.readFileSync(src, "utf-8");
+		parsed = src.endsWith(".jsonc") ? parseJsonc(raw) : JSON.parse(raw);
+	} catch {
+		return;
+	}
+	if (!parsed || typeof parsed !== "object") return;
+	delete parsed.mcp;
+	fs.mkdirSync(BRAIN_CONFIG_DIR, { recursive: true });
+	fs.writeFileSync(BRAIN_MCP_JSON, JSON.stringify(parsed, null, 2), "utf-8");
+}
+/** 继承真实配置目录的「非 MCP」设置（模型/免确认等），让大脑与日常使用同款配置；mcp 段保持沙箱权威。
+*  `mcpViaAcp` 预设没有文件式 MCP/settings 可继承，跳过（模型走 preset.model + set_config_option）。 */
+function syncSettings$1() {
+	if (AG$1.mcpViaAcp) return;
+	if (!AG$1.inherit || !AG$1.realHome) return;
+	if (AG$1.mcpFormat === "opencode") syncOpencodeBase$1();
+	else syncKiroSettings$1();
+}
+/** 启动时确保沙箱存在并与激活集一致。 */
+function ensureBrainHome() {
+	syncSettings$1();
+	applySandbox();
+	mirrorRealKiro$1();
+	syncCredentialFile$1();
+}
+function addMcp(name) {
+	if (FORBIDDEN.has(name)) return `不允许加载「${name}」（防回环）。`;
+	const cat = loadCatalog$1();
+	if (!cat[name]) return `未找到 MCP「${name}」。可选：${catalogNames().join(", ") || "（无）"}`;
+	if (AG$1.mcpViaAcp && !toAcpMcpServers({ [name]: cat[name] }).servers.length) return `MCP「${name}」的定义无法转换（需要 command 或 url），已拒绝加载。`;
+	const a = loadActive();
+	if (!a.includes(name)) {
+		a.push(name);
+		saveActive(a);
+	}
+	applySandbox();
+	return `已加载 MCP「${name}」。当前激活：${a.join(", ")}（下一条消息生效）`;
+}
+function removeMcp(name) {
+	const a = loadActive();
+	if (!a.includes(name)) return `「${name}」当前未激活。`;
+	const next = a.filter((x) => x !== name);
+	saveActive(next);
+	applySandbox();
+	return `已卸载 MCP「${name}」。当前激活：${next.join(", ") || "（空）"}`;
+}
+function listMcp() {
+	const avail = catalogNames();
+	const active = loadActive();
+	return `可选 MCP：${avail.join(", ") || "（无）"}\n已激活：${active.join(", ") || "（空，默认不加载）"}`;
+}
+//#endregion
+//#region src/spawn-agent.ts
+/** cmd 需要加引号的字符：空白 + 元字符（不加引号时 cmd 会自行解释：`&` 断命令、`|` 管道…）。 */
+const CMD_NEEDS_QUOTE = /[\s"&|<>^()%!]/;
+/**
+* cmd.exe（MS CRT）参数转义：无空白/元字符则裸写；否则用双引号包裹，
+* 并按其规则处理引号前的前导反斜杠与结尾反斜杠。
+* 注：引号挡得住元字符，但挡不住 `%VAR%` 展开（cmd 命令行无法转义 `%`），与改动前行为一致。
+*/
+function quoteCmdArg(arg) {
+	if (arg === "") return "\"\"";
+	if (!CMD_NEEDS_QUOTE.test(arg)) return arg;
+	return `"${arg.replace(/(\\*)"/g, "$1$1\\\"").replace(/(\\+)$/, "$1$1")}"`;
+}
+/** POSIX sh 参数转义：安全字符集裸写，否则单引号包裹（内部单引号写成 `'\''`）。 */
+function quoteShArg(arg) {
+	if (arg === "") return "''";
+	if (!/[^\w@%+=:,./-]/.test(arg)) return arg;
+	return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+/** 把 `bin + args` 拼成一条交给 shell 的命令行（`platform` 仅为可测性暴露）。 */
+function buildShellLine(bin, args, platform = process.platform) {
+	const quote = platform === "win32" ? quoteCmdArg : quoteShArg;
+	return [bin, ...args].map(quote).join(" ");
+}
+/**
+* 启动 agent：`shell=true` 的走「整串命令行 + shell」（见文件头注释），其余直接 spawn。
+* 默认 `windowsHide: true`（不闪控制台窗口），其余选项透传。
+*/
+function spawnAgent(agent, opts = {}) {
+	const base = {
+		windowsHide: true,
+		...opts
+	};
+	if (!agent.shell) return spawn(agent.bin, agent.args, base);
+	return spawn(buildShellLine(agent.bin, agent.args), {
+		...base,
+		shell: true
+	});
+}
+//#endregion
+//#region src/acp-brain.ts
+/**
+* ACP 大脑：维护一个常驻的 ACP agent 进程（JSON-RPC over stdio，换行分隔）。
+* 通过标准 ACP 协议驱动，agent 可配置（默认 kiro-cli，见 brain-agents.ts），任意兼容 ACP 的 CLI 均可接入。
+* - 每用户一个 ACP session（原生多轮记忆）；session 映射持久化到磁盘。
+* - 自愈：session/prompt 超时/失败 → 杀进程重建；重建后用 session/load 恢复上下文。
+* - 诊断日志（[wemind/wechat-daemon/acp] 前缀，进 daemon.log）：发出请求、收帧、超时时已收 chunk 数与最后收帧时间差。
+* 跑在 brain 沙箱目录下（默认空 MCP），通过 agent 配置的环境变量把该目录传给 agent。
+*/
+function dlog$1(...a) {
+	console.error("[wemind/wechat-daemon/acp]", ...a);
+}
+const AGENT$1 = resolveAgent(loadBrainConfig());
+const REQ_TIMEOUT$1 = 3e4;
+const PROMPT_IDLE_MS$1 = Number(process.env.WECHAT_BRAIN_IDLE_MS) || 12e4;
+const PROMPT_CAP_MS$1 = Number(process.env.WECHAT_BRAIN_CAP_MS) || 9e5;
+const FIRST_FRAME_MS$1 = Number(process.env.WECHAT_BRAIN_FIRST_FRAME_MS) || AGENT$1.firstFrameMs || 25e3;
+const SESSION_MAP_FILE$1 = path.join(DATA_DIR, "brain-sessions.json");
+const BRAIN_PID_FILE = path.join(DATA_DIR, "brain.pid");
+let child$1 = null;
+let initialized$1 = false;
+let idCounter$1 = 0;
+const pending$1 = /* @__PURE__ */ new Map();
+const userSessions = /* @__PURE__ */ new Map();
+const assembling$1 = /* @__PURE__ */ new Map();
+let stdoutBuf$1 = "";
+let lastFrameAt$1 = 0;
+let frameSeq$1 = 0;
+let currentOnProgress$1 = null;
+let answerStarted$1 = false;
+let thoughtStarted$1 = false;
+const seenUpdateTypes$1 = /* @__PURE__ */ new Set();
+const seenTools$1 = /* @__PURE__ */ new Set();
+const hintedSessions = /* @__PURE__ */ new Set();
+function isAlive$1() {
+	return !!child$1 && child$1.exitCode === null && !child$1.killed;
+}
+/** 杀进程（按 PID 进程树）并清空内部态；不清磁盘 session 映射（留给重建后 load）。 */
+function reset$1() {
+	const c = child$1;
+	child$1 = null;
+	initialized$1 = false;
+	if (c?.pid) try {
+		if (process.platform === "win32") spawnSync("taskkill", [
+			"/PID",
+			String(c.pid),
+			"/T",
+			"/F"
+		], {
+			stdio: "ignore",
+			windowsHide: true
+		});
+		else c.kill();
+	} catch {}
+	try {
+		fs.unlinkSync(BRAIN_PID_FILE);
+	} catch {}
+	for (const p of pending$1.values()) {
+		p.clear();
+		p.reject(/* @__PURE__ */ new Error("acp process reset"));
+	}
+	pending$1.clear();
+	userSessions.clear();
+	assembling$1.clear();
+	stdoutBuf$1 = "";
+}
+function loadSessionMap$1() {
+	try {
+		const j = JSON.parse(fs.readFileSync(SESSION_MAP_FILE$1, "utf-8"));
+		return j && typeof j === "object" ? j : {};
+	} catch {
+		return {};
+	}
+}
+function saveSessionMap$1(m) {
+	fs.mkdirSync(DATA_DIR, { recursive: true });
+	fs.writeFileSync(SESSION_MAP_FILE$1, JSON.stringify(m, null, 2), "utf-8");
+}
+function handleReverseRequest$1(f) {
+	const method = String(f.method);
+	dlog$1(`← reverse request ${method}#${f.id}`);
+	if (method === "session/request_permission") {
+		const options = Array.isArray(f.params?.options) ? f.params.options : [];
+		const allow = process.env.WEMIND_ACP_AUTO_ALLOW === "1" ? options.find((o) => o?.kind === "allow_once" || o?.kind === "allow_always") : void 0;
+		const result = allow ? { outcome: {
+			outcome: "selected",
+			optionId: allow.optionId
+		} } : { outcome: { outcome: "cancelled" } };
+		child$1?.stdin.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id: f.id,
+			result
+		}) + "\n");
+		dlog$1(`permission ${allow ? "allowed" : "rejected"}`);
+		return;
+	}
+	child$1?.stdin.write(JSON.stringify({
+		jsonrpc: "2.0",
+		id: f.id,
+		error: {
+			code: -32601,
+			message: "method not supported"
+		}
+	}) + "\n");
+}
+function handleFrame$1(f) {
+	lastFrameAt$1 = Date.now();
+	frameSeq$1 += 1;
+	if (typeof f.id === "number" && (f.result !== void 0 || f.error !== void 0)) {
+		const p = pending$1.get(f.id);
+		if (!p) return;
+		p.clear();
+		pending$1.delete(f.id);
+		if (f.error) {
+			dlog$1(`← ${p.method}#${f.id} ERROR ${JSON.stringify(f.error).slice(0, 200)}`);
+			p.reject(new Error(JSON.stringify(f.error)));
+		} else p.resolve(f.result);
+		return;
+	}
+	if (f.method && f.id !== void 0) {
+		handleReverseRequest$1(f);
+		return;
+	}
+	if (f.method === "session/update") {
+		const u = f.params?.update;
+		if (u?.sessionUpdate) seenUpdateTypes$1.add(String(u.sessionUpdate));
+		if (currentOnProgress$1) try {
+			currentOnProgress$1({ type: "activity" });
+		} catch {}
+		if (u?.sessionUpdate === "agent_message_chunk" && u.content?.type === "text") {
+			const arr = assembling$1.get(f.params.sessionId);
+			if (arr) arr.push(String(u.content.text ?? ""));
+			if (!answerStarted$1 && currentOnProgress$1) {
+				answerStarted$1 = true;
+				try {
+					currentOnProgress$1({ type: "answer" });
+				} catch {}
+			}
+		} else if (u?.sessionUpdate === "agent_thought_chunk") {
+			if (!thoughtStarted$1 && currentOnProgress$1) {
+				thoughtStarted$1 = true;
+				try {
+					currentOnProgress$1({ type: "thinking" });
+				} catch {}
+			}
+		} else if ((u?.sessionUpdate === "tool_call" || u?.sessionUpdate === "tool_call_update") && currentOnProgress$1) {
+			const tid = String(u.toolCallId ?? u.title ?? "");
+			if (tid && !seenTools$1.has(tid)) {
+				seenTools$1.add(tid);
+				const purpose = typeof u.rawInput?.__tool_use_purpose === "string" ? u.rawInput.__tool_use_purpose : void 0;
+				try {
+					currentOnProgress$1({
+						type: "tool",
+						kind: u.kind,
+						purpose,
+						title: u.title
+					});
+				} catch {}
+			}
+		}
+	}
+}
+function onStdout$1(d) {
+	stdoutBuf$1 += d.toString();
+	let i;
+	while ((i = stdoutBuf$1.indexOf("\n")) >= 0) {
+		const line = stdoutBuf$1.slice(0, i).trim();
+		stdoutBuf$1 = stdoutBuf$1.slice(i + 1);
+		if (!line) continue;
+		let f;
+		try {
+			f = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		handleFrame$1(f);
+	}
+}
+function request$1(method, params, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		if (!child$1) {
+			reject(/* @__PURE__ */ new Error("no acp process"));
+			return;
+		}
+		const id = ++idCounter$1;
+		dlog$1(`→ ${method}#${id}`);
+		const t = setTimeout(() => {
+			pending$1.delete(id);
+			reject(/* @__PURE__ */ new Error(`${method} timeout after ${timeoutMs}ms`));
+		}, timeoutMs);
+		pending$1.set(id, {
+			resolve,
+			reject,
+			clear: () => clearTimeout(t),
+			method
+		});
+		child$1.stdin.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		}) + "\n");
+	});
+}
+/**
+* session/prompt 专用：空闲超时（PROMPT_IDLE_MS 内无任何帧才判卡死）+ 硬上限（PROMPT_CAP_MS）。
+* 只要 brain 还在出帧（工具进度/正文），就不打断——避免误杀"慢但在干活"的长查询。
+*/
+function promptRequest$1(params) {
+	return new Promise((resolve, reject) => {
+		if (!child$1) {
+			reject(/* @__PURE__ */ new Error("no acp process"));
+			return;
+		}
+		const id = ++idCounter$1;
+		const startedAt = Date.now();
+		lastFrameAt$1 = Date.now();
+		const startSeq = frameSeq$1;
+		dlog$1(`→ session/prompt#${id} (idle=${PROMPT_IDLE_MS$1}ms cap=${PROMPT_CAP_MS$1}ms firstFrame=${FIRST_FRAME_MS$1}ms)`);
+		const iv = setInterval(() => {
+			const idle = Date.now() - lastFrameAt$1;
+			const total = Date.now() - startedAt;
+			const firstFrameTimeout = frameSeq$1 === startSeq && total > FIRST_FRAME_MS$1;
+			if (firstFrameTimeout || idle > PROMPT_IDLE_MS$1 || total > PROMPT_CAP_MS$1) {
+				if (pending$1.delete(id)) {
+					clearInterval(iv);
+					reject(/* @__PURE__ */ new Error(`session/prompt ${firstFrameTimeout ? "no-first-frame" : idle > PROMPT_IDLE_MS$1 ? "idle" : "cap"} timeout (idle=${idle}ms total=${total}ms)`));
+				}
+			}
+		}, 5e3);
+		pending$1.set(id, {
+			resolve,
+			reject,
+			clear: () => clearInterval(iv),
+			method: "session/prompt"
+		});
+		child$1.stdin.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method: "session/prompt",
+			params
+		}) + "\n");
+	});
+}
+async function ensureProcess$1() {
+	if (isAlive$1() && initialized$1) return;
+	reset$1();
+	const env = { ...process.env };
+	if (AGENT$1.homeEnvVar) env[AGENT$1.homeEnvVar] = BRAIN_HOME;
+	for (const [k, v] of Object.entries(AGENT$1.env ?? {})) env[k] = v.replaceAll("%HOME%", BRAIN_HOME);
+	const proc = spawnAgent(AGENT$1, {
+		cwd: BRAIN_HOME,
+		env
+	});
+	child$1 = proc;
+	dlog$1(`spawn ${AGENT$1.name} acp pid=${proc.pid} bin=${AGENT$1.bin} args=[${AGENT$1.args.join(" ")}]`);
+	try {
+		fs.writeFileSync(BRAIN_PID_FILE, String(proc.pid), "utf-8");
+	} catch {}
+	proc.stdout.on("data", onStdout$1);
+	proc.stderr.on("data", () => {});
+	proc.on("exit", (code) => {
+		dlog$1(`acp exited code=${code}`);
+		if (child$1 === proc) reset$1();
+	});
+	proc.on("error", (e) => {
+		dlog$1(`acp error ${String(e)}`);
+		if (child$1 === proc) reset$1();
+	});
+	await request$1("initialize", {
+		protocolVersion: 1,
+		clientCapabilities: {}
+	}, REQ_TIMEOUT$1);
+	initialized$1 = true;
+	dlog$1("initialized");
+}
+/** 按预设选择模型路由（如 DSH 的 deepseek-account）；没有 model 的 agent 跳过。 */
+async function applyModel$1(sid) {
+	if (!AGENT$1.model) return;
+	try {
+		await request$1("session/set_config_option", {
+			sessionId: sid,
+			configId: "model",
+			value: AGENT$1.model
+		}, REQ_TIMEOUT$1);
+		dlog$1(`model set ${AGENT$1.model}`);
+	} catch (e) {
+		dlog$1(`model set failed (${String(e)})`);
+		throw e;
+	}
+}
+async function ensureSession$1(userId) {
+	const existing = userSessions.get(userId);
+	if (existing) return existing;
+	const mcpServers = AGENT$1.mcpViaAcp ? activeMcpServers() : [];
+	const map = loadSessionMap$1();
+	const saved = map[userId];
+	if (saved) {
+		const methods = AGENT$1.restore === "resume" ? ["resume"] : ["load", "resume"];
+		for (const method of methods) try {
+			await request$1(`session/${method}`, {
+				sessionId: saved,
+				cwd: BRAIN_HOME,
+				mcpServers
+			}, REQ_TIMEOUT$1);
+			await applyModel$1(saved);
+			userSessions.set(userId, saved);
+			dlog$1(`session/${method} ok ${saved} mcp=[${mcpServers.map((s) => s.name).join(",")}]`);
+			return saved;
+		} catch (e) {
+			dlog$1(`session/${method} failed (${String(e)})`);
+		}
+	}
+	const res = await request$1("session/new", {
+		cwd: BRAIN_HOME,
+		mcpServers
+	}, REQ_TIMEOUT$1);
+	if (!res?.sessionId) throw new Error("session/new returned no sessionId");
+	await applyModel$1(res.sessionId);
+	userSessions.set(userId, res.sessionId);
+	map[userId] = res.sessionId;
+	saveSessionMap$1(map);
+	dlog$1(`session/new ok ${res.sessionId} mcp=[${mcpServers.map((s) => s.name).join(",")}]`);
+	return res.sessionId;
+}
+/** 向大脑（配置的 ACP agent）提问（常驻 + 原生多轮）。失败即重建进程（下条用 session/load 恢复上下文）。 */
+async function askBrain(userId, message, onProgress, images) {
+	await ensureProcess$1();
+	const sid = await ensureSession$1(userId);
+	assembling$1.set(sid, []);
+	currentOnProgress$1 = onProgress ?? null;
+	answerStarted$1 = false;
+	thoughtStarted$1 = false;
+	seenUpdateTypes$1.clear();
+	seenTools$1.clear();
+	const t0 = Date.now();
+	const prompt = [];
+	if (images?.length && !AGENT$1.images) prompt.push({
+		type: "text",
+		text: "（用户发来图片，但当前大脑不支持图片输入；请让用户改用文字，或切换到支持图片的大脑。不要臆测图片内容。）"
+	});
+	if (AGENT$1.images) for (const im of images ?? []) prompt.push({
+		type: "image",
+		mimeType: im.mimeType,
+		data: im.data
+	});
+	if (!hintedSessions.has(sid)) {
+		hintedSessions.add(sid);
+		prompt.push({
+			type: "text",
+			text: "（系统提示：你正在通过微信和用户对话。需要给用户发图片时，在回复里用 Markdown 图片语法 ![](图片的 http 链接或本地文件绝对路径)，系统会自动把它作为图片消息发出（你本身不会文生图，可发联网搜到的图、本地已有的图、或自己用代码渲染保存的图表）。重要：服务器从中国大陆下载该图，请选「可直接下载的直链」——优先 raw.githubusercontent.com 等原始文件直链；避免 wikipedia/wikimedia（大陆被墙）以及 pixabay/unsplash 等带热链保护、直链常返回 403 的图床。拿不准时优先把图先下载到本地再用本地绝对路径引用，或直接发链接让用户自己点。其余正常用文字/Markdown 回复。此提示只出现一次，无需理会本句。）"
+		});
+	}
+	prompt.push({
+		type: "text",
+		text: message || "（用户发来一张图片，请查看并回应）"
+	});
+	try {
+		await promptRequest$1({
+			sessionId: sid,
+			prompt
+		});
+		const txt = (assembling$1.get(sid) ?? []).join("").trim();
+		dlog$1(`prompt ok ${Date.now() - t0}ms chunks=${(assembling$1.get(sid) ?? []).length} updateTypes=[${[...seenUpdateTypes$1].join(",")}]`);
+		return txt;
+	} catch (e) {
+		const chunks = (assembling$1.get(sid) ?? []).length;
+		const sinceFrame = lastFrameAt$1 ? Date.now() - lastFrameAt$1 : -1;
+		dlog$1(`prompt FAIL ${Date.now() - t0}ms chunks=${chunks} lastFrameAgo=${sinceFrame}ms err=${String(e)} -> rebuild`);
+		reset$1();
+		throw e;
+	} finally {
+		currentOnProgress$1 = null;
+		assembling$1.delete(sid);
+	}
+}
+/** 用户主动开新会话：丢弃旧 session（含磁盘映射），重建一个全新 session。 */
+async function newSession(userId) {
+	const map = loadSessionMap$1();
+	delete map[userId];
+	saveSessionMap$1(map);
+	userSessions.delete(userId);
+	await ensureProcess$1();
+	await ensureSession$1(userId);
+}
+/** MCP 激活集变更后调用：重启 acp 进程（重建后会 session/load 恢复上下文）。 */
+function restart() {
+	reset$1();
+}
+/** 当前大脑是否接受图片输入（预设能力；默认 true）。 */
+function supportsImages() {
+	return AGENT$1.images;
+}
+/** 当前预设的静默期心跳覆盖（默认 undefined → 15s）。 */
+function heartbeatMs() {
+	return AGENT$1.heartbeatMs;
+}
+//#endregion
+//#region src/image-reply.ts
+/**
+* 从 brain 的文本回复里提取「要作为图片发送」的引用，并返回去掉这些引用后的纯文本。
+* 覆盖三种来源：
+*  A. Markdown 图片 `![alt](src)`，src 可为 http(s) URL 或本地绝对路径；
+*  B. brain 按约定输出的也是上述 Markdown 语法（见 acp-brain 注入的系统提示）；
+*  C. 回复中裸露的图片 URL（http(s) 且以图片扩展名结尾）。
+*/
+const IMG_EXT = /\.(png|jpe?g|gif|webp|bmp)(\?[^\s)]*)?$/i;
+const MAX_BYTES = 10 * 1024 * 1024;
+function extractImages(text) {
+	const images = [];
+	const seen = /* @__PURE__ */ new Set();
+	const push = (src) => {
+		const s = src.trim();
+		if (s && !seen.has(s)) {
+			seen.add(s);
+			images.push({ src: s });
+		}
+	};
+	let out = text ?? "";
+	out = out.replace(/!\[[^\]]*\]\(\s*<?([^)\s>]+)>?(?:\s+"[^"]*")?\s*\)/g, (_m, src) => {
+		push(src);
+		return "";
+	});
+	out = out.replace(/(?<!\()(https?:\/\/[^\s)]+\.(?:png|jpe?g|gif|webp|bmp)(?:\?[^\s)]*)?)/gi, (m) => {
+		push(m);
+		return "";
+	});
+	out = out.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+	return {
+		images,
+		text: out
+	};
+}
+/** 把图片引用解析成字节：http(s) 下载，或本地文件读取。带大小/类型校验。 */
+async function resolveImageBytes(src) {
+	if (/^https?:\/\//i.test(src)) {
+		const res = await fetch(src, {
+			signal: AbortSignal.timeout(15e3),
+			headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36" }
+		});
+		if (!res.ok) throw new Error(`下载图片失败 ${res.status}`);
+		const buf = Buffer.from(await res.arrayBuffer());
+		if (buf.length > MAX_BYTES) throw new Error(`图片过大 ${buf.length}`);
+		const ct = res.headers.get("content-type") || "";
+		if (!ct.startsWith("image/") && !IMG_EXT.test(src)) throw new Error(`非图片内容(${ct})`);
+		return buf;
+	}
+	const p = src.startsWith("file://") ? fileURLToPath(src) : src;
+	if (!IMG_EXT.test(p)) throw new Error(`非图片文件（仅按图片扩展名发送）: ${p}`);
+	const stat = fs.statSync(p);
+	if (!stat.isFile()) throw new Error("不是文件");
+	if (stat.size > MAX_BYTES) throw new Error(`图片过大 ${stat.size}`);
+	return fs.readFileSync(p);
+}
+//#endregion
+//#region src/md-reply.ts
+/**
+* 长回复转 Markdown 文件：超过阈值的回复正文，作为 .md 文件发送（一条消息），
+* 比拆成多条文本更不易触发 iLink 连续发送上限、且阅读体验完整。
+* 文件名由内容生成一个合适的标题。
+*/
+/** 超过此字符数的回复转 .md 文件发送。可用 WECHAT_REPLY_FILE_THRESHOLD 覆盖。 */
+const LONG_REPLY_THRESHOLD = Number(process.env.WECHAT_REPLY_FILE_THRESHOLD) || 1500;
+const ILLEGAL_FILENAME = /[\\/:*?"<>|\r\n\t]/g;
+/** 由内容生成一个合适的标题：取首个 Markdown 标题或首个非空行，清洗为合法文件名片段。 */
+function generateTitle(text) {
+	let first = "";
+	for (const ln of text.split(/\r?\n/)) {
+		const t = ln.trim();
+		if (t) {
+			first = t;
+			break;
+		}
+	}
+	first = first.replace(/^#{1,6}\s*/, "").replace(/^[-*+]\s+/, "").replace(/^\d+[.)]\s+/, "").replace(/[*_`~]/g, "");
+	first = first.replace(ILLEGAL_FILENAME, " ").replace(/\s+/g, " ").trim();
+	if (first.length > 40) first = first.slice(0, 40).trim();
+	return first || "回复";
+}
+/**
+* 构造长回复的 md 文件（不落盘，直接内存 buffer）。
+* 若正文未以 Markdown 标题开头，则前置一个由内容生成的 H1，便于打开后阅读。
+*/
+function buildMdReply(text) {
+	const title = generateTitle(text);
+	const body = /^\s*#/.test(text) ? text : `# ${title}\n\n${text}`;
+	return {
+		fileName: `${title}.md`,
+		data: Buffer.from(body, "utf-8")
+	};
+}
+//#endregion
+//#region src/worker-sandbox.ts
+/**
+* worker 沙箱：与 brain 沙箱（mcp-sandbox.ts）并列，但 MCP 策略相反。
+*
+* worker 是无人值守的任务执行机，默认**继承真实配置目录的全部 MCP**（仅排除 wechat 防回环），
+* 而非 brain 的「默认空 + 对话中按需加载」——因为没人在旁边逐个加载工具，任务需要开箱即用的完整能力。
+* 记忆/技能/规则（mirrorRealKiro）与 settings（syncSettings，含模型/信任）的继承与 brain 一致。
+*
+* 按 agent 适配（同 mcp-sandbox.ts）：配置目录、MCP 格式、设置继承方式均随 agent 而变。
+*
+* 设计依据：docs/方案C-MVP-远程human-in-the-loop.md §8.4。
+* 与 mcp-sandbox.ts 有少量重复（mirrorRealKiro/syncSettings），刻意复制以隔离演进、不动已稳定的 brain 沙箱。
+*/
+const AG = resolveAgent(loadBrainConfig());
+/** worker 专用沙箱根（由 agent 的 homeEnvVar 指向它）。 */
+const WORKER_HOME = process.env.WEMIND_WORKER_HOME?.trim() || path.join(DATA_DIR, "worker-home");
+/** 该 agent 在 worker 沙箱里的「配置目录」（kiro=沙箱根；opencode=<沙箱>/opencode）。 */
+const WORKER_CONFIG_DIR = path.join(WORKER_HOME, AG.configSubdir);
+const WORKER_MCP_JSON = path.join(WORKER_CONFIG_DIR, AG.mcpConfigFile);
+/** MCP「目录」：可继承的 MCP 定义来源（同 brain，默认取 agent 真实配置目录的 catalogFile）。 */
+const CATALOG = process.env.WEMIND_MCP_CATALOG?.trim() || process.env.WECHAT_MCP_CATALOG?.trim() || path.join(AG.realHome || path.join(os.homedir(), ".kiro"), AG.catalogFile);
+/** worker 不继承的 MCP：wechat 始终强制排除（防回环），外加 WEMIND_WORKER_MCP_EXCLUDE 指定的。 */
+function excludeSet() {
+	const raw = process.env.WEMIND_WORKER_MCP_EXCLUDE ?? "wechat";
+	const s = new Set(raw.split(/[,\s]+/).map((x) => x.trim()).filter(Boolean));
+	s.add("wechat");
+	return s;
+}
+function readJson(file) {
+	try {
+		return JSON.parse(fs.readFileSync(file, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/** 同 brain：把凭据文件（如 DSH 的 .credentials.yaml）新者胜地同步进 worker 沙箱。 */
+function syncCredentialFile() {
+	if (!AG.credentialFile || !AG.realHome) return;
+	const src = path.join(AG.realHome, AG.credentialFile);
+	const dst = path.join(WORKER_CONFIG_DIR, AG.credentialFile);
+	try {
+		if (!fs.existsSync(src)) return;
+		fs.mkdirSync(path.dirname(dst), { recursive: true });
+		const s = fs.statSync(src);
+		const d = fs.existsSync(dst) ? fs.statSync(dst) : null;
+		if (!d || s.mtimeMs > d.mtimeMs + 1e3) fs.copyFileSync(src, dst);
+	} catch {}
+}
+function loadCatalog() {
+	return readMcpServers(readJson(CATALOG), AG.mcpFormat);
+}
+/** worker 继承全量 MCP：复制 catalog 全部 server，去掉排除集与 disabled:true 的。
+*  `mcpViaAcp` 预设（DSH）不写文件——全量集合经 workerMcpServers() 转成 ACP mcpServers 随 session 下发。 */
+function applyWorkerSandbox() {
+	if (AG.mcpViaAcp) return;
+	const cat = loadCatalog();
+	const ex = excludeSet();
+	const servers = {};
+	for (const [name, def] of Object.entries(cat)) {
+		if (ex.has(name)) continue;
+		if (def && typeof def === "object" && def.disabled === true) continue;
+		servers[name] = def;
+	}
+	const next = withMcpServers(readJson(WORKER_MCP_JSON) ?? {}, servers, AG.mcpFormat);
+	fs.mkdirSync(path.dirname(WORKER_MCP_JSON), { recursive: true });
+	fs.writeFileSync(WORKER_MCP_JSON, JSON.stringify(next, null, 2), "utf-8");
+}
+/** worker 当前应挂载的 ACP mcpServers（mcpViaAcp 预设用）：全量 catalog（除排除集/disabled/坏条目）→ ACP 声明。 */
+function workerMcpServers() {
+	const cat = loadCatalog();
+	const ex = excludeSet();
+	const picked = {};
+	for (const [name, def] of Object.entries(cat)) {
+		if (ex.has(name)) continue;
+		if (def && typeof def === "object" && def.disabled === true) continue;
+		picked[name] = def;
+	}
+	const { servers, skipped } = toAcpMcpServers(picked, { exclude: ex });
+	if (skipped.length) console.error(`[wemind/wechat-daemon/mcp] worker 跳过无法转换的 MCP：${skipped.join(", ")}`);
+	return servers;
+}
+/** kiro：继承真实 settings/ 下除 mcp.json 外的文件（cli.json 含模型/免确认等）。逻辑同 brain 的 syncKiroSettings。 */
+function syncKiroSettings() {
+	const realSettings = path.join(AG.realHome, "settings");
+	const workerSettings = path.join(WORKER_CONFIG_DIR, "settings");
+	if (!fs.existsSync(realSettings)) return;
+	try {
+		fs.mkdirSync(workerSettings, { recursive: true });
+	} catch {}
+	let names = [];
+	try {
+		names = fs.readdirSync(realSettings);
+	} catch {
+		return;
+	}
+	for (const f of names) {
+		if (f === "mcp.json") continue;
+		try {
+			const src = path.join(realSettings, f);
+			if (fs.statSync(src).isFile()) fs.copyFileSync(src, path.join(workerSettings, f));
+		} catch {}
+	}
+}
+/** opencode：把用户全局 opencode.json(c)（去 mcp 段）作基底写入 worker 沙箱，继承 model 等；mcp 由 applyWorkerSandbox 覆盖。 */
+function syncOpencodeBase() {
+	const src = ["opencode.json", "opencode.jsonc"].map((f) => path.join(AG.realHome, f)).find((f) => fs.existsSync(f));
+	if (!src) return;
+	let parsed = null;
+	try {
+		const raw = fs.readFileSync(src, "utf-8");
+		parsed = src.endsWith(".jsonc") ? parseJsonc(raw) : JSON.parse(raw);
+	} catch {
+		return;
+	}
+	if (!parsed || typeof parsed !== "object") return;
+	delete parsed.mcp;
+	fs.mkdirSync(WORKER_CONFIG_DIR, { recursive: true });
+	fs.writeFileSync(WORKER_MCP_JSON, JSON.stringify(parsed, null, 2), "utf-8");
+}
+function syncSettings() {
+	if (AG.mcpViaAcp) return;
+	if (!AG.inherit || !AG.realHome) return;
+	if (AG.mcpFormat === "opencode") syncOpencodeBase();
+	else syncKiroSettings();
+}
+/** 用 junction/symlink 把真实配置目录的记忆/技能/规则类子目录链入 worker 配置目录；单文件记忆直接拷。逻辑同 brain 的 mirrorRealKiro。 */
+function mirrorRealKiro() {
+	if (!AG.inherit || !AG.realHome) return;
+	if (path.resolve(WORKER_HOME) === path.resolve(AG.realHome)) return;
+	try {
+		fs.mkdirSync(WORKER_CONFIG_DIR, { recursive: true });
+	} catch {}
+	for (const d of AG.inheritDirs) {
+		const target = path.join(AG.realHome, d);
+		const link = path.join(WORKER_CONFIG_DIR, d);
+		if (!fs.existsSync(target)) continue;
+		let present = false;
+		try {
+			fs.lstatSync(link);
+			present = true;
+		} catch {}
+		if (present) try {
+			const st = fs.lstatSync(link);
+			if (st.isSymbolicLink()) continue;
+			if (st.isDirectory()) if (fs.readdirSync(link).length === 0) fs.rmdirSync(link);
+			else {
+				for (const f of fs.readdirSync(target)) {
+					const dst = path.join(link, f);
+					const src = path.join(target, f);
+					try {
+						if (!fs.existsSync(dst) && fs.statSync(src).isFile()) fs.copyFileSync(src, dst);
+					} catch {}
+				}
+				continue;
+			}
+			else continue;
+		} catch {
+			continue;
+		}
+		try {
+			fs.symlinkSync(target, link, process.platform === "win32" ? "junction" : "dir");
+		} catch {}
+	}
+	for (const f of AG.inheritFiles) {
+		const src = path.join(AG.realHome, f);
+		const dst = path.join(WORKER_CONFIG_DIR, f);
+		try {
+			if (fs.existsSync(src) && !fs.existsSync(dst)) fs.copyFileSync(src, dst);
+		} catch {}
+	}
+}
+/** 启动时确保 worker 沙箱就绪：继承 settings（除 mcp）→ 写全量 MCP（除排除集）→ 链入记忆/技能。 */
+function ensureWorkerHome() {
+	syncSettings();
+	applyWorkerSandbox();
+	mirrorRealKiro();
+	syncCredentialFile();
+}
+//#endregion
+//#region src/worker-acp.ts
+/**
+* worker ACP 客户端：维护一个常驻的 ACP agent 进程，专跑「漫长任务」（与 acp-brain 的对话大脑并存、互不干扰）。
+* 约 70% 复制自 acp-brain.ts，差异：
+* - **独立单例**（独立 child/pending/session），与 brain 进程并存；
+* - **单任务 session**（MVP 单任务，固定 key="task"）；持久化到 worker-sessions.json，重建后 session/load 续上下文；
+* - **cwd = 任务工作目录**（WEMIND_WORKER_CWD，默认用户主目录），而 KIRO_HOME 指向 WORKER_HOME 沙箱（继承全量 MCP 除 wechat + 记忆）；
+* - **更宽松超时**（漫长任务，env 可调）；
+* - 去掉 brain 的「可发图」首轮提示（worker 是任务执行，非聊天发图场景）。
+* 自愈：session/prompt 超时/失败 → 杀进程；下次 askWorker 重建并 session/load 恢复（→ 用户回「继续」即可续跑）。
+*/
+function dlog(...a) {
+	console.error("[wemind/wechat-daemon/worker]", ...a);
+}
+const AGENT = resolveAgent(loadBrainConfig());
+const WORKER_CWD = process.env.WEMIND_WORKER_CWD?.trim() || os.homedir();
+const REQ_TIMEOUT = 3e4;
+const PROMPT_IDLE_MS = Number(process.env.WEMIND_WORKER_IDLE_MS) || 18e4;
+const PROMPT_CAP_MS = Number(process.env.WEMIND_WORKER_CAP_MS) || 18e5;
+const FIRST_FRAME_MS = Number(process.env.WEMIND_WORKER_FIRST_FRAME_MS) || AGENT.firstFrameMs || 3e4;
+const SESSION_MAP_FILE = path.join(DATA_DIR, "worker-sessions.json");
+const WORKER_PID_FILE = path.join(DATA_DIR, "worker.pid");
+const TASK_KEY = "task";
+let pendingCwd;
+/** 设置「下次（本任务首轮）spawn worker 用的 cwd」。本地命令派发传入终端当前目录；不传/空则用默认 WORKER_CWD。 */
+function setWorkerCwd(cwd) {
+	pendingCwd = cwd?.trim() || void 0;
+}
+/** 本任务有效 cwd（指定优先，否则默认）。 */
+function effectiveCwd() {
+	return pendingCwd ?? WORKER_CWD;
+}
+let child = null;
+let initialized = false;
+let idCounter = 0;
+const pending = /* @__PURE__ */ new Map();
+const taskSessions = /* @__PURE__ */ new Map();
+const assembling = /* @__PURE__ */ new Map();
+let stdoutBuf = "";
+let lastFrameAt = 0;
+let frameSeq = 0;
+let currentOnProgress = null;
+let answerStarted = false;
+let thoughtStarted = false;
+const seenUpdateTypes = /* @__PURE__ */ new Set();
+const seenTools = /* @__PURE__ */ new Set();
+function isWorkerAlive() {
+	return !!child && child.exitCode === null && !child.killed;
+}
+/** 杀进程（按 PID 进程树）并清空内部态；不清磁盘 session 映射（留给重建后 load）。 */
+function reset() {
+	const c = child;
+	child = null;
+	initialized = false;
+	if (c?.pid) try {
+		if (process.platform === "win32") spawnSync("taskkill", [
+			"/PID",
+			String(c.pid),
+			"/T",
+			"/F"
+		], {
+			stdio: "ignore",
+			windowsHide: true
+		});
+		else c.kill();
+	} catch {}
+	try {
+		fs.unlinkSync(WORKER_PID_FILE);
+	} catch {}
+	for (const p of pending.values()) {
+		p.clear();
+		p.reject(/* @__PURE__ */ new Error("worker process reset"));
+	}
+	pending.clear();
+	taskSessions.clear();
+	assembling.clear();
+	stdoutBuf = "";
+}
+function loadSessionMap() {
+	try {
+		const j = JSON.parse(fs.readFileSync(SESSION_MAP_FILE, "utf-8"));
+		return j && typeof j === "object" ? j : {};
+	} catch {
+		return {};
+	}
+}
+function saveSessionMap(m) {
+	fs.mkdirSync(DATA_DIR, { recursive: true });
+	fs.writeFileSync(SESSION_MAP_FILE, JSON.stringify(m, null, 2), "utf-8");
+}
+function handleReverseRequest(f) {
+	const method = String(f.method);
+	dlog(`← reverse request ${method}#${f.id}`);
+	if (method === "session/request_permission") {
+		const options = Array.isArray(f.params?.options) ? f.params.options : [];
+		const allow = process.env.WEMIND_ACP_AUTO_ALLOW === "1" ? options.find((o) => o?.kind === "allow_once" || o?.kind === "allow_always") : void 0;
+		const result = allow ? { outcome: {
+			outcome: "selected",
+			optionId: allow.optionId
+		} } : { outcome: { outcome: "cancelled" } };
+		child?.stdin.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id: f.id,
+			result
+		}) + "\n");
+		dlog(`permission ${allow ? "allowed" : "rejected"}`);
+		return;
+	}
+	child?.stdin.write(JSON.stringify({
+		jsonrpc: "2.0",
+		id: f.id,
+		error: {
+			code: -32601,
+			message: "method not supported"
+		}
+	}) + "\n");
+}
+function handleFrame(f) {
+	lastFrameAt = Date.now();
+	frameSeq += 1;
+	if (typeof f.id === "number" && (f.result !== void 0 || f.error !== void 0)) {
+		const p = pending.get(f.id);
+		if (!p) return;
+		p.clear();
+		pending.delete(f.id);
+		if (f.error) {
+			dlog(`← ${p.method}#${f.id} ERROR ${JSON.stringify(f.error).slice(0, 200)}`);
+			p.reject(new Error(JSON.stringify(f.error)));
+		} else p.resolve(f.result);
+		return;
+	}
+	if (f.method && f.id !== void 0) {
+		handleReverseRequest(f);
+		return;
+	}
+	if (f.method === "session/update") {
+		const u = f.params?.update;
+		if (u?.sessionUpdate) seenUpdateTypes.add(String(u.sessionUpdate));
+		if (currentOnProgress) try {
+			currentOnProgress({ type: "activity" });
+		} catch {}
+		if (u?.sessionUpdate === "agent_message_chunk" && u.content?.type === "text") {
+			const arr = assembling.get(f.params.sessionId);
+			if (arr) arr.push(String(u.content.text ?? ""));
+			if (!answerStarted && currentOnProgress) {
+				answerStarted = true;
+				try {
+					currentOnProgress({ type: "answer" });
+				} catch {}
+			}
+		} else if (u?.sessionUpdate === "agent_thought_chunk") {
+			if (!thoughtStarted && currentOnProgress) {
+				thoughtStarted = true;
+				try {
+					currentOnProgress({ type: "thinking" });
+				} catch {}
+			}
+		} else if ((u?.sessionUpdate === "tool_call" || u?.sessionUpdate === "tool_call_update") && currentOnProgress) {
+			const tid = String(u.toolCallId ?? u.title ?? "");
+			if (tid && !seenTools.has(tid)) {
+				seenTools.add(tid);
+				const purpose = typeof u.rawInput?.__tool_use_purpose === "string" ? u.rawInput.__tool_use_purpose : void 0;
+				try {
+					currentOnProgress({
+						type: "tool",
+						kind: u.kind,
+						purpose,
+						title: u.title
+					});
+				} catch {}
+			}
+		}
+	}
+}
+function onStdout(d) {
+	stdoutBuf += d.toString();
+	let i;
+	while ((i = stdoutBuf.indexOf("\n")) >= 0) {
+		const line = stdoutBuf.slice(0, i).trim();
+		stdoutBuf = stdoutBuf.slice(i + 1);
+		if (!line) continue;
+		let f;
+		try {
+			f = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		handleFrame(f);
+	}
+}
+function request(method, params, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		if (!child) {
+			reject(/* @__PURE__ */ new Error("no worker process"));
+			return;
+		}
+		const id = ++idCounter;
+		dlog(`→ ${method}#${id}`);
+		const t = setTimeout(() => {
+			pending.delete(id);
+			reject(/* @__PURE__ */ new Error(`${method} timeout after ${timeoutMs}ms`));
+		}, timeoutMs);
+		pending.set(id, {
+			resolve,
+			reject,
+			clear: () => clearTimeout(t),
+			method
+		});
+		child.stdin.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		}) + "\n");
+	});
+}
+/** session/prompt 专用：空闲超时 + 首帧超时 + 硬上限（漫长任务，比 brain 宽松）。 */
+function promptRequest(params) {
+	return new Promise((resolve, reject) => {
+		if (!child) {
+			reject(/* @__PURE__ */ new Error("no worker process"));
+			return;
+		}
+		const id = ++idCounter;
+		const startedAt = Date.now();
+		lastFrameAt = Date.now();
+		const startSeq = frameSeq;
+		dlog(`→ session/prompt#${id} (idle=${PROMPT_IDLE_MS}ms cap=${PROMPT_CAP_MS}ms firstFrame=${FIRST_FRAME_MS}ms)`);
+		const iv = setInterval(() => {
+			const idle = Date.now() - lastFrameAt;
+			const total = Date.now() - startedAt;
+			const firstFrameTimeout = frameSeq === startSeq && total > FIRST_FRAME_MS;
+			if (firstFrameTimeout || idle > PROMPT_IDLE_MS || total > PROMPT_CAP_MS) {
+				if (pending.delete(id)) {
+					clearInterval(iv);
+					reject(/* @__PURE__ */ new Error(`session/prompt ${firstFrameTimeout ? "no-first-frame" : idle > PROMPT_IDLE_MS ? "idle" : "cap"} timeout (idle=${idle}ms total=${total}ms)`));
+				}
+			}
+		}, 5e3);
+		pending.set(id, {
+			resolve,
+			reject,
+			clear: () => clearInterval(iv),
+			method: "session/prompt"
+		});
+		child.stdin.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method: "session/prompt",
+			params
+		}) + "\n");
+	});
+}
+async function ensureProcess() {
+	if (isWorkerAlive() && initialized) return;
+	reset();
+	const env = { ...process.env };
+	if (AGENT.homeEnvVar) env[AGENT.homeEnvVar] = WORKER_HOME;
+	for (const [k, v] of Object.entries(AGENT.env ?? {})) env[k] = v.replaceAll("%HOME%", WORKER_HOME);
+	const cwd = effectiveCwd();
+	const proc = spawnAgent(AGENT, {
+		cwd,
+		env
+	});
+	child = proc;
+	dlog(`spawn ${AGENT.name} worker pid=${proc.pid} cwd=${cwd} home=${WORKER_HOME}`);
+	try {
+		fs.writeFileSync(WORKER_PID_FILE, String(proc.pid), "utf-8");
+	} catch {}
+	proc.stdout.on("data", onStdout);
+	proc.stderr.on("data", () => {});
+	proc.on("exit", (code) => {
+		dlog(`worker exited code=${code}`);
+		if (child === proc) reset();
+	});
+	proc.on("error", (e) => {
+		dlog(`worker error ${String(e)}`);
+		if (child === proc) reset();
+	});
+	await request("initialize", {
+		protocolVersion: 1,
+		clientCapabilities: {}
+	}, REQ_TIMEOUT);
+	initialized = true;
+	dlog("initialized");
+}
+async function applyModel(sid) {
+	if (!AGENT.model) return;
+	try {
+		await request("session/set_config_option", {
+			sessionId: sid,
+			configId: "model",
+			value: AGENT.model
+		}, REQ_TIMEOUT);
+		dlog(`model set ${AGENT.model}`);
+	} catch (e) {
+		dlog(`model set failed (${String(e)})`);
+		throw e;
+	}
+}
+async function ensureSession(key) {
+	const existing = taskSessions.get(key);
+	if (existing) return existing;
+	const mcpServers = AGENT.mcpViaAcp ? workerMcpServers() : [];
+	const map = loadSessionMap();
+	const saved = map[key];
+	if (saved) {
+		const methods = AGENT.restore === "resume" ? ["resume"] : ["load", "resume"];
+		for (const method of methods) try {
+			await request(`session/${method}`, {
+				sessionId: saved,
+				cwd: effectiveCwd(),
+				mcpServers
+			}, REQ_TIMEOUT);
+			await applyModel(saved);
+			taskSessions.set(key, saved);
+			dlog(`session/${method} ok ${saved} mcp=[${mcpServers.map((s) => s.name).join(",")}]`);
+			return saved;
+		} catch (e) {
+			dlog(`session/${method} failed (${String(e)})`);
+		}
+	}
+	const res = await request("session/new", {
+		cwd: effectiveCwd(),
+		mcpServers
+	}, REQ_TIMEOUT);
+	if (!res?.sessionId) throw new Error("session/new returned no sessionId");
+	await applyModel(res.sessionId);
+	taskSessions.set(key, res.sessionId);
+	map[key] = res.sessionId;
+	saveSessionMap(map);
+	dlog(`session/new ok ${res.sessionId} mcp=[${mcpServers.map((s) => s.name).join(",")}]`);
+	return res.sessionId;
+}
+/**
+* 向 worker 发一轮 prompt（任务派发或注入续跑），等这一轮 ACP 响应结束，返回拼接文本。
+* 失败即重建进程（下一轮 session/load 恢复上下文）→ 配合「继续」实现中断恢复。
+*/
+async function askWorker(instruction, onProgress) {
+	await ensureProcess();
+	const sid = await ensureSession(TASK_KEY);
+	assembling.set(sid, []);
+	currentOnProgress = onProgress ?? null;
+	answerStarted = false;
+	thoughtStarted = false;
+	seenUpdateTypes.clear();
+	seenTools.clear();
+	const t0 = Date.now();
+	const prompt = [{
+		type: "text",
+		text: instruction || "（继续）"
+	}];
+	try {
+		await promptRequest({
+			sessionId: sid,
+			prompt
+		});
+		const txt = (assembling.get(sid) ?? []).join("").trim();
+		dlog(`prompt ok ${Date.now() - t0}ms chunks=${(assembling.get(sid) ?? []).length} updateTypes=[${[...seenUpdateTypes].join(",")}]`);
+		return txt;
+	} catch (e) {
+		const chunks = (assembling.get(sid) ?? []).length;
+		const sinceFrame = lastFrameAt ? Date.now() - lastFrameAt : -1;
+		dlog(`prompt FAIL ${Date.now() - t0}ms chunks=${chunks} lastFrameAgo=${sinceFrame}ms err=${String(e)} -> rebuild`);
+		reset();
+		throw e;
+	} finally {
+		currentOnProgress = null;
+		assembling.delete(sid);
+	}
+}
+/** 开新任务会话：丢弃旧 session（含磁盘映射），下次 askWorker 全新开始。 */
+function newWorkerSession() {
+	const map = loadSessionMap();
+	delete map[TASK_KEY];
+	saveSessionMap(map);
+	taskSessions.delete(TASK_KEY);
+}
+/** 停止 worker：杀进程、清状态、丢弃任务 session（任务结束）。 */
+function stopWorker() {
+	reset();
+	newWorkerSession();
+	pendingCwd = void 0;
+}
+//#endregion
+//#region src/task-manager.ts
+const log$1 = (...a) => console.error("[wemind/wechat-daemon/task]", ...a);
+let activeTask = null;
+let push = () => {};
+function setTaskPush(fn) {
+	push = fn;
+}
+let typing = () => {};
+function setTaskTyping(fn) {
+	typing = fn;
+}
+let stateSink = () => {};
+function setTaskStateSink(fn) {
+	stateSink = fn;
+}
+/** 用当前 activeTask 构造快照并落盘（在派发/每轮/waiting/停止等关键节点调用）。 */
+function emitState() {
+	const t = activeTask;
+	const snap = t ? {
+		active: true,
+		status: t.status,
+		to: t.to,
+		startedAt: t.startedAt,
+		updatedAt: Date.now(),
+		turns: t.turns,
+		lastOutput: t.lastOutput
+	} : {
+		active: false,
+		status: "idle",
+		updatedAt: Date.now(),
+		turns: 0
+	};
+	try {
+		stateSink(snap);
+	} catch {}
+}
+const PROGRESS = (process.env.WEMIND_WORKER_PROGRESS ?? "0") === "1";
+/** 是否存在活跃任务（可选限定某用户）。 */
+function hasActiveTask(to) {
+	return !!activeTask && (to === void 0 || activeTask.to === to);
+}
+/** worker 是否正等该用户回复（waiting 态）。路由用：仅此时「无前缀」消息才默认注入 worker。 */
+function isAwaiting(to) {
+	return !!activeTask && activeTask.to === to && activeTask.status === "waiting";
+}
+/** 派发新任务（后台异步执行，立即返回回执文案，不阻塞调用方）。 */
+function dispatchTask(to, instruction, cwd) {
+	if (activeTask) return "已有任务在跑，先回复「结束任务」再派发新任务。";
+	setWorkerCwd(cwd);
+	runTask(to, instruction);
+	return "✅ 已派给工作机执行（任务运行中）。需要你决策或中断时我会主动找你；随时可回复「结束任务」终止。";
+}
+/** 注入用户消息：waiting → 直接喂下一轮；running → 暂存为 pendingInject。 */
+function injectTask(to, text) {
+	if (!activeTask || activeTask.to !== to) return;
+	if (activeTask.status === "waiting" && activeTask.injectResolver) {
+		const r = activeTask.injectResolver;
+		activeTask.injectResolver = void 0;
+		r(text);
+	} else {
+		(activeTask.pendingInjects ??= []).push(text);
+		push(to, "📝 已记下，等当前这步跑完就处理。");
+	}
+}
+/** 结束任务：停 worker、清状态、唤醒退出循环。 */
+function stopTask(to) {
+	if (!activeTask || activeTask.to !== to) {
+		emitState();
+		return "当前没有正在运行的任务。";
+	}
+	const task = activeTask;
+	activeTask = null;
+	if (task.injectResolver) {
+		const r = task.injectResolver;
+		task.injectResolver = void 0;
+		r(null);
+	}
+	stopWorker();
+	emitState();
+	return "🛑 任务已结束。";
+}
+/** 等待用户注入（waiting 态）；若有暂存的 pendingInject 直接消费。 */
+function waitForInject(task) {
+	if (task.pendingInjects?.length) {
+		const t = task.pendingInjects.join("\n");
+		task.pendingInjects = void 0;
+		return Promise.resolve(t);
+	}
+	return new Promise((resolve) => {
+		task.injectResolver = resolve;
+	});
+}
+function reason(e) {
+	const s = String(e instanceof Error ? e.message : e);
+	if (/no-first-frame|idle|cap|timeout/i.test(s)) return "超时/卡住";
+	return "执行出错";
+}
+/** 后台任务循环：每轮 askWorker → 推送本轮输出 → 等注入 → 续跑。绝不在 workerLoop 里 await 它。 */
+async function runTask(to, firstInstruction) {
+	activeTask = {
+		to,
+		status: "running",
+		startedAt: Date.now(),
+		turns: 0
+	};
+	emitState();
+	let instruction = firstInstruction;
+	while (activeTask && instruction !== null) {
+		typing(to);
+		const ti = setInterval(() => typing(to), 5e3);
+		try {
+			const out = await askWorker(instruction, PROGRESS ? (ev) => {
+				if (ev.type === "tool") push(to, "🔧 worker 正在调用工具…");
+			} : void 0);
+			if (!activeTask) break;
+			const text = `🤖【任务】${out || "（本轮无输出，可回复「继续」推进或「结束任务」终止）"}`;
+			activeTask.turns += 1;
+			activeTask.lastOutput = text;
+			push(to, text);
+		} catch (e) {
+			if (!activeTask) break;
+			log$1("worker turn failed:", String(e));
+			const text = `⚠️ 任务中断了（${reason(e)}）。回复「继续」我从中断处恢复，或「结束任务」终止。`;
+			activeTask.lastOutput = text;
+			push(to, text);
+		} finally {
+			clearInterval(ti);
+		}
+		if (!activeTask) break;
+		activeTask.status = "waiting";
+		emitState();
+		instruction = await waitForInject(activeTask);
+		if (activeTask) {
+			activeTask.status = "running";
+			emitState();
+		}
+	}
+	emitState();
+	log$1("runTask loop ended");
+}
+//#endregion
+//#region src/index.ts
+const log = (...a) => console.error("[wemind/wechat-daemon]", ...a);
+const sleep$2 = (ms) => new Promise((r) => setTimeout(r, ms));
+/** 分类大脑错误：backend=模型后端瞬时错误(可多重试)；timeout=超时/卡死；other=其它。 */
+function classifyBrainError(e) {
+	const s = String(e instanceof Error ? e.message : e);
+	if (/-32603|internal error|please try again|response stream|overloaded|rate.?limit|\b(429|503)\b/i.test(s)) return "backend";
+	if (/idle timeout|no-first-frame|cap timeout|timeout/i.test(s)) return "timeout";
+	return "other";
+}
+/** 按错误类型给用户的失败提示。 */
+function brainErrorMessage(e) {
+	switch (classifyBrainError(e)) {
+		case "backend": return "（模型后端临时出错了，自动重试多次仍失败，请稍后把消息再发一次）";
+		case "timeout": return "（这次处理超时/卡住被中断了，重试也没成功——可把任务拆小一点再发）";
+		default: return "（处理出错了，请把消息再发一次试试）";
+	}
+}
+function extractText(msg) {
+	return (msg.item_list ?? []).map((it) => {
+		if (it.type === MessageItemType.TEXT) return it.text_item?.text ?? "";
+		if (it.type === MessageItemType.VOICE) return it.voice_item?.text ?? "";
+		return "";
+	}).filter((s) => s).join("\n").trim();
+}
+/** 工具标题中文化（无 purpose 时的兜底）。 */
+function zhTool(t) {
+	return t.replace(/^Searching the web for:?\s*/i, "联网搜索：").replace(/^Running:?\s*/i, "执行：").replace(/^Reading\s+/i, "读取 ").replace(/^Writing\s+/i, "写入 ").replace(/^Finding\s+/i, "查找 ");
+}
+/** 按工具类型给图标。 */
+function toolIcon(kind) {
+	switch (kind) {
+		case "read": return "📄";
+		case "search": return "🔍";
+		case "execute": return "⌨️";
+		case "fetch": return "🌐";
+		case "edit":
+		case "write": return "✏️";
+		case "delete": return "🗑️";
+		default: return "🔧";
+	}
+}
+/** 解析控制指令（命中则由 daemon 直接处理，不转发给 brain）。 */
+function parseControl(text) {
+	const t = text.trim();
+	if (/^(\/?mcp|列出\s*mcp|mcp\s*list)$/i.test(t)) return { kind: "list" };
+	if (/^(新会话|重置|清空上下文|\/new|new\s*session)$/i.test(t)) return { kind: "new" };
+	let m = t.match(/^(?:加载|load)\s+(\S+)$/i);
+	if (m) return {
+		kind: "add",
+		name: m[1]
+	};
+	m = t.match(/^(?:卸载|unload)\s+(\S+)$/i);
+	if (m) return {
+		kind: "remove",
+		name: m[1]
+	};
+	return null;
+}
+/** 解析「明确发给 worker」指令：任务：xxx / 任务 xxx / >xxx（toWorker：无任务则启动、有任务则注入）；结束任务/停止任务 → stop。 */
+function parseTaskControl(text) {
+	const t = text.trim();
+	if (/^(结束任务|停止任务|\/stop)$/i.test(t)) return { kind: "stop" };
+	let m = t.match(/^(?:任务|task)[:：]\s*([\s\S]+)$/i);
+	if (m) return {
+		kind: "toWorker",
+		text: m[1].trim()
+	};
+	m = t.match(/^>\s*([\s\S]+)$/);
+	if (m) return {
+		kind: "toWorker",
+		text: m[1].trim()
+	};
+	return null;
+}
+/** 解析「明确问大脑」逃逸前缀：问大脑 xxx / 问大脑：xxx。命中返回去前缀后的文本（强制走 brain，即使 worker 在等你）。 */
+function parseBrainEscape(text) {
+	const m = text.trim().match(/^问大脑[:：]?\s*([\s\S]+)$/);
+	return m ? m[1].trim() : null;
+}
+async function handleControl(c, userId) {
+	if (c.kind === "list") return listMcp();
+	if (c.kind === "new") {
+		await newSession(userId);
+		return "已开启新会话（上下文已清空）。";
+	}
+	if (c.kind === "add") {
+		const r = addMcp(c.name);
+		restart();
+		return r;
+	}
+	const r = removeMcp(c.name);
+	restart();
+	return r;
+}
+async function setTyping(account, to, ctx, status) {
+	if (!ctx) return;
+	try {
+		const cfg = await getConfig({
+			baseUrl: account.baseUrl,
+			token: account.botToken,
+			ilinkUserId: to,
+			contextToken: ctx
+		});
+		await sendTyping({
+			baseUrl: account.baseUrl,
+			token: account.botToken,
+			body: {
+				ilink_user_id: to,
+				typing_ticket: cfg.typing_ticket,
+				status
+			}
+		});
+	} catch (e) {
+		log(`setTyping(${status}) failed:`, String(e));
+	}
+}
+async function reply(account, to, ctx, text, state = MessageState.FINISH, fallbackToken) {
+	const send = (token) => {
+		const req = { msg: {
+			from_user_id: "",
+			to_user_id: to,
+			client_id: generateId("wemind/wechat-daemon"),
+			message_type: MessageType.BOT,
+			message_state: state,
+			item_list: [{
+				type: MessageItemType.TEXT,
+				text_item: { text }
+			}],
+			context_token: token
+		} };
+		return sendMessage({
+			baseUrl: account.baseUrl,
+			token: account.botToken,
+			body: req
+		});
+	};
+	try {
+		await send(ctx);
+	} catch (e) {
+		if (e instanceof ILinkError && e.kind === "param_error") {
+			log("send -2(限流或token失效) → 退避 1.5s 后重试");
+			await new Promise((r) => setTimeout(r, 1500));
+			await send(fallbackToken && fallbackToken !== ctx ? fallbackToken : ctx);
+			return;
+		}
+		if (!(e instanceof ILinkError)) {
+			const t = classifyTransportError(e);
+			if (t.retryable) {
+				log(`send 传输错误(${t.kind}) → 退避 1.5s 后重试`);
+				await new Promise((r) => setTimeout(r, 1500));
+				await send(ctx);
+				return;
+			}
+		}
+		throw e;
+	}
+}
+/** 统一的发送错误处理：按错误类型分类记录；会话过期则暂停账号。 */
+function handleSendError(e, account) {
+	if (e instanceof ILinkError) {
+		log("send error:", e.message);
+		if (e.kind === "session_expired") {
+			pauseSession(account.botId);
+			log("会话过期(-14) on send → 该账号暂停 1h，待重新登录");
+		}
+	} else {
+		const t = classifyTransportError(e);
+		log(`send error(传输/${t.kind}${t.retryable ? ",可重试" : ""}):`, t.message);
+	}
+}
+let replyChain = Promise.resolve();
+let lastSendAt = 0;
+const MIN_SEND_GAP_MS = Number(process.env.WECHAT_MIN_SEND_GAP_MS) || 1500;
+const CONSEC_SEND_LIMIT = Number(process.env.WECHAT_CONSEC_SEND_LIMIT) || 10;
+const HEARTBEAT_MS = Number(process.env.WECHAT_BRAIN_HEARTBEAT_MS) || heartbeatMs() || 15e3;
+const sendBudget = /* @__PURE__ */ new Map();
+function budgetOf(to) {
+	let b = sendBudget.get(to);
+	if (!b) {
+		b = {
+			count: 0,
+			awaiting: false
+		};
+		sendBudget.set(to, b);
+	}
+	return b;
+}
+let activeTurn = null;
+function sendOrdered(account, to, ctx, text, state = MessageState.FINISH, fallbackToken) {
+	replyChain = replyChain.then(async () => {
+		const wait = MIN_SEND_GAP_MS - (Date.now() - lastSendAt);
+		if (wait > 0) await sleep$2(wait);
+		await reply(account, to, ctx, text, state, fallbackToken).catch((e) => handleSendError(e, account));
+		lastSendAt = Date.now();
+	});
+	return replyChain;
+}
+/** 把长回复作为 .md 文件发送（走同一串行链+节流）；发文件失败则兜底回退为文本。 */
+function sendMdOrdered(account, to, ctx, finalText, fallbackToken) {
+	replyChain = replyChain.then(async () => {
+		const wait = MIN_SEND_GAP_MS - (Date.now() - lastSendAt);
+		if (wait > 0) await sleep$2(wait);
+		const { fileName, data } = buildMdReply(finalText);
+		try {
+			await sendFile({
+				baseUrl: account.baseUrl,
+				token: account.botToken,
+				to,
+				data,
+				fileName,
+				kind: "file",
+				contextToken: ctx
+			});
+			log(`final as md file: ${fileName} (${finalText.length} chars)`);
+		} catch (e) {
+			log("send md file failed, fallback to text:", String(e));
+			await reply(account, to, ctx, finalText, MessageState.FINISH, fallbackToken).catch((er) => handleSendError(er, account));
+		}
+		lastSendAt = Date.now();
+	});
+	return replyChain;
+}
+/** 从解密后的字节嗅探图片 MIME。 */
+function sniffMime(b) {
+	const h = b.subarray(0, 4).toString("hex");
+	if (h.startsWith("89504e47")) return "image/png";
+	if (h.startsWith("47494638")) return "image/gif";
+	if (h.startsWith("52494646")) return "image/webp";
+	return "image/jpeg";
+}
+async function handleMessage(account, ctx, to, text, imageItems, createTimeMs, latestToken) {
+	const msgAge = () => createTimeMs ? `${Math.round((Date.now() - createTimeMs) / 1e3)}s` : "?";
+	activeTurn = {
+		from: to,
+		token: ctx
+	};
+	const cx = () => activeTurn?.token ?? ctx;
+	await setTyping(account, to, cx(), 1);
+	const keepAlive = setInterval(() => {
+		setTyping(account, to, cx(), 1).catch(() => {});
+	}, 5e3);
+	const t0 = Date.now();
+	let lastProgressAt = Date.now();
+	const sendProgress = (msg) => {
+		lastProgressAt = Date.now();
+		const b = budgetOf(to);
+		if (b.awaiting) return;
+		const sendWithTyping = (text) => {
+			sendOrdered(account, to, cx(), text, MessageState.GENERATING).then(() => setTyping(account, to, cx(), 1)).catch(() => {});
+		};
+		if (b.count >= CONSEC_SEND_LIMIT - 2) {
+			b.count += 1;
+			b.awaiting = true;
+			sendWithTyping("⚠️ 接近微信连续消息上限，我先暂停进度提示、继续在后台处理；完成后会把结果直接发给你。想立刻恢复进度可回复「继续」。");
+			return;
+		}
+		b.count += 1;
+		sendWithTyping(msg);
+	};
+	if (imageItems.length === 0) {
+		const t = cx();
+		log(`turn start to=${to} msgAge=${msgAge()} usingCtx=…${t ? t.slice(-12) : "NONE"}`);
+		sendProgress("🤖 收到，正在处理…");
+	}
+	let hbCount = 0;
+	let answerNoticeSent = false;
+	const heartbeat = setInterval(() => {
+		if (Date.now() - lastProgressAt >= HEARTBEAT_MS) {
+			hbCount += 1;
+			sendProgress(hbCount === 1 ? "🤔 还在思考/检索中…" : `⏳ 仍在处理中…（已 ${Math.round((Date.now() - t0) / 1e3)} 秒）`);
+		}
+	}, HEARTBEAT_MS);
+	const images = [];
+	if (imageItems.length > 0) {
+		sendProgress(`🖼️ 收到 ${imageItems.length} 张图片，下载识别中…`);
+		for (const im of imageItems) try {
+			const buf = await downloadImage(im);
+			images.push({
+				data: buf.toString("base64"),
+				mimeType: sniffMime(buf)
+			});
+		} catch (e) {
+			log("image download failed:", String(e));
+		}
+	}
+	if (images.length > 0 && !supportsImages()) {
+		clearInterval(keepAlive);
+		clearInterval(heartbeat);
+		await setTyping(account, to, cx(), 2);
+		budgetOf(to).count += 1;
+		try {
+			await sendOrdered(account, to, cx(), "🖼️ 当前大脑暂不支持看图，请改用文字描述，或切换到支持图片的大脑。", MessageState.FINISH);
+			log("image unsupported by current brain; rejected gracefully");
+		} finally {
+			activeTurn = null;
+		}
+		return;
+	}
+	const attempt = (promptText, imgs) => {
+		let step = 0;
+		let lastToolProgressAt = 0;
+		return askBrain(to, promptText, (ev) => {
+			if (ev.type === "tool") {
+				lastProgressAt = Date.now();
+				if (Date.now() - lastToolProgressAt >= 15e3) {
+					lastToolProgressAt = Date.now();
+					step += 1;
+					const desc = ev.purpose || (ev.title ? zhTool(ev.title) : "") || "调用工具";
+					sendProgress(`${toolIcon(ev.kind)} 步骤 ${step}：${desc}`);
+				}
+			} else if (ev.type === "thinking") lastProgressAt = Date.now();
+			else if (ev.type === "answer") {
+				if (!answerNoticeSent) {
+					answerNoticeSent = true;
+					sendProgress("✍️ 正在整理回复…");
+				}
+			} else lastProgressAt = Date.now();
+		}, imgs);
+	};
+	const runWithRetry = async (promptText, imgs) => {
+		let n = 0;
+		while (true) {
+			n++;
+			try {
+				return await attempt(promptText, imgs);
+			} catch (e) {
+				const cat = classifyBrainError(e);
+				log(`brain error (try ${n}, ${cat}): ${String(e)}`);
+				if (n < (cat === "backend" ? 3 : 2)) {
+					sendProgress(cat === "backend" ? "⚠️ 模型后端临时出错，正在重试…" : "⏳ 响应中断了，正在自动重试…");
+					continue;
+				}
+				throw e;
+			}
+		}
+	};
+	let answer;
+	try {
+		answer = await runWithRetry(text, images);
+	} catch (e2) {
+		answer = brainErrorMessage(e2);
+	} finally {
+		clearInterval(keepAlive);
+		clearInterval(heartbeat);
+	}
+	await setTyping(account, to, cx(), 2);
+	const { images: replyImages, text: cleaned } = extractImages(answer || "");
+	const failedImgs = [];
+	for (const im of replyImages) try {
+		const buf = await resolveImageBytes(im.src);
+		await sendImage({
+			baseUrl: account.baseUrl,
+			token: account.botToken,
+			to,
+			image: buf,
+			contextToken: cx()
+		});
+		log(`sent image: ${im.src.slice(0, 80)}`);
+	} catch (e) {
+		log("send image failed:", im.src, String(e));
+		failedImgs.push(im.src);
+	}
+	let finalText = cleaned;
+	if (failedImgs.length) {
+		const note = `（有 ${failedImgs.length} 张图片我没能下载下来，附原链接：\n${failedImgs.join("\n")}）`;
+		finalText = finalText ? `${finalText}\n\n${note}` : note;
+	}
+	if (!finalText && !replyImages.length) finalText = "（没有内容）";
+	if (finalText) {
+		budgetOf(to).count += 1;
+		log(`final send: msgAge=${msgAge()} sent=${budgetOf(to).count} len=${finalText.length}`);
+		const ft = latestToken ? latestToken() : void 0;
+		if (finalText.length > LONG_REPLY_THRESHOLD) await sendMdOrdered(account, to, cx(), finalText, ft);
+		else await sendOrdered(account, to, cx(), finalText, MessageState.FINISH, ft);
+	}
+	log(`replied to ${to} (msgAge=${msgAge()}): ${(answer || "").slice(0, 60)}`);
+	activeTurn = null;
+}
+const msgQueue = [];
+let wakeWorker = null;
+function notifyWorker() {
+	const w = wakeWorker;
+	wakeWorker = null;
+	if (w) w();
+}
+/** 发件人鉴权：账号本人(owner，始终允许，作安全兜底) 或 在 allowFrom 授权清单中。 */
+function isAuthorized(from, owner) {
+	return !!from && (from === owner || isAllowed(from));
+}
+async function pollerLoop(account, owner, state) {
+	while (true) {
+		if (isSessionPaused(account.botId)) {
+			await sleep$2(Math.min(getRemainingPauseMs(account.botId), 6e4) || 6e4);
+			continue;
+		}
+		let resp;
+		try {
+			resp = await getUpdates({
+				baseUrl: account.baseUrl,
+				token: account.botToken,
+				updatesBuf: state.updatesBuf,
+				timeoutMs: 25e3
+			});
+		} catch (e) {
+			log("getUpdates error:", String(e));
+			await sleep$2(2e3);
+			continue;
+		}
+		try {
+			if (resp.errcode === -14) {
+				log("session expired (-14); pausing 1h. Send a WeChat message to revive after re-login.");
+				pauseSession(account.botId);
+				continue;
+			}
+			if (resp.errcode) {
+				log("server error:", resp.errcode, resp.errmsg);
+				await sleep$2(2e3);
+				continue;
+			}
+			if (resp.get_updates_buf) state.updatesBuf = resp.get_updates_buf;
+			const news = (resp.msgs ?? []).filter((m) => m.message_type === MessageType.USER && m.message_id && m.message_id > state.lastMessageId);
+			for (const m of news) {
+				const f = m.from_user_id ?? "";
+				if (isAuthorized(f, owner)) log(`recv msg id=${m.message_id} ctx=…${m.context_token ? m.context_token.slice(-12) : "NONE"} age=${m.create_time_ms ? Math.round((Date.now() - m.create_time_ms) / 1e3) + "s" : "?"}`);
+				if (m.context_token) state.contextTokens[`${account.botId}:${f}`] = m.context_token;
+			}
+			let enq = false;
+			for (const msg of news) {
+				state.lastMessageId = Math.max(state.lastMessageId, msg.message_id ?? 0);
+				const from = msg.from_user_id ?? "";
+				if (!isAuthorized(from, owner)) {
+					log("ignore unauthorized sender:", from);
+					continue;
+				}
+				const text = extractText(msg);
+				const voiceItem = (msg.item_list ?? []).find((it) => it.type === MessageItemType.VOICE)?.voice_item;
+				if (voiceItem) log(`recv voice: text=${voiceItem.text ? `"${voiceItem.text.slice(0, 30)}"` : "(空,无微信转写)"} playtime=${voiceItem.playtime ?? "?"}`);
+				const imageItems = (msg.item_list ?? []).filter((it) => it.type === MessageItemType.IMAGE && it.image_item).map((it) => it.image_item);
+				if (!text && imageItems.length === 0) {
+					log("skip empty/unsupported message");
+					continue;
+				}
+				const b = budgetOf(from);
+				const wasAwaiting = b.awaiting;
+				b.count = 0;
+				b.awaiting = false;
+				if (text.trim() === "继续" && activeTurn && activeTurn.from === from && wasAwaiting) {
+					activeTurn.token = msg.context_token ?? activeTurn.token;
+					log("收到「继续」(等待中) → 恢复进度、重置计数、换新 token");
+					continue;
+				}
+				msgQueue.push({
+					from,
+					text,
+					imageItems,
+					createTimeMs: msg.create_time_ms,
+					contextToken: msg.context_token
+				});
+				enq = true;
+			}
+			saveState(state);
+			if (enq) notifyWorker();
+		} catch (e) {
+			log("poller error:", e instanceof Error ? e.stack || e.message : String(e));
+		}
+	}
+}
+async function workerLoop(account, state) {
+	while (true) {
+		if (isSessionPaused(account.botId)) {
+			await sleep$2(Math.min(getRemainingPauseMs(account.botId), 3e4) || 3e4);
+			continue;
+		}
+		if (msgQueue.length === 0) {
+			await new Promise((r) => {
+				wakeWorker = r;
+				if (msgQueue.length > 0) {
+					wakeWorker = null;
+					r();
+				}
+			});
+			continue;
+		}
+		const item = msgQueue.shift();
+		const from = item.from;
+		const token = item.contextToken;
+		const latestToken = () => state.contextTokens[`${account.botId}:${from}`];
+		const ctrl = item.text ? parseControl(item.text) : null;
+		if (ctrl) {
+			let r;
+			try {
+				r = await handleControl(ctrl, from);
+			} catch (e) {
+				r = "处理指令出错：" + String(e);
+			}
+			log("control:", JSON.stringify(ctrl), "->", r.replace(/\n/g, " | "));
+			await reply(account, from, token, r, MessageState.FINISH, latestToken()).catch((e) => handleSendError(e, account));
+			continue;
+		}
+		const tcmd = item.text ? parseTaskControl(item.text) : null;
+		if (tcmd?.kind === "stop") {
+			const r = stopTask(from);
+			log("task: stop ->", r);
+			await reply(account, from, token, r, MessageState.FINISH, latestToken()).catch((e) => handleSendError(e, account));
+			continue;
+		}
+		if (tcmd?.kind === "toWorker") {
+			if (hasActiveTask(from)) {
+				log("task: inject(explicit):", tcmd.text.slice(0, 40));
+				injectTask(from, tcmd.text);
+			} else await reply(account, from, token, dispatchTask(from, tcmd.text), MessageState.FINISH, latestToken()).catch((e) => handleSendError(e, account));
+			continue;
+		}
+		const brainEscape = item.text ? parseBrainEscape(item.text) : null;
+		if (!brainEscape && item.imageItems.length === 0 && isAwaiting(from)) {
+			log("task: inject(awaiting):", item.text.slice(0, 40));
+			injectTask(from, item.text);
+			continue;
+		}
+		const brainText = brainEscape ?? item.text;
+		try {
+			await handleMessage(account, token, from, brainText, item.imageItems, item.createTimeMs, latestToken);
+		} catch (e) {
+			log("handleMessage error:", e instanceof Error ? e.stack || e.message : String(e));
+			await reply(account, from, token, "处理这条消息时出错了，请再发一次试试。", MessageState.FINISH, latestToken()).catch((e2) => handleSendError(e2, account));
+		}
+	}
+}
+const TASK_INBOX_DIR = path.join(DATA_DIR, "task-inbox");
+const TASK_STATE_FILE = path.join(DATA_DIR, "task-state.json");
+const TASK_SCAN_MS = Number(process.env.WEMIND_TASK_SCAN_MS) || 1e3;
+/** 扫描 task-inbox：按文件名(时间戳)升序逐个读、分发到 task-manager（dispatch/reply/stop）、删文件。本地命令默认作用于 owner。 */
+function scanTaskInbox(owner) {
+	let files;
+	try {
+		files = fs.readdirSync(TASK_INBOX_DIR).filter((f) => f.endsWith(".json"));
+	} catch {
+		return;
+	}
+	if (!files.length) return;
+	files.sort();
+	for (const f of files) {
+		const fp = path.join(TASK_INBOX_DIR, f);
+		let cmd;
+		try {
+			cmd = JSON.parse(fs.readFileSync(fp, "utf-8"));
+		} catch {
+			try {
+				fs.unlinkSync(fp);
+			} catch {}
+			continue;
+		}
+		try {
+			fs.unlinkSync(fp);
+		} catch {}
+		try {
+			if (cmd.kind === "dispatch") log("local task dispatch:", dispatchTask(owner, String(cmd.text ?? ""), cmd.cwd ? String(cmd.cwd) : void 0).slice(0, 50));
+			else if (cmd.kind === "reply") {
+				injectTask(owner, String(cmd.text ?? ""));
+				log("local task reply:", String(cmd.text ?? "").slice(0, 40));
+			} else if (cmd.kind === "stop") log("local task stop:", stopTask(owner));
+			else log("unknown task-inbox cmd:", cmd.kind);
+		} catch (e) {
+			log("task-inbox dispatch error:", String(e));
+		}
+	}
+}
+async function runDaemon() {
+	const agent = resolveAgent(loadBrainConfig());
+	const brainProblem = agentProblem(agent);
+	if (brainProblem) {
+		log(`FATAL 大脑不可用：${brainProblem}`);
+		process.exit(78);
+	}
+	log(`brain=${agent.name} bin=${agent.bin} args=[${agent.args.join(" ")}] shell=${agent.shell} (source: ${agent.source})`);
+	const account = loadAccount();
+	if (!account?.botToken) {
+		log("not logged in; run the MCP login_qrcode flow first.");
+		process.exit(1);
+	}
+	const owner = process.env.WECHAT_OWNER_ID?.trim() || account.userId;
+	if (owner) addAllowFrom(owner, DATA_DIR);
+	const pidFile = path.join(DATA_DIR, "daemon.pid");
+	try {
+		fs.writeFileSync(pidFile, String(process.pid), "utf-8");
+	} catch {}
+	const cleanupPid = () => {
+		try {
+			fs.unlinkSync(pidFile);
+		} catch {}
+	};
+	process.on("exit", cleanupPid);
+	process.on("SIGINT", () => {
+		cleanupPid();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		cleanupPid();
+		process.exit(0);
+	});
+	process.on("unhandledRejection", (reason) => {
+		log("unhandledRejection:", reason instanceof Error ? reason.stack || reason.message : String(reason));
+	});
+	process.on("uncaughtException", (err) => {
+		log("uncaughtException:", err?.stack || String(err));
+	});
+	ensureBrainHome();
+	ensureWorkerHome();
+	log(`up. bot=${account.botId} owner=${owner} allowFrom=${readAllowFrom(DATA_DIR).length}`);
+	await notifyStart({
+		baseUrl: account.baseUrl,
+		token: account.botToken
+	}).catch(() => {});
+	const state = loadState();
+	setTaskPush((to, text) => {
+		const tok = state.contextTokens[`${account.botId}:${to}`];
+		budgetOf(to).count += 1;
+		sendOrdered(account, to, tok, text, MessageState.FINISH, tok);
+	});
+	setTaskTyping((to) => {
+		setTyping(account, to, state.contextTokens[`${account.botId}:${to}`], 1);
+	});
+	setTaskStateSink((snap) => {
+		try {
+			const tmp = `${TASK_STATE_FILE}.tmp-${process.pid}`;
+			fs.writeFileSync(tmp, JSON.stringify(snap, null, 2), "utf-8");
+			fs.renameSync(tmp, TASK_STATE_FILE);
+		} catch {}
+	});
+	try {
+		fs.rmSync(TASK_INBOX_DIR, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	try {
+		fs.mkdirSync(TASK_INBOX_DIR, { recursive: true });
+	} catch {}
+	setInterval(() => scanTaskInbox(owner), TASK_SCAN_MS);
+	pollerLoop(account, owner, state);
+	await workerLoop(account, state);
+}
+//#endregion
+//#region src/pm2-runner.ts
+function pm2Run(cmd, opts = {}) {
+	return spawnSync(`pm2 ${cmd}`, {
+		shell: true,
+		stdio: opts.quiet ? "ignore" : "inherit",
+		env: opts.env ?? process.env,
+		windowsHide: true
+	});
+}
+/** pm2 是否已全局安装、可用。 */
+function pm2Available() {
+	try {
+		return pm2Run("-v", { quiet: true }).status === 0;
+	} catch {
+		return false;
+	}
+}
+/** 账号的 daemon 日志路径，与 run-daemon.ps1 / ecosystem 方式一致：`~/.wemind/<key>/daemon.log`。 */
+function daemonLogPath(key) {
+	const root = process.env.WEMIND_HOME?.trim() || path.join(os.homedir(), ".wemind");
+	return path.join(root, key, "daemon.log");
+}
+/** 用 pm2 启动某账号的 daemon：app 名 `wemind-<key>`，注入 WECHAT_ACCOUNT，日志归一到账号 daemon.log。 */
+function pm2Start(key, cliPath) {
+	if (!pm2Available()) return {
+		ok: false,
+		msg: "未检测到 pm2。请先安装：npm i -g pm2，再重试 `wemind start`。"
+	};
+	const name = `wemind-${key}`;
+	const log = daemonLogPath(key);
+	pm2Run(`delete ${name}`, { quiet: true });
+	const r = pm2Run(`start "${cliPath}" --name ${name} --interpreter node --output "${log}" --error "${log}" --merge-logs -- daemon`, { env: {
+		...process.env,
+		WECHAT_ACCOUNT: key
+	} });
+	if (r.status !== 0) return {
+		ok: false,
+		msg: `pm2 启动失败（exit=${r.status}）。`
+	};
+	pm2Run("save", { quiet: true });
+	return {
+		ok: true,
+		msg: `已用 pm2 启动 ${name}（日志：${log}）。\n  开机自启（首次）：执行 \`pm2 startup\`——Linux/macOS 按提示操作；Windows 用计划任务跑 \`pm2 resurrect\`。`
+	};
+}
+/** 停止某账号的 daemon（pm2 delete）。 */
+function pm2Stop(key) {
+	if (!pm2Available()) return {
+		ok: false,
+		msg: "未检测到 pm2。"
+	};
+	const name = `wemind-${key}`;
+	const r = pm2Run(`delete ${name}`, { quiet: true });
+	pm2Run("save", { quiet: true });
+	return r.status === 0 ? {
+		ok: true,
+		msg: `已停止 ${name}。`
+	} : {
+		ok: false,
+		msg: `${name} 未在运行，或停止失败。`
+	};
+}
+//#endregion
+//#region src/proc-identity.ts
+/** pid 是否活着（零成本，仅探活；不代表是我们的进程）。 */
+function isAlive(pid) {
+	if (pid === null || pid === void 0 || !Number.isInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** 归一化：小写 + 反斜杠统一成正斜杠，便于跨平台、跨相对/绝对路径匹配。 */
+function normalize(s) {
+	return s.replaceAll("\\", "/").toLowerCase();
+}
+/**
+* 取文件名。**不依赖平台**：`/` 与 `\` 都当分隔符——
+* POSIX 的 `path.basename` 不认 `\`，会把 Windows 风格路径整条留下（CI 上踩过）。
+*/
+function baseName(p) {
+	const i = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+	return i >= 0 ? p.slice(i + 1) : p;
+}
+/** 某条命令行是否命中「任一 marker 组合」（组合内每个 token 都必须出现、大小写与斜杠不敏感）。 */
+function matchesMarkers(line, markerSets) {
+	if (!line) return false;
+	const hay = normalize(line);
+	return markerSets.some((set) => set.length > 0 && set.every((t) => hay.includes(normalize(t))));
+}
+function parsePipePairs(stdout, out) {
+	for (const raw of stdout.split(/\r?\n/)) {
+		const i = raw.indexOf("|");
+		if (i <= 0) continue;
+		const pid = Number.parseInt(raw.slice(0, i).trim(), 10);
+		if (Number.isInteger(pid) && pid > 0) out.set(pid, raw.slice(i + 1));
+	}
+}
+/**
+* 批量查询 pid → 命令行。查不到（不存在 / 无权限 / 平台不支持）的 pid 不会出现在结果里。
+* 只查询「活着的」pid（调用方传一堆陈旧 pid 也不会白白起进程）。
+*/
+function commandLines(pids) {
+	const out = /* @__PURE__ */ new Map();
+	const list = [...new Set(pids.filter((p) => isAlive(p)))];
+	if (!list.length) return out;
+	try {
+		if (process.platform === "win32") parsePipePairs(spawnSync(path.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			`Get-CimInstance Win32_Process -Filter "${list.map((p) => `ProcessId=${p}`).join(" or ")}" | ForEach-Object { "$($_.ProcessId)|$($_.CommandLine)" }`
+		], {
+			encoding: "utf8",
+			windowsHide: true,
+			timeout: 15e3
+		}).stdout ?? "", out);
+		else if (process.platform === "linux") for (const p of list) try {
+			out.set(p, fs.readFileSync(`/proc/${p}/cmdline`, "utf-8").replaceAll("\0", " ").trim());
+		} catch {}
+		else for (const p of list) {
+			const line = (spawnSync("ps", [
+				"-o",
+				"command=",
+				"-p",
+				String(p)
+			], {
+				encoding: "utf8",
+				timeout: 5e3
+			}).stdout ?? "").trim();
+			if (line) out.set(p, line);
+		}
+	} catch {}
+	return out;
+}
+/** 该 pid 是否「活着**且确实是我们自己的**进程」（命令行命中 markerSets 之一）。 */
+function isOurProcess(pid, markerSets) {
+	if (!isAlive(pid)) return false;
+	return matchesMarkers(commandLines([pid]).get(pid), markerSets);
+}
+/**
+* 我们自己的 CLI / wrapper 进程特征：命令行里同时含 `wemind` + `cli.js`。
+*
+* 这串必须同时覆盖**三种**安装方式（少一种 → 对应场景下 stop/list/单实例判断全失效）：
+*  - 源码仓库：`<node> D:\repo\WeMind\packages\wechat-daemon\dist\cli.js daemon`
+*    （由 marker 组合里的 `wemind` 命中仓库名 WeMind；注意大小写不敏感比较在下面已处理）；
+*  - 全局/本地安装：`<node> …/node_modules/@wemind/cli/dist/cli.js daemon`
+*    （npm 的 bin shim 最终 exec 的正是这个路径；Windows 上可能走 `…\@wemind\cli\dist\cli.js` 短路径。
+*     两种形态都命中 marker 里的 `wemind`——它同时是 scope 名与命令名）；
+*  - 源码开发期的 PowerShell wrapper：`pwsh -File …\scripts\run-daemon.ps1`。
+*
+* 注意**不能**再用 `wechat-daemon`：那是源码目录名，发布到 npm 后包目录叫 `@wemind/cli`，
+* 用目录名做特征会让「装出来的 wemind」永远匹配不上，从而 list 永远显示「已停止」。
+*/
+const CLI_PID_MARKERS = [["wemind", "cli.js"], ["run-daemon.ps1"]];
+/**
+* 大脑进程特征：`<bin> <args…>`（如 `opencode acp`、`kiro-cli acp`）。
+* 取 bin 的**文件名**并去掉扩展名，兼顾 shell=true（命令行是原始命令）与 `--bin` 绝对路径两种情况；
+* args 是关键区分位——用户自己的 `opencode serve`（本机 OpenCode 服务）不含 `acp`，不会被误判。
+* bin 为空（配置异常）时返回空数组 → matchesMarkers 恒判否，绝不误杀。
+*/
+function brainPidMarkers(bin, args) {
+	const name = baseName(bin ?? "").replace(/\.(exe|cmd|bat|ps1)$/i, "");
+	if (!name) return [];
+	return [[name, ...args].filter((t) => t !== "")];
+}
+//#endregion
+//#region src/watchdog-runner.ts
+const RESTART_DELAY_MS = 5e3;
+const sleep$1 = (ms) => new Promise((r) => setTimeout(r, ms));
+function readPidFile(file) {
+	try {
+		const n = Number.parseInt(fs.readFileSync(file, "utf-8").trim(), 10);
+		return Number.isInteger(n) && n > 0 ? n : null;
+	} catch {
+		return null;
+	}
+}
+/** 单实例守卫：已有存活**且确认是我们**的看门狗返回 false；否则写自己 pid、返回 true。 */
+function acquireSingleton(wrapperPidFile) {
+	const old = readPidFile(wrapperPidFile);
+	if (old && isOurProcess(old, CLI_PID_MARKERS)) return false;
+	fs.writeFileSync(wrapperPidFile, String(process.pid), "ascii");
+	return true;
+}
+/** 看门狗循环本体（由 `cli.js _watchdog` 调用，常驻）：单实例守卫 → 循环拉起 daemon、退出 5s 重拉。 */
+async function runWatchdog() {
+	const dataDir = DATA_DIR;
+	fs.mkdirSync(dataDir, { recursive: true });
+	const log = path.join(dataDir, "daemon.log");
+	const wrapperPidFile = path.join(dataDir, "wrapper.pid");
+	if (!acquireSingleton(wrapperPidFile)) {
+		fs.appendFileSync(log, `[wemind/wechat-daemon/wrapper] 已有实例在跑，本次退出。${(/* @__PURE__ */ new Date()).toISOString()}\n`);
+		return;
+	}
+	const cleanup = () => {
+		try {
+			if (readPidFile(wrapperPidFile) === process.pid) fs.unlinkSync(wrapperPidFile);
+		} catch {}
+	};
+	process.on("exit", cleanup);
+	process.on("SIGINT", () => {
+		cleanup();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		cleanup();
+		process.exit(0);
+	});
+	const cliPath = process.argv[1];
+	for (;;) {
+		fs.appendFileSync(log, `[wemind/wechat-daemon/wrapper] start daemon ${(/* @__PURE__ */ new Date()).toISOString()}\n`);
+		const logFd = fs.openSync(log, "a");
+		const child = spawn(process.execPath, [cliPath, "daemon"], {
+			env: process.env,
+			stdio: [
+				"ignore",
+				logFd,
+				logFd
+			],
+			windowsHide: true
+		});
+		const code = await new Promise((resolve) => {
+			child.on("exit", (c) => resolve(c ?? -1));
+			child.on("error", () => resolve(-1));
+		});
+		try {
+			fs.closeSync(logFd);
+		} catch {}
+		if (code === 78) {
+			fs.appendFileSync(log, `[wemind/wechat-daemon/wrapper] 大脑配置错误（exit ${code}），已停止自动重启。修好后执行：wemind start <账号>\n`);
+			return;
+		}
+		fs.appendFileSync(log, `[wemind/wechat-daemon/wrapper] daemon exited (code=${code}), restart in 5s ${(/* @__PURE__ */ new Date()).toISOString()}\n`);
+		await sleep$1(RESTART_DELAY_MS);
+	}
+}
+/** 从 manage 脱离式启动某账号的看门狗（方案 b：builtin runner）。 */
+function watchdogStart(key, cliPath) {
+	const child = spawn(process.execPath, [cliPath, "_watchdog"], {
+		detached: true,
+		stdio: "ignore",
+		windowsHide: true,
+		env: {
+			...process.env,
+			WECHAT_ACCOUNT: key
+		}
+	});
+	child.unref();
+	return {
+		ok: true,
+		msg: `已启动自带看门狗（账号 ${key}，看门狗 pid ${child.pid}）。日志：${path.join(accountDir(key), "daemon.log")}`
+	};
+}
+//#endregion
+//#region src/brain-check.ts
+async function checkAgent(ag, timeoutMs = 6e4) {
+	const started = Date.now();
+	const home = fs.mkdtempSync(path.join(os.tmpdir(), "wemind-brain-check-"));
+	const env = { ...process.env };
+	if (ag.homeEnvVar) env[ag.homeEnvVar] = home;
+	for (const [k, v] of Object.entries(ag.env ?? {})) env[k] = v.replaceAll("%HOME%", home);
+	const proc = spawnAgent(ag, {
+		cwd: home,
+		env
+	});
+	let buf = "";
+	let seq = 0;
+	const pending = /* @__PURE__ */ new Map();
+	const settleAll = (msg) => {
+		for (const [id, done] of pending) {
+			pending.delete(id);
+			done({
+				id,
+				error: { message: msg }
+			});
+		}
+	};
+	proc.stdout.on("data", (d) => {
+		buf += d.toString();
+		let i;
+		while ((i = buf.indexOf("\n")) >= 0) {
+			const line = buf.slice(0, i).trim();
+			buf = buf.slice(i + 1);
+			if (!line) continue;
+			let frame;
+			try {
+				frame = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (typeof frame.id === "number" && pending.has(frame.id)) {
+				const done = pending.get(frame.id);
+				pending.delete(frame.id);
+				done(frame);
+			}
+		}
+	});
+	const stderrTail = [];
+	proc.stderr.on("data", (d) => {
+		stderrTail.push(d.toString());
+		if (stderrTail.length > 20) stderrTail.shift();
+	});
+	proc.on("error", (e) => settleAll(`无法启动：${String(e)}`));
+	proc.on("exit", (code) => settleAll(`进程已退出（code=${code}）`));
+	const req = (method, params) => new Promise((resolve, reject) => {
+		const id = ++seq;
+		const t = setTimeout(() => {
+			pending.delete(id);
+			reject(/* @__PURE__ */ new Error(`${method} 超时（${timeoutMs}ms）`));
+		}, timeoutMs);
+		pending.set(id, (frame) => {
+			clearTimeout(t);
+			if (frame?.error) reject(new Error(typeof frame.error === "string" ? frame.error : JSON.stringify(frame.error)));
+			else resolve(frame?.result);
+		});
+		proc.stdin.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		}) + "\n");
+	});
+	try {
+		await req("initialize", {
+			protocolVersion: 1,
+			clientCapabilities: {}
+		});
+		return {
+			ok: true,
+			detail: `ACP 握手成功（initialize + session/new，sessionId=${(await req("session/new", {
+				cwd: home,
+				mcpServers: []
+			}))?.sessionId ?? "?"}）`,
+			ms: Date.now() - started
+		};
+	} catch (e) {
+		const tail = stderrTail.join("").trim().slice(-400);
+		return {
+			ok: false,
+			detail: `${e instanceof Error ? e.message : String(e)}${tail ? `\n  stderr: ${tail}` : ""}`,
+			ms: Date.now() - started
+		};
+	} finally {
+		try {
+			if (process.platform === "win32" && proc.pid) spawnSync("taskkill", [
+				"/PID",
+				String(proc.pid),
+				"/T",
+				"/F"
+			], {
+				stdio: "ignore",
+				windowsHide: true
+			});
+			else proc.kill();
+		} catch {}
+		try {
+			fs.rmSync(home, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+//#endregion
+//#region src/version.ts
+/**
+* CLI 版本号（`wemind version` / `wemind --version` / help 头部）。
+* 与 package.json 的 version 必须一致——单测 version.test.ts 会读 package.json 校验，
+* 避免「发了新版本、CLI 还报旧版本号」这种排查成本极高的小漂移。
+*/
+const CLI_VERSION = "1.0.0";
+/**
+* npm 包名（与 package.json 的 name 一致，单测校验）。
+* 命令名是 `wemind`，但**包名**是 `@wemind/cli`——两者不同，所以 `npx` 不能靠「唯一 bin」自动解析，
+* 必须写全 `npx @wemind/cli`（见 README 与 docs/发布-wemind-npm.md）。
+*/
+const CLI_PKG_NAME = "@wemind/cli";
+/** 单行版本串（供 --version 输出）：命令名 + 版本，包名放括号里便于反馈问题时对上 npm 页面。 */
+function versionLine() {
+	return `wemind ${CLI_VERSION} (${CLI_PKG_NAME}, node ${process.versions.node}, ${process.platform}-${process.arch})`;
+}
+//#endregion
+//#region src/manage.ts
+/**
+* WeMind 多账号管理 CLI。
+* 账号 key = 由微信 botId 派生的唯一标识；每个账号独立目录 ~/.wemind/<key>。
+* label = 人类可读别名（可改、可重复）；管理命令可用 key 或 label 选择账号。
+* 推荐用 `login` 一条命令完成：自刷新二维码 → 扫码 → 自动归档（→ 可选自动启动）。
+*/
+const BASE = process.env.WEMIND_ILINK_BASE?.trim() || "https://ilinkai.weixin.qq.com";
+const STAGING = path.join(WEMIND_ROOT, ".staging");
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function readAccount(dir) {
+	try {
+		return JSON.parse(fs.readFileSync(path.join(dir, "account.json"), "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function readPid(dir, name) {
+	try {
+		const n = parseInt(fs.readFileSync(path.join(dir, name), "utf-8").trim(), 10);
+		return Number.isFinite(n) ? n : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 该 pid 是否「活着**且确实是我们自己的** CLI 进程」。
+* 只判存活不够：pid 会复用（尤其重启后），陈旧 pid 文件可能指向**别人的**进程 → 会误杀/误判。
+*/
+function aliveOurs(pid, markers = CLI_PID_MARKERS) {
+	return isOurProcess(pid, markers);
+}
+function killPid(pid) {
+	if (process.platform === "win32") spawnSync("taskkill", [
+		"/PID",
+		String(pid),
+		"/T",
+		"/F"
+	], {
+		stdio: "ignore",
+		windowsHide: true
+	});
+	else try {
+		process.kill(pid);
+	} catch {}
+}
+function openFile(p) {
+	try {
+		if (process.platform === "win32") spawn("cmd", [
+			"/c",
+			"start",
+			"",
+			p
+		], {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true
+		}).unref();
+		else spawn(process.platform === "darwin" ? "open" : "xdg-open", [p], {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+	} catch {}
+}
+/** key 或 label → key（label 唯一匹配才行）。 */
+function resolveKey(arg) {
+	if (!arg) throw new Error("需要 <key 或 label>");
+	const accs = listAccounts();
+	if (accs.some((a) => a.key === arg)) return arg;
+	const byLabel = accs.filter((a) => a.label === arg);
+	if (byLabel.length === 1) return byLabel[0].key;
+	if (byLabel.length > 1) throw new Error(`label「${arg}」对应多个账号，请改用 key：${byLabel.map((a) => a.key).join(", ")}`);
+	throw new Error(`未找到账号：${arg}（既不是 key 也不是 label）`);
+}
+/** 启动某账号的 daemon（方案 a：委托 pm2 常驻，跑 `wemind daemon`，注入 WECHAT_ACCOUNT）。 */
+function startDaemon(key, runner) {
+	const cliPath = process.argv[1] || path.join(path.dirname(fileURLToPath(import.meta.url)), "cli.js");
+	stopDaemon(key);
+	const useRunner = (runner || process.env.WEMIND_RUNNER || "builtin").toLowerCase();
+	console.log((useRunner === "pm2" ? pm2Start(key, cliPath) : watchdogStart(key, cliPath)).msg);
+}
+/** 停止某账号的常驻：先 pm2 delete（方案 a），再按 pid 兜底杀 wrapper/daemon/brain（兼容直接启动的）。 */
+function stopDaemon(key) {
+	pm2Stop(key);
+	const dir = accountDir(key);
+	const ag = resolveAgent(loadBrainConfig(dir));
+	const cand = [
+		{
+			pid: readPid(dir, "wrapper.pid"),
+			name: "wrapper",
+			markers: CLI_PID_MARKERS
+		},
+		{
+			pid: readPid(dir, "daemon.pid"),
+			name: "daemon",
+			markers: CLI_PID_MARKERS
+		},
+		{
+			pid: readPid(dir, "brain.pid"),
+			name: "brain",
+			markers: brainPidMarkers(ag.bin, ag.args)
+		}
+	];
+	const lines = commandLines(cand.map((c) => c.pid));
+	const stopped = [];
+	const skipped = [];
+	for (const c of cand) {
+		if (!c.pid || !isAlive(c.pid)) continue;
+		if (matchesMarkers(lines.get(c.pid), c.markers)) {
+			killPid(c.pid);
+			stopped.push(`${c.name} ${c.pid}`);
+		} else skipped.push(`${c.name} ${c.pid}`);
+	}
+	for (const f of [
+		"wrapper.pid",
+		"daemon.pid",
+		"brain.pid"
+	]) try {
+		fs.unlinkSync(path.join(dir, f));
+	} catch {}
+	const parts = [];
+	if (stopped.length) parts.push(`已停止 ${stopped.join(" + ")}`);
+	if (skipped.length) parts.push(`跳过 ${skipped.join(" + ")}（非本程序，未杀；已清陈旧 pid 文件）`);
+	return parts.length ? parts.join("；") : "无运行中的进程";
+}
+/** 把 STAGING 的登录按 botId 归档 + 登记。 */
+function finalizeStaging(label) {
+	const acc = readAccount(STAGING);
+	if (!acc?.botId) throw new Error(`staging 无有效登录（${STAGING}）`);
+	const key = deriveAccountKey(acc.botId);
+	const dest = accountDir(key);
+	if (fs.existsSync(dest)) {
+		fs.rmSync(STAGING, {
+			recursive: true,
+			force: true
+		});
+		throw new Error(`账号目录已存在: ${dest}（该微信号此前已登录过；如需重登请先 delete ${key}）`);
+	}
+	fs.renameSync(STAGING, dest);
+	for (const f of [
+		"qrcode.png",
+		"qrcode.txt",
+		"qr_login.json",
+		"poll.out",
+		"poll.err",
+		"auto.out",
+		"auto.err"
+	]) try {
+		fs.unlinkSync(path.join(dest, f));
+	} catch {}
+	const meta = registerAccount({
+		key,
+		botId: acc.botId,
+		userId: acc.userId,
+		baseUrl: acc.baseUrl,
+		label: label || key
+	});
+	if (acc.userId) addAllowFrom(acc.userId, dest);
+	return {
+		key,
+		msg: `已归档：key=${key}  label=${meta.label}  botId=${acc.botId}\n目录：${dest}`
+	};
+}
+/**
+* 懒加载 `qrcode`：只有扫码登录要画二维码，`list` / `brain` / `task` / `daemon` 全用不上。
+* 顶层 `import` 会让**每次**启动都付约 36ms（实测）解析 qrcode + yargs 依赖树；
+* 这里在第一次画码时才加载，之后同进程内复用（登录过程会因过期刷新多次）。
+* 用函数声明而非 `const QRCode = await import(...)`：后者在 ESM 顶层要多一层 TDZ 心智负担。
+*/
+let qrcodeMod;
+async function loadQrCode() {
+	if (!qrcodeMod) try {
+		qrcodeMod = await import("qrcode");
+	} catch (e) {
+		throw new Error(`无法加载二维码库 qrcode（依赖缺失或安装损坏）：${e instanceof Error ? e.message : String(e)}\n请重试安装：npm i -g @wemind/cli`);
+	}
+	return qrcodeMod;
+}
+/** 一条命令完成扫码登录：自刷新二维码 + 终端码 + 自动开图 + 自动归档（→ 可选自动启动）。 */
+async function cmdLogin(label, autoStart, runner) {
+	const QRCode = await loadQrCode();
+	fs.rmSync(STAGING, {
+		recursive: true,
+		force: true
+	});
+	fs.mkdirSync(STAGING, { recursive: true });
+	const png = path.join(STAGING, "qrcode.png");
+	const overall = Date.now() + 900 * 1e3;
+	let code = "";
+	let opened = false;
+	const refresh = async () => {
+		const qr = await fetchQRCode(BASE);
+		code = qr.qrcode;
+		saveQrState({
+			qrcode: qr.qrcode,
+			qrcodeUrl: qr.qrcode_img_content,
+			createdAt: Date.now()
+		});
+		await QRCode.toFile(png, qr.qrcode_img_content, {
+			width: 480,
+			margin: 2
+		});
+		const term = await QRCode.toString(qr.qrcode_img_content, {
+			type: "terminal",
+			small: true
+		});
+		console.log("\n用要登录的微信扫下面的二维码（过期会自动刷新）：\n");
+		console.log(term);
+		console.log("图片(已自动打开): " + png);
+		console.log("链接: " + qr.qrcode_img_content + "\n");
+		if (!opened) {
+			openFile(png);
+			opened = true;
+		}
+	};
+	await refresh();
+	console.log("等待扫码确认…（最多 15 分钟，Ctrl+C 取消）");
+	while (Date.now() < overall) {
+		let s;
+		try {
+			s = await pollQRStatus(BASE, code);
+		} catch {
+			await sleep(2e3);
+			continue;
+		}
+		if (s.status === "confirmed") {
+			if (!s.bot_token || !s.ilink_bot_id || !s.ilink_user_id) throw new Error("confirmed 但数据不全");
+			fs.writeFileSync(path.join(STAGING, "account.json"), JSON.stringify({
+				botToken: s.bot_token,
+				botId: s.ilink_bot_id,
+				userId: s.ilink_user_id,
+				baseUrl: s.baseurl ?? BASE,
+				savedAt: Date.now()
+			}, null, 2), "utf-8");
+			clearSessionPause(s.ilink_bot_id);
+			await notifyStart({
+				baseUrl: s.baseurl ?? BASE,
+				token: s.bot_token
+			}).catch(() => {});
+			for (const f of ["qrcode.png", "qr_login.json"]) try {
+				fs.unlinkSync(path.join(STAGING, f));
+			} catch {}
+			console.log("\n登录成功，归档中…");
+			const { key, msg } = finalizeStaging(label);
+			console.log(msg);
+			if (autoStart) {
+				startDaemon(key, runner);
+				console.log(`已启动 daemon（账号 ${key}）。`);
+			} else console.log(`启动：wemind start ${key}`);
+			return;
+		}
+		if (s.status === "expired") {
+			console.log("二维码过期，自动刷新…");
+			await refresh();
+			continue;
+		}
+		await sleep(1500);
+	}
+	throw new Error("超时（15 分钟）未完成登录");
+}
+function cmdList() {
+	const def = getDefaultKey();
+	const accs = listAccounts();
+	if (!accs.length) return "（无已登记账号）。用 `login` 添加。";
+	const entries = accs.map((a) => {
+		const dir = accountDir(a.key);
+		const ag = resolveAgent(loadBrainConfig(dir));
+		return {
+			a,
+			dir,
+			dpid: readPid(dir, "daemon.pid"),
+			bpid: readPid(dir, "brain.pid"),
+			brainMarkers: brainPidMarkers(ag.bin, ag.args)
+		};
+	});
+	const lines = commandLines(entries.flatMap((e) => [e.dpid, e.bpid]));
+	const aliveOursIn = (pid, markers) => !!pid && matchesMarkers(lines.get(pid), markers);
+	return entries.map((e) => {
+		const running = aliveOursIn(e.dpid, CLI_PID_MARKERS) ? `运行中(pid ${e.dpid})` : "已停止";
+		const brainPid = aliveOursIn(e.bpid, e.brainMarkers) ? `  brain(pid ${e.bpid})` : "";
+		return `- ${e.a.key}${e.a.key === def ? " [默认]" : ""}  label=${e.a.label}  botId=${e.a.botId}  agent=${agentLabel(e.dir)}  ${running}${brainPid}`;
+	}).join("\n");
+}
+const BRAIN_SRC_LABEL = {
+	env: "环境变量 WEMIND_BRAIN*",
+	file: "账号 brain.json",
+	auto: "自动探测（未配置）"
+};
+/** list 用：账号「配置 / 自动探测」得到的大脑标签（不看当前 shell 的 env，避免误导）。 */
+function agentLabel(dir) {
+	const cfg = loadBrainConfig(dir);
+	if (cfg?.agent && cfg.agent.toLowerCase() !== "auto") return cfg.agent;
+	const picked = AUTO_PROBE_ORDER.find((k) => presetAvailable(k));
+	return picked ? `${picked}（自动）` : "（无可用）";
+}
+/** `wemind brain`（show）：打印某账号大脑的「配置」与「生效」情况。 */
+function describeBrain(key) {
+	const cfg = loadBrainConfig(accountDir(key));
+	const ag = resolveAgent(cfg);
+	const problem = agentProblem(ag);
+	const cfgLine = cfg ? `brain.json → agent=${cfg.agent}${cfg.bin ? ` bin=${cfg.bin}` : ""}${cfg.args ? ` args=[${cfg.args.join(" ")}]` : ""}${cfg.shell !== void 0 ? ` shell=${cfg.shell}` : ""}` : "（未设置 brain.json）";
+	return [
+		`账号 ${key}`,
+		`  配置：${cfgLine}`,
+		`  请求：${ag.requestedKey}    来源：${BRAIN_SRC_LABEL[ag.source]}`,
+		`  生效：name=${ag.name}  bin=${ag.bin}  args=[${ag.args.join(" ")}]  shell=${ag.shell}  home_env=${ag.homeEnvVar ?? "(无)"}`,
+		`  可用：${problem ? `❌ ${problem}` : `✅ ${ag.binPath ?? ag.bin}`}`,
+		`  预设：${Object.keys(ACP_AGENT_PRESETS).join("、")}`,
+		`  自动探测顺序：${AUTO_PROBE_ORDER.join(" → ")}`
+	].join("\n");
+}
+/** `wemind brain set <预设|auto>`：把选择按账号落盘（可选 --bin/--args/--shell；--restart 立即重启 daemon）。 */
+function cmdBrainSet(agentName, key, opts) {
+	const agent = agentName.trim().toLowerCase();
+	if (agent !== "auto" && !ACP_AGENT_PRESETS[agent]) throw new Error(`未知预设「${agentName}」。可选：auto、${Object.keys(ACP_AGENT_PRESETS).join("、")}（自定义二进制用 --bin 搭配任一预设）`);
+	const cfg = { agent };
+	if (opts.bin) cfg.bin = opts.bin;
+	if (opts.args !== void 0) cfg.args = opts.args.trim() ? opts.args.trim().split(/\s+/) : [];
+	if (opts.shell !== void 0) cfg.shell = opts.shell;
+	const dir = accountDir(key);
+	saveBrainConfig(cfg, dir);
+	const lines = [`已设置 ${key} 的大脑：agent=${agent}${cfg.bin ? ` bin=${cfg.bin}` : ""}${cfg.args ? ` args=[${cfg.args.join(" ")}]` : ""}`, `配置文件：${brainConfigPath(dir)}`];
+	if (opts.restart) if (aliveOurs(readPid(dir, "daemon.pid"))) {
+		startDaemon(key);
+		lines.push(`已重启 daemon（账号 ${key}）。`);
+	} else lines.push(`daemon 未在运行，未重启（用 wemind start ${key} 启动）。`);
+	else lines.push(`（daemon 需重启才生效：wemind start ${key}）`);
+	return lines.join("\n");
+}
+/** `wemind brain unset`：清除账号级配置，回退到自动探测/默认。 */
+function cmdBrainUnset(key) {
+	return clearBrainConfig(accountDir(key)) ? `${key} 已清除 brain.json（回退到自动探测/默认）。daemon 需重启才生效。` : `${key} 未设置 brain.json（无需清除）。`;
+}
+/** `wemind brain check`：真起一个进程跑 ACP 握手，验证大脑「不仅找得到、而且能说 ACP」。 */
+async function cmdBrainCheck(key) {
+	const ag = resolveAgent(loadBrainConfig(accountDir(key)));
+	const problem = agentProblem(ag);
+	if (problem) return `❌ ${key} 的大脑不可用：${problem}`;
+	const r = await checkAgent(ag);
+	return `${r.ok ? "✅" : "❌"} ${key} 大脑自检（${ag.name}，bin=${ag.bin}）：${r.detail}（${r.ms}ms）`;
+}
+/** brain 子命令派发：show（默认）/ set / unset / check。 */
+async function cmdBrain(rest) {
+	const argv = [...rest];
+	const takeFlag = (name) => {
+		const i = argv.indexOf(name);
+		if (i < 0) return void 0;
+		const v = argv[i + 1];
+		argv.splice(i, 2);
+		return v;
+	};
+	const bin = takeFlag("--bin");
+	const argsOverride = takeFlag("--args");
+	const restart = argv.includes("--restart");
+	if (restart) argv.splice(argv.indexOf("--restart"), 1);
+	const shell = argv.includes("--shell") ? true : argv.includes("--no-shell") ? false : void 0;
+	for (const f of ["--shell", "--no-shell"]) {
+		const i = argv.indexOf(f);
+		if (i >= 0) argv.splice(i, 1);
+	}
+	const pos = argv.filter((x) => x && !x.startsWith("--"));
+	const first = (pos[0] || "").toLowerCase();
+	if (first && !(/* @__PURE__ */ new Set([
+		"show",
+		"set",
+		"unset",
+		"check"
+	])).has(first)) return describeBrain(pickKey(pos[0]));
+	const sub = first || "show";
+	switch (sub) {
+		case "show": return describeBrain(pickKey(pos[1]));
+		case "set":
+			if (!pos[1]) throw new Error("用法: brain set <预设|auto> [--bin X] [--args \"…\"] [--shell|--no-shell] [--restart] [<key|label>]");
+			return cmdBrainSet(pos[1], pickKey(pos[2]), {
+				bin,
+				args: argsOverride,
+				shell,
+				restart
+			});
+		case "unset": return cmdBrainUnset(pickKey(pos[1]));
+		case "check": return await cmdBrainCheck(pickKey(pos[1]));
+		default: throw new Error(`未知 brain 子命令「${sub}」（可用：show / set / unset / check）`);
+	}
+}
+function cmdAdopt(key, label) {
+	if (!key) throw new Error("用法: adopt <key> [--label 名]");
+	const acc = readAccount(accountDir(key));
+	if (!acc?.botId) throw new Error(`${accountDir(key)} 无有效 account.json`);
+	const meta = registerAccount({
+		key,
+		botId: acc.botId,
+		userId: acc.userId,
+		baseUrl: acc.baseUrl,
+		label: label || key
+	});
+	if (acc.userId) addAllowFrom(acc.userId, accountDir(key));
+	return `已登记：key=${key}  label=${meta.label}  botId=${acc.botId}`;
+}
+async function cmdLogout(sel) {
+	const key = resolveKey(sel);
+	const dir = accountDir(key);
+	const acc = readAccount(dir);
+	const stopMsg = stopDaemon(key);
+	if (acc?.botToken) try {
+		await notifyStop({
+			baseUrl: acc.baseUrl,
+			token: acc.botToken
+		});
+	} catch {}
+	for (const f of [
+		"account.json",
+		"state.json",
+		"qr_login.json",
+		"qrcode.png",
+		"qrcode.txt"
+	]) try {
+		fs.unlinkSync(path.join(dir, f));
+	} catch {}
+	return `账号 ${key} 已登出（${stopMsg}）。目录与会话保留，可重新登录。`;
+}
+function cmdDelete(sel) {
+	const key = resolveKey(sel);
+	const stopMsg = stopDaemon(key);
+	try {
+		fs.rmSync(accountDir(key), {
+			recursive: true,
+			force: true
+		});
+	} catch (e) {
+		throw new Error(`删除目录失败: ${String(e)}`);
+	}
+	unregisterAccount(key);
+	return `账号 ${key} 已删除（${stopMsg}，已移除目录与注册）。`;
+}
+function cmdStart(sel, runner) {
+	const key = resolveKey(sel);
+	startDaemon(key, runner);
+	return `已启动 daemon（账号 ${key}）。用 list 查看运行状态。`;
+}
+function taskInboxDir(key) {
+	return path.join(accountDir(key), "task-inbox");
+}
+/** 原子写一个命令文件到收件箱（临时文件 + rename，避免 daemon 读到半截）。 */
+function writeTaskCmd(key, obj) {
+	const dir = taskInboxDir(key);
+	fs.mkdirSync(dir, { recursive: true });
+	const fp = path.join(dir, `${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`);
+	const tmp = `${fp}.tmp`;
+	fs.writeFileSync(tmp, JSON.stringify({
+		...obj,
+		ts: Date.now()
+	}, null, 2), "utf-8");
+	fs.renameSync(tmp, fp);
+}
+/** 选账号：显式 key/label 优先，否则用默认账号。 */
+function pickKey(sel) {
+	if (sel) return resolveKey(sel);
+	const d = getDefaultKey();
+	if (!d) throw new Error("无默认账号，请指定 <key|label> 或先 login");
+	return d;
+}
+/** 预检 daemon 存活（本地命令需 daemon 在跑才有人消费收件箱）。 */
+function requireDaemonAlive(key) {
+	if (!aliveOurs(readPid(accountDir(key), "daemon.pid"))) throw new Error(`账号 ${key} 的 daemon 未运行。先启动：wemind start ${key}（用 wemind list 查看状态）`);
+}
+async function cmdTask(text, cwd, sel) {
+	if (!text) throw new Error("用法: task \"<任务描述>\" [--cwd 目录] [<key|label>]");
+	const key = pickKey(sel);
+	requireDaemonAlive(key);
+	const useCwd = cwd || process.cwd();
+	writeTaskCmd(key, {
+		kind: "dispatch",
+		text,
+		cwd: useCwd
+	});
+	const stateFile = path.join(accountDir(key), "task-state.json");
+	for (let i = 0; i < 15; i++) {
+		await sleep(200);
+		try {
+			if (JSON.parse(fs.readFileSync(stateFile, "utf-8")).active) return `已派发任务（worker 运行中，cwd=${useCwd}）。\n用 task-status 看进展、task-reply 回复、task-stop 结束。`;
+		} catch {}
+	}
+	return `已投递任务（cwd=${useCwd}）。daemon 处理中，用 task-status 查看。`;
+}
+function cmdTaskReply(text, sel) {
+	if (!text) throw new Error("用法: task-reply \"<内容>\" [<key|label>]");
+	const key = pickKey(sel);
+	requireDaemonAlive(key);
+	writeTaskCmd(key, {
+		kind: "reply",
+		text
+	});
+	return `已发送给任务：${text.slice(0, 40)}`;
+}
+function cmdTaskStop(sel) {
+	const key = pickKey(sel);
+	requireDaemonAlive(key);
+	writeTaskCmd(key, { kind: "stop" });
+	return "已发送「结束任务」指令。";
+}
+function cmdTaskStatus(sel) {
+	const key = pickKey(sel);
+	const stateFile = path.join(accountDir(key), "task-state.json");
+	let s;
+	try {
+		s = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
+	} catch {
+		return `账号 ${key}：无任务状态（task-state.json 不存在，daemon 可能未跑过任务）。`;
+	}
+	if (!s.active) return `账号 ${key}：当前无活跃任务（idle）。`;
+	const since = s.startedAt ? `${Math.round((Date.now() - s.startedAt) / 1e3)}s` : "?";
+	return [
+		`账号 ${key} 任务状态：`,
+		`  状态：${s.status}  轮次：${s.turns ?? 0}  已运行：${since}`,
+		`  最近输出：${s.lastOutput ? s.lastOutput.slice(0, 300) : "（无）"}`
+	].join("\n");
+}
+async function runManage(argv) {
+	const cmd = argv.shift();
+	const rest = [...argv];
+	const li = rest.indexOf("--label");
+	let label;
+	if (li >= 0) {
+		label = rest[li + 1];
+		rest.splice(li, 2);
+	}
+	const si = rest.indexOf("--start");
+	const autoStart = si >= 0;
+	if (autoStart) rest.splice(si, 1);
+	const ci = rest.indexOf("--cwd");
+	let cwd;
+	if (ci >= 0) {
+		cwd = rest[ci + 1];
+		rest.splice(ci, 2);
+	}
+	const ri = rest.indexOf("--runner");
+	let runner;
+	if (ri >= 0) {
+		runner = rest[ri + 1];
+		rest.splice(ri, 2);
+	}
+	switch (cmd) {
+		case "version":
+		case "--version":
+		case "-v":
+			console.log(versionLine());
+			break;
+		case "login":
+			await cmdLogin(label, autoStart, runner);
+			break;
+		case "list":
+			console.log(cmdList());
+			break;
+		case "brain":
+			console.log(await cmdBrain(rest));
+			break;
+		case "adopt":
+			console.log(cmdAdopt(rest[0], label));
+			break;
+		case "start":
+			console.log(cmdStart(rest[0], runner));
+			break;
+		case "stop": {
+			const k = resolveKey(rest[0]);
+			console.log(stopDaemon(k));
+			break;
+		}
+		case "task":
+			console.log(await cmdTask(rest[0], cwd, rest[1]));
+			break;
+		case "task-reply":
+			console.log(cmdTaskReply(rest[0], rest[1]));
+			break;
+		case "task-status":
+			console.log(cmdTaskStatus(rest[0]));
+			break;
+		case "task-stop":
+			console.log(cmdTaskStop(rest[0]));
+			break;
+		case "label": {
+			const k = resolveKey(rest[0]);
+			setLabel(k, rest.slice(1).join(" "));
+			console.log(`已设置 ${k} 的别名为「${rest.slice(1).join(" ")}」`);
+			break;
+		}
+		case "set-default": {
+			const k = resolveKey(rest[0]);
+			setDefaultKey(k);
+			console.log(`默认账号 = ${k}`);
+			break;
+		}
+		case "logout":
+			console.log(await cmdLogout(rest[0]));
+			break;
+		case "delete":
+			console.log(cmdDelete(rest[0]));
+			break;
+		case "finalize": {
+			const { msg } = finalizeStaging(label);
+			console.log(msg);
+			break;
+		}
+		case "allow": {
+			const k = resolveKey(rest[0]);
+			const uid = rest[1];
+			if (!uid) throw new Error("用法: allow <key|label> <userId>");
+			const list = addAllowFrom(uid, accountDir(k));
+			console.log(`已授权 ${uid} → ${k}\n当前清单(${list.length})：${list.join(", ")}`);
+			break;
+		}
+		case "revoke": {
+			const k = resolveKey(rest[0]);
+			const uid = rest[1];
+			if (!uid) throw new Error("用法: revoke <key|label> <userId>");
+			const list = removeAllowFrom(uid, accountDir(k));
+			console.log(`已撤销 ${uid} → ${k}\n当前清单(${list.length})：${list.join(", ") || "（空）"}`);
+			break;
+		}
+		case "allowlist": {
+			const k = resolveKey(rest[0]);
+			const list = readAllowFrom(accountDir(k));
+			console.log(`${k} 授权用户(${list.length})：\n${list.map((u) => "  - " + u).join("\n") || "  （空）"}`);
+			break;
+		}
+		default: console.log(`WeMind 多账号管理（wemind v${CLI_VERSION}）
+用法: wemind <command>            其余：wemind version | help
+
+  login [--label 名] [--start]   一条命令完成扫码登录：自刷新二维码 + 自动归档（--start 顺带启动 daemon）
+  list                           列出账号、别名、运行状态
+  start <key|label>              启动某账号的 daemon
+  stop <key|label>               停止某账号的 daemon
+  brain [show|set|unset|check] [<key|label>]   查看/切换/清除/自检账号的大脑（ACP agent）
+                                 set: brain set <预设|auto> [--bin X] [--args "…"] [--restart] [<key|label>]
+                                 大脑选择按账号持久化在 brain.json；环境变量 WEMIND_BRAIN* 为一次性覆盖
+  task "<描述>" [--cwd 目录] [<key|label>]   本地派发任务给 worker（默认 cwd=当前终端目录）
+  task-reply "<内容>" [<key|label>]          回复/注入当前任务（「task-reply 继续」= 续跑）
+  task-status [<key|label>]                  查看当前任务状态与最近输出
+  task-stop [<key|label>]                    结束当前任务
+  logout <key|label>             停 daemon + 通知下线 + 清凭证（保留目录，可重登）
+  delete <key|label>             停 daemon + 删除目录 + 移除注册
+  label <key|label> <新别名>     改别名
+  set-default <key|label>        设默认账号
+  adopt <key> [--label 名]       把已存在的账号目录登记进注册表
+  allowlist <key|label>          查看该账号的授权用户清单(allowFrom)
+  allow <key|label> <userId>     授权某用户可驱动该账号 bot
+  revoke <key|label> <userId>    撤销某用户的授权
+
+说明：key = 由微信 botId 派生的唯一标识（目录名）；label = 人类可读别名。多数命令可用 key 或 label。`);
+	}
+}
+//#endregion
+//#region src/cli.ts
+/**
+* wemind —— 完整应用的命令行入口（bin）。
+* - 子命令 `daemon`：跑 daemon 本体（长轮询 + 大脑 + worker），通常由 pm2 调用，用户不直接用。
+* - 其余子命令（login/list/start/stop/task…）：交给 manage 派发。
+*/
+const argv = process.argv.slice(2);
+if (argv[0] === "daemon") runDaemon().catch((err) => {
+	console.error("[wemind/wechat-daemon] fatal:", err);
+	process.exit(1);
+});
+else if (argv[0] === "_watchdog") runWatchdog().catch((err) => {
+	console.error("[wemind/wechat-daemon/watchdog] fatal:", err);
+	process.exit(1);
+});
+else runManage(argv).catch((e) => {
+	console.error("error:", e instanceof Error ? e.message : e);
+	process.exit(1);
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.js.map