@napuketto/loader 0.0.1 → 0.0.3

package/dist/host/self-host.cjs

@@ -1,6 +1,135 @@
-let node_path = require("node:path");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
 let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_process = require("node:process");
+node_process = __toESM(node_process, 1);
+let node_readline = require("node:readline");
 let node_os = require("node:os");
+//#region src/instance-lock.ts
+/**
+* instance-lock.ts：单实例锁（2026-08-07 根治「多实例抢数据目录锁挂起」）
+*
+* 背景（实测）：同一账号数据目录（~/.napuketto/<uin>）只能被一个实例持有——
+* QQ 原生层（MMKV / 登录单例 / 数据库）有锁，第二个实例抢不到锁会卡在
+* loginService.initConfig 之后无响应（挂起）。此前 create-napukettoqq 生成的
+* 副本实例常驻占锁，导致用户后续启动全部卡死。
+*
+* 方案：以数据目录为粒度加锁文件 `<dataDir>/instance.lock`（JSON 内容：
+* pid / startedAt / cmdline 摘要）。启动前 checkInstanceLock：
+*   - 锁不存在 → 可启动（然后 acquireInstanceLock 写入）
+*   - 锁存在但 PID 已死 → 崩溃残留，自动清理（rm + 重新获取）
+*   - 锁存在且 PID 存活 → 已被占用，拒绝启动（返回占用 PID 供提示）
+*
+* 退出清理：进程正常退出时 releaseInstanceLock 删除锁文件；崩溃/强杀残留
+* 由下次启动的「PID 存活检测」兜底（PID 已死 → 残留视为过期）。
+*
+* 放置说明：放 loader 而非 kernel——self-host.cjs 是 rolldown 内联 bundle
+* （只内联 src/host/ 依赖树），静态 import kernel 会留 external 缺口；
+* 放 loader 则 self-host（内联）与 cli（@napuketto/loader 导入）双入口可用。
+*/
+/** 锁文件名（置于数据目录内）。 */
+const INSTANCE_LOCK_FILE = "instance.lock";
+/**
+* 检测指定数据目录是否已被其他实例占用。
+*
+* @param dataDir 数据目录（账号级，如 ~/.napuketto/3567141148）
+*/
+function checkInstanceLock(dataDir) {
+	const lockPath = (0, node_path.join)(dataDir, INSTANCE_LOCK_FILE);
+	let info = null;
+	try {
+		info = JSON.parse((0, node_fs.readFileSync)(lockPath, "utf-8"));
+	} catch {
+		return {
+			occupied: false,
+			pid: null,
+			lockPath
+		};
+	}
+	if (typeof info.pid !== "number" || Number.isNaN(info.pid) || info.pid <= 0) return {
+		occupied: false,
+		pid: null,
+		lockPath
+	};
+	let alive = false;
+	try {
+		node_process.default.kill(info.pid, 0);
+		alive = true;
+	} catch {
+		alive = false;
+	}
+	if (!alive) return {
+		occupied: false,
+		pid: null,
+		lockPath
+	};
+	return {
+		occupied: true,
+		pid: info.pid,
+		lockPath
+	};
+}
+/**
+* 获取数据目录锁。占用（其他实例存活）返回 false；成功或清理残留后返回 true。
+* 幂等：本进程已持有则直接返回 true（不重复写）。
+*/
+function acquireInstanceLock(dataDir, cmdline) {
+	const { occupied, pid, lockPath } = checkInstanceLock(dataDir);
+	if (occupied) {
+		if (pid === node_process.default.pid) return true;
+		return false;
+	}
+	const info = {
+		pid: node_process.default.pid,
+		startedAt: Date.now(),
+		...cmdline !== void 0 && cmdline !== "" ? { cmdline } : {}
+	};
+	try {
+		(0, node_fs.rmSync)(lockPath, { force: true });
+		(0, node_fs.writeFileSync)(lockPath, JSON.stringify(info), "utf-8");
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 释放数据目录锁（正常退出时调用）。仅当持有者是本进程时才删除，
+* 避免误删新持有者的锁（PID 复用 / 快速重启场景）。
+*/
+function releaseInstanceLock(dataDir) {
+	const lockPath = (0, node_path.join)(dataDir, INSTANCE_LOCK_FILE);
+	try {
+		if (JSON.parse((0, node_fs.readFileSync)(lockPath, "utf-8")).pid === node_process.default.pid) (0, node_fs.rmSync)(lockPath, { force: true });
+	} catch {}
+}
+/** 注册进程退出清理（SIGINT/SIGTERM/exit 均触发；崩溃强杀由残留检测兜底）。 */
+function registerLockCleanup(dataDir) {
+	node_process.default.on("exit", () => {
+		releaseInstanceLock(dataDir);
+	});
+}
+//#endregion
 //#region src/host/env.ts
 /**
 * env.ts：引导进程环境变量访问层（2026-08-07 阶段 2）。
@@ -32,6 +161,8 @@ const env = {
 	NAPUTO_QUICK_UIN: process.env["NAPUTO_QUICK_UIN"],
 	/** 收发消息冒烟自检开关（=1 触发）。 */
 	NAPUTO_SMOKE: process.env["NAPUTO_SMOKE"],
+	/** IPC 子进程模式（=1：koishi 插件驱动——stdout 走 JSON 行协议，stdin 收 action/control）。 */
+	NAPUTO_IPC: process.env["NAPUTO_IPC"],
 	/** 冒烟目标 peer（c2c:<uin> / group:<uin>，缺省发给自己）。 */
 	NAPUTO_SMOKE_PEER: process.env["NAPUTO_SMOKE_PEER"],
 	/** 运行时探测开关（=1 触发 probeRuntime）。 */
@@ -42,6 +173,293 @@ const env = {
 	NAPKETTO_DATA: process.env["NAPKETTO_DATA"]
 };
 //#endregion
+//#region src/host/ipc/ipc-actions.ts
+/**
+* 从宽松 params 构造 Peer（缺省 chatType=1 群聊）。
+* 优先 peerUid（uid 直通）；缺省时 peerUin（QQ 号）经 uinToUid 转换。
+*/
+async function toPeer(params, uinToUid) {
+	const chatType = typeof params["chatType"] === "number" ? params["chatType"] : 1;
+	const uidParam = params["peerUid"];
+	if (typeof uidParam === "string" && uidParam !== "") return {
+		chatType,
+		peerUid: uidParam
+	};
+	const uinParam = params["peerUin"];
+	if (typeof uinParam === "string" && uinParam !== "" && uinToUid !== void 0) {
+		const uid = (await uinToUid([uinParam])).get(uinParam);
+		if (uid !== void 0 && uid !== "") return {
+			chatType,
+			peerUid: uid
+		};
+		throw new Error(`uin 转 uid 失败: ${uinParam}`);
+	}
+	throw new Error("缺 peerUid（或 peerUin 且未注入 uinToUid）");
+}
+/** 构造动作表（map 顺序即注册顺序，重复动作名后注册覆盖）。 */
+function createIpcActions(ctx) {
+	const actions = /* @__PURE__ */ new Map();
+	actions.set("login.getSelf", async () => ctx.self);
+	actions.set("msg.sendMessage", async (params) => {
+		const peer = await toPeer(params, ctx.uinToUid);
+		const elements = Array.isArray(params["elements"]) ? params["elements"] : [];
+		return ctx.msgApi.sendMessage(peer, elements);
+	});
+	actions.set("msg.recallMessage", async (params) => {
+		const peer = await toPeer(params, ctx.uinToUid);
+		const msgIds = Array.isArray(params["msgIds"]) ? params["msgIds"].map(String) : [];
+		await ctx.msgApi.recallMessage(peer, msgIds);
+	});
+	actions.set("msg.fetchMessages", async (params) => {
+		const peer = await toPeer(params, ctx.uinToUid);
+		const count = typeof params["count"] === "number" ? params["count"] : 20;
+		const msgId = typeof params["msgId"] === "string" ? params["msgId"] : void 0;
+		return ctx.msgApi.fetchMessages(peer, {
+			count,
+			...msgId !== void 0 ? { msgId } : {}
+		});
+	});
+	actions.set("msg.markRead", async (params) => {
+		const peer = await toPeer(params, ctx.uinToUid);
+		await ctx.msgApi.markRead(peer);
+	});
+	actions.set("group.getGroupList", async (params) => {
+		const force = params["force"] === true;
+		return ctx.groupApi.getGroupList(force);
+	});
+	actions.set("friend.getFriendList", async () => ctx.friendApi.getFriendList());
+	return actions;
+}
+/** 统一动作调用：查找动作表 → 执行 → 返回结果或错误（不抛，调用方转 result）。 */
+async function callIpcAction(actions, action, params) {
+	const handler = actions.get(action);
+	if (handler === void 0) return {
+		ok: false,
+		error: {
+			code: "NOT_FOUND",
+			message: `未知动作: ${action}`
+		}
+	};
+	try {
+		return {
+			ok: true,
+			value: await handler(params ?? {})
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		return {
+			ok: false,
+			error: {
+				code: errorCodeOf(err),
+				message
+			}
+		};
+	}
+}
+/** 宽松提取错误码（KernelError 有 string code 字段；其他错误 UNKNOWN）。 */
+function errorCodeOf(err) {
+	if (typeof err === "object" && err !== null) {
+		const code = err.code;
+		if (typeof code === "string" && code !== "") return code;
+	}
+	return "UNKNOWN";
+}
+//#endregion
+//#region src/host/ipc/ipc-types.ts
+/** 消息类型集合（解码校验用）。 */
+const IPC_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+	"status",
+	"login",
+	"qr",
+	"event",
+	"result",
+	"log",
+	"ping",
+	"pong",
+	"action",
+	"control"
+]);
+//#endregion
+//#region src/host/ipc/ipc-sender.ts
+/**
+* ipc-sender.ts：IPC 消息发送封装（self-host 子进程 → koishi 插件）。
+*
+* 仅 NAPUTO_IPC=1 启用：stdout 专用于 JSON 行协议（stdin 收 action/control）。
+* 非 IPC 模式（cli pnpm start）stdout 不输出协议行，零干扰。
+*/
+/** IPC 模式开关（self-host.ts 在 env.NAPUTO_IPC=1 时 enable）。 */
+let enabled = false;
+/** 启用 IPC 发送（幂等）。 */
+function enableIpc() {
+	enabled = true;
+}
+/** 发送一条 IPC 消息（JSON 行）。失败静默（不阻塞引导）。 */
+function sendIpc(message) {
+	if (!enabled) return;
+	try {
+		process.stdout.write(`${JSON.stringify(message)}\n`);
+	} catch {}
+}
+/** 引导状态（booting/dlopening/logging/sessioning/ready/failed）。 */
+function sendStatus(phase, message, error) {
+	sendIpc({
+		v: 1,
+		type: "status",
+		payload: {
+			phase,
+			...message !== void 0 ? { message } : {},
+			...error !== void 0 ? { error } : {}
+		}
+	});
+}
+/** 登录状态（QR 状态机 idle/waiting_scan/scanned/logged_in/failed）。 */
+function sendLogin(state, selfInfo) {
+	sendIpc({
+		v: 1,
+		type: "login",
+		payload: {
+			state,
+			...selfInfo !== void 0 ? { selfInfo } : {}
+		}
+	});
+}
+/** 二维码数据（扫码登录展示用）。 */
+function sendQr(pngBase64, qrcodeUrl) {
+	sendIpc({
+		v: 1,
+		type: "qr",
+		payload: {
+			pngBase64,
+			qrcodeUrl
+		}
+	});
+}
+/** kernel 事件转发（service/name/args 原样透传，koishi 插件翻译层消费）。 */
+function sendEvent(service, name, args) {
+	sendIpc({
+		v: 1,
+		type: "event",
+		payload: {
+			service,
+			name,
+			args
+		}
+	});
+}
+/** 动作响应。 */
+function sendResult(id, payload) {
+	sendIpc({
+		v: 1,
+		type: "result",
+		id,
+		payload
+	});
+}
+/** 心跳应答（收到 ping 时回）。 */
+function sendPong() {
+	sendIpc({
+		v: 1,
+		type: "pong"
+	});
+}
+/** 心跳（定期发送，koishi 插件探活）。 */
+function sendPing() {
+	sendIpc({
+		v: 1,
+		type: "ping"
+	});
+}
+//#endregion
+//#region src/host/ipc/ipc-codec.ts
+/**
+* ipc-codec.ts：IPC 消息编解码（JSON 行协议，与 koishi 插件侧 src/ipc/codec.ts 对齐）。
+*
+* 每行一条 JSON 消息，`\n` 结尾。解码宽松：非法行 / 空行 / v 不匹配 /
+* 未知 type → null，调用方忽略，不崩通道。
+*/
+/** 类型守卫：v 匹配 + type 合法。 */
+function isIpcMessage(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return record["v"] === 1 && typeof record["type"] === "string" && IPC_MESSAGE_TYPES.has(record["type"]);
+}
+/** 解码一行 JSON；非法行/空行返回 null。 */
+function decodeIpcMessage(line) {
+	const trimmed = line.trim();
+	if (trimmed === "") return null;
+	try {
+		const parsed = JSON.parse(trimmed);
+		return isIpcMessage(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+/** 启动 IPC 服务端（stdin 接收 + 心跳）。返回停止函数。 */
+function startIpcServer(options) {
+	const heartbeatMs = options.heartbeatMs ?? 15e3;
+	const onExit = options.onExit ?? (() => process.exit(0));
+	const rl = (0, node_readline.createInterface)({
+		input: process.stdin,
+		crlfDelay: Infinity
+	});
+	rl.on("line", (line) => {
+		const message = decodeIpcMessage(line);
+		if (message === null) return;
+		switch (message.type) {
+			case "action":
+				handleAction(message.id, message.payload.action, message.payload.params, options.actions);
+				break;
+			case "control":
+				handleControl(message.payload, onExit);
+				break;
+			case "ping": sendPong();
+		}
+	});
+	const timer = setInterval(() => sendPing(), heartbeatMs);
+	return () => {
+		clearInterval(timer);
+		rl.close();
+	};
+}
+/** 动作执行 → result 响应（不抛：callIpcAction 内部兜底转错误）。 */
+async function handleAction(id, action, params, actions) {
+	sendResult(id, await callIpcAction(actions, action, params));
+}
+/** 控制指令处理（stop/restart 退出；login 预留——引导期登录由 bootstrap 内部驱动）。 */
+function handleControl(payload, onExit) {
+	if (payload.command === "stop" || payload.command === "restart") onExit();
+}
+//#endregion
+//#region src/host/ipc/ipc-bootstrap.ts
+/** 订阅事件通道 → event 消息转发（事件名 "Service/method" 拆分）。 */
+function forwardChannel(channel, stops) {
+	if (typeof channel.onAny !== "function") return;
+	const off = channel.onAny((event, ...args) => {
+		const slash = event.indexOf("/");
+		sendEvent(slash >= 0 ? event.slice(0, slash) : event, slash >= 0 ? event.slice(slash + 1) : "", args);
+	});
+	if (typeof off === "function") stops.push(off);
+}
+/** IPC 模式装配（enableIpc + 动作表 + 服务端 + 事件转发）。返回停止函数。 */
+function startIpcMode(services) {
+	enableIpc();
+	const groupApi = services.groupApi;
+	const stopServer = startIpcServer({ actions: createIpcActions({
+		msgApi: services.msgApi,
+		groupApi: services.groupApi,
+		friendApi: services.friendApi,
+		self: services.self,
+		...groupApi.uinToUid !== void 0 ? { uinToUid: groupApi.uinToUid } : {}
+	}) });
+	const stops = [];
+	forwardChannel(services.channel, stops);
+	forwardChannel(services.groupChannel, stops);
+	return () => {
+		stopServer();
+		for (const stop of stops) stop();
+	};
+}
+//#endregion
 //#region src/host/util.ts
 /**
 * util.ts：引导公共工具（日志 + 共享状态）。
@@ -60,6 +478,17 @@ function log(msg) {
 function errMsg(e) {
 	return `${e?.message ?? e}`;
 }
+/**
+* 逐条处理消息回调参数（onRecvMsg 为消息数组——2026-08-07 运行时实证；
+* 兼容单条对象，过滤无效项）。
+*/
+function forEachRawMessage(msgs, handler) {
+	const list = Array.isArray(msgs) ? msgs : [msgs];
+	for (const msg of list) {
+		if (!msg || typeof msg !== "object") continue;
+		handler(msg);
+	}
+}
 function createState() {
 	return {
 		wrapperExports: null,
@@ -69,7 +498,7 @@ function createState() {
 	};
 }
 //#endregion
-//#region src/host/login.ts
+//#region src/host/core/login.ts
 /** 打印可用快速登录账号 + 返回目标账号（启动横幅）。forcedUin（cli `-q` / NAPUTO_QUICK_UIN）优先。 */
 async function pickLoginAccount(kernel, ctx, loginResultRef, forcedUin) {
 	try {
@@ -112,32 +541,56 @@ async function doLogin(core, opts) {
 	}
 }
 //#endregion
-//#region src/host/protocols.ts
+//#region src/host/load-config.ts
 /**
-* protocols.ts：协议装配（登录成功后）。
-* 2026-08-07 阶段 2：由 runtime/boot-protocols.js TS 化（零语义改动）。
-* 动态 import adapter/network 入口，装配 OB11 适配器。
-* 依赖 launcher 注入的 NAPUTO_ADAPTER_ENTRY / NAPUTO_NETWORK_ENTRY。
+* 协议配置段读取（从 protocols.ts 拆分，2026-08-08 FTA 优化；2026-08-08 结构拍板：按账号取段）
+*
+* 全局 TOML 配置（<项目根>/napuketto.toml）：**协议配置嵌在账号内**——
+* accounts 数组每项含 [onebot11] / [satori] 段，登录成功后按账号 uin 找到对应项，
+* 取其段作 seed（zod 校验）。路径优先级：NAPKETTO_CONFIG（launcher 注入）>
+* 装配链自身探测（kernel.resolveConfigPath）> NAPUTO_CFG_DIR 兜底（旧行为兼容）。
+* （ConfigBase seed 模式：load() 直接用内存值，不再读写独立协议文件）
 */
+/** 账号内取协议段（宽松对象，装配时 zod 校验）。 */
+function sectionOf(account, key) {
+	const section = account[key];
+	if (section !== void 0 && section !== null && typeof section === "object") return section;
+}
 /**
-* 终端 ANSI 颜色（消息日志颜色分层，2026-08-07 用户定稿）：
-* `loader | 接收 <- 群聊` 灰色（背景噪音）/ `[会话]` 青色 / `[发送者]` 绿色 / 内容默认色。
-* 仅 console 版嵌入；boot 文件日志用纯文本版（log），不污染文件。
+* 按登录账号 uin 读取全局 TOML 的协议段（读取失败 / 未找到账号 / 无协议段 → 空段，
+* 不阻塞装配）。uin 为登录成功后实际账号（-q 指定账号与配置不一致时以 uin 为准）。
 */
-const ANSI = {
-	gray: "\x1B[90m",
-	cyan: "\x1B[36m",
-	green: "\x1B[32m",
-	reset: "\x1B[0m"
-};
+function loadProtocolSections(kernel, uin) {
+	const cfgFile = env.NAPKETTO_CONFIG || (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "napuketto.toml");
+	let ob11Section = {};
+	let satoriSection = {};
+	try {
+		const raw = (0, node_fs.readFileSync)(cfgFile, "utf8");
+		const accounts = kernel.parseToml(raw)["accounts"];
+		if (Array.isArray(accounts)) {
+			const mine = accounts.find((item) => typeof item === "object" && item !== null && String(item["qq"]) === uin);
+			if (mine !== void 0) {
+				ob11Section = sectionOf(mine, "onebot11") ?? {};
+				satoriSection = sectionOf(mine, "satori") ?? {};
+			}
+		}
+	} catch (e) {
+		log(`bootstrap: 全局配置读取失败（用默认 ob11/satori 配置）: ${errMsg(e)}`);
+	}
+	return {
+		cfgFile,
+		ob11Section,
+		satoriSection
+	};
+}
+//#endregion
+//#region src/host/core/assemble-protocols.ts
 /**
-* 登录成功后装配协议：kernel 各 Api + network 广播 + OB11 适配器。
+* assemble-protocols.ts：OB11 / Satori 协议装配（非 IPC 模式，cli pnpm start）。
+* 2026-08-08：从 protocols.ts 拆分——protocols.ts 只留入口 + IPC 分支。
 */
-async function startProtocols(kernel, ctx, loginResult) {
-	const logger = kernel.createLogger?.({
-		console: true,
-		base: { name: "loader" }
-	});
+/** 装配 OB11 + Satori 适配器（登录成功后，非 IPC 模式）。 */
+async function assembleOb11AndSatori(kernel, services, loginResult) {
 	const adapterEntry = env.NAPUTO_ADAPTER_ENTRY;
 	const networkEntry = env.NAPUTO_NETWORK_ENTRY;
 	if (!adapterEntry || !networkEntry) {
@@ -147,80 +600,14 @@ async function startProtocols(kernel, ctx, loginResult) {
 	try {
 		const network = await import(`file://${networkEntry.replace(/\\/g, "/")}`);
 		const onebot11Entry = adapterEntry.replace(/index\.mjs$/, "onebot11/index.mjs");
+		const satoriEntry = adapterEntry.replace(/index\.mjs$/, "satori/index.mjs");
 		const coreEntry = adapterEntry.replace(/index\.mjs$/, "core/index.mjs");
 		const adapter = await import(`file://${onebot11Entry.replace(/\\/g, "/")}`);
+		const satoriAdapter = await import(`file://${satoriEntry.replace(/\\/g, "/")}`);
 		const adapterCore = await import(`file://${coreEntry.replace(/\\/g, "/")}`);
-		const session = ctx.session;
-		if (!session) {
-			log("bootstrap: session 为空，无法装配协议");
-			return;
-		}
-		const channel = new kernel.NTEventChannel("Msg");
-		new kernel.MsgBridge(session, channel).register();
-		channel.on("Msg/onRecvMsg", (msgs) => {
-			const list = Array.isArray(msgs) ? msgs : [msgs];
-			for (const msg of list) {
-				if (!msg || typeof msg !== "object") continue;
-				try {
-					let rendered = "";
-					for (const el of kernel.toCanonicalElements(msg)) if (el.type === "text") rendered += el.text;
-					else if (el.type === "at") {
-						const name = el.display ?? (el.target === "all" ? "全体" : el.target);
-						rendered += `@${name}`;
-					} else if (el.type === "face") rendered += "[表情]";
-					else if (el.type === "image") rendered += "[图片]";
-					else if (el.type === "voice") rendered += "[语音]";
-					else if (el.type === "video") rendered += "[视频]";
-					else if (el.type === "reply") rendered += "[回复]";
-					else if (el.type === "file") rendered += `[文件${el.name ?? ""}]`;
-					else if (el.type === "forward") rendered += "[合并转发]";
-					else if (el.type === "json") rendered += "[json]";
-					else if (el.type === "xml") rendered += "[xml]";
-					if (rendered === "") rendered = "[空消息/媒体]";
-					const isGroup = msg.chatType === kernel.ChatType.GROUP;
-					const kind = isGroup ? "群聊" : "私聊";
-					const peerUin = String(msg.peerUin ?? "");
-					const senderUin = String(msg.senderUin ?? (peerUin || "未知"));
-					const plainTags = isGroup ? `[群${peerUin}] [用户${senderUin}]` : `[用户${senderUin}]`;
-					const coloredTags = isGroup ? `${ANSI.cyan}[群${peerUin}]${ANSI.reset} ${ANSI.green}[用户${senderUin}]${ANSI.reset}` : `${ANSI.green}[用户${senderUin}]${ANSI.reset}`;
-					const content = rendered.replace(/\n/g, "\n    ");
-					const plain = `接收 <- ${kind} ${plainTags}： ${content}`;
-					const colored = `${ANSI.gray}loader | 接收 <- ${kind}${ANSI.reset} ${coloredTags}： ${content}`;
-					log(plain);
-					logger?.info(colored);
-				} catch (e) {
-					const line2 = `接收消息（解析失败: ${errMsg(e)}）`;
-					log(line2);
-					logger?.warn(line2);
-				}
-			}
-		});
-		const groupApi = new kernel.GroupApi(session);
-		const msgApi = new kernel.MsgApi(session);
-		const friendApi = new kernel.FriendApi(session, { uidToUin: (uids) => groupApi.uidToUin(uids) });
-		const groupChannel = new kernel.NTEventChannel("Group");
-		new kernel.GroupBridge(session, groupChannel).register();
-		const groupCache = new kernel.GroupCache({
-			channel: groupChannel,
-			groupApi
-		});
-		groupCache.register();
-		const groupNotifyApi = new kernel.GroupNotifyApi(session);
-		const ticketApi = new kernel.TicketApi(session);
-		const richMediaApi = new kernel.RichMediaApi(session);
-		const profileApi = new kernel.ProfileApi(session);
-		const profileLikeApi = new kernel.ProfileLikeApi(session);
-		const webApi = new kernel.WebApi({ getCookies: (domain) => ticketApi.getCookies(domain, loginResult.uin) });
+		const { channel, groupCache } = services;
 		const broadcaster = new network.EventBroadcaster();
-		let ob11Section = {};
-		const cfgFile = env.NAPKETTO_CONFIG || (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "napuketto.toml");
-		try {
-			const raw = (0, node_fs.readFileSync)(cfgFile, "utf8");
-			const parsed = kernel.parseToml(raw);
-			if (parsed && typeof parsed["onebot11"] === "object" && parsed["onebot11"] !== null) ob11Section = parsed["onebot11"];
-		} catch (e) {
-			log(`bootstrap: 全局配置读取失败（用默认 ob11 配置）: ${errMsg(e)}`);
-		}
+		const { cfgFile, ob11Section, satoriSection } = loadProtocolSections(kernel, loginResult.uin);
 		const ob11Config = new adapterCore.ProtocolConfig({
 			path: cfgFile,
 			schema: adapter.ob11ConfigSchema,
@@ -231,19 +618,16 @@ async function startProtocols(kernel, ctx, loginResult) {
 			config: ob11Config,
 			broadcaster,
 			msgChannel: channel,
-			msgApi,
-			groupApi,
-			groupNotifyApi,
-			friendApi,
-			ticketApi,
-			richMediaApi,
-			profileApi,
-			profileLikeApi,
-			webApi,
-			self: {
-				uin: loginResult.uin,
-				nickname: loginResult.nick
-			},
+			msgApi: services.msgApi,
+			groupApi: services.groupApi,
+			groupNotifyApi: services.groupNotifyApi,
+			friendApi: services.friendApi,
+			ticketApi: services.ticketApi,
+			richMediaApi: services.richMediaApi,
+			profileApi: services.profileApi,
+			profileLikeApi: services.profileLikeApi,
+			webApi: services.webApi,
+			self: services.self,
 			system: {
 				appVersion: env.NAPUTO_QQ_VERSION || "unknown",
 				cleanCache: async () => {
@@ -265,12 +649,168 @@ async function startProtocols(kernel, ctx, loginResult) {
 			groupCache
 		}).start();
 		log("bootstrap: onebot11 adapter started");
+		const satoriCacheDir = typeof satoriSection["cacheDir"] === "string" && satoriSection["cacheDir"] !== "" ? satoriSection["cacheDir"] : (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "cache");
+		const satoriConfig = new adapterCore.ProtocolConfig({
+			path: cfgFile,
+			schema: satoriAdapter.satoriConfigSchema,
+			defaults: satoriAdapter.satoriConfigSchema.parse({}),
+			seed: satoriAdapter.satoriConfigSchema.parse(satoriSection)
+		});
+		await new satoriAdapter.NapukettoSatoriAdapter({
+			config: satoriConfig,
+			broadcaster,
+			msgChannel: channel,
+			msgApi: services.msgApi,
+			groupApi: services.groupApi,
+			groupNotifyApi: services.groupNotifyApi,
+			friendApi: services.friendApi,
+			profileApi: services.profileApi,
+			self: services.self,
+			cacheDir: satoriCacheDir,
+			groupCache
+		}).start();
+		log("bootstrap: satori adapter started");
+	} catch (e) {
+		log(`bootstrap: 协议装配失败: ${errMsg(e)}`);
+	}
+}
+//#endregion
+//#region src/host/msg-log.ts
+/** 终端 ANSI 颜色（消息日志颜色分层，2026-08-07 用户定稿）。 */
+const ANSI = {
+	gray: "\x1B[90m",
+	cyan: "\x1B[36m",
+	green: "\x1B[32m",
+	reset: "\x1B[0m"
+};
+/** canonical 元素 → 日志占位文本。 */
+function elementToText(el) {
+	if (el.type === "text") return el.text ?? "";
+	if (el.type === "at") return `@${el.display ?? (el.target === "all" ? "全体" : el.target)}`;
+	if (el.type === "file") return `[文件${el.name ?? ""}]`;
+	if (el.type === "forward") return "[合并转发]";
+	return `[${el.type}]`;
+}
+/** 渲染消息为单行文本（text 拼接，at/媒体元素转占位）。 */
+function renderMessage(kernel, msg) {
+	let rendered = "";
+	for (const el of kernel.toCanonicalElements(msg)) rendered += elementToText(el);
+	return rendered === "" ? "[空消息/媒体]" : rendered;
+}
+/**
+* 消息日志订阅（onRecvMsg 回调参数为消息数组——2026-08-07 运行时实证，遍历逐条打印）。
+*/
+function setupMsgLogging(kernel, channel, logger) {
+	channel.on("Msg/onRecvMsg", (msgs) => {
+		forEachRawMessage(msgs, (m) => {
+			try {
+				const raw = m;
+				const rendered = renderMessage(kernel, m);
+				const isGroup = raw.chatType === kernel.ChatType.GROUP;
+				const kind = isGroup ? "群聊" : "私聊";
+				const peerUin = String(raw.peerUin ?? "");
+				const senderUin = String(raw.senderUin ?? (peerUin || "未知"));
+				const plainTags = isGroup ? `[群${peerUin}] [用户${senderUin}]` : `[用户${senderUin}]`;
+				const coloredTags = isGroup ? `${ANSI.cyan}[群${peerUin}]${ANSI.reset} ${ANSI.green}[用户${senderUin}]${ANSI.reset}` : `${ANSI.green}[用户${senderUin}]${ANSI.reset}`;
+				const content = rendered.replace(/\n/g, "\n    ");
+				const plain = `接收 <- ${kind} ${plainTags}： ${content}`;
+				const colored = `${ANSI.gray}loader | 接收 <- ${kind}${ANSI.reset} ${coloredTags}： ${content}`;
+				log(plain);
+				logger?.info(colored);
+			} catch (e) {
+				const line2 = `接收消息（解析失败: ${errMsg(e)}）`;
+				log(line2);
+				logger?.warn(line2);
+			}
+		});
+	});
+}
+//#endregion
+//#region src/host/core/kernel-services.ts
+/**
+* kernel-services.ts：kernel 业务服务装配（IPC 模式与协议模式共用）。
+*
+* 登录成功后创建：消息/群事件通道 + 桥 + 缓存 + kernel 各 Api + 自身信息。
+* IPC 模式（koishi 插件）经此拿服务装配 ipc-server；非 IPC（cli）经此拿服务
+* 装配 OB11/Satori 适配器。
+*/
+/** 登录成功后创建 kernel 业务服务（channel/bridge/cache/apis）。失败返回 null。 */
+async function createKernelServices(kernel, ctx, loginResult) {
+	const logger = kernel.createLogger?.({
+		console: true,
+		base: { name: "loader" }
+	});
+	const session = ctx.session;
+	if (!session) {
+		log("bootstrap: session 为空，无法创建 kernel 服务");
+		return null;
+	}
+	const channel = new kernel.NTEventChannel("Msg");
+	new kernel.MsgBridge(session, channel).register();
+	setupMsgLogging(kernel, channel, logger);
+	const groupApi = new kernel.GroupApi(session);
+	const msgApi = new kernel.MsgApi(session);
+	const friendApi = new kernel.FriendApi(session, { uidToUin: (uids) => groupApi.uidToUin(uids) });
+	const groupChannel = new kernel.NTEventChannel("Group");
+	new kernel.GroupBridge(session, groupChannel).register();
+	const groupCache = new kernel.GroupCache({
+		channel: groupChannel,
+		groupApi
+	});
+	groupCache.register();
+	const groupNotifyApi = new kernel.GroupNotifyApi(session);
+	const ticketApi = new kernel.TicketApi(session);
+	return {
+		kernel,
+		ctx,
+		logger,
+		channel,
+		groupChannel,
+		msgApi,
+		groupApi,
+		friendApi,
+		groupCache,
+		groupNotifyApi,
+		ticketApi,
+		richMediaApi: new kernel.RichMediaApi(session),
+		profileApi: new kernel.ProfileApi(session),
+		profileLikeApi: new kernel.ProfileLikeApi(session),
+		webApi: new kernel.WebApi({ getCookies: (domain) => ticketApi.getCookies(domain, loginResult.uin) }),
+		self: {
+			uin: loginResult.uin,
+			nickname: loginResult.nick ?? ""
+		}
+	};
+}
+//#endregion
+//#region src/host/core/protocols.ts
+/**
+* protocols.ts：协议装配入口（登录成功后）。
+* 2026-08-08 重构：kernel 服务创建 → kernel-services.ts；OB11/Satori 装配 →
+* assemble-protocols.ts。本文件只留入口 + IPC 模式分支。
+*
+* 分支：
+*  - IPC 模式（NAPUTO_IPC=1，koishi 插件驱动）：跳过 OB11/Satori（插件直接消费
+*    kernel 服务），返回 KernelServices 由 bootstrap 装配 ipc-server。
+*  - 非 IPC（cli pnpm start）：照旧装配 OB11/Satori 网络传输。
+*/
+/** 登录成功后装配协议：IPC 模式返回 kernel 服务（供 ipc-server），否则装配 OB11/Satori。 */
+async function startProtocols(kernel, ctx, loginResult) {
+	const services = await createKernelServices(kernel, ctx, loginResult);
+	if (services === null) return null;
+	if (env.NAPUTO_IPC === "1") {
+		log("bootstrap: IPC 模式，跳过 OB11/Satori 装配（koishi 插件直接消费 kernel 服务）");
+		return services;
+	}
+	try {
+		await assembleOb11AndSatori(kernel, services, loginResult);
 	} catch (e) {
 		log(`bootstrap: 协议装配失败: ${errMsg(e)}`);
 	}
+	return services;
 }
 //#endregion
-//#region src/host/session.ts
+//#region src/host/core/session.ts
 /** 对象有效性判断：getMsgService() 调用不抛断言（cpp_impl 已激活）。
 * 与 isSessionUsable 的区别：这里允许返回 null（未 init 但对象有效）。 */
 function isSessionObjectValid(s) {
@@ -395,7 +935,7 @@ function pickBestSession(candidates) {
 	return bestValid;
 }
 //#endregion
-//#region src/host/smoke.ts
+//#region src/host/core/smoke.ts
 /**
 * smoke.ts：P2-1 收发消息冒烟自检（NAPUTO_SMOKE=1 触发，2026-08-06）。
 * 2026-08-07 阶段 2：由 runtime/boot-smoke.js TS 化（零语义改动）。
@@ -434,6 +974,10 @@ function parseSmokeTarget(envPeer, selfUin) {
 		uin: selfUin
 	};
 }
+/** 提取消息纯文本（text 元素拼接，onRecvMsg 与落库核对共用）。 */
+function extractTexts(kernel, msg) {
+	return kernel.toCanonicalElements(msg).filter((el) => el.type === "text").map((el) => el.text).join("");
+}
 /** uin → uid（c2c 目标用；group 直接拿群号作 peerUid）。 */
 async function resolvePeerUid(kernel, ctx, target, selfUid) {
 	const groupApi = new kernel.GroupApi(ctx.session);
@@ -471,18 +1015,16 @@ async function runSmokeTest(kernel, ctx, loginResult) {
 	let received = 0;
 	let receivedText = "";
 	channel.on("Msg/onRecvMsg", (msgs) => {
-		const list = Array.isArray(msgs) ? msgs : [msgs];
-		for (const msg of list) {
-			if (!msg || typeof msg !== "object") continue;
+		forEachRawMessage(msgs, (m) => {
 			received += 1;
 			try {
-				const texts = kernel.toCanonicalElements(msg).filter((el) => el.type === "text").map((el) => el.text).join("");
+				const texts = extractTexts(kernel, m);
 				if (texts) receivedText = texts;
 			} catch (e) {
 				log(`smoke: onRecvMsg 解析失败: ${errMsg(e)}`);
 			}
-			log(`smoke: 📥 onRecvMsg 收到 #${received}（msgId=${msg.msgId ?? "?"} seq=${msg.msgSeq ?? "?"} text="${receivedText}"）`);
-		}
+			log(`smoke: 📥 onRecvMsg 收到 #${received}（msgId=${m.msgId ?? "?"} seq=${m.msgSeq ?? "?"} text="${receivedText}"）`);
+		});
 	});
 	const msgApi = new kernel.MsgApi(session);
 	const peer = await resolvePeerUid(kernel, ctx, target, loginResult.uid);
@@ -504,10 +1046,7 @@ async function runSmokeTest(kernel, ctx, loginResult) {
 		const recent = await msgApi.fetchMessages(peer, { count: 10 });
 		landed = recent.some((m) => m.msgId === sentMsgId || m.msgSeq === sentMsgId);
 		log(`smoke: 落库验证: 最近 ${recent.length} 条${landed ? " ✅ 含刚发消息" : " ❌ 未找到（可能同步延迟）"}`);
-		if (!landed) for (const m of recent.slice(0, 3)) {
-			const texts = kernel.toCanonicalElements(m).filter((el) => el.type === "text").map((el) => el.text).join("");
-			log(`smoke:   最近消息 msgId=${m.msgId} seq=${m.msgSeq} text="${texts}"`);
-		}
+		if (!landed) for (const m of recent.slice(0, 3)) log(`smoke:   最近消息 msgId=${m.msgId} seq=${m.msgSeq} text="${extractTexts(kernel, m)}"`);
 	} catch (e) {
 		log(`smoke: 落库验证失败: ${errMsg(e)}`);
 	}
@@ -522,7 +1061,176 @@ async function runSmokeTest(kernel, ctx, loginResult) {
 	return ok;
 }
 //#endregion
-//#region src/host/bootstrap.ts
+//#region src/host/core/bootstrap-core.ts
+/**
+* bootstrap-core.ts：NapukettoCore 装配路径（从 bootstrap.ts 拆分，2026-08-08 FTA 优化）。
+*
+* NapukettoCore.create → attachWrapper → 登录（pickLoginAccount + doLogin）→
+* session 替换/激活 → 就绪等待 → 冒烟自检 → 协议装配 → 探测模式。
+*/
+/** 探测：create() 与捕获的 QQ session 关系（确认 create() 是否干扰 QQ）。 */
+function probeCreatedSession(state, ctx) {
+	try {
+		const S2 = state.wrapperExports?.["NodeIQQNTWrapperSession"];
+		const created = S2 && typeof S2.create === "function" ? S2.create() : null;
+		log(`BOOT: create()===qqSession? ${created === state.qqSession} | create()===ctx.session? ${created === ctx.session} | qqSession===ctx.session? ${state.qqSession === ctx.session}`);
+		const sess = created;
+		const svc = sess && typeof sess.getMsgService === "function" ? sess.getMsgService() : null;
+		const qs = state.qqSession;
+		log(`BOOT: create().getMsgService=${svc !== null && svc !== void 0 ? "ready" : "null"} qqSession.getMsgService=${qs && typeof qs.getMsgService === "function" && qs.getMsgService() !== null && qs.getMsgService() !== void 0 ? "ready" : "null"}`);
+	} catch (e) {
+		log(`BOOT: create() 探测失败: ${errMsg(e)}`);
+	}
+}
+/** 登录状态字面量（IPC login 消息，与 kernel LoginState 对齐）。 */
+const LOGIN_STATES = [
+	"idle",
+	"waiting_scan",
+	"scanned",
+	"logged_in",
+	"failed"
+];
+/** 宽松收窄（kernel onLoginProgress.state 是 string）。 */
+function isLoginState(value) {
+	return LOGIN_STATES.includes(value);
+}
+/** 登录参数（NAPUTO_QUICK_UIN 强制指定 / ref 目标 / 默认）。 */
+function buildLoginOpts(Appid, forcedUin, ref) {
+	const quickUin = forcedUin ?? ref.targetUin;
+	const opts = {
+		appid: Appid,
+		initTimeoutMs: 2e4,
+		...quickUin !== void 0 ? { quickUin } : {}
+	};
+	if (env.NAPUTO_IPC === "1") opts["onLoginProgress"] = (progress) => {
+		if (progress.qr !== void 0) sendQr(progress.qr.pngBase64, progress.qr.qrcodeUrl);
+		if (isLoginState(progress.state)) sendLogin(progress.state, progress.selfInfo);
+	};
+	return opts;
+}
+/** V2 登录后替换 session：优先 QQ 主 session，其次 vehicle 单例表；自建宿主例外。 */
+function replaceSession(kernel, core, state, ctx) {
+	if (env.NAPUTO_SELF_HOST === "1") return null;
+	const chosen = pickBestSession(collectCandidateSessions(state, kernel, ctx));
+	if (chosen && chosen.s !== ctx.session) {
+		core.setSession(chosen.s);
+		log(`bootstrap: 已替换 session（来源=${chosen.tag}，msgSvc=${isSessionUsable(chosen.s) ? "READY" : "null"}）`);
+	} else if (chosen) log(`bootstrap: 候选 session 与 ctx.session 相同（${chosen.tag}）`);
+	else log("bootstrap: 无有效候选 session（保留 kernel 自建 session）");
+	return chosen;
+}
+/**
+* 激活目标 session（先 init 后 startupSession.start，HANDOVER-V6 三要素）。
+* 自建宿主无候选时对 kernel 自建 session 走 NapCat 激活。
+*/
+async function activateSession(kernel, state, ctx, chosen, loginResult, Appid, bootEnv) {
+	const activateTarget = chosen ?? {
+		s: ctx.session,
+		tag: "kernel 自建 session"
+	};
+	if (!activateTarget.s || isSessionUsable(activateTarget.s)) return;
+	log(`bootstrap: 激活 session（${activateTarget.tag}，先 init 后 startupSession.start）...`);
+	try {
+		const qqDataRoot = typeof kernel.resolveQqUserDataRoot === "function" ? kernel.resolveQqUserDataRoot(state.wrapperExports) : null;
+		const accountPath = qqDataRoot && typeof kernel.resolveQqGlobalPath === "function" ? kernel.resolveQqGlobalPath(qqDataRoot) : bootEnv.dataDir || ".";
+		const sessionConfig = kernel.buildSessionConfig({
+			appid: Appid,
+			fullVersion: bootEnv.qqVersion || "",
+			selfUin: loginResult.uin,
+			selfUid: loginResult.uid,
+			accountPath,
+			downloadPath: (0, node_path.join)(accountPath, "NapCat", "temp")
+		});
+		const listener = kernel.createLifecycleSessionListener();
+		await kernel.initAndStartSession(ctx, sessionConfig, listener, { timeoutMs: 2e4 });
+		log("bootstrap: 激活 session init + start 完成");
+	} catch (initErr) {
+		log(`bootstrap: 激活 session init 失败: ${errMsg(initErr)}`);
+	}
+}
+/** 等 session 就绪（getMsgService 非 null）——init 完成后才有。 */
+async function waitSessionReady(kernel, ctx) {
+	try {
+		await kernel.waitSessionReady(ctx, { timeoutMs: 3e4 });
+		log("bootstrap: QQ session 就绪（getMsgService 可用）");
+	} catch (readyErr) {
+		log(`bootstrap: 等待 session 就绪失败: ${errMsg(readyErr)}`);
+	}
+}
+/** P2-1 收发消息冒烟自检（NAPUTO_SMOKE=1）：MsgBridge + MsgApi 真发/收一条。 */
+async function runSmokeIfEnabled(kernel, ctx, loginResult) {
+	if (env.NAPUTO_SMOKE !== "1") return;
+	try {
+		log(`bootstrap: 冒烟自检${await runSmokeTest(kernel, ctx, loginResult) ? "通过" : "未完全通过"}（见上文 smoke 日志）`);
+	} catch (smokeErr) {
+		log(`bootstrap: 冒烟自检异常: ${errMsg(smokeErr)}`);
+	}
+}
+/** 探测模式（NAPUTO_PROBE=1）：立即探测 + 35s 后晚探测（napuketto-probe-late.json）。 */
+function runProbePhase(kernel, ctx) {
+	if (env.NAPUTO_PROBE !== "1" || typeof kernel.probeRuntime !== "function") return;
+	try {
+		const probe = kernel.probeRuntime(ctx);
+		log(`bootstrap: probe done, session=${probe.session ? "ok" : "null"}, services=${Object.keys(probe.services ?? {}).length}`);
+		setTimeout(() => {
+			try {
+				if (typeof kernel.probeRuntime !== "function") return;
+				const late = kernel.probeRuntime(ctx, "napuketto-probe-late.json");
+				log(`bootstrap: probe-late done, session=${late.session ? "ok" : "null"}, services=${Object.keys(late.services ?? {}).length}`);
+			} catch (e2) {
+				log(`bootstrap: probe-late error: ${errMsg(e2)}`);
+			}
+		}, 35e3);
+	} catch (e) {
+		log(`bootstrap: probe error: ${errMsg(e)}`);
+	}
+}
+/** NapukettoCore 装配路径：create → attachWrapper → 登录 → 激活 → 协议 → 探测。 */
+async function bootstrapWithCore(kernel, state, bootEnv, Appid) {
+	const coreCtor = kernel.NapukettoCore;
+	if (coreCtor === void 0) return;
+	const core = coreCtor.create({
+		paths: { dataRoot: bootEnv.dataDir },
+		logLevel: "info"
+	});
+	const ctx = core.attachWrapper(state.wrapperExports, { ...bootEnv });
+	log(`bootstrap: attachWrapper OK, engine=${typeof ctx.engine}, session=${ctx.session !== null}`);
+	probeCreatedSession(state, ctx);
+	startSessionProbe(state, ctx);
+	probeSessionMethods(ctx);
+	if (typeof core.login !== "function") {
+		log("bootstrap: kernel core missing login fn");
+		return;
+	}
+	const forcedUin = env.NAPUTO_QUICK_UIN;
+	const ref = { targetUin: void 0 };
+	await pickLoginAccount(kernel, ctx, ref, forcedUin);
+	if (env.NAPUTO_IPC === "1") sendStatus("logging");
+	const loginResult = await doLogin(core, buildLoginOpts(Appid, forcedUin, ref));
+	if (loginResult === null) {
+		log("bootstrap: 登录失败，引导中止");
+		if (env.NAPUTO_IPC === "1") sendStatus("failed", "登录失败", {
+			code: "NOT_LOGIN",
+			message: "登录失败"
+		});
+		return;
+	}
+	log(`bootstrap: 登录成功 uin=${loginResult.uin} uid=${loginResult.uid} nick=${loginResult.nick}`);
+	if (env.NAPUTO_IPC === "1") sendLogin("logged_in", {
+		uin: loginResult.uin,
+		uid: loginResult.uid,
+		nick: loginResult.nick ?? ""
+	});
+	await activateSession(kernel, state, ctx, replaceSession(kernel, core, state, ctx), loginResult, Appid, bootEnv);
+	await waitSessionReady(kernel, ctx);
+	if (env.NAPUTO_IPC === "1") sendStatus("sessioning");
+	await runSmokeIfEnabled(kernel, ctx, loginResult);
+	const services = await startProtocols(kernel, ctx, loginResult);
+	if (env.NAPUTO_IPC === "1" && services !== null) startIpcMode(services);
+	runProbePhase(kernel, ctx);
+}
+//#endregion
+//#region src/host/core/bootstrap.ts
 /**
 * bootstrap.ts：kernel 引导核心（import kernel → 装配 → 登录 → session 替换 → 协议装配）。
 * 2026-08-07 阶段 2：由 runtime/boot-bootstrap.js TS 化（零语义改动）。
@@ -532,6 +1240,7 @@ async function runSmokeTest(kernel, ctx, loginResult) {
 *  - 登录流程（选账号 / 快速登录 / QR 回退）→ login.ts
 *  - session 选择 / 探测 / 就绪 → session.ts
 *  - 协议装配 → protocols.ts；冒烟自检 → smoke.ts
+* 2026-08-08 FTA 优化：NapukettoCore 装配路径 → bootstrap-core.ts（本文件留入口 + fallback）。
 *
 * session 来源（2026-08-07 实测结论；V1 Proxy 捕获与 vehicle 载具已归档 archive/）：
 *  登录成功后按优先级取 session：
@@ -540,6 +1249,52 @@ async function runSmokeTest(kernel, ctx, loginResult) {
 *    ② get() / qqSession（V1 兼容）
 *  取到后 core.setSession 替换 → waitSessionReady 确认 getMsgService READY。
 */
+/** ⭐ appid 动态解析（2026-08-06 P2-0 实测：硬编码 537237765 在 9.9.33 扫码失败
+* 「请下载最新版」；major.node 解析的 537376818 成功）。自研，参考 NapCat 思路。 */
+function resolveAppid(kernel, bootEnv) {
+	return typeof kernel.parseAppidFromMajor === "function" && bootEnv.wrapperPath && kernel.parseAppidFromMajor((0, node_path.join)((0, node_path.dirname)(bootEnv.wrapperPath), "major.node")) || typeof kernel.resolveAppidQua === "function" && kernel.resolveAppidQua(bootEnv.qqVersion || "").appid || "537237765";
+}
+/** 回退：旧装配路径（startNapuketto + 手工 lifecycle）。 */
+async function bootstrapFallback(kernel, state, bootEnv, Appid) {
+	log("bootstrap: kernel has no NapukettoCore, falling back");
+	const ctx = kernel.startNapuketto?.({
+		wrapperExports: state.wrapperExports,
+		env: { ...bootEnv }
+	});
+	if (ctx === void 0) {
+		log("bootstrap: startNapuketto 不可用");
+		return;
+	}
+	log(`bootstrap: startNapuketto OK, engine=${typeof ctx.engine}, session=${ctx.session !== null}`);
+	if (typeof kernel.quickLogin === "function" && typeof kernel.initAndStartSession === "function") {
+		if (typeof kernel.buildLoginConfig === "function" && ctx.loginService) {
+			const loginCfg = kernel.buildLoginConfig(Appid, bootEnv.qqVersion || "", bootEnv.dataDir || ".");
+			if (typeof ctx.loginService.initConfig === "function") {
+				ctx.loginService.initConfig(loginCfg);
+				log("bootstrap: loginService.initConfig OK");
+			}
+		}
+		const loginResult = await kernel.quickLogin(ctx, {});
+		log(`bootstrap: quickLogin OK, uin=${loginResult.uin}, uid=${loginResult.uid}`);
+		const sessionConfig = kernel.buildSessionConfig({
+			appid: Appid,
+			fullVersion: bootEnv.qqVersion || "",
+			selfUin: loginResult.uin,
+			selfUid: loginResult.uid,
+			accountPath: bootEnv.dataDir || ".",
+			downloadPath: (0, node_path.join)(bootEnv.dataDir || ".", "temp")
+		});
+		const listener = kernel.createLifecycleSessionListener();
+		await kernel.initAndStartSession(ctx, sessionConfig, listener, { timeoutMs: 2e4 });
+		log("bootstrap: session init + startNT OK!");
+	} else log("bootstrap: kernel missing lifecycle fns (quickLogin/initAndStartSession)");
+	if (env.NAPUTO_PROBE === "1" && typeof kernel.probeRuntime === "function") try {
+		const probe = kernel.probeRuntime(ctx);
+		log(`bootstrap: probe done, session=${probe.session ? "ok" : "null"}, services=${Object.keys(probe.services ?? {}).length}`);
+	} catch (e) {
+		log(`bootstrap: probe error: ${errMsg(e)}`);
+	}
+}
 /** 核心引导：import kernel → 装配 → 登录 → 替换 session → 等待就绪 → 协议装配。 */
 async function bootstrap(state) {
 	const kernelEntry = env.NAPUTO_KERNEL_ENTRY;
@@ -555,148 +1310,15 @@ async function bootstrap(state) {
 			return;
 		}
 		const bootEnv = {
-			qqVersion: env.NAPUTO_QQ_VERSION,
-			dataDir: env.NAPUTO_CFG_DIR,
-			wrapperPath: env.NAPUTO_WRAPPER_PATH
+			qqVersion: env.NAPUTO_QQ_VERSION || "",
+			dataDir: env.NAPUTO_CFG_DIR || "",
+			wrapperPath: env.NAPUTO_WRAPPER_PATH || ""
 		};
-		const Appid = typeof kernel.parseAppidFromMajor === "function" && bootEnv.wrapperPath && kernel.parseAppidFromMajor((0, node_path.join)((0, node_path.dirname)(bootEnv.wrapperPath), "major.node")) || typeof kernel.resolveAppidQua === "function" && kernel.resolveAppidQua(bootEnv.qqVersion || "").appid || "537237765";
+		const Appid = resolveAppid(kernel, bootEnv);
 		log(`bootstrap: appid=${Appid}（wrapper=${bootEnv.wrapperPath}）`);
 		try {
-			if (kernel.NapukettoCore !== void 0) {
-				const core = kernel.NapukettoCore.create({
-					paths: { dataRoot: bootEnv.dataDir },
-					logLevel: "info"
-				});
-				const ctx = core.attachWrapper(state.wrapperExports, bootEnv);
-				log(`bootstrap: attachWrapper OK, engine=${typeof ctx.engine}, session=${ctx.session !== null}`);
-				try {
-					const S2 = state.wrapperExports?.["NodeIQQNTWrapperSession"];
-					const created = S2 && typeof S2.create === "function" ? S2.create() : null;
-					log(`BOOT: create()===qqSession? ${created === state.qqSession} | create()===ctx.session? ${created === ctx.session} | qqSession===ctx.session? ${state.qqSession === ctx.session}`);
-					const sess = created;
-					const svc = sess && typeof sess.getMsgService === "function" ? sess.getMsgService() : null;
-					const qs = state.qqSession;
-					log(`BOOT: create().getMsgService=${svc !== null && svc !== void 0 ? "ready" : "null"} qqSession.getMsgService=${qs && typeof qs.getMsgService === "function" && qs.getMsgService() !== null && qs.getMsgService() !== void 0 ? "ready" : "null"}`);
-				} catch (e) {
-					log(`BOOT: create() 探测失败: ${errMsg(e)}`);
-				}
-				startSessionProbe(state, ctx);
-				probeSessionMethods(ctx);
-				let loginResult = null;
-				if (typeof core.login === "function") {
-					const forcedUin = env.NAPUTO_QUICK_UIN;
-					const ref = { targetUin: void 0 };
-					await pickLoginAccount(kernel, ctx, ref, forcedUin);
-					loginResult = await doLogin(core, {
-						appid: Appid,
-						initTimeoutMs: 2e4,
-						...forcedUin ? { quickUin: forcedUin } : ref.targetUin !== void 0 ? { quickUin: ref.targetUin } : {}
-					});
-					if (loginResult === null) {
-						log("bootstrap: 登录失败，引导中止");
-						return;
-					}
-					log(`bootstrap: 登录成功 uin=${loginResult.uin} uid=${loginResult.uid} nick=${loginResult.nick}`);
-					const isSelfHost = env.NAPUTO_SELF_HOST === "1";
-					let chosen = null;
-					if (!isSelfHost) chosen = pickBestSession(collectCandidateSessions(state, kernel, ctx));
-					if (chosen && chosen.s !== ctx.session) {
-						core.setSession(chosen.s);
-						log(`bootstrap: 已替换 session（来源=${chosen.tag}，msgSvc=${isSessionUsable(chosen.s) ? "READY" : "null"}）`);
-					} else if (chosen) log(`bootstrap: 候选 session 与 ctx.session 相同（${chosen.tag}）`);
-					else log("bootstrap: 无有效候选 session（保留 kernel 自建 session）");
-					const activateTarget = chosen ?? {
-						s: ctx.session,
-						tag: "kernel 自建 session"
-					};
-					if (activateTarget.s && !isSessionUsable(activateTarget.s)) {
-						log(`bootstrap: 激活 session（${activateTarget.tag}，先 init 后 startupSession.start）...`);
-						try {
-							const qqDataRoot = typeof kernel.resolveQqUserDataRoot === "function" ? kernel.resolveQqUserDataRoot(state.wrapperExports) : null;
-							const accountPath = qqDataRoot && typeof kernel.resolveQqGlobalPath === "function" ? kernel.resolveQqGlobalPath(qqDataRoot) : bootEnv.dataDir || ".";
-							const sessionConfig = kernel.buildSessionConfig({
-								appid: Appid,
-								fullVersion: bootEnv.qqVersion || "",
-								selfUin: loginResult.uin,
-								selfUid: loginResult.uid,
-								accountPath,
-								downloadPath: (0, node_path.join)(accountPath, "NapCat", "temp")
-							});
-							const listener = kernel.createLifecycleSessionListener();
-							await kernel.initAndStartSession(ctx, sessionConfig, listener, { timeoutMs: 2e4 });
-							log("bootstrap: 激活 session init + start 完成");
-						} catch (initErr) {
-							log(`bootstrap: 激活 session init 失败: ${errMsg(initErr)}`);
-						}
-					}
-					try {
-						await kernel.waitSessionReady(ctx, { timeoutMs: 3e4 });
-						log("bootstrap: QQ session 就绪（getMsgService 可用）");
-					} catch (readyErr) {
-						log(`bootstrap: 等待 session 就绪失败: ${errMsg(readyErr)}`);
-					}
-					if (env.NAPUTO_SMOKE === "1" && loginResult !== null) try {
-						log(`bootstrap: 冒烟自检${await runSmokeTest(kernel, ctx, loginResult) ? "通过" : "未完全通过"}（见上文 smoke 日志）`);
-					} catch (smokeErr) {
-						log(`bootstrap: 冒烟自检异常: ${errMsg(smokeErr)}`);
-					}
-				} else log("bootstrap: kernel core missing login fn");
-				if (loginResult !== null) await startProtocols(kernel, ctx, loginResult);
-				if (env.NAPUTO_PROBE === "1" && typeof kernel.probeRuntime === "function") try {
-					const probe = kernel.probeRuntime(ctx);
-					log(`bootstrap: probe done, session=${probe.session ? "ok" : "null"}, services=${Object.keys(probe.services ?? {}).length}`);
-					setTimeout(() => {
-						try {
-							if (typeof kernel.probeRuntime !== "function") return;
-							const late = kernel.probeRuntime(ctx, "napuketto-probe-late.json");
-							log(`bootstrap: probe-late done, session=${late.session ? "ok" : "null"}, services=${Object.keys(late.services ?? {}).length}`);
-						} catch (e2) {
-							log(`bootstrap: probe-late error: ${errMsg(e2)}`);
-						}
-					}, 35e3);
-				} catch (e) {
-					log(`bootstrap: probe error: ${errMsg(e)}`);
-				}
-			} else {
-				log("bootstrap: kernel has no NapukettoCore, falling back");
-				const ctx = kernel.startNapuketto?.({
-					wrapperExports: state.wrapperExports,
-					env: bootEnv
-				});
-				if (ctx === void 0) {
-					log("bootstrap: startNapuketto 不可用");
-					return;
-				}
-				log(`bootstrap: startNapuketto OK, engine=${typeof ctx.engine}, session=${ctx.session !== null}`);
-				if (typeof kernel.quickLogin === "function" && typeof kernel.initAndStartSession === "function") {
-					if (typeof kernel.buildLoginConfig === "function" && ctx.loginService) {
-						const loginCfg = kernel.buildLoginConfig(Appid, bootEnv.qqVersion || "", bootEnv.dataDir || ".");
-						if (typeof ctx.loginService.initConfig === "function") {
-							ctx.loginService.initConfig(loginCfg);
-							log("bootstrap: loginService.initConfig OK");
-						}
-					}
-					const loginResult = await kernel.quickLogin(ctx, {});
-					log(`bootstrap: quickLogin OK, uin=${loginResult.uin}, uid=${loginResult.uid}`);
-					const sessionConfig = kernel.buildSessionConfig({
-						appid: Appid,
-						fullVersion: bootEnv.qqVersion || "",
-						selfUin: loginResult.uin,
-						selfUid: loginResult.uid,
-						accountPath: bootEnv.dataDir || ".",
-						downloadPath: (0, node_path.join)(bootEnv.dataDir || ".", "temp")
-					});
-					const listener = kernel.createLifecycleSessionListener();
-					await kernel.initAndStartSession(ctx, sessionConfig, listener, { timeoutMs: 2e4 });
-					log("bootstrap: session init + startNT OK!");
-				} else log("bootstrap: kernel missing lifecycle fns (quickLogin/initAndStartSession)");
-				if (env.NAPUTO_PROBE === "1" && typeof kernel.probeRuntime === "function") try {
-					const probe = kernel.probeRuntime(ctx);
-					log(`bootstrap: probe done, session=${probe.session ? "ok" : "null"}, services=${Object.keys(probe.services ?? {}).length}`);
-				} catch (e) {
-					log(`bootstrap: probe error: ${errMsg(e)}`);
-				}
-			}
+			if (kernel.NapukettoCore !== void 0) await bootstrapWithCore(kernel, state, bootEnv, Appid);
+			else await bootstrapFallback(kernel, state, bootEnv, Appid);
 		} catch (e) {
 			log(`bootstrap: lifecycle error: ${errMsg(e)}`);
 		}
@@ -705,7 +1327,7 @@ async function bootstrap(state) {
 	}
 }
 //#endregion
-//#region src/host/self-host.ts
+//#region src/host/core/self-host.ts
 /**
 * self-host.ts：自建宿主（路线 A，NAPUTO_SELF_HOST）入口——标准 Node 进程直接运行。
 * 2026-08-07 阶段 2：由 runtime/self-host.cjs TS 化（零语义改动）。
@@ -730,14 +1352,38 @@ async function bootstrap(state) {
 *     → kernel 装配 → 登录（快速/QR）→ session（先 init 后 start）→ 冒烟 → 协议装配
 */
 const state = createState();
+const ipcMode = env.NAPUTO_IPC === "1";
+if (ipcMode) {
+	enableIpc();
+	sendStatus("booting");
+}
 log(`[self-host] 启动 @ ${(/* @__PURE__ */ new Date()).toISOString()} pid=${process.pid} node=${process.version} type=${process.type ?? "(标准 node)"}`);
 log(`[self-host] stub 目录: ${env.NAPUTO_STUB_DIR ?? "(PATH 前置，未记录)"}`);
+const lockDataDir = env.NAPUTO_CFG_DIR;
+if (lockDataDir) {
+	if (!acquireInstanceLock(lockDataDir)) {
+		const { pid: holderPid } = checkInstanceLock(lockDataDir);
+		log(`[self-host] ❌ 数据目录已被其他实例占用（pid=${holderPid ?? "?"}），退出；同一账号数据目录仅允许一个实例，请先停止已有实例`);
+		if (ipcMode) sendStatus("failed", "数据目录被占用", {
+			code: "INVALID_STATE",
+			message: `数据目录已被其他实例占用（pid=${holderPid ?? "?"}）`
+		});
+		process.exit(1);
+	}
+	registerLockCleanup(lockDataDir);
+	log(`[self-host] ✅ 已获取数据目录锁（${lockDataDir}）`);
+} else log("[self-host] ⚠️ NAPUTO_CFG_DIR 未设置，跳过单实例锁");
 const wrapperPath = env.NAPUTO_WRAPPER_PATH;
 if (!wrapperPath) {
 	log("[self-host] NAPUTO_WRAPPER_PATH 未设置，退出");
+	if (ipcMode) sendStatus("failed", "NAPUTO_WRAPPER_PATH 未设置", {
+		code: "INVALID_STATE",
+		message: "NAPUTO_WRAPPER_PATH 未设置，退出"
+	});
 	process.exit(1);
 }
 log(`[self-host] dlopen wrapper.node: ${wrapperPath}`);
+if (ipcMode) sendStatus("dlopening");
 try {
 	const m = { exports: {} };
 	process.dlopen(m, wrapperPath);
@@ -745,11 +1391,19 @@ try {
 	log(`[self-host] ✅ dlopen 成功，exports ${keys.length} 个`);
 	if (!keys.includes("NodeIKernelLoginService")) {
 		log("[self-host] ❌ exports 无 NodeIKernelLoginService（stub 环境异常？）");
+		if (ipcMode) sendStatus("failed", "exports 无 NodeIKernelLoginService", {
+			code: "INVALID_STATE",
+			message: "exports 无 NodeIKernelLoginService（stub 环境异常？）"
+		});
 		process.exit(1);
 	}
 	state.wrapperExports = m.exports;
 } catch (e) {
 	log(`[self-host] ❌ dlopen 失败: ${errMsg(e)}`);
+	if (ipcMode) sendStatus("failed", "dlopen 失败", {
+		code: "UNKNOWN",
+		message: errMsg(e)
+	});
 	process.exit(1);
 }
 try {
@@ -766,8 +1420,13 @@ log("[self-host] 调 bootstrap(state) ...");
 	try {
 		await bootstrap(state);
 		log("[self-host] bootstrap 完成");
+		if (ipcMode) sendStatus("ready");
 	} catch (e) {
 		log(`[self-host] bootstrap 失败: ${errMsg(e)}`);
+		if (ipcMode) sendStatus("failed", "bootstrap 失败", {
+			code: "UNKNOWN",
+			message: errMsg(e)
+		});
 		process.exit(1);
 	}
 })();