feat: 模块化内核（编译期依赖图定序）+ 密钥防火墙 + 插件三态生命周期 (#10)

* feat(kernel): 模块化内核 + 编译期依赖图定序

把单体 init 序列拆成「模块自声明依赖 + 编译期生成依赖图 + 运行期只读图」。

## 为什么

原 cmd/homed/main.go 里 17 步 init 是**手写顺序**，依赖关系只存在于
注释和人脑里。实测踩到的坑（见 docs/zh/kernel-modularization-design.md）：
 · nlp.defaultParser 被 initONNXParser 写、被 distiller 读，两者相距 60 行，
   只靠 ticker 10min 才没炸（隐式依赖，无声明）
 · 加一个模块要人肉找"该插在哪"，插错的表现是运行期 nil 解引用
 · 关停是 defer ks.CloseAll()，而热更新路径 os.Exit(42) **跳过 defer**
   ⇒ docStore/distiller/textMem 的 flush 全部丢失（每次热更新都发生）

## 怎么改

- internal/kernelboot/：KernelState（一个结构体收全部包级共享变量，字段
  nil 安全）、Module 接口、graphfile（依赖图编解码 + 与二进制 hash 对账）、
  scheduler（按 BFS 层并行 Init）、syncbus（层边界写通知）、
  lifecycle（Quiesce/Resume 可逆伪关机，区别于一次性 CloseAll）
- internal/kernelmod/<name>/：每个模块一个文件夹，Requires/Provides 自声明；
  all/all.go 是唯一的 import 清单（Go 循环导入约束）
- cmd/homed-depgraph：编译期生成依赖图，Makefile 注入 digest
- 运行期只**读**图，不计算顺序（顺序是编译期决定的，源码里没有中央清单）

## 判据

kernelboot 8 条 + 图失败模式 7 条（全部拒绝并给准确错误）+ 模块目录数
与注册表一致性。变异测试 15/15 咬住，含：
 · 删掉 AddCloser 的锁 → -race 报数据竞争
 · Scheduler 同批跑去重 → 203 vs 200
 · 图 hash 不匹配 → 拒绝启动

## 顺带修的缺陷

热更新路径漏调模块关闭 ⇒ 显式 stopKernelModules()，并用 AST 判据钉住
"必须在 os.Exit 之前"（字符串检查在本仓已骗过我三次）。

实测：冷启动 1630ms（5 层/17 模块，原 17 步串行）；生产 22 插件全部建链。

* feat(security): 密钥防火墙 + 配置加密 + close 纪律

## 密钥防火墙

模型只见别名、不见明文；插件工具调用入口（StageHost.ExecuteTool）做入向
回填。三维能力：
 · 出向：工具输出里的密钥被替换成 [[secret:name]] 别名后才进上下文
 · 入向：模型传别名，入口处填回真值（插件完全无感知）
 · 存储：config.db 里不存明文（0644 的库可读），敏感值独立 0600 文件

模式库「宁漏勿误伤」：宁可漏掉一次替换，也不把正常文本误当密钥。

## 配置加密

- internal/security/{codec,key,keyring,store,global}.go：AES-256-GCM，
  enc:v1: 前缀，密钥轮换（OldKeys 解码 + 新钥加密）
- harden.go：数据目录权限收紧
- embedded.go：支持内嵌主密钥（可选，仍保留外部 key 文件路径）
- EncryptExistingSecrets / AuditSecrets：启动时幂等迁移 + 审计

## close 纪律（用户明确要求：只要调 close 就要有前置检查）

internal/safeclose：Safe / SafeFunc。全仓 37 处裸 close(chan) → 0。
关键教训（都写进注释和判据）：
 · `select { case <-ch: default: close(ch) }` **不是**并发安全的
   （两个 goroutine 可同时命中 default）—— healthcheck 原先是这种写法
 · `sync.Once` **不可重入**：X.Do(func(){ Safe(&X, ...) }) 会自锁，
   症状是 go test 直接挂住（3 个包 600s 超时），栈里只有嵌套的 Once.Do
 · map 里按请求持有的 channel（mcp/stdio.go、clawhubadapter/sidecar.go）
   改成 *pendingRPC 包装，每通道一个 once

## 判据

security 全量 + TestNoBareCloseOutsideSafeclose（AST 级扫描，含注释剥离）
+ TestNoNestedSelfOnceDeadlock（正则修正：\w+ 不匹配点号，捕获组要含 '.'）。
变异 2/2 咬住。全量 52 包 ok。

* feat(plugin+deploy): 插件三态生命周期、数据目录迁移、发行包修复

## 插件三态生命周期（用户要求：自动启动 / 启用但不自动启动 / 禁用）

- Manifest 新增 requires_facilities / auto_start（*bool，用于区分
  "未声明"与"显式 false"）
- plugin-host 模块（internal/kernelmod/pluginhost）：用 kernelboot.Scheduler
  按依赖时机拉起，**不再手写两阶段**
- 运行态停启 StopPlugin/StartPlugin **可逆**：不写 disabled_plugins
  （不改用户决定）、不置 shuttingDown（之后还能加载）、会摘掉注册面
- 与 StopAll 的区别写进注释 —— StopAll 置 shuttingDown 后**永久无法加载**，
  那是进程退出用的，误用于"暂停"就是关了就死

## 数据目录迁移（伪关机 → 迁移 → 唤醒）

- kernelboot/lifecycle.go：Quiesce/Resume（可逆，区别于一次性 CloseAll），
  逆序暂停、逆序恢复、Pause 失败回滚
- kernelboot/migrate.go：BeginMigration/End 编排（先停插件 → 再停内核写者
  → 等在途归零）
- distiller/textmem 增 Pause/Resume 门（不是 cancel —— cancel 不可逆，
  恢复要重建整个对象）
- 模块 migration：体检 + 生成可执行迁移脚本

★ 迁移脚本的三个实测教训（都写成了判据）：
 1. 无条件改 /etc/systemd/system ⇒ 演练把**生产** -data 改成了演练目录。
    加 --dry-run（零改动）+ 强制校验 systemd 当前 -data == OLD
 2. 本机没装 rsync，脚本在"服务已停、数据未搬"处硬失败 ⇒ cp -a 回退，
    并明确警告不保硬链接/ACL（生产 plugindev 有大量 git 硬链接）

## 发行包修复（全部经实测确认）

 1. package-linux.sh **完全漏打 depgraph.bin** ⇒ 内核 exit 1
    （"生产构建（内嵌 hash 非空）但读不到依赖图"）
 2. build_homed 不走 Makefile ⇒ 单独修 Makefile 无效，必须同时生成图+注入
 3. build.sh 的 LDFLAGS 用**历史模块路径 gitcode.com** ⇒ -X 静默 no-op
    ⇒ --version 显示 unknown
 4. Makefile -ldflags 用**单引号** ⇒ 注入了字面 $GRAPH_HASH

## ★ build.sh 的版本号必须校验（真实事故）

原 `VERSION="$(git describe --tags --dirty)"`。无 tag 分支上它返回**分支名**
`backup/pre-identity-rewrite-20261005-51-g03d87a4e-dirty`，被注入 meta.Version
⇒ 插件握手判据 MajorVersion() 把整串当主版本 ⇒ **22 个子进程插件全部
握手失败**（"主版本不匹配"）。内核活着、systemd active、日志每条都像
插件的问题 —— 实际是发行包带着非法版本号。

修法：git describe 只在形如 vX.Y.Z 时采用，否则回退 meta.Version（权威源），
并对最终值做形态守卫。deploy/packaging/version_guard_test.go 3 条判据，
变异 2/2 咬住。

## deb 的 systemd unit 改为 guard 模式

ExecStart=/usr/bin/homed --role=guard --data /var/lib/homeagent
（worker exit 42 → guard 重拉，不经过 systemd、不计失败）
含 RestartSteps/RestartMaxDelaySec/TimeoutStopSec + 硬化
（NoNewPrivileges/ProtectSystem/ProtectHome/DevicePolicy/ReadWritePaths）。

## 其他

- internal/plugin/proc：非法 JSON 帧的报错**可定位**（内容摘要 + 可能原因 +
  修法）。生产实测 1038 条非法帧（插件往 stdout 打日志 = 污染协议通道）
- 示例插件 4 个 14 处 fmt.Printf → log.Printf
- hmapdev 模板同步修复；scaffold 判据剥离注释（模板注释里就含 fmt.Printf）

* chore: 收尾（主密钥轮换命令、IPC/知识库加固、SDK 对齐）

- cmd/homed-key-rotate：把 security 里的 RotateKey/RotateKeyFile/RekeySecrets
  串成一条**可执行**的运维路径。没有它，E-1 就只是库里的能力而不是
  "出事时能做的事"，而轮换的价值恰恰在于能执行。
- cmd/homed：kmod_runtime（模块装配入口）、plugins_scheduled（failback
  白名单）、memcandidate、bootstrap_order_test / shutdown_flush_test
- internal/ipc、internal/devicebridge、internal/knowledge：配套加固
- third_party/homeagent-sdk/sdk：PluginMgrAPI 增三态能力（mgrStop/mgrStart/
  mgrIsRuntimeStopped）+ settings 对齐

判据：bootstrap_order_test（启动顺序不依赖手写序列）、
shutdown_flush_test（停机的两条路径必须对称 —— exit 42 会跳过 defer，
热更新路径下模块关闭/flush 曾全部丢失）。

* test(security): 测试夹具改用不可误认的占位值（修 push protection 拦截）

GitHub secret scanning 拦住了推送：三处测试夹具用了"看起来像真密钥"的
字面量：

  internal/security/prefilter_test.go:39
  internal/security/store_test.go:177
  internal/security/survey_test.go:20

它们全是**假密钥**（`AKIAIOSFODNN7EXAMPLE` 是 AWS 官方文档的标准示例，
其余是 `abcdefghij...` 这类可读占位符），但扫描器无法区分 —— 它只看形态。

★ 不绕过（不用 unblock URL、不加 allowlist）：直接改夹具。
原因：一旦允许"假密钥可以通过"，真密钥混进来时就没有最后一道门了。

改法：保留**模式库匹配所需的结构**，把可识别内容换成 FAKE：
  glpat-abcdefghijklmnopqrst       → glpat-FAKE-TEST-TOKEN-NOT-REAL
  sk-abcdefghij...012345           → sk-FAKE-TEST-KEY-NOT-REAL-0000000
  AKIAIOSFODNN7EXAMPLE             → AKIA0000FAKE0000TEST   (保持 20 字符)
  ASIAIOSFODNN7EXAMPLE             → ASIA0000FAKE0000TEST
  xoxb-123456789012-abcdefghijklmnop → xoxb-FAKE-TEST-TOKEN-NOT-REAL

★ 中途踩到一次：AWS 键的模式是 `\b(AKIA|ASIA)[0-9A-Z]{16}\b`（共 20 字符），
我第一次替换成 19 字符的 `AKIAFAKETESTKEY0000` ⇒ 模式匹配不上 ⇒
TestSurvey_WhatIsCaught / TestRecognizesCommonShapes /
TestPrefilterNeverBlocksRealMatches 三条当场变红。
判据正确地拒绝了"为了过扫描器而削弱覆盖"。

顺带核实：全仓 grep 无任何真实密钥泄漏。

* fix(packaging): package-linux.sh 的版本解析与 build.sh 统一

上一版只修了 build.sh，漏了 package-linux.sh —— 它仍只看 git describe：

  VERSION="${VERSION:-$(git describe --tags --dirty)}"

无 tag 分支上 git describe 返回**分支名**
（backup/pre-identity-rewrite-20261005-56-g98850e1），守卫会正确拒绝，
但要求人**手动传 VERSION** 才能打包。而 build.sh 早已能自动回退 meta.Version
⇒ 同一个版本，走 build.sh 打得出来、走 package-linux.sh 打不出来。

危害不只是"要手动传参"：运维为了跑通会去掉守卫，而分支名一旦进
meta.Version 就是**插件协议主版本**的来源 ⇒ 22 个子进程插件全部握手失败
（这是真实发生过的事故，见 3efa4e5）。

修法：两个脚本用同一套规则（git describe 仅在 vX.Y.Z 形态时采用，
否则回退 meta.Version），并对最终值做形态守卫。

判据：TestBothPackagingScriptsShareVersionRules —— 逐个读两个脚本，
要求都能从 meta/meta.go 取权威版本、都校验 git describe 形态。
变异（把 package-linux.sh 改回旧规则）咬住并准确指出是哪个脚本。

实测：不传 VERSION 跑 package-linux.sh，输出
  [PKG] warn: git describe 给出非版本串（...），改用 meta.Version=1.4.0
  Version: 1.4.0

* fix(test): 跨仓判据在 CI 上应 skip 而非 fail（修 PR 双红）

CI 上 "Go build / vet / test" 与 "Build linux/amd64" 双红：

  --- FAIL: TestHmapdevTemplateImplementsAllPluginMgrMethods
      bridge_sync_test.go:170: 读模板: open
      ../../../third_party/homeagent-sdk/tools/hmapdev/templates/proc_main.go.tmpl:
      no such file or directory

## 根因：判据依赖了一个**被 gitignore 的路径**

`.gitignore:33` 有 `third_party/homeagent-sdk/tools/`（SDK 仓自治，本仓不跟踪）。
于是：
  · 本机（完整 SDK 检出）有该文件 ⇒ 判据通过
  · CI（只 checkout 本仓）没有该文件 ⇒ Fatalf ⇒ **必红**

我提交时只在本机跑测试、没看 CI，所以这个问题拖到 PR 才暴露。

## 修法

文件缺失时 `t.Skipf` 而不是 `t.Fatalf`。

★ 这不是"放弃检查"：
  · 跨仓一致性由 **SDK 仓自己的判据**守着
    （tools/hmapdev/scaffold_stdout_test.go 等），那里才是模板的真实归属地
  · 本判据在本机开发时**仍然生效**（已验证：有文件时 PASS，缺文件时 SKIP）

## 验证

 · 本机（有文件）  → PASS（判据真跑）
 · 模拟 CI（移走 tools/）→ SKIP（不再 fail）
 · 全量 53 包 ok / 0 fail

## 顺带

同目录还有 e2e_template_test.go 也读 tools/，但它是 `//go:build` 门控的
e2e 判据，CI 默认不跑，无需处理。

---------

Co-authored-by: JianFeeeee <JianFeeeee@users.noreply.gitcode.com>

internal/kernelmod/all/all.go

@@ -0,0 +1,43 @@
+// Package all 把全部内核模块**引入编译**（Go 要求 import 才会编译进来）。
+//
+// ## 为什么这层是必要的（一个真实的 Go 约束）
+//
+// 模块各自在 init() 里 `kernelmod.Register(...)`，但必须有东西把它们
+// 引进来。若把 import 写在 `kernelmod/core.go` 里：
+//
+//	core.go import lua/  ⇒ core → lua → core（lua 要调 Register 必须 import core）
+//	⇒ **循环导入**，Go 禁止
+//
+// 所以注册表 API 在 `kernelmod` 包，模块 import 它（单向），
+// 而"引进来"的清单放在**本子包**（`kernelmod/all`）—— 它 import 两者。
+//
+// ## 加一个新模块要做什么（**唯一的一处编辑**）
+//
+//	① 新建 internal/kernelmod/<name>/mod.go，实现 kernelboot.Module
+//	② 在**本文件**加一行空白 import
+//
+// 依赖写在模块自己的 Requires() 里 —— **没有**中央依赖清单。
+package all
+
+import (
+	// 每个模块一个独立文件夹（用户设计）。
+	//
+	// ★ 顺序**无关**：模块注册顺序由 init() 决定，而注册表刻意乱序
+	// （见 kernelmod/core.go）。真正的先后只由 Requires/Provides 决定。
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/agent"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/config"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/docstore"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/kernelapi"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/knowledge"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/llm"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/lua"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/memory"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/migration"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/multimodal"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/onnx"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/pluginhost"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/stagehost"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/supervisor"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/textmem"
+	_ "github.com/JianFeeeee/HomeAgent/internal/kernelmod/tracker"
+)

internal/kernelmod/all/facilities_sync_test.go

@@ -0,0 +1,112 @@
+package all
+
+// 设施名「内核 ↔ 公开 SDK」一致性判据（2026-10-16）。
+//
+// ## 为什么需要它
+//
+// 设施名同时存在于**两处**，且必须逐字一致：
+//
+//	内核：internal/kernelmod/facilities.go   （模块 Provides 用）
+//	SDK：third_party/homeagent-sdk/sdk/facilities.go （插件声明用）
+//
+// 它们**不能合并**：SDK 是独立发布的模块（外部插件依赖它），
+// 而内核的 internal 规则又禁止内部包被外部 import。
+//
+// ⇒ 两处并存 ⇒ 有漂移风险。**改一处忘另一处**的后果是：
+// 插件按 SDK 声明的名字，内核从未注册 ⇒ 插件**永不启动**，且（在本判据
+// 与运行期校验出现前）无任何报错。
+//
+// 本判据把"两边一致"变成可执行的检查。
+//
+// ## 为什么必须从**源码**提取而不是手写清单
+//
+// 手写清单在"新增了一个设施名但只改了内核"时**也不会包含新名字**
+// ⇒ 判据照样绿（守卫形同虚设）。本仓已有先例
+// （TestCapability_AllMethodsClassified 初版就是这个毛病）。
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"testing"
+)
+
+// internalOnlyFacilities 是**内核内部**顺序标记（不是给插件的契约）。
+//
+// ★ 判据要排除它们：它们的消费者是内核模块，不该进公开 SDK。
+// 若把它们也拿去比对，会得到"内核有但 SDK 没有"的**假红**（实测撞到：
+// knowledge-migrated）。反向也要防：有人误把内部标记放进 SDK 当对外契约。
+var internalOnlyFacilities = map[string]bool{
+	"knowledge-migrated": true,
+}
+
+// extractFacilities 从 Go 源码里提取 `FacilityXxx = "值"` 形式的常量。
+func extractFacilities(t *testing.T, path string) map[string]string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("读 %s: %v", path, err)
+	}
+	re := regexp.MustCompile(`(?m)^\s*(Fac[A-Za-z0-9_]*|Facility[A-Za-z0-9_]*)\s*=\s*"([^"]+)"`)
+	out := map[string]string{}
+	for _, m := range re.FindAllStringSubmatch(string(b), -1) {
+		out[m[1]] = m[2]
+	}
+	if len(out) < 10 {
+		t.Fatalf("只从 %s 提取到 %d 个设施常量 —— 正则或文件结构变了（判据会假绿）",
+			path, len(out))
+	}
+	return out
+}
+
+// ★★★ 判据：**内核与 SDK 的设施名值集合逐字一致**。
+func TestFacilityNamesMatchPublicSDK(t *testing.T) {
+	kernel := extractFacilities(t, filepath.Join("..", "facilities.go"))
+	sdk := extractFacilities(t, filepath.Join("..", "..", "..",
+		"third_party", "homeagent-sdk", "sdk", "facilities.go"))
+
+	kernelVals := map[string]string{} // 值 → 内核常量名
+	for name, v := range kernel {
+		if internalOnlyFacilities[v] {
+			continue // 内核内部顺序标记，不是插件契约
+		}
+		kernelVals[v] = name
+	}
+	sdkVals := map[string]string{}
+	for name, v := range sdk {
+		sdkVals[v] = name
+	}
+
+	var missingInSDK, missingInKernel []string
+	for v, name := range kernelVals {
+		if _, ok := sdkVals[v]; !ok {
+			missingInSDK = append(missingInSDK, name+"="+v)
+		}
+	}
+	for v, name := range sdkVals {
+		if _, ok := kernelVals[v]; !ok {
+			missingInKernel = append(missingInKernel, name+"="+v)
+		}
+	}
+	sort.Strings(missingInSDK)
+	sort.Strings(missingInKernel)
+
+	if len(missingInSDK) > 0 {
+		t.Errorf("★ 内核有但**公开 SDK 没有**的设施名: %v\n"+
+			"   后果：插件作者无法 import 该常量（只能照文档抄 ⇒ 易拼错），"+
+			"且打包期校验会把它当'未知设施名'而拒绝", missingInSDK)
+	}
+	for v := range sdkVals {
+		if internalOnlyFacilities[v] {
+			t.Errorf("★ 公开 SDK 里出现了内核**内部顺序标记** %q —— "+
+				"它的消费者是内核模块，不该成为插件契约（插件声明它没有意义，"+
+				"且会误导作者以为可用）", v)
+		}
+	}
+	if len(missingInKernel) > 0 {
+		t.Errorf("★ 公开 SDK 有但**内核没有**的设施名: %v\n"+
+			"   后果：插件按此声明 ⇒ 内核从未注册 ⇒ 插件**永不启动**（静默）",
+			missingInKernel)
+	}
+}

internal/kernelmod/all/registry_test.go

@@ -0,0 +1,351 @@
+package all
+
+// 内核模块注册表 + 分层的判据（2026-10-16）。
+//
+// 设计见 docs/zh/kernel-modularization-design.md §2.3/§2.6/§2.8。
+//
+// ## 用户的验收标准（必须被判据钉住）
+//
+// > 模块应该在 /modelname/ 独立文件夹下，根目录只有 core.go，
+// > core 内有一个注册表注册各个模块 … 注意注册表中的模块列表是乱序的
+//
+// ⇒ 四条底线：
+//   ① 每个模块**独立文件夹**
+//   ② 依赖写在**模块自己**的 Requires() 里（无中央依赖清单）
+//   ③ 注册表列表**乱序**（顺序无意义，不能被依赖）
+//   ④ 第 0 层模块**不依赖任何模块**（"core 不依赖任何模块"字面成立）
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/JianFeeeee/HomeAgent/internal/kernelboot"
+	"github.com/JianFeeeee/HomeAgent/internal/kernelmod"
+)
+
+// ★★★ 判据：**依赖图可建 + 模块全登记 + 无重复**。
+func TestRegistryBuildsValidGraph(t *testing.T) {
+	if d := kernelmod.Duplicates(); len(d) > 0 {
+		t.Fatalf("★ 模块名重复注册: %v（两个模块同名，或一个模块被导入两次）", d)
+	}
+	mods := kernelmod.Registered()
+	if len(mods) < 10 {
+		t.Fatalf("★ 只登记 %d 个模块 —— 可能有模块漏了 init() 注册", len(mods))
+	}
+	plan, err := kernelboot.Build(mods)
+	if err != nil {
+		t.Fatalf("★ 依赖图无解（结构错误）: %v", err)
+	}
+	total := 0
+	for _, l := range plan.Layers {
+		total += len(l)
+	}
+	if total != len(mods) {
+		t.Fatalf("★ 分层丢失模块: %d != %d", total, len(mods))
+	}
+}
+
+// ★★★ 判据（用户验收标准 ④）：**第 0 层不依赖任何模块**。
+func TestFirstLayerHasNoDependencies(t *testing.T) {
+	plan, err := kernelboot.Build(kernelmod.Registered())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, m := range plan.Layers[0] {
+		if len(m.Requires()) != 0 {
+			t.Errorf("★ 第 0 层模块 %s 有依赖 %v —— 分层正确的话不该有",
+				m.Name(), m.Requires())
+		}
+	}
+	names := map[string]bool{}
+	for _, m := range plan.Layers[0] {
+		names[m.Name()] = true
+	}
+	for _, want := range []string{"config", "kernel-api"} {
+		if !names[want] {
+			t.Errorf("★ %s 应在第 0 层（它不依赖任何模块）", want)
+		}
+	}
+}
+
+// ★★★ 判据（用户验收标准 ①②）：**每模块独立文件夹；依赖写在自己文件里**。
+func TestEachModuleInOwnFolder(t *testing.T) {
+	root := ".."
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	modDirs := 0
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		modDirs++
+		files, _ := filepath.Glob(filepath.Join(root, e.Name(), "*.go"))
+		if len(files) == 0 {
+			t.Errorf("★ 模块目录 %s 下没有 .go 文件", e.Name())
+		}
+	}
+	if modDirs < 10 {
+		t.Fatalf("★ 只找到 %d 个模块目录（期望 ≥10）", modDirs)
+	}
+
+	// ② 依赖不能出现在"中央清单"里：根目录只有 core.go/facilities.go/all 子包
+	for _, f := range []string{"core.go", "facilities.go"} {
+		b, err := os.ReadFile(filepath.Join(root, f))
+		if err != nil {
+			continue
+		}
+		src := string(b)
+		if strings.Contains(src, "Requires() []string { return []string{") {
+			t.Errorf("★ %s 里出现了具体的 Requires —— 依赖应写在各模块自己的文件里", f)
+		}
+	}
+}
+
+// ★★★ 判据（用户验收标准 ③）：**注册表列表乱序**（顺序无意义，不能被依赖）。
+//
+// ★ 怎么测"乱序"：注册顺序由 init() 决定。这里断言 Names() 的顺序
+// **不等于**按名字排序的顺序 —— 若相等，说明有人给它排过序，
+// 那会给使用者"这个顺序有意义"的错觉（用户明确要求乱序）。
+//
+// ⚠ 注意：这条是**性质检查**，不是绝对的（init 顺序恰好等于字典序时也会通过
+// 排序检查）。所以真正守"顺序无意义"的是**文档 + 分层器内部排序**，
+// 而本判据是"如果有人显式排序就报红"的报警器。
+func TestRegistryOrderIsNotMeaningful(t *testing.T) {
+	names := kernelmod.Names()
+	if len(names) < 2 {
+		t.Fatal("模块太少")
+	}
+	sorted := append([]string(nil), names...)
+	sort.Strings(sorted)
+	if strings.Join(names, ",") == strings.Join(sorted, ",") {
+		t.Logf("提示：注册顺序恰好等于字典序（不必然是错误，但请确认没有人"+
+			"给注册表排序——顺序无意义是设计的一部分）: %v", names)
+	}
+	// 核心断言：Registered() 返回的列表**不得**按依赖序排列
+	// （即：不能有人把"启动顺序"写进注册表）
+	plan, err := kernelboot.Build(kernelmod.Registered())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var layerOrder []string
+	for _, l := range plan.Layers {
+		for _, m := range l {
+			layerOrder = append(layerOrder, m.Name())
+		}
+	}
+	if strings.Join(names, ",") == strings.Join(layerOrder, ",") {
+		t.Fatal("★ 注册表顺序恰好等于**依赖分层序** —— 说明注册表被用来表达启动顺序了，" +
+			"那正是要消灭的隐式顺序依赖（用户要求注册表乱序）")
+	}
+}
+
+// ★★★ 判据：**关键顺序被依赖图保证**（每条都来自真实约束）。
+func TestLayeringPreservesCriticalOrder(t *testing.T) {
+	plan, err := kernelboot.Build(kernelmod.Registered())
+	if err != nil {
+		t.Fatal(err)
+	}
+	layerOf := map[string]int{}
+	for i, l := range plan.Layers {
+		for _, m := range l {
+			layerOf[m.Name()] = i
+		}
+	}
+	cases := []struct{ a, b, why string }{
+		{"config", "lua", "initLuaVM(cfg) 收 cfg"},
+		{"lua", "llm", "initLLMProviders 收 luaVM"},
+		{"config", "memory", "initMemoryStack 收 cfgReg"},
+		{"knowledge-migration", "knowledge-store", "迁移必须早于 store 扫盘"},
+		{"llm", "stage-host", "newStageAndRegistry 收 providerMgr"},
+		{"memory", "stage-host", "newStageAndRegistry 收 mem.db"},
+		{"stage-host", "agent", "newMainAgent 收 stageHost"},
+		{"llm", "agent", "newMainAgent 收 provider"},
+		{"memory", "agent", "newMainAgent 收 mem.db"},
+		{"tracker", "agent", "newMainAgent 收 trk"},
+	}
+	for _, c := range cases {
+		la, ok1 := layerOf[c.a]
+		lb, ok2 := layerOf[c.b]
+		if !ok1 || !ok2 {
+			t.Errorf("模块缺失: %s=%v %s=%v", c.a, ok1, c.b, ok2)
+			continue
+		}
+		if la >= lb {
+			t.Errorf("★ %s 应在 %s 之前（%s），实际层号 %d >= %d", c.a, c.b, c.why, la, lb)
+		}
+	}
+}
+
+// ★★★ 判据：**text-memory 显式依赖 onnx-parser**（隐藏依赖，见 textmem 包注释）。
+//
+// ★ 不能用层号断言：text-memory 已因 memory 被推到第 2 层，
+// 而 onnx-parser 在第 1 层 ⇒ 删掉依赖后层号依然满足。必须断言**声明本身**。
+func TestHiddenDependencyOnnxDeclared(t *testing.T) {
+	src := readMod(t, filepath.Join("..", "textmem", "mod.go"))
+	if !strings.Contains(src, "FacONNX") {
+		t.Fatal("★ text-memory 未声明对 onnx-parser 的依赖 —— " +
+			"它在运行期读 nlp.defaultParser（onnx 模块写的包级单例）。" +
+			"当前靠 distillLoop 的 Interval=10min 碰巧安全；" +
+			"Interval 变小或解析器装配更后 ⇒ 静默降级（图记忆实体退化成整句复合值）")
+	}
+}
+
+// ★★★ 判据：**分层带来并行**（对照原 17 步串行）。
+func TestLayeringYieldsParallelism(t *testing.T) {
+	mods := kernelmod.Registered()
+	plan, err := kernelboot.Build(mods)
+	if err != nil {
+		t.Fatal(err)
+	}
+	maxLayer := 0
+	for _, l := range plan.Layers {
+		if len(l) > maxLayer {
+			maxLayer = len(l)
+		}
+	}
+	if len(plan.Layers) >= len(mods) {
+		t.Fatalf("★ 无并行度（%d 层 / %d 模块）", len(plan.Layers), len(mods))
+	}
+	t.Logf("并行度: %d 层 / %d 模块，最宽层 %d 个", len(plan.Layers), len(mods), maxLayer)
+}
+
+func readMod(t *testing.T, path string) string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("读 %s: %v", path, err)
+	}
+	return string(b)
+}
+
+// ★★★ 判据：**每个模块目录都被 import 引入**（漏 import ⇒ 模块静默消失）。
+//
+// ## ★ 这条是变异测试发现的**真实覆盖漏洞**
+//
+// 我删掉 `all.go` 里 `multimodal` 的 import 后，**全部判据仍然通过** ——
+// 因为：
+//
+//	· 依赖图仍然解得开（multimodal **没有下游依赖**，没人需要它）
+//	· 注册表数量检查只有 `>= 10` 这种下限（少一个不报）
+//
+// 后果：**多模态能力凭空消失**，而启动照常成功、无任何报错。
+// 这与本仓反复吃亏的"静默降级"是同一形态：
+//
+//	· 漏 import 插件包 ⇒ 插件静默消失（已有同类教训）
+//	· 漏 import 模块包 ⇒ 模块静默消失（本条）
+//
+// ## 判据做法：**统计目录 vs 统计注册**
+//
+// 扫描 `internal/kernelmod/` 下的模块目录（含 `mod.go` 或实现 Module 的 .go
+// 文件），与注册表里的模块名比对 —— 目录有而注册表没有 ⇒ 漏 import。
+//
+// ★ 为什么不用"手写清单"：手写清单在"新增目录忘了加 import"时
+// **也不会包含新目录** ⇒ 判据照样绿（本仓已有先例）。
+func TestEveryModuleDirIsImported(t *testing.T) {
+	root := ".."
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	registered := map[string]bool{}
+	for _, n := range kernelmod.Names() {
+		registered[n] = true
+	}
+
+	// 收集"看起来是模块目录"的：含 .go 文件、且文件里有 kernelmod.Register 调用
+	var moduleDirs []string
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		name := e.Name()
+		if name == "all" {
+			continue // 这个子包是 import 清单本身
+		}
+		files, _ := filepath.Glob(filepath.Join(root, name, "*.go"))
+		hasRegister := false
+		for _, f := range files {
+			if strings.Contains(f, "_test.go") {
+				continue
+			}
+			b, err := os.ReadFile(f)
+			if err != nil {
+				continue
+			}
+			if strings.Contains(string(b), "kernelmod.Register(") {
+				hasRegister = true
+				break
+			}
+		}
+		if hasRegister {
+			moduleDirs = append(moduleDirs, name)
+		}
+	}
+	if len(moduleDirs) < 5 {
+		t.Fatalf("只找到 %d 个模块目录 —— 扫描逻辑失效（判据会假绿）", len(moduleDirs))
+	}
+
+	// 每个模块目录里的 Register(...) 参数名 → 期望的模块名
+	// （用"目录名"与"注册名"的映射，因为目录名与 Name() 不必相同）
+	dirToNames := map[string][]string{}
+	for _, d := range moduleDirs {
+		files, _ := filepath.Glob(filepath.Join(root, d, "*.go"))
+		for _, f := range files {
+			if strings.Contains(f, "_test.go") {
+				continue
+			}
+			b, _ := os.ReadFile(f)
+			// ★ 正则要容忍 gofmt 的对齐空格（列对齐会让 `{` 前有多个空格）。
+			// 初版写成 `\{ return` （单空格）⇒ 只匹配到 agent 一个，
+			// 其余全部"找不到目录"（判据假红）。实测撞到。
+			re := regexp.MustCompile(`(?m)^func \([A-Za-z0-9_]+\) Name\(\) string\s+\{ return "([^"]+)" \}`)
+			for _, m := range re.FindAllStringSubmatch(string(b), -1) {
+				dirToNames[d] = append(dirToNames[d], m[1])
+			}
+		}
+	}
+
+	var missing []string
+	for dir, names := range dirToNames {
+		if len(names) == 0 {
+			continue
+		}
+		// 该目录的**每个**模块名都必须在注册表里
+		//（一个目录可含多个模块，如 knowledge/{migration,store}）
+		anyFound := false
+		for _, n := range names {
+			if registered[n] {
+				anyFound = true
+			}
+		}
+		if !anyFound {
+			missing = append(missing, fmt.Sprintf("%s(%v)", dir, names))
+		}
+	}
+	sort.Strings(missing)
+	if len(missing) > 0 {
+		t.Fatalf("★ 这些模块目录**没有被 import 引入**（模块静默消失，启动不报错）: %v\n"+
+			"   修复：在 internal/kernelmod/all/all.go 里加空白 import", missing)
+	}
+
+	// 反向：注册表里的每个模块都应能对应到某个目录
+	known := map[string]bool{}
+	for _, ns := range dirToNames {
+		for _, n := range ns {
+			known[n] = true
+		}
+	}
+	for n := range registered {
+		if !known[n] {
+			t.Errorf("★ 注册表里的模块 %s 找不到对应目录 —— 可能是测试夹具注册的，或扫描漏了", n)
+		}
+	}
+}