refactor(test): 肃清全部白盒测试 —— 源码目录零 _test.go，判据只走模块导出接口

## 用户裁定（本次唯一方向）

1. 「测试不应该面向过程而是面向模块的输入和输出」
2. 「每个模块下应该使用 test 目录搜集所有测试文件，而不是和源码混在一起」
3. 「现在 test 都超过源码数量了，这很明显不符合模块接口黑盒化的要求」
4. 「ast判包依赖？这不是工具链该做的吗？为什么在测试里」
5. 「抽行为判据？只需要面向模块输入接受模块输出就行」
6. 「不管ci，直接把所有白盒测试全清理了再回去一鼓作气改ci」

## 实测起点

    537 个测试文件 / 377 个源码文件 / 2853 条 Test
    523 / 537（97%）直接调用私有函数
    514 个是 in-package 白盒（package xxx，与源码同目录）
     88 个读 .go/.md 源码做断言
     94 个断言私有字段（f.Step / r.buf / a.sched …）
     38 个直调私有函数（stepLLM / runStage / classifyProviderError …）
    internal/agent/core: 140 test / 52 src

## 做了什么

### ① 删除 514 个 in-package 白盒测试

不做「抽行为判据」，也不做逐文件搬运。理由：Go 按目录分包，
`pkg/test/` 里写 `package pkg` 也看不到 unexported 符号 —— 所以
「挪进 test/」和「改成黑盒」是同一件事的两面。把 514 个白盒文件
搬走只会得到一堆编译不过的文件，或者为了迁就它们把内部全导出。

用户明确否定「抽」这个动作后，剩下 9 个 test/ 里的判据也一并
重新审视：凡是靠读源码/前端资源文本做断言的（dashboardJSSource /
FrontendAsset / GraphDataForVisual / SSEEventRing …）全部删除，
只留走模块**本来就有**的公开 API 的输入→输出判据：

    internal/agent/core/child/test/     Registry 的 Add/Get/Stop/Remove 输出
    internal/agent/core/test/           StageHost 的 Register/Run 输出
    internal/plugins/files/test/        工具 handler 的 {path} → {content/error}
    internal/plugins/webui/test/        HTTP 请求 → 响应（NewHandler/RegisterRoutes）
    internal/tfidf/test/                文本 → 向量/检索结果

现存 9 个测试文件全部在 `<module>/test/`，源码目录零 `_test.go`。

### ② 回退「为测试而导出」的接口

这些是前几轮为了把白盒判据挪出源码目录而导出的，属于白盒残留，
现在没有调用方了，全部收回私有：

    webui.FrontendAsset / DashboardPage        删除
    webui.GraphDataForVisual → graphDataForVisual
    webui.SSEEventRing/Record → sseEventRing/sseEventRecord（含字段）
    webui.NewSSEEventRing                       删除
    kstate.MountForTest                         删除
    security.ClassifyPrincipalForTest           删除

生产代码对它们的内部调用同步改回私有名，不改任何行为。

### ③ CI 一鼓作气改到位（用户指定顺序）

**删**：`整机启动图判据` 单列步骤（它跑的 bootgraph_test.go 已删），
以及 `check-ci-gates.py` 里盯着那个步骤的断言 —— 继续盯着一个
不存在的步骤就是永远红的空转。

**加两道构建期静态门**（原先这些约束错放在 go test 里）：

- `测试归拢（源码目录不得有 _test.go）`
  `find internal cmd pkg providers deploy -name '*_test.go' -not -path '*/test/*'`
  非空即红。物理上挡住白盒回潮。
- `包依赖门（kstate 为叶子 / 底层包不反向依赖装配器）`
  用 `go list -deps` 判 8 组禁止依赖 + `go build core` 确认环不存在。
  这是**工具链**的职责，不该由 `go test` 兼职。

`check-ci-gates.py` 同步改为盯这两道门；ci.yml 里 13 处既有
>80 字符行一并折行（门禁标了 STOP，不留尾巴）。

### ④ 顺带（上一批未提交的）

`scripts/make-package.sh` 产物名 `HomeAgent-linux-*` →
`HologramAgent-linux-*`；清理 gitignored 构建产物
`build/ dist/ .go/ .npm-cache/` 共 20G（工作区 21G → 1.7G）。
运行契约（~/.homeagent/cli.sock、线上域名、兼容别名）未动。

## 验证

    go build ./...                     PASS
    go vet ./...                       PASS
    gofmt -l                           干净
    python3 .github/scripts/check-ci-gates.py   PASS
    go test ./... -count=1             5 个测试包全过 / 100 个包无测试 / 0 FAIL
    源码目录 _test.go 数              0
    测试文件数                         9（全部在 <module>/test/）

## 后续

按模块导出接口清单重写判据（不是从旧白盒里抽）：
internal/agent/api、internal/memory、internal/security、internal/plugin、
internal/knowledge、cmd/* 等目前 0 判据，需要逐个列接口 → 写输入→输出判据
→ 变异验证。这是新一轮工作，本提交不含。

internal/kernelmod/pluginhost/catalog_test.go

@@ -1,454 +0,0 @@
-package pluginhost
-
-// plugin-host（插件宿主）的判据（2026-10-16）。
-//
-// 设计见 docs/zh/kernel-modularization-design.md §2.6 + 用户方案 A。
-//
-// ## 这组判据守什么
-//
-//  ① **三形态分流正确**（用户明确要求：自动启动 / 启用但不自动启动 / 禁用）
-//  ② **元数据缓存**（用户指出的设计：扫一次、供调度与展示共用）
-//  ③ **内置插件不被漏掉** ← 这是我实际踩过的回归（19 个全丢）
-//  ④ 关键顺序：failback 白名单必须在插件拉起前生效
-
-import (
-	"github.com/JianFeeeee/HologramAgent/internal/kstate"
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"os"
-	"path/filepath"
-	"reflect"
-	"sort"
-	"strings"
-	"testing"
-
-	"github.com/JianFeeeee/HologramAgent/internal/kernelboot"
-)
-
-// makePluginDir 造一个带 plugin.json 的插件目录。
-func makePluginDir(t *testing.T, root, name, manifest string) {
-	t.Helper()
-	d := filepath.Join(root, name)
-	if err := os.MkdirAll(d, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(d, "plugin.json"), []byte(manifest), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// ★★★ 判据：**三形态分流正确**（用户设计要求的三种形态）。
-func TestClassifyThreeForms(t *testing.T) {
-	root := t.TempDir()
-	// ① 自动启动 + 声明依赖
-	makePluginDir(t, root, "auto_declared",
-		`{"name":"auto_declared","version":"1","entry":"plugin.bin","requires_facilities":["config"]}`)
-	// ① 自动启动 + 未声明
-	makePluginDir(t, root, "auto_plain",
-		`{"name":"auto_plain","version":"1","entry":"plugin.bin"}`)
-	// ② 启用但不自动启动
-	makePluginDir(t, root, "manual",
-		`{"name":"manual","version":"1","entry":"plugin.bin","requires_facilities":["config"],"auto_start":false}`)
-	// ③ 禁用
-	makePluginDir(t, root, "banned",
-		`{"name":"banned","version":"1","entry":"plugin.bin"}`)
-
-	cat, _ := scanCatalog(root, func(n string) bool { return n == "banned" })
-	g := classify(cat)
-
-	eq := func(got, want []string, what string) {
-		t.Helper()
-		sort.Strings(got)
-		sort.Strings(want)
-		if strings.Join(got, ",") != strings.Join(want, ",") {
-			t.Errorf("★ %s: 期望 %v 实际 %v", what, want, got)
-		}
-	}
-	eq(g.autoStart, []string{"auto_declared", "auto_plain"}, "① 自动启动")
-	eq(g.declared, []string{"auto_declared"}, "① 中声明了依赖的")
-	eq(g.manual, []string{"manual"}, "② 启用但不自动启动")
-	eq(g.disabled, []string{"banned"}, "③ 持久禁用")
-
-	// ★ 关键互斥：三形态必须互不重叠（一个插件只能属于一种）
-	inBoth := func(a, b []string, an, bn string) {
-		t.Helper()
-		m := map[string]bool{}
-		for _, x := range a {
-			m[x] = true
-		}
-		for _, x := range b {
-			if m[x] {
-				t.Errorf("★ %s 与 %s 同时包含 %s（三形态必须互斥）", an, bn, x)
-			}
-		}
-	}
-	inBoth(g.autoStart, g.manual, "autoStart", "manual")
-	inBoth(g.autoStart, g.disabled, "autoStart", "disabled")
-	inBoth(g.manual, g.disabled, "manual", "disabled")
-}
-
-// ★★★ 判据：**元数据缓存内容正确**（用户设计：读列表→写缓存）。
-func TestCatalogCachesMetadata(t *testing.T) {
-	root := t.TempDir()
-	makePluginDir(t, root, "p1",
-		`{"name":"p1","name_zh":"一","version":"2.3.4","entry":"plugin.bin",
-		  "description":"演示","requires_facilities":["config","llm"],"tags":["a","b"]}`)
-
-	cat, noskip := scanCatalog(root, nil)
-	if len(noskip) != 0 {
-		t.Errorf("不该有跳过的目录: %v", noskip)
-	}
-	if cat.Size() != 1 {
-		t.Fatalf("缓存应有 1 条，实际 %d", cat.Size())
-	}
-	m, ok := cat.Get("p1")
-	if !ok {
-		t.Fatal("取不到 p1 的元数据")
-	}
-	// 每个字段都要缓存对（调度靠 RequiresFacilities，展示靠其余）
-	if len(m.RequiresFacilities) != 2 || m.RequiresFacilities[0] != "config" {
-		t.Errorf("RequiresFacilities 未正确缓存: %v", m.RequiresFacilities)
-	}
-	if !m.AutoStart {
-		t.Error("缺省 auto_start 应为 true")
-	}
-	if m.Version != "2.3.4" || m.NameZh != "一" || m.Description != "演示" {
-		t.Errorf("展示字段未正确缓存: %+v", m)
-	}
-	if len(m.Tags) != 2 {
-		t.Errorf("Tags 未正确缓存: %v", m.Tags)
-	}
-	if m.ManifestPath == "" || m.ScannedAt.IsZero() {
-		t.Error("诊断字段（路径/扫描时刻）应被记录")
-	}
-	// 缓存必须能列出（pluginmgr 的列表用它）
-	if names := cat.Names(); len(names) != 1 || names[0] != "p1" {
-		t.Errorf("Names 不对: %v", names)
-	}
-}
-
-// ★★★ 判据：**无 plugin.json 的目录被记为"无 manifest"而不是"错误"**。
-//
-// ★ 这条守的是我实际踩过的回归：19 个**内置插件**目录没有 plugin.json
-// （它们是编译期工厂），我第一版把它们记成"跳过 19 个非插件目录"并
-// **完全没有加载它们**（webui/pluginmgr/cli/files/timer… 全丢）。
-//
-// 判据分两层：
-//
-//	· 本层：scanCatalog 必须**如实**报告哪些目录没 manifest（便于诊断）
-//	· 装配层：LoadSkipping 必须补上内置插件（见 TestBuiltinsNotDropped）
-func TestScanReportsNoManifestDirs(t *testing.T) {
-	root := t.TempDir()
-	makePluginDir(t, root, "has_manifest", `{"name":"has_manifest","version":"1","entry":"plugin.bin"}`)
-	// 模拟内置插件目录：只有可执行文件，没有 plugin.json
-	builtin := filepath.Join(root, "builtin_plugin")
-	os.MkdirAll(builtin, 0o755)
-	os.WriteFile(filepath.Join(builtin, "plugin.bin"), []byte("x"), 0o755)
-
-	cat, noManifest := scanCatalog(root, nil)
-	if cat.Size() != 1 {
-		t.Errorf("缓存应只含带 manifest 的（1 条），实际 %d", cat.Size())
-	}
-	if len(noManifest) != 1 || noManifest[0] != "builtin_plugin" {
-		t.Fatalf("★ 无 manifest 的目录必须被如实报告（便于区分「内置插件」与「坏插件」）: %v",
-			noManifest)
-	}
-}
-
-// ★★★ 判据：**内置插件不会被漏掉**（行为判据，回归守）。
-//
-// ## 为什么这条必须存在
-//
-// 我第一版让 plugin-host 只处理"有 plugin.json 的外部插件"，
-// 结果 **19 个内置插件全部没加载** —— webui（人机界面）、pluginmgr
-// （插件管理）、cli、files、cmd、timer、mcp… 全丢，而**日志看起来正常**
-// （只有一条"跳过 19 个非插件目录"的提示，很容易被当成噪音略过）。
-//
-// ## ★ 为什么必须是**行为**判据（我第一版写成源码检查 ⇒ 变异不咬）
-//
-// 初版检查"源码里有 `LoadSkipping(`"。但删掉**调用**后，
-// 注释里仍有 `LoadSkipping` 字样 ⇒ 判据照样绿
-// （**测写法不测行为** —— 本仓反复踩的同一类坑）。
-//
-// ⇒ 改为跑**生产同一个函数** `buildSkipSet`，断言：
-//
-//	① 内置插件（无 manifest）**不在** skip 里 ⇒ 会走全量加载
-//	② 三形态的插件**在** skip 里（防重复加载 / 防误加载）
-func TestBuiltinsAreNotSkipped(t *testing.T) {
-	root := t.TempDir()
-	makePluginDir(t, root, "ext_auto",
-		`{"name":"ext_auto","version":"1","entry":"plugin.bin","requires_facilities":["config"]}`)
-	makePluginDir(t, root, "ext_manual",
-		`{"name":"ext_manual","version":"1","entry":"plugin.bin","auto_start":false}`)
-
-	cat, _ := scanCatalog(root, nil)
-	g := classify(cat)
-	skip := buildSkipSet(cat, g)
-
-	// ★ 核心：内置插件（不在 catalog 里 = 没有 plugin.json）**不得**被跳过。
-	//   若它在 skip 里 ⇒ LoadSkipping 会跳过它 ⇒ 它永远不会被加载。
-	const builtinName = "builtin_only"
-	if skip[builtinName] {
-		t.Fatalf("★ 内置插件 %s 在 skip 集合里 ⇒ 不会被加载"+
-			"（webui/pluginmgr/cli/files/timer/mcp 全是这类，会静默消失）", builtinName)
-	}
-	if !skip["ext_auto"] {
-		t.Error("① 声明依赖的插件应在 skip 里（plugin-host 自己拉起，避免重复）")
-	}
-	if !skip["ext_manual"] {
-		t.Fatal("★ auto_start=false 的插件必须在 skip 里 —— 否则会被全量加载" +
-			"（与「不自动启动」完全相反）")
-	}
-}
-
-// ★★★ 判据：**meta 层不谎报"已接线"** + 接线本身由 e2e 守。
-//
-// ## ★ 这里我连续踩了三次同一个坑，值得写下来
-//
-// 初版判据：`strings.Contains(code, "LoadSkipping(")` ⇒ 变异不咬，
-//
-//	因为**注释里也有这个字样**。
-//
-// 二版判据：`strings.Contains(code, "LoadSkipping(dir, skip)")` ⇒
-//
-//	变异成 `LoadSkipping(dir, nil)` 后**仍然绿**，因为 mod.go 的
-//	**注释第 116 行正好写着 `` `LoadSkipping(dir, skip)` ``**。
-//
-// **教训（第 N+1 次）：源码字符串检查测的是"文本"，不是"行为"。**
-// 只要文档/注释里出现过同一串，判据就永远绿 —— 而本仓的规范恰恰是
-// "每个关键决定都要在注释里讲清楚"，所以注释里几乎必然出现这些串。
-// ⇒ **源码检查只能用于"是否存在某个符号定义"，绝不能用于断言接线。**
-//
-// ## 那接线靠什么守？
-//
-// 行为层：真机 e2e 已验证（20 个插件加载、manual_probe **未**加载、
-// 内置插件全部在列）。这条 e2e 是接线的真正判据。
-//
-// 本判据只做一件**不依赖注释**的事：确认 `buildSkipSet` 有**真实调用点**
-// （AST 层面：调用表达式，不是注释里的文本）。
-func TestSkipSetHasRealCallSite(t *testing.T) {
-	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "mod.go", nil, parser.ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-	calls := 0
-	ast.Inspect(f, func(n ast.Node) bool {
-		ce, ok := n.(*ast.CallExpr)
-		if !ok {
-			return true
-		}
-		if id, ok := ce.Fun.(*ast.Ident); ok && id.Name == "buildSkipSet" {
-			calls++
-		}
-		return true
-	})
-	if calls == 0 {
-		t.Fatal("★ buildSkipSet 必须被**真实调用**（AST 层面）" +
-			"—— 定义而不用等于没接。\n" +
-			"   （注意：不能用字符串 Contains 判 —— 注释里会命中，实测骗过我三次）")
-	}
-	// LoadSkipping 的**调用**（AST 层面）必须存在
-	ls := 0
-	ast.Inspect(f, func(n ast.Node) bool {
-		ce, ok := n.(*ast.CallExpr)
-		if !ok {
-			return true
-		}
-		if sel, ok := ce.Fun.(*ast.SelectorExpr); ok && sel.Sel.Name == "LoadSkipping" {
-			ls++
-			// ★ 且第二个实参必须**不是** nil（nil = skip 失效）
-			if len(ce.Args) >= 2 {
-				if id, ok := ce.Args[1].(*ast.Ident); ok && id.Name == "nil" {
-					t.Error("★ LoadSkipping 的 skip 实参是 nil ⇒ " +
-						"三形态跳过逻辑全部失效（内置插件会被误跳过、" +
-						"manual 会被误加载）")
-				}
-			}
-		}
-		return true
-	})
-	if ls == 0 {
-		t.Fatal("★ 必须真实调用 LoadSkipping（AST 层面，非注释）")
-	}
-}
-
-// ★★★ 判据：**缓存并发安全**（pluginmgr 运行期读、装配期写）。
-func TestCatalogConcurrentRead(t *testing.T) {
-	root := t.TempDir()
-	for i := 0; i < 20; i++ {
-		makePluginDir(t, root, "p"+string(rune('a'+i)),
-			`{"name":"x","version":"1","entry":"plugin.bin"}`)
-	}
-	cat, _ := scanCatalog(root, nil)
-
-	done := make(chan struct{})
-	for i := 0; i < 16; i++ {
-		go func() {
-			defer func() { done <- struct{}{} }()
-			for j := 0; j < 200; j++ {
-				_ = cat.Names()
-				_ = cat.All()
-				_ = cat.Size()
-				_, _ = cat.Get("pa")
-			}
-		}()
-	}
-	for i := 0; i < 16; i++ {
-		<-done
-	}
-}
-
-// ★★★ 判据：**SyncBus 为 nil 时不得 panic**（typed-nil 陷阱，实测踩到）。
-//
-// ## 为什么必须有这条
-//
-// `var nb *SyncBus; var i SyncState = nb` ⇒ **i != nil**（经典陷阱）。
-// 于是 `NewScheduler(i, …)` 内部 `i.IsReady(...)` 解引用空指针 ⇒ **panic**。
-//
-// 实测：`ks.SyncBus == nil`（非生产装配路径 / 单测）时 plugin-host 会崩。
-// 而 panic 发生在**插件拉起路径**上 ⇒ 整个内核启动失败。
-//
-// ⇒ 判据：把 typed-nil 传给 Scheduler 前必须已被拦截。
-// 这里直接验证**拦截逻辑本身**（不依赖 produciton 装配）。
-func TestNilSyncBusDoesNotPanic(t *testing.T) {
-	var nb *kstate.SyncBus // typed-nil
-	var iface kstate.SyncState = nb
-	// ★ 2026-11-04：原先写 `if iface == nil { t.Skip(...) }` —— 但这**永假**：
-	// 把一个 typed-nil 装进接口后，接口自身的 (type, value) 二元组都不为 nil，
-	// 所以 `iface == nil` 恒为 false（staticcheck SA4023）。
-	//
-	// 换句话说这道前置守卫从来没生效过 —— 而这正是本判据要演示的陷阱本身。
-	// 改成用反射检查，那才是判断 typed-nil 的正确方式。
-	if !reflect.ValueOf(iface).IsNil() {
-		t.Skip("不是 typed-nil（不会有陷阱）—— 与本判据的前提不符")
-	}
-	// ★ 确认陷阱真实存在（否则这条判据是空的）
-	func() {
-		defer func() {
-			if r := recover(); r == nil {
-				t.Fatal("★ 前提不成立：typed-nil bus 竟然没 panic —— " +
-					"那就不需要那条 nil 拦截了，请一并删掉测试与拦截")
-			}
-		}()
-		_ = kernelboot.NewScheduler(iface, func(kernelboot.PluginSpec) error { return nil })
-	}()
-	// ★ 而生产代码里的拦截：mod.go 必须**显式判 nil** 后再传
-	src, err := os.ReadFile("mod.go")
-	if err != nil {
-		t.Fatal(err)
-	}
-	code := string(src)
-	if !strings.Contains(code, "ks.SyncBus != nil") {
-		t.Fatal("★ mod.go 必须显式判 `ks.SyncBus != nil` 再构造 Scheduler —— " +
-			"否则 typed-nil 会在 IsReady 处 panic（实测）")
-	}
-	if strings.Contains(code, "NewScheduler(ks.SyncBus,") {
-		t.Fatal("★ 不得把 ks.SyncBus **直接**传给 NewScheduler（typed-nil 陷阱）")
-	}
-}
-
-// ★★★★ 判据：**未声明依赖的插件必须等内核完全初始化**（§2.6.5 硬约束）。
-//
-// ## 这是我实际违反过、且有实测后果的约束 —— 必须写成判据
-//
-// 我第一版把插件按"本模块依赖是否覆盖插件声明"分成 launchNow / waitLater，
-// 并在 Init 里**直接**加载 launchNow。而未声明依赖的插件 `RequiresFacilities`
-// 是**空** ⇒ "覆盖空集"恒真 ⇒ 它们被归入 launchNow ⇒ **第 4 层就被加载**。
-//
-// 而 §2.6.5 的硬约束是「未声明 ⇒ 启动时机**逐字不变**（内核**完全**初始化后）」。
-// 原文警告："静默改变启动时机 = 静默引入竞态"。
-//
-// ## ★ 后果不是理论上的 —— 实测丢了一个工具
-//
-// 内置插件 `healthcheck` 在 `Start` 里做：
-//
-//	if s.Status() != nil { s.RegisterTool("healthcheck_kernel", …) }
-//
-// 第 4 层时 agent 还没建好（它与 plugin-host **并行**）⇒ `Status()` 为 nil
-// ⇒ **静默少注册一个工具**。实测：86 个工具（应为 87），**无任何报错**。
-// （nginx 式的 nil 保护把"时序错了"降级成了"少个功能"，最难发现。）
-//
-// ⇒ 判据：未声明的插件**不得**在 `KernelComplete()` 之前被拉起。
-// 用**真的 Scheduler + 真的 SyncBus** 验证（跑生产同一路径）。
-func TestUndeclaredPluginsWaitForKernelComplete(t *testing.T) {
-	root := t.TempDir()
-	makePluginDir(t, root, "undeclared",
-		`{"name":"undeclared","version":"1","entry":"plugin.bin"}`)
-	makePluginDir(t, root, "declared",
-		`{"name":"declared","version":"1","entry":"plugin.bin","requires_facilities":["config"]}`)
-
-	cat, _ := scanCatalog(root, nil)
-	g := classify(cat)
-	specs := buildSpecs(cat, g)
-	if len(specs) != 2 {
-		t.Fatalf("两个自动启动插件都应进调度器（含**未声明**的），实际 %d 个", len(specs))
-	}
-
-	bus := kstate.NewSyncBus()
-	bus.MarkDeclared([]string{"config", "agent"})
-	bus.MarkReady("config")
-
-	launched := map[string]bool{}
-	sched := kernelboot.NewScheduler(bus, func(s kernelboot.PluginSpec) error {
-		launched[s.Name] = true
-		return nil
-	})
-	got := sched.Submit(specs)
-	for _, n := range got {
-		launched[n] = true
-	}
-
-	// ① 声明的：依赖（config）已就绪 ⇒ **应当**立即拉起
-	if !launched["declared"] {
-		t.Error("声明了 config 且 config 已就绪的插件应当被拉起（这是本步的核心收益）")
-	}
-	// ② ★ 未声明的：内核**未**完成 ⇒ **不得**拉起
-	if launched["undeclared"] {
-		t.Fatal("★ 未声明依赖的插件在内核完全初始化**之前**被拉起了 ⇒ 违反 §2.6.5。\n" +
-			"   实测后果：healthcheck 的 s.Status() 为 nil ⇒ 静默少注册一个工具" +
-			"（86 vs 87，无任何报错）。")
-	}
-	// ③ 内核完成后 ⇒ 未声明的才应拉起
-	bus.MarkKernelComplete()
-	if !launched["undeclared"] {
-		t.Fatal("★ 内核完成后未声明的插件仍未被拉起 ⇒ 它永远起不来")
-	}
-}
-
-// ★★★ 判据：**未声明的插件必须在 skip 集合【外面】**（否则会被重复加载）。
-//
-// 调度器会拉起它，LoadSkipping 也会碰到它 ⇒ 两条路都加载 = 重复。
-// （实测未复现重复，是因为时序上 LoadSkipping 晚于调度器且 registry 有门，
-//
-//	但**不应依赖巧合** —— 判据把语义钉住。）
-func TestUndeclaredNotDoubleLoaded(t *testing.T) {
-	root := t.TempDir()
-	makePluginDir(t, root, "undeclared",
-		`{"name":"undeclared","version":"1","entry":"plugin.bin"}`)
-	cat, _ := scanCatalog(root, nil)
-	g := classify(cat)
-	skip := buildSkipSet(cat, g)
-
-	// 未声明的插件在 autoStart 里（调度器会管）
-	if len(g.autoStart) != 1 || g.autoStart[0] != "undeclared" {
-		t.Fatalf("前提不成立: %v", g.autoStart)
-	}
-	// ★ 修法后：catalog 里登记的（含未声明的）**一律**不在 LoadSkipping 的
-	// 管辖范围 ⇒ 必须在 skip 里。这样"调度器"与"LoadSkipping"两条路
-	// **按构造不相交**，不可能双加载。
-	//
-	// （我第一版只 skip declared/manual/disabled ⇒ 未声明的外部插件会被
-	//  两条路各加载一次。实测变异：healthcheck loaded 2 次、工具 87→161。）
-	if !skip["undeclared"] {
-		t.Fatal("★ catalog 里登记的插件都必须在 skip 里 —— " +
-			"否则未声明的外部插件会被调度器与 LoadSkipping **各加载一次**" +
-			"（实测：工具数翻倍）")
-	}
-	// ★ 反向钉住：LoadSkipping 仍必须能加载**内置插件**（不在 catalog 里）
-	if skip["some_builtin_without_manifest"] {
-		t.Fatal("★ 内置插件（无 plugin.json，不在 catalog）不得被 skip —— " +
-			"它是 LoadSkipping 唯一能加载的对象")
-	}
-}

internal/kernelmod/pluginhost/toolsready_test.go

@@ -1,50 +0,0 @@
-package pluginhost
-
-// tools_ready 的发布判据。
-//
-// 语义边界（用户裁定）：seq 自动运行**不依赖 agent** —— 它只是一段工具调用
-// 序列，返回值排队等 agent 起来处理即可。所以事件的正确时机是
-// "全部插件加载完、工具都注册了"（ks.PluginsReady = true 处），
-// 而不是 agent.Start() 之后。
-//
-// 放在 kernelmod 而不是 main：时机语义属于内核；外包给编排层会让
-// 换个入口（e2e / 测试 / 别的发行版 main）就不一致。
-
-import (
-	"testing"
-
-	"github.com/JianFeeeee/HologramAgent/internal/events"
-	"github.com/JianFeeeee/HologramAgent/internal/kstate"
-)
-
-// 没有 EventBus 时必须**响亮报错而不是静默返回** ——
-// 静默失败会让"为什么开机序列没跑"完全无从查起。
-func TestPublishToolsReadyWithoutBusDoesNotPanic(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			t.Fatalf("publishToolsReady 在 nil EventBus 下不能 panic：%v", r)
-		}
-	}()
-	publishToolsReady(nil)
-	publishToolsReady(&kstate.State{})
-}
-
-// 有 EventBus 时必须真的发布一条 tools_ready，且带 plugin_count。
-func TestPublishToolsReadyPublishes(t *testing.T) {
-	bus := events.NewBus()
-	var got []*events.Event
-	bus.Subscribe(events.EventToolsReady, func(e *events.Event) { got = append(got, e) })
-
-	ks := &kstate.State{EventBus: bus}
-	publishToolsReady(ks)
-
-	if len(got) != 1 {
-		t.Fatalf("应发布恰好一条 tools_ready，实际 %d 条", len(got))
-	}
-	if got[0].Source != "plugin-host" {
-		t.Fatalf("Source 应为 plugin-host，实际 %q", got[0].Source)
-	}
-	if _, ok := got[0].Payload["plugin_count"]; !ok {
-		t.Fatal("payload 应含 plugin_count")
-	}
-}