@napuketto/loader 0.1.0 → 0.3.0

package/dist/host/self-host.cjs

@@ -373,6 +373,8 @@ const env = {
 	NAPUTO_PROBE: process.env["NAPUTO_PROBE"],
 	/** 全局 TOML 配置显式路径（优先级最高）。 */
 	NAPKETTO_CONFIG: process.env["NAPKETTO_CONFIG"],
+	/** 内联主配置 JSON 文本（嵌入式宿主注入；优先级高于 NAPKETTO_CONFIG 文件，2026-10-25）。 */
+	NAPKETTO_CONFIG_JSON: process.env["NAPKETTO_CONFIG_JSON"],
 	/** 数据根（kernel 数据目录，cleanCache 用）。 */
 	NAPKETTO_DATA: process.env["NAPKETTO_DATA"],
 	/** 数据根（launcher 注入，停止哨兵目录解析用）。 */
@@ -398,6 +400,39 @@ function errMsg(e) {
 	return `${e?.message ?? e}`;
 }
 /**
+* 配置校验失败标记错误（2026-10-25 嵌入式退出码契约）。
+* 与 kernel ConfigError 同契约定名（name="ConfigError"）——loader 不静态依赖
+* kernel（运行期动态 import），按错误名复刻判定面：协议段 seed 校验失败与
+* kernel 主配置校验失败同族，bootstrap 链重抛后由 self-host 以 78 退出
+* （宿主据此区分「配置未就绪」与运行时崩溃，免重启）。
+*/
+var ConfigError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ConfigError";
+	}
+};
+/** 配置校验失败判定（name 契约：kernel ConfigError 与 loader 复刻类都命中）。 */
+function isConfigError(err) {
+	return err instanceof Error && err.name === "ConfigError";
+}
+/** bootstrap 失败 → 进程退出码（78 = 配置校验失败一族；1 = 其余运行时失败）。 */
+function bootstrapExitCode(err) {
+	return isConfigError(err) ? 78 : 1;
+}
+/**
+* bootstrap 失败收敛（2026-10-25 退出码契约）：配置校验失败（ConfigError 一族）
+* 原样重抛——self-host 据此以 78 退出（宿主免重启），链条上任何 catch 都不得
+* 吞掉；其余失败记日志并收敛 false（引导失败原因见 napuketto-boot.log）。
+* @param phase 失败阶段标注（日志前缀，如 "lifecycle error" / "import kernel failed"）
+* @returns 恒 false（调用方直接 `return convergeBootstrapFailure(e, ...)`）
+*/
+function convergeBootstrapFailure(e, phase) {
+	if (isConfigError(e)) throw e;
+	log(`bootstrap: ${phase}: ${errMsg(e)}`);
+	return false;
+}
+/**
 * 逐条处理消息回调参数（onRecvMsg 为消息数组——2026-08-07 运行时实证；
 * 兼容单条对象，过滤无效项）。
 */
@@ -1313,15 +1348,109 @@ function handleControl(payload, onExit, onLogin) {
 	});
 }
 //#endregion
+//#region src/host/load-config.ts
+/**
+* 协议配置段读取（从 protocols.ts 拆分，2026-08-08 FTA 优化；2026-08-08 结构拍板：按账号取段）
+*
+* 主配置来源（2026-10-25 嵌入式内联契约）：**NAPKETTO_CONFIG_JSON（内联 JSON，
+* 与 napuketto.toml 同构）> NAPKETTO_CONFIG（文件）> NAPUTO_CFG_DIR 兜底（旧行为
+* 兼容）**。内联生效时不读任何 toml 文件，cfgFile 返回哨兵 "<inline>"（仅作
+* ProtocolConfig 来源标注；seed 模式本就不读盘，协议段热更新在内联形态不可用）。
+*
+* 全局配置：**协议配置嵌在账号内**——accounts 数组每项含 [onebot11] / [satori] /
+* [kurobot] / [milky] 段，登录成功后按账号 uin 找到对应项，取其段作 seed（zod 校验）。
+* （ConfigBase seed 模式：load() 直接用内存值，不再读写独立协议文件）
+*
+* 内联分支宽松（解析失败回退文件形态并记日志，不阻塞引导）：cli 主路径已在
+* 拉起前完整校验（exit 78），走到这里的坏内联多见于绕过 cli 的直跑场景。
+*/
+/** 内联来源时 cfgFile 的哨兵值（非文件路径；日志/错误标注里不出现真实路径）。 */
+const INLINE_CONFIG_SENTINEL = "<inline>";
+/** 账号内取协议段（宽松对象，装配时 zod 校验）。 */
+function sectionOf(account, key) {
+	const section = account[key];
+	if (section !== void 0 && section !== null && typeof section === "object") return section;
+}
+/**
+* 读内联配置文档（NAPKETTO_CONFIG_JSON 非空才生效；JSON 解析失败 / 非对象 →
+* undefined 回退文件形态并记日志）。
+*/
+function readInlineConfigDoc() {
+	const raw = env.NAPKETTO_CONFIG_JSON;
+	if (raw === void 0 || raw.trim() === "") return;
+	try {
+		const doc = JSON.parse(raw);
+		if (typeof doc === "object" && doc !== null && !Array.isArray(doc)) return doc;
+		log("bootstrap: 内联配置不是 JSON 对象（回退文件形态）");
+		return;
+	} catch (e) {
+		log(`bootstrap: 内联配置 JSON 解析失败（回退文件形态）: ${errMsg(e)}`);
+		return;
+	}
+}
+/** accounts 数组按登录 uin 取协议段（文件/内联共用；未找到账号 / 无协议段 → 空段）。 */
+function extractSections(accounts, uin) {
+	let ob11Section = {};
+	let satoriSection = {};
+	let kurobotSection = {};
+	let milkySection = {};
+	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") ?? {};
+			kurobotSection = sectionOf(mine, "kurobot") ?? {};
+			milkySection = sectionOf(mine, "milky") ?? {};
+		}
+	}
+	return {
+		ob11Section,
+		satoriSection,
+		kurobotSection,
+		milkySection
+	};
+}
+/**
+* 按登录账号 uin 读取主配置的协议段（读取失败 / 未找到账号 / 无协议段 → 空段，
+* 不阻塞装配）。uin 为登录成功后实际账号（-q 指定账号与配置不一致时以 uin 为准）。
+*/
+function loadProtocolSections(kernel, uin) {
+	const inlineDoc = readInlineConfigDoc();
+	if (inlineDoc !== void 0) {
+		log("bootstrap: 配置来源: inline（NAPKETTO_CONFIG_JSON）");
+		return {
+			cfgFile: INLINE_CONFIG_SENTINEL,
+			...extractSections(inlineDoc["accounts"], uin)
+		};
+	}
+	const cfgFile = env.NAPKETTO_CONFIG || (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "napuketto.toml");
+	let sections = {
+		ob11Section: {},
+		satoriSection: {},
+		kurobotSection: {},
+		milkySection: {}
+	};
+	try {
+		const raw = (0, node_fs.readFileSync)(cfgFile, "utf8");
+		sections = extractSections(kernel.parseToml(raw)["accounts"], uin);
+	} catch (e) {
+		log(`bootstrap: 全局配置读取失败（用默认 ob11/satori 配置）: ${errMsg(e)}`);
+	}
+	return {
+		cfgFile,
+		...sections
+	};
+}
+//#endregion
 //#region src/host/log-cfg.ts
 /**
-* loader 引导链日志配置解析（2026-10-25 日志可配置化）。
+* loader 引导链日志配置解析（2026-10-25 日志可配置化；2026-10-25 内联配置接入）。
 *
 * 自建宿主进程（self-host → bootstrap → NapukettoCore / kernel-services）不经过
-* cli 的 loadCliConfig，这里按同一契约解析：读全局 TOML（路径优先级与
-* loadProtocolSections 一致：NAPKETTO_CONFIG > NAPUTO_CFG_DIR 兜底）的 [log] 段，
-* 经 kernel.parseLogConfig（env 覆盖在内）解析。kernel 无该导出（老版本）或
-* 配置读取失败时回退缺省——日志配置损坏不阻塞引导。
+* cli 的 loadCliConfig，这里按同一契约解析：主配置 [log] 段经 kernel.parseLogConfig
+* （env 覆盖在内）解析。主配置来源优先级与 loadProtocolSections 一致：
+* NAPKETTO_CONFIG_JSON（内联，不读盘）> NAPKETTO_CONFIG > NAPUTO_CFG_DIR 兜底。
+* kernel 无该导出（老版本）或配置读取失败时回退缺省——日志配置损坏不阻塞引导。
 */
 /** 缺省（kernel parseLogConfig 缺省值的最小面镜像；未配置/解析失败兜底）。 */
 function defaultLogConfig() {
@@ -1333,13 +1462,18 @@ function defaultLogConfig() {
 		levels: {}
 	};
 }
-/** 解析引导链日志配置（toml [log] 段 + env 覆盖；失败回退缺省）。 */
+/** 解析引导链日志配置（内联 > toml 文件的 [log] 段 + env 覆盖；失败回退缺省）。 */
 function resolveLoaderLogConfig(kernel) {
 	if (typeof kernel.parseLogConfig !== "function") return defaultLogConfig();
-	const cfgFile = env.NAPKETTO_CONFIG || (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "napuketto.toml");
 	try {
-		const parsed = kernel.parseToml((0, node_fs.readFileSync)(cfgFile, "utf8"));
-		return kernel.parseLogConfig(parsed["log"], process.env);
+		const inlineDoc = readInlineConfigDoc();
+		let section;
+		if (inlineDoc !== void 0) section = inlineDoc["log"];
+		else {
+			const cfgFile = env.NAPKETTO_CONFIG || (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "napuketto.toml");
+			section = kernel.parseToml((0, node_fs.readFileSync)(cfgFile, "utf8"))["log"];
+		}
+		return kernel.parseLogConfig(section, process.env);
 	} catch {
 		return defaultLogConfig();
 	}
@@ -1398,52 +1532,6 @@ async function doLogin(core, opts) {
 	}
 }
 //#endregion
-//#region src/host/load-config.ts
-/**
-* 协议配置段读取（从 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;
-}
-/**
-* 按登录账号 uin 读取全局 TOML 的协议段（读取失败 / 未找到账号 / 无协议段 → 空段，
-* 不阻塞装配）。uin 为登录成功后实际账号（-q 指定账号与配置不一致时以 uin 为准）。
-*/
-function loadProtocolSections(kernel, uin) {
-	const cfgFile = env.NAPKETTO_CONFIG || (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "napuketto.toml");
-	let ob11Section = {};
-	let satoriSection = {};
-	let kurobotSection = {};
-	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") ?? {};
-				kurobotSection = sectionOf(mine, "kurobot") ?? {};
-			}
-		}
-	} catch (e) {
-		log(`bootstrap: 全局配置读取失败（用默认 ob11/satori 配置）: ${errMsg(e)}`);
-	}
-	return {
-		cfgFile,
-		ob11Section,
-		satoriSection,
-		kurobotSection
-	};
-}
-//#endregion
 //#region src/host/core/assemble-protocols.ts
 /**
 * assemble-protocols.ts：OB11 / Satori 协议装配（非 IPC 模式，cli pnpm start）。
@@ -1454,6 +1542,20 @@ const BACKSLASH_RE = /\\/g;
 /** adapter 入口 index.mjs 后缀（子路径导出替换用）。 */
 const INDEX_MJS_RE = /index\.mjs$/;
 /**
+* 协议段 seed 校验（zod 错误 → ConfigError，2026-10-25 嵌入式退出码契约）：
+* 「必填缺失/形状非法」的本体就在这里（如 kurobot url 必填）——包装后沿
+* startProtocols → bootstrap 重抛，self-host 以 78 退出，supervisor 识别 78
+* 不再守护重启，堵死「少配协议必填项 → 子进程死循环重启」。zod issue 列表
+* 是多行 JSON，压成单行（日志单行契约）。
+*/
+function parseSeed(label, schema, section) {
+	try {
+		return schema.parse(section);
+	} catch (e) {
+		throw new ConfigError(`协议配置 ${label} 段校验失败: ${errMsg(e).replace(/\s+/g, " ").trim()}`, { cause: e });
+	}
+}
+/**
 * 装配 OB11 + Satori 适配器（登录成功后，非 IPC 模式）。
 *
 * 返回停止函数（ob11/satori 适配器 stop：传输关闭 + 订阅清理；装配跳过时
@@ -1472,23 +1574,26 @@ async function assembleOb11AndSatori(kernel, services, loginResult) {
 		return async () => {};
 	}
 	try {
+		const milkyAdapters = [];
 		const network = await import(`file://${networkEntry.replace(BACKSLASH_RE, "/")}`);
 		const onebot11Entry = adapterEntry.replace(INDEX_MJS_RE, "onebot11/index.mjs");
 		const satoriEntry = adapterEntry.replace(INDEX_MJS_RE, "satori/index.mjs");
 		const kurobotEntry = adapterEntry.replace(INDEX_MJS_RE, "kurobot/index.mjs");
+		const milkyEntry = adapterEntry.replace(INDEX_MJS_RE, "milky/index.mjs");
 		const coreEntry = adapterEntry.replace(INDEX_MJS_RE, "core/index.mjs");
 		const adapter = await import(`file://${onebot11Entry.replace(BACKSLASH_RE, "/")}`);
 		const satoriAdapter = await import(`file://${satoriEntry.replace(BACKSLASH_RE, "/")}`);
 		const kurobotAdapter = await import(`file://${kurobotEntry.replace(BACKSLASH_RE, "/")}`);
+		const milkyAdapter = await import(`file://${milkyEntry.replace(BACKSLASH_RE, "/")}`);
 		const adapterCore = await import(`file://${coreEntry.replace(BACKSLASH_RE, "/")}`);
 		const { channel, groupCache } = services;
 		const broadcaster = new network.EventBroadcaster();
-		const { cfgFile, ob11Section, satoriSection, kurobotSection } = loadProtocolSections(kernel, loginResult.uin);
+		const { cfgFile, ob11Section, satoriSection, kurobotSection, milkySection } = loadProtocolSections(kernel, loginResult.uin);
 		const ob11Config = new adapterCore.ProtocolConfig({
 			path: cfgFile,
 			schema: adapter.ob11ConfigSchema,
 			defaults: adapter.ob11ConfigSchema.parse({}),
-			seed: adapter.ob11ConfigSchema.parse(ob11Section)
+			seed: parseSeed("onebot11", adapter.ob11ConfigSchema, ob11Section)
 		});
 		const wrapperExports = services.ctx.wrapper?.exports;
 		const qqRoot = kernel.resolveQqUserDataRoot?.(wrapperExports) ?? null;
@@ -1539,7 +1644,7 @@ async function assembleOb11AndSatori(kernel, services, loginResult) {
 			path: cfgFile,
 			schema: satoriAdapter.satoriConfigSchema,
 			defaults: satoriAdapter.satoriConfigSchema.parse({}),
-			seed: satoriAdapter.satoriConfigSchema.parse(satoriSection)
+			seed: parseSeed("satori", satoriAdapter.satoriConfigSchema, satoriSection)
 		});
 		const satori = new satoriAdapter.NapukettoSatoriAdapter({
 			config: satoriConfig,
@@ -1562,7 +1667,7 @@ async function assembleOb11AndSatori(kernel, services, loginResult) {
 				path: cfgFile,
 				schema: kurobotAdapter.kurobotConfigSchema,
 				defaults: kurobotAdapter.kurobotConfigDefaults(),
-				seed: kurobotAdapter.kurobotConfigSchema.parse(kurobotSection)
+				seed: parseSeed("kurobot", kurobotAdapter.kurobotConfigSchema, kurobotSection)
 			});
 			kurobot = new kurobotAdapter.NapukettoKurobotAdapter({
 				config: kurobotConfig,
@@ -1575,10 +1680,36 @@ async function assembleOb11AndSatori(kernel, services, loginResult) {
 			await kurobot.start();
 			log("bootstrap: kurobot adapter started");
 		}
+		if (Object.keys(milkySection).length > 0) {
+			const milkyConfig = new adapterCore.ProtocolConfig({
+				path: cfgFile,
+				schema: milkyAdapter.milkyConfigSchema,
+				defaults: milkyAdapter.milkyConfigSchema.parse({}),
+				seed: parseSeed("milky", milkyAdapter.milkyConfigSchema, milkySection)
+			});
+			const milky = new milkyAdapter.NapukettoMilkyAdapter({
+				config: milkyConfig,
+				broadcaster,
+				msgChannel: channel,
+				msgApi: services.msgApi,
+				groupApi: services.groupApi,
+				friendApi: services.friendApi,
+				profileApi: services.profileApi,
+				self: services.self,
+				groupCache,
+				qqVersion: env.NAPUTO_QQ_VERSION || "unknown",
+				mediaDir: (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "cache"),
+				logger: services.calibLogger
+			});
+			await milky.start();
+			log("bootstrap: milky adapter started");
+			milkyAdapters.push(milky);
+		}
 		return async () => {
 			await ob11.stop();
 			await satori.stop();
 			if (kurobot !== null) await kurobot.stop();
+			for (const milky of milkyAdapters) await milky.stop();
 		};
 	} catch (e) {
 		log(`bootstrap: 协议装配失败: ${errMsg(e)}`);
@@ -1808,6 +1939,7 @@ async function startProtocols(kernel, ctx, loginResult, logCfg) {
 		services.stopAdapters = await assembleOb11AndSatori(kernel, services, loginResult);
 	} catch (e) {
 		log(`bootstrap: 协议装配失败: ${errMsg(e)}`);
+		if (isConfigError(e)) throw e;
 		return null;
 	}
 	return services;
@@ -2320,25 +2452,30 @@ async function runSmokeIfEnabled(kernel, ctx, loginResult) {
 		log(`bootstrap: 冒烟自检异常: ${errMsg(smokeErr)}`);
 	}
 }
-/** 探测模式（NAPUTO_PROBE=1）：立即探测 + 35s 后晚探测（napuketto-probe-late.json）。 */
-function runProbePhase(kernel, ctx) {
+/** 立即探测一次（NAPUTO_PROBE=1）：fallback / core 两处引导路径共用的探测原语。 */
+function probeOnce(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)}`);
 	}
 }
+/** 探测模式（NAPUTO_PROBE=1）：立即探测 + 35s 后晚探测（napuketto-probe-late.json）。 */
+function runProbePhase(kernel, ctx) {
+	if (env.NAPUTO_PROBE !== "1") return;
+	probeOnce(kernel, ctx);
+	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);
+}
 /** NapukettoCore.create 选项（[log] 段 + env 折叠；IPC 模式关 console）。 */
 function buildCoreCreateOptions(logCfg, bootEnv) {
 	return {
@@ -2513,45 +2650,47 @@ function resolveAppid(kernel, bootEnv) {
 	}
 	throw new Error("无法从 major.node 解析 appid，请确认 wrapper.node/major.node 完整，或更新 qq-releases.json");
 }
-/** 快速登录 + session 初始化（kernel lifecycle 路径）。生命周期方法缺失 → false（无登录态，引导不完整）。 */
-async function quickLoginAndStartSession(kernel, ctx, Appid, bootEnv) {
-	if (typeof kernel.quickLogin !== "function" || typeof kernel.initAndStartSession !== "function") {
-		log("bootstrap: kernel missing lifecycle fns (quickLogin/initAndStartSession)");
-		return false;
-	}
-	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");
-		}
+/** kernel 生命周期能力探测（quickLogin / initAndStartSession 是否可用）。 */
+function hasLifecycleFns(kernel) {
+	return typeof kernel.quickLogin === "function" && typeof kernel.initAndStartSession === "function";
+}
+/** 登录前置：loginConfig 构建并 initConfig（kernel/ctx 能力缺失时跳过，不阻塞登录）。 */
+function initLoginConfig(kernel, ctx, Appid, qqVersion, dataDir) {
+	if (typeof kernel.buildLoginConfig !== "function" || !ctx.loginService) return;
+	const loginCfg = kernel.buildLoginConfig(Appid, qqVersion, 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}`);
+}
+/** NT session 配置构建 + initAndStartSession（登录成功后拉起 session）。 */
+async function buildAndStartSession(kernel, ctx, loginResult, Appid, qqVersion, dataDir) {
 	const machineGuid = typeof kernel.readMachineGuid === "function" ? kernel.readMachineGuid(ctx.loginService) : "";
 	const sessionConfig = kernel.buildSessionConfig({
 		appid: Appid,
-		fullVersion: bootEnv.qqVersion || "",
+		fullVersion: qqVersion,
 		selfUin: loginResult.uin,
 		selfUid: loginResult.uid,
-		accountPath: bootEnv.dataDir || ".",
-		downloadPath: (0, node_path.join)(bootEnv.dataDir || ".", "temp"),
+		accountPath: dataDir,
+		downloadPath: (0, node_path.join)(dataDir, "temp"),
 		machineGuid
 	});
 	const listener = kernel.createLifecycleSessionListener();
 	await kernel.initAndStartSession(ctx, sessionConfig, listener, { timeoutMs: 2e4 });
-	log("bootstrap: session init + startNT OK!");
-	return true;
 }
-/** 冒烟探测（NAPUTO_PROBE=1 时运行）。 */
-async function probeRuntime(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}`);
-	} catch (e) {
-		log(`bootstrap: probe error: ${errMsg(e)}`);
+/** 快速登录 + session 初始化（kernel lifecycle 路径）。生命周期方法缺失 → false（无登录态，引导不完整）。 */
+async function quickLoginAndStartSession(kernel, ctx, Appid, bootEnv) {
+	if (!hasLifecycleFns(kernel)) {
+		log("bootstrap: kernel missing lifecycle fns (quickLogin/initAndStartSession)");
+		return false;
 	}
+	const dataDir = bootEnv.dataDir || ".";
+	initLoginConfig(kernel, ctx, Appid, bootEnv.qqVersion, dataDir);
+	const loginResult = await kernel.quickLogin(ctx, {});
+	log(`bootstrap: quickLogin OK, uin=${loginResult.uin}, uid=${loginResult.uid}`);
+	await buildAndStartSession(kernel, ctx, loginResult, Appid, bootEnv.qqVersion, dataDir);
+	log("bootstrap: session init + startNT OK!");
+	return true;
 }
 /** 回退：旧装配路径（startNapuketto + 手工 lifecycle）。返回引导是否完整完成。 */
 async function bootstrapFallback(kernel, state, bootEnv, Appid) {
@@ -2566,45 +2705,61 @@ async function bootstrapFallback(kernel, state, bootEnv, Appid) {
 	}
 	log(`bootstrap: startNapuketto OK, engine=${typeof ctx.engine}, session=${ctx.session !== null}`);
 	const loggedIn = await quickLoginAndStartSession(kernel, ctx, Appid, bootEnv);
-	await probeRuntime(kernel, ctx);
+	probeOnce(kernel, ctx);
 	return loggedIn;
 }
+/** kernel 入口能力探测（startNapuketto / NapukettoCore 任一装配入口即可）。 */
+function hasAssemblyEntry(kernel) {
+	return typeof kernel.startNapuketto === "function" || typeof kernel.NapukettoCore === "function";
+}
+/** 动态 import kernel 入口（未注入 / 导入失败 / 无装配入口 → undefined，调用方收敛 false）。 */
+async function importKernel() {
+	const kernelEntry = env.NAPUTO_KERNEL_ENTRY;
+	if (!kernelEntry) {
+		log("bootstrap: NAPUTO_KERNEL_ENTRY not set");
+		return;
+	}
+	const kernel = await import(`file://${kernelEntry.replace(/\\/g, "/")}`);
+	log(`bootstrap: kernel imported, keys: ${Object.keys(kernel).join(", ")}`);
+	if (!hasAssemblyEntry(kernel)) {
+		log("bootstrap: kernel 无 startNapuketto/NapukettoCore 导出");
+		return;
+	}
+	return kernel;
+}
+/** bootEnv 三元组归一化（env 快照 string | undefined → string）。 */
+function buildBootEnv() {
+	return {
+		qqVersion: env.NAPUTO_QQ_VERSION || "",
+		dataDir: env.NAPUTO_CFG_DIR || "",
+		wrapperPath: env.NAPUTO_WRAPPER_PATH || ""
+	};
+}
+/** appid 解析 + 装配路径分发（NapukettoCore 走 core 装配，否则旧 fallback 路径）。 */
+async function dispatchAssembly(kernel, state, bootEnv) {
+	try {
+		const Appid = resolveAppid(kernel, bootEnv);
+		log(`bootstrap: appid=${Appid}（wrapper=${bootEnv.wrapperPath}）`);
+		if (kernel.NapukettoCore !== void 0) return await bootstrapWithCore(kernel, state, bootEnv, Appid);
+		return await bootstrapFallback(kernel, state, bootEnv, Appid);
+	} catch (e) {
+		return convergeBootstrapFailure(e, "lifecycle error");
+	}
+}
 /**
 * 核心引导：import kernel → 装配 → 登录 → 替换 session → 等待就绪 → 协议装配。
 * @returns 引导是否完整完成（IPC 模式 = 协议服务装配成功；各失败路径静默收敛为
 *   false 而非抛错，具体原因记录在 NAPUTO_CFG_DIR 下 napuketto-boot.log——
-*   调用方 self-host 依此决定 ready/failed 与进程去留）。
+*   调用方 self-host 依此决定 ready/failed 与进程去留）。唯一例外：配置校验
+*   失败（ConfigError 契约）重抛，self-host 以 78 区分配置未就绪与运行时崩溃。
 */
 async function bootstrap(state) {
-	const kernelEntry = env.NAPUTO_KERNEL_ENTRY;
-	if (!kernelEntry) {
-		log("bootstrap: NAPUTO_KERNEL_ENTRY not set");
-		return false;
-	}
 	try {
-		const kernel = await import(`file://${kernelEntry.replace(/\\/g, "/")}`);
-		log(`bootstrap: kernel imported, keys: ${Object.keys(kernel).join(", ")}`);
-		if (typeof kernel.startNapuketto !== "function" && typeof kernel.NapukettoCore !== "function") {
-			log("bootstrap: kernel 无 startNapuketto/NapukettoCore 导出");
-			return false;
-		}
-		const bootEnv = {
-			qqVersion: env.NAPUTO_QQ_VERSION || "",
-			dataDir: env.NAPUTO_CFG_DIR || "",
-			wrapperPath: env.NAPUTO_WRAPPER_PATH || ""
-		};
-		try {
-			const Appid = resolveAppid(kernel, bootEnv);
-			log(`bootstrap: appid=${Appid}（wrapper=${bootEnv.wrapperPath}）`);
-			if (kernel.NapukettoCore !== void 0) return await bootstrapWithCore(kernel, state, bootEnv, Appid);
-			return await bootstrapFallback(kernel, state, bootEnv, Appid);
-		} catch (e) {
-			log(`bootstrap: lifecycle error: ${errMsg(e)}`);
-			return false;
-		}
+		const kernel = await importKernel();
+		if (kernel === void 0) return false;
+		return await dispatchAssembly(kernel, state, buildBootEnv());
 	} catch (e) {
-		log(`bootstrap: import kernel failed: ${errMsg(e)}`);
-		return false;
+		return convergeBootstrapFailure(e, "import kernel failed");
 	}
 }
 //#endregion
@@ -2711,24 +2866,33 @@ try {
 	log(`[self-host] ⚠️ O3MiscService 激活失败: ${errMsg(e)}`);
 }
 log("[self-host] 调 bootstrap(state) ...");
+/** 引导未完成出口：补发（或不覆盖）failed 状态后退出——运行时失败，exit 1。 */
+function exitBootIncomplete() {
+	if (shouldSendGenericBootFailed(ipcMode, lastIpcStatusPhase())) sendStatus("failed", "bootstrap 未完成", {
+		code: "UNKNOWN",
+		message: "bootstrap 未完成，详见 napuketto-boot.log"
+	});
+	process.exit(1);
+}
+/** bootstrap 抛错出口（2026-10-25 退出码契约）：配置校验失败（ConfigError 一族，
+* 含协议段 seed zod 校验）= 78（EX_CONFIG 惯例，宿主据此免重启）；其余 = 1。
+* 日志文案不做机器耦合，判定只认错误名。 */
+function exitOnBootstrapError(e) {
+	const code = bootstrapExitCode(e);
+	log(`[self-host] bootstrap 失败${code === 78 ? "（配置校验失败）" : ""}: ${errMsg(e)}`);
+	if (ipcMode) sendStatus("failed", "bootstrap 失败", {
+		code: code === 78 ? "INVALID_PARAM" : "UNKNOWN",
+		message: errMsg(e)
+	});
+	process.exit(code);
+}
 (async () => {
 	try {
-		if (!await bootstrap(state)) {
-			if (shouldSendGenericBootFailed(ipcMode, lastIpcStatusPhase())) sendStatus("failed", "bootstrap 未完成", {
-				code: "UNKNOWN",
-				message: "bootstrap 未完成，详见 napuketto-boot.log"
-			});
-			process.exit(1);
-		}
+		if (!await bootstrap(state)) exitBootIncomplete();
 		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);
+		exitOnBootstrapError(e);
 	}
 })();
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@napuketto/loader",
-    "version": "0.1.0",
+    "version": "0.3.0",
     "description": "NapukettoQQ 引导组件：自建宿主（标准 Node + stub QQNT.dll）dlopen wrapper.node 并启动 kernel，不拉起 QQ / 不注入",
     "type": "module",
     "files": [