refactor(memory): 裁剪与召回收敛到唯一入口 memoryPass

把「踢出去（prune）」与「取进来（recall）」从两处各写一遍，收敛为
memoryPass(query, trigger, prune, recall) 单一入口，统一：

- 同一份清洗后的 query（避免噪声带偏相关性打分）；
- 同一次 token 预算与召回截断；
- 同一条带 trigger 的审计日志（谁、据什么触发了哪种操作）。

落地：
- 新增 memorypass.go：memoryPass + pruneByQuery（原 pruneOnInput 的执行体）；
- pruneOnInput 只解析声明，执行委托 memoryPass；
- stepToolAfter 的裁剪/召回改为一次 memoryPass 调用（去掉重复的 topK 逻辑）；
- 抽出 recallText，输入侧 buildTaskMemoryContext 与工具侧 recallTextFor 共用；
- 输入侧召回 query 改用 CleanInput（清洗文本），与裁剪侧同一语义；
- QQ qq_get_history 补齐声明 ContextPolicy=prune + RecallPolicy=auto
  （内容类工具：真实聊天正文既当轮用完即裁，又据正文召回）。

测试：新增 memorypass_test.go，锁死 no-op / 两轴同时生效 / 正交不互相触发 /
输入侧用清洗 query。go build/vet 干净，internal/... 全绿，qq 插件模块测试通过。

.gitignore

@@ -31,6 +31,7 @@ cmd/gui/dist/
 third_party/homeagent-sdk/bin/
 third_party/homeagent-sdk/tools/
 third_party/homeagent-sdk/package/
+third_party/homeagent-sdk/scripts/
 third_party/homeagent-sdk/.gitignore
 third_party/homeagent-sdk/README*
 third_party/homeagent-sdk/example/

.golangci.yml

@@ -0,0 +1,46 @@
+# golangci-lint 配置 —— 「超大函数/超大文件」治理的防复发闸门。
+#
+# 背景：main 上曾有 4 个 ≥300 行函数、12 个 ≥200 行函数（见审查报告）。
+# 没有复杂度 linter 是它们能长期存活的直接原因。本配置先以 **warn-only**
+# 起步：`issues.exit-code: 0`，只产出清单、不阻断构建。等历史债降到可接受
+# 水位后，再把 exit-code 改成 1 收成硬门禁。
+#
+# 运行：make lint-full（需先 `go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest`）
+# 注意：这是 golangci-lint v1 的配置格式（v2 的 `linters.default` 写法不同）。
+run:
+  timeout: 5m
+  tests: true
+
+linters:
+  disable-all: true
+  enable:
+    - funlen   # 函数长度
+    - gocyclo  # 圈复杂度
+    - lll      # 行宽
+    - dupl     # 重复代码
+    - govet    # 与 make lint 对齐的基线
+
+linters-settings:
+  funlen:
+    lines: 150
+    statements: 100
+  gocyclo:
+    min-complexity: 30
+  lll:
+    line-length: 140
+  dupl:
+    threshold: 200
+
+issues:
+  # 起步阶段不阻断（warn-only）。收紧后改为 1。
+  exit-code: 0
+  max-issues-per-linter: 0
+  max-same-issues: 0
+  exclude-rules:
+    # 测试与生成/夹具代码不受长度类规则约束。
+    - path: _test\.go
+      linters: [funlen, dupl, gocyclo]
+    - path: internal/plugin/proc/testdata
+      linters: [funlen, dupl]
+    - path: third_party/
+      linters: [funlen, dupl, gocyclo, lll]

Makefile

@@ -61,3 +61,14 @@ fmt:
 
 lint:
 	$(GO) vet ./...
+
+# lint-full：在 vet 之外跑 golangci-lint（阈值见 .golangci.yml，起步 warn-only）。
+# 未安装时给出可执行的安装提示与跳过原因，而不是静默成功。
+.PHONY: lint-full
+lint-full:
+	@if command -v golangci-lint >/dev/null 2>&1; then \
+		golangci-lint run; \
+	else \
+		echo "golangci-lint 未安装，跳过（阈值见 .golangci.yml）"; \
+		echo "  go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest"; \
+	fi

assets/docs/en/PLUGIN_DEV.md

@@ -599,23 +599,26 @@ When running inside the kernel, `sdk.*` global variables are injected by the Go
 
 ### Lua SDK API
 
-The `sdk.*` API of Lua plugins is fully aligned with external plugins (toolchain-built `plugin.bin` subprocesses): registration functions raise a Lua error on failure; data functions uniformly return `(result, err)` with `err == nil` on success. Subsystems not wired by the core (e.g. SocialAPI) return empty values instead of errors.
+The `sdk.*` API of Lua plugins is aligned with external plugins (toolchain-built `plugin.bin` subprocesses) up to **SDK 1.3.0** (requires kernel **1.4.0+**, also backfilled by the Lua-alignment patch `v1.3.11`): registration functions raise a Lua error on failure; data functions uniformly return `(result, err)` with `err == nil` on success. Subsystems not wired by the core (e.g. SocialAPI) return empty values instead of errors.
+
+> Historical note: the 1.1–1.3 media / inject-flags / priority capabilities were long available only on the Go side and were silently missing on the Lua side. They are now fully aligned, guarded by the contract test in `internal/plugin/lua_surface_test.go` (every function promised by the mock has a runtime binding).
 
 **Registration**
 
 | Function | Description |
 |----------|-------------|
 | `sdk.log(level, msg)` | Log output |
-| `sdk.register_tool(name, def, handler)` | Register tool; `def` supports `description`, `parameters`, `no_memory`, `cleaner` |
+| `sdk.register_tool(name, def, handler)` | Register tool; `def` supports `description`, `parameters`, `no_memory`, `context_policy` (`"none"`/`"prune"`), `cleaner` |
 | `sdk.register_stage(stage, handler, scope)` | Register stage hook; `scope` is `nil`/`"global"` (default) or `"own_tools"` (fires only for `before_toolcall`/`after_toolcall` when the tool belongs to this plugin) |
 | `sdk.register_api(name)` | Register API |
-| `sdk.register_output_channel(name, caps, desc, def, handler)` | Register output channel; `def` supports `no_memory`, `cleaner` |
+| `sdk.register_output_channel(name, caps, desc, def, handler)` | Register output channel; `def` supports `no_memory`, `context_policy`, `cleaner` |
 | `sdk.register_input_channel(name, def)` | Register input channel; `def` as above |
+| `sdk.unregister_output_channel(name)` | Unregister an output channel (for resource-bound channels, e.g. remote devices); returns `(nil, err)` |
 | `sdk.set_auto_restart(enabled)` | Auto-restart the plugin after a crash |
 
 **Stage hook context**
 
-Stage handlers receive the full context (same as external plugins): `raw_message`, `user_id`, `group_id`, `phase`, `llm_text`, `final_text`, `no_memory`, `response` (when responded), `tool_calls`, `tool_results`.
+Stage handlers receive the full context (same as external plugins): `raw_message`, `user_id`, `group_id`, `phase`, `llm_text`, `reasoning_content`, `final_text`, `no_memory`, `context_msgs`, `token_usage`, `memory`, `extra`, `errors`, `response` (when responded), `tool_calls`, `tool_results`.
 
 **Stage writeback**: the `ctx` table passed to the handler is a reference — mutating writable fields inside the handler syncs back to the core `StageContext` (aligned with subprocess external-plugin capability):
 
@@ -644,20 +647,37 @@ Writable fields: `raw_message`, `llm_text`, `final_text`, `user_id`, `group_id`,
 | `sdk.inject_text(source, channel, text)` | Deliver text message |
 | `sdk.inject_interrupt(source, channel, text)` | Interrupt delivery |
 | `sdk.inject_text_no_memory(source, channel, text)` | Deliver without memory computation |
+| `sdk.inject_text_opts` / `sdk.inject_interrupt_opts(source, channel, text, opts)` | Delivery with flags; `opts = { no_memory=bool, context_policy="none"|"prune", cleaner_name=string, priority="L1".."L3" }` |
+| `sdk.inject_input_sync(source, channel, text)` | ⚠️ **Unavailable in Lua**: always returns `(nil, err)`. It waits for this turn's reply while a Lua callback holds the plugin lock, so it would self-deadlock. Use a Go plugin for synchronous waits, or the async injectors below |
+| `sdk.inject_input_sync_opts(source, channel, text, opts)` | Same (unavailable) |
+| `sdk.inject_input_media(source, channel, text, blocks)` | Inject text + multimodal content blocks |
+| `sdk.inject_input_media_opts(source, channel, text, blocks, opts)` | Same, with flags |
+| `sdk.inject_input_media_sync` / `..._sync_opts(...)` | ⚠️ **Unavailable in Lua** (same as `inject_input_sync`) |
+| `sdk.inject_interrupt_media(source, channel, text, blocks)` | Interrupt delivery with media |
+| `sdk.inject_interrupt_media_opts(source, channel, text, blocks, opts)` | Same, with flags |
+| `sdk.set_tool_blocks(blocks)` | Set multimodal blocks carried by the next tool message (lets the model see images / hear audio) |
+
+Each `blocks` item: `{ type="text", text="..." }`, `{ type="image_url", image_url={ url="...", detail="high" } }`, or `{ type="audio_url", audio_url={ url="..." } }`. An absent `opts` is the zero value (recorded in memory + no pruning), equivalent to the three-argument form.
 
 **Data APIs (aligned with subprocess external plugins, all return `(result, err)`)**
 
 | Sub-table | Functions |
 |-----------|-----------|
-| `sdk.memory.*` | `recall(query, depth)`, `commit({triples})`, `introspect()`, `merge(source, target)`, `purge(criteria, hard)` |
-| `sdk.doc.*` | `query(text, top_k)`, `insert({id,title,content})`, `remove(id)`, `stats()` |
+| `sdk.memory.*` | `recall(query, depth)`, `commit({triples})` (triple supports `subject/relation/object/confidence/subject_type/object_type/sentence_text/media_digests`), `introspect()`, `merge(source, target)`, `purge(criteria, hard)` |
+| `sdk.doc.*` | `query(text, top_k)`, `insert({id,title,content})`, `insert_with_media(doc, attachments)`, `remove(id)`, `stats()` |
 | `sdk.knowledge.*` | `search(query, limit)`, `add(tag, content)`, `list()` |
-| `sdk.text_memory.*` | `append({role,content,timestamp,channel})` |
+| `sdk.text_memory.*` | `append({role,content,timestamp,channel,attachments})` |
 | `sdk.llm.*` | `list_sources()`, `set_source(name)`, `current_source()` |
 | `sdk.social.*` (read-only) | `get_person(name)`, `get_network(name, depth)`, `get_trait(name, trait)`, `get_relations(name)`, `list_persons()` |
+| `sdk.events.*` | `subscribe(event_type, handler)` → returns an unsubscribe function; handler receives `{type,source,timestamp,payload}` |
+| `sdk.plugin_mgr.*` | `reload_one(name)`, `list_loaded()`, `is_disabled(name)` |
 | `sdk.json.*` | `encode(val)`, `decode(str)` |
 | `sdk.http.*` | `get(url)`, `post(url, body, content_type)` |
 
+Each `attachments` item: `{ digest=, mime=, name=, data=<base64> }`; with `data` it is new content (stored in the content-addressed store), with only `digest` it references existing content.
+
+> The `sdk.events.subscribe` callback runs on the kernel's event-publishing goroutine, and Lua is single-state + mutex-guarded — **do only lightweight forwarding inside the callback; never block**, or every call of this plugin will stall.
+
 ---
 
 <img src="../../assets/branding/mascot-xiaozhai.webp" width="20" style="border-radius:50%;vertical-align:middle"> :

assets/docs/zh/PLUGIN_DEV.md

@@ -592,23 +592,26 @@ lua main.lua
 
 ### Lua SDK API
 
-Lua 插件的 `sdk.*` API 与外部插件（工具链编译的 `plugin.bin` 子进程）能力完全对齐：注册类函数调用即时报错（抛 Lua error），数据类函数统一返回 `(result, err)`，`err` 为 nil 表示成功。核心未装配的子系统（如 SocialAPI）返回空值而非报错。
+Lua 插件的 `sdk.*` API 与外部插件（工具链编译的 `plugin.bin` 子进程）能力对齐至 **SDK 1.3.0**（需内核 **1.4.0+**，也在 `v1.3.11` 的 Lua 对齐补丁中回填）：注册类函数调用即时报错（抛 Lua error），数据类函数统一返回 `(result, err)`，`err` 为 nil 表示成功。核心未装配的子系统（如 SocialAPI）返回空值而非报错。
+
+> 历史提醒：1.1–1.3 的媒体/注入标志位/优先级能力曾长期只在 Go 侧，Lua 侧静默缺失。现已全量对齐，并由 `internal/plugin/lua_surface_test.go` 的契约测试守住「mock 承诺的每个函数都有运行时绑定」。
 
 **注册类**
 
 | 函数 | 说明 |
 |------|------|
 | `sdk.log(level, msg)` | 日志输出 |
-| `sdk.register_tool(name, def, handler)` | 注册工具；`def` 支持 `description`、`parameters`、`no_memory`、`cleaner` |
+| `sdk.register_tool(name, def, handler)` | 注册工具；`def` 支持 `description`、`parameters`、`no_memory`、`context_policy`（`"none"`/`"prune"`）、`cleaner` |
 | `sdk.register_stage(stage, handler, scope)` | 注册阶段钩子；`scope` 为 `nil`/`"global"`（默认）或 `"own_tools"`（仅 `before_toolcall`/`after_toolcall` 且工具属于本插件时触发） |
 | `sdk.register_api(name)` | 注册 API |
-| `sdk.register_output_channel(name, caps, desc, def, handler)` | 注册输出通道；`def` 支持 `no_memory`、`cleaner` |
+| `sdk.register_output_channel(name, caps, desc, def, handler)` | 注册输出通道；`def` 支持 `no_memory`、`context_policy`、`cleaner` |
 | `sdk.register_input_channel(name, def)` | 注册输入通道；`def` 同上 |
+| `sdk.unregister_output_channel(name)` | 注销输出通道（随资源生灭的动态通道，如远程设备）；返回 `(nil, err)` |
 | `sdk.set_auto_restart(enabled)` | 崩溃时内核自动拉起插件 |
 
 **阶段钩子上下文**
 
-`register_stage` 的 handler 收到完整上下文（与外部插件一致）：`raw_message`、`user_id`、`group_id`、`phase`、`llm_text`、`final_text`、`no_memory`、`response`（已响应时）、`tool_calls`、`tool_results`。
+`register_stage` 的 handler 收到完整上下文（与外部插件一致）：`raw_message`、`user_id`、`group_id`、`phase`、`llm_text`、`reasoning_content`、`final_text`、`no_memory`、`context_msgs`、`token_usage`、`memory`、`extra`、`errors`、`response`（已响应时）、`tool_calls`、`tool_results`。
 
 **Stage 写回**：handler 收到的 `ctx` 是引用 table——在 handler 内直接修改可写回字段并同步至内核 `StageContext`（与子进程外部插件能力对齐）：
 
@@ -637,20 +640,37 @@ end)
 | `sdk.inject_text(source, channel, text)` | 投递文本消息 |
 | `sdk.inject_interrupt(source, channel, text)` | 中断投递 |
 | `sdk.inject_text_no_memory(source, channel, text)` | 免记忆投递 |
+| `sdk.inject_text_opts` / `sdk.inject_interrupt_opts(source, channel, text, opts)` | 带标志位投递；`opts = { no_memory=bool, context_policy="none"|"prune", cleaner_name=string, priority="L1".."L3" }` |
+| `sdk.inject_input_sync(source, channel, text)` | ⚠️ **Lua 中不可用**：恒返回 `(nil, err)`。它要等本轮回复而 Lua 回调持有插件锁，必然自锁。需要同步等待请用 Go 插件，或用下面的异步注入 |
+| `sdk.inject_input_sync_opts(source, channel, text, opts)` | 同上（不可用） |
+| `sdk.inject_input_media(source, channel, text, blocks)` | 注入文本 + 多模态内容块 |
+| `sdk.inject_input_media_opts(source, channel, text, blocks, opts)` | 同上带标志位 |
+| `sdk.inject_input_media_sync` / `..._sync_opts(...)` | ⚠️ **Lua 中不可用**（同 `inject_input_sync`） |
+| `sdk.inject_interrupt_media(source, channel, text, blocks)` | 带媒体的中断注入 |
+| `sdk.inject_interrupt_media_opts(source, channel, text, blocks, opts)` | 同上带标志位 |
+| `sdk.set_tool_blocks(blocks)` | 设置下一轮 tool message 携带的多模态内容块（模型据此看图/听音频） |
+
+`blocks` 每项形如：`{ type="text", text="..." }`、`{ type="image_url", image_url={ url="...", detail="high" } }`、`{ type="audio_url", audio_url={ url="..." } }`。`opts` 缺省即零值（记入记忆 + 不裁剪），与三参数版本等价。
 
 **数据类（与子进程外部插件对齐，均返回 `(result, err)`）**
 
 | 子表 | 函数 |
 |------|------|
-| `sdk.memory.*` | `recall(query, depth)`、`commit({triples})`、`introspect()`、`merge(source, target)`、`purge(criteria, hard)` |
-| `sdk.doc.*` | `query(text, top_k)`、`insert({id,title,content})`、`remove(id)`、`stats()` |
+| `sdk.memory.*` | `recall(query, depth)`、`commit({triples})`（triple 支持 `subject/relation/object/confidence/subject_type/object_type/sentence_text/media_digests`）、`introspect()`、`merge(source, target)`、`purge(criteria, hard)` |
+| `sdk.doc.*` | `query(text, top_k)`、`insert({id,title,content})`、`insert_with_media(doc, attachments)`、`remove(id)`、`stats()` |
 | `sdk.knowledge.*` | `search(query, limit)`、`add(tag, content)`、`list()` |
-| `sdk.text_memory.*` | `append({role,content,timestamp,channel})` |
+| `sdk.text_memory.*` | `append({role,content,timestamp,channel,attachments})` |
 | `sdk.llm.*` | `list_sources()`、`set_source(name)`、`current_source()` |
 | `sdk.social.*`（只读） | `get_person(name)`、`get_network(name, depth)`、`get_trait(name, trait)`、`get_relations(name)`、`list_persons()` |
+| `sdk.events.*` | `subscribe(event_type, handler)` → 返回取消订阅函数；handler 收到 `{type,source,timestamp,payload}` |
+| `sdk.plugin_mgr.*` | `reload_one(name)`、`list_loaded()`、`is_disabled(name)` |
 | `sdk.json.*` | `encode(val)`、`decode(str)` |
 | `sdk.http.*` | `get(url)`、`post(url, body, content_type)` |
 
+`attachments` 每项：`{ digest=, mime=, name=, data=<base64> }`；带 `data` 是新内容（落进内容寻址存储），只带 `digest` 是引用已有内容。
+
+> `sdk.events.subscribe` 的回调在内核事件发布 goroutine 上执行，且 Lua 是单状态 + 互斥锁——**回调内只做轻量转发，不可阻塞**，否则会卡死本插件的全部调用。
+
 ---
 
 <img src="../../assets/branding/mascot-xiaozhai.webp" width="20" style="border-radius:50%;vertical-align:middle"> :

cmd/gui/renderer/app.js

@@ -696,6 +696,10 @@ async function refreshDataOnly() {
   try {
     state.kernel = await api("/kernel");
   } catch (e) {}
+  try {
+    // 运行态快照：只给指标与队列/阶段展示用，不影响其他卡片。
+    state.runtime = await api("/runtime");
+  } catch (e) {}
   try {
     var s = await api("/settings");
     state.settings = s.settings || {};
@@ -775,6 +779,10 @@ async function refreshAll() {
   try {
     state.kernel = await api("/kernel");
   } catch (e) {}
+  try {
+    // 运行态快照（调度器/驻留子/通道），供总览的运行态面板使用。
+    state.runtime = await api("/runtime");
+  } catch (e) {}
   try {
     var s = await api("/settings");
     state.settings = s.settings || {};
@@ -1004,6 +1012,249 @@ function statCard(l, v) {
   );
 }
 
+// ===== 运行态面板：阶段管道 + 中断队列 =====
+//
+// 与 WebUI 总览**同一套设计语言：等大表框**。此前桌面版总览只有四个数字卡，
+// 既看不到「这一轮走到哪一步」，也看不到四级中断队列的积压。
+// 数据来自 /api/v1/runtime（KernelStatus 的运行态子集）。
+var RT_LEVELS = [
+  { lv: 4, name: "L4", zh: "内核独占", en: "kernel only", cls: "rt-lv-4" },
+  { lv: 3, name: "L3", zh: "交互", en: "interactive", cls: "rt-lv-3" },
+  { lv: 2, name: "L2", zh: "消息", en: "message", cls: "rt-lv-2" },
+  { lv: 1, name: "L1", zh: "后台", en: "background", cls: "rt-lv-1" },
+];
+// 七阶段归并成五格（与内核 sdk.Stage 的顺序一致）：
+// 一轮里工具调用会反复回到「行动后」，线性滑块本身就是错的表述，
+// 所以画成 输入 → 行动 ⇄(工具) → 输出 → 结束，工具那格带循环标记。
+var RT_PIPE_GROUPS = [
+  { zh: "输入", en: "in", ico: "in" },
+  { zh: "行动", en: "act", ico: "act" },
+  { zh: "工具", en: "tool", ico: "tool", loop: true },
+  { zh: "输出", en: "out", ico: "out" },
+  { zh: "结束", en: "done", ico: "done" },
+];
+// 图标一律内联 SVG（24x24 / currentColor），不用 emoji/符号字符充当图标。
+var RT_ICO = {
+  in: '<svg class="rt-ico" viewBox="0 0 24 24"><path d="M21 12H8"/><path d="M13 6l-6 6 6 6"/></svg>',
+  act: '<svg class="rt-ico" viewBox="0 0 24 24"><circle cx="12" cy="12" r="3.2"/><path d="M12 2v3M12 19v3M2 12h3M19 12h3M5.5 5.5l2.1 2.1M16.4 16.4l2.1 2.1M18.5 5.5l-2.1 2.1M7.6 16.4l-2.1 2.1"/></svg>',
+  tool: '<svg class="rt-ico" viewBox="0 0 24 24"><path d="M14.5 6.5a3.8 3.8 0 0 1 5 5L10 21l-5-5z"/><path d="M14.5 6.5 17.5 9.5"/></svg>',
+  out: '<svg class="rt-ico" viewBox="0 0 24 24"><path d="M4 12h13"/><path d="M13 6l6 6-6 6"/></svg>',
+  done: '<svg class="rt-ico" viewBox="0 0 24 24"><path d="M20 6 9 17l-5-5"/></svg>',
+  loop: '<svg class="rt-ico" viewBox="0 0 24 24"><path d="M20.5 12a8.5 8.5 0 1 1-2.5-6"/><path d="M21 3.5V9h-5.5"/></svg>',
+};
+
+function rtPhaseGroup(phase) {
+  switch (phase) {
+    case "on_input":
+      return 0;
+    case "pre_action":
+    case "post_action":
+      return 1;
+    case "before_toolcall":
+    case "after_toolcall":
+      return 2;
+    case "before_output":
+      return 3;
+    case "after_output":
+      return 4;
+  }
+  return -1;
+}
+function rtShortTool(name) {
+  var n = String(name || "");
+  var i = n.lastIndexOf("__");
+  if (i >= 0) n = n.slice(i + 2);
+  return n.length > 14 ? n.slice(0, 13) + "…" : n;
+}
+// rtSlots 画一组「车位」式格槽：槽位数量固定可见，被占用的点亮。
+// 为什么不用进度条：队列为 0 时进度条宽度就是 0，整行只剩文字，看上去就是「这块空着」。
+function rtSlots(depth, slots, cls) {
+  var n = Math.max(5, Math.min(16, slots || 5));
+  var d = depth || 0;
+  var out = '<span class="rt-slots ' + (cls || "") + '">';
+  for (var i = 0; i < n; i++) out += '<i class="' + (i < d ? "on" : "") + '"></i>';
+  // 溢出计数必须留在 .rt-slots 内：格槽是 flex 行，多一个兄弟节点会被挤出去
+  if (d > n) out += '<b class="rt-slots-more">+' + (d - n) + "</b>";
+  return out + "</span>";
+}
+// rtTrailPush 把一条「本轮发生过的事」落到它实际发生的阶段列里；
+// 同一阶段重复的同一条（如同一工具连调 3 次）只累加计数，不刷屏。
+function rtTrailPush(g, kind, label, short) {
+  if (!state.stageTrail) state.stageTrail = [];
+  var arr = state.stageTrail;
+  var last = arr.length ? arr[arr.length - 1] : null;
+  if (last && last.g === g && last.kind === kind && last.short === short) {
+    last.n = (last.n || 1) + 1;
+    return;
+  }
+  arr.push({ g: g, kind: kind, label: label, short: short, n: 1 });
+  if (arr.length > 24) arr.shift();
+}
+
+function renderRuntimePanel() {
+  var title = __("运行态", "Runtime");
+  var rt = state.runtime;
+  // 工具格的滑入动画只在「新到一条工具调用」那一次播放：overview 是整块
+  // innerHTML 重建，节点每次都是新的；若无条件带动画类，任何重渲染都会闪一下。
+  var toolFlash = !!state.toolFlash;
+  state.toolFlash = false;
+  if (!rt) {
+    return (
+      '<div class="card"><h2>' + title + '</h2><p class="rt-empty">' +
+      __("运行态数据不可用", "runtime unavailable") + "</p></div>"
+    );
+  }
+  var sc = rt.scheduler || {};
+  var q = sc.interrupt_queues || [0, 0, 0, 0, 0];
+  var pending = sc.pending_interrupts || 0;
+  var ready = sc.ready_queue_depth || 0;
+  var stack = sc.suspend_stack || 0;
+  var maxStack = sc.max_suspend_depth || 4;
+  var residents = rt.residents || [];
+  var byLv = sc.interrupts_by_level || [];
+  var preLv = sc.preempts_by_level || [];
+  var maxQ = Math.max(1, ready, q[1] || 0, q[2] || 0, q[3] || 0, q[4] || 0);
+  // 至少 5 格：0 时也有可见形状
+  var qSlots = Math.max(5, Math.min(16, maxQ));
+
+  var html = '<div class="card"><h2>' + title + "</h2>";
+  // 四个数字块（沿用本 app 的 statCard 风格）
+  html +=
+    '<div class="grid-4">' +
+    statCard(__("排队", "Ready"), ready, "") +
+    statCard(__("中断", "Pending"), pending, "") +
+    statCard(__("栈", "Stack"), stack + "/" + maxStack, "") +
+    statCard(__("子代理", "Subagents"), residents.length, "") +
+    "</div>";
+
+  // ---- 阶段管道：五个等大表框 ----
+  var g = rtPhaseGroup(state.pipelinePhase || "");
+  html +=
+    '<div class="rt-section-title">' + __("阶段管道", "Stage pipeline") +
+    (g < 0 ? "　" + __("（空闲）", "(idle)") : "") + "</div>";
+  html += '<div class="rt-pipe-row' + (g < 0 ? " rt-pipe-idle" : "") + '">';
+  html += RT_PIPE_GROUPS.map(function (s, i) {
+    var items = (state.stageTrail || []).filter(function (t) {
+      return (t.g | 0) === i;
+    });
+    // 「工具」是循环格：一轮里可能调几十次工具/输出通道，全部追加会把这一格
+    // 撑成长条，反而看不出「现在在调什么」。只留**最新一条**，右侧给本轮累计
+    // 次数（与 WebUI 同一口径，见 internal/plugins/webui/dashboard.js）。
+    var cls = "rt-pipe-events";
+    var body;
+    if (!items.length) {
+      body = '<span class="rt-chip rt-chip-none">' + __("无", "none") + "</span>";
+    } else if (s.loop) {
+      cls += " rt-pipe-scroll";
+      var total = 0;
+      for (var k = 0; k < items.length; k++) total += items[k].n || 1;
+      var latest = items[items.length - 1];
+      var lkind = latest.kind || "stage";
+      var lico = lkind === "output" ? RT_ICO.out : lkind === "tool" ? RT_ICO.tool : "";
+      body =
+        '<span class="rt-chip rt-chip-' + lkind + (toolFlash ? " rt-chip-enter" : "") +
+        '" title="' + escHtml(latest.label) + '">' + lico +
+        '<b class="rt-chip-t">' + escHtml(latest.short || latest.label) + "</b>" +
+        (latest.n > 1 ? '<i class="rt-chip-n">x' + latest.n + "</i>" : "") +
+        "</span>" +
+        '<i class="rt-scroll-count" title="' +
+        __("本轮工具调用累计次数", "tool calls this turn") + '">x' + total + "</i>";
+    } else {
+      body = items
+        .map(function (t) {
+          var kind = t.kind || "stage";
+          var ico =
+            kind === "output" ? RT_ICO.out : kind === "tool" ? RT_ICO.tool : "";
+          return (
+            '<span class="rt-chip rt-chip-' + kind + '" title="' +
+            escHtml(t.label) + '">' + ico +
+            '<b class="rt-chip-t">' + escHtml(t.short || t.label) + "</b>" +
+            (t.n > 1 ? '<i class="rt-chip-n">x' + t.n + "</i>" : "") +
+            "</span>"
+          );
+        })
+        .join("");
+    }
+    return (
+      '<div class="rt-pipe-cell' + (i === g ? " active" : "") + '">' +
+      '<div class="rt-pipe-head">' + RT_ICO[s.ico] +
+      "<b>" + __(s.zh, s.en) + "</b>" +
+      (s.loop
+        ? '<em class="rt-loop" title="' +
+          __("工具调用会回到行动后，可多次", "tool calls loop back; may repeat") +
+          '">' + RT_ICO.loop + "</em>"
+        : "") +
+      '</div><div class="' + cls + '">' + body + "</div></div>"
+    );
+  }).join("");
+  html += "</div>";
+
+  // ---- 中断队列：五个等大表框（L4/L3/L2/L1 + 排队）----
+  html += '<div class="rt-section-title">' + __("队列", "Queues") + "</div>";
+  html += '<div class="rt-queues">';
+  RT_LEVELS.forEach(function (L) {
+    var depth = q[L.lv] || 0;
+    var reg = byLv[L.lv] || 0;
+    var pre = preLv[L.lv] || 0;
+    var desc = __(L.zh, L.en);
+    html +=
+      '<div class="rt-qcell ' + L.cls + (depth ? " rt-active" : "") +
+      '" title="' + escHtml(desc) + '">' +
+      '<div class="rt-qhead"><b>' + L.name + "</b><span>" + escHtml(desc) + "</span></div>" +
+      '<div class="rt-qnum">' + depth + "</div>" +
+      rtSlots(depth, qSlots, L.cls) +
+      '<div class="rt-qmeta">' + reg + " " + __("登记", "reg") + " · " +
+      pre + " " + __("抢占", "pre") + "</div></div>";
+  });
+  // 排队队列无级别：用虚线框与四级中断区分（另一**类别**，不是另一优先级）
+  html +=
+    '<div class="rt-qcell rt-qcell-queued rt-lv-q' + (ready ? " rt-active" : "") +
+    '" title="' + __("排队（无级别，纯 FIFO）", "queued (no priority, FIFO)") + '">' +
+    '<div class="rt-qhead"><b>' + __("排队", "queued") + "</b><span>FIFO</span></div>" +
+    '<div class="rt-qnum">' + ready + "</div>" +
+    rtSlots(ready, qSlots, "rt-lv-q") +
+    '<div class="rt-qmeta">' + __("无级别", "no priority") + "</div></div>";
+  html += "</div></div>";
+  return html;
+}
+
+// 开源许可卡：协议标识 + 协议全文 + 源码仓库。
+// AGPL-3.0 §13 的义务是「向网络使用者提供取得 Corresponding Source 的机会」——
+// 只给一个仓库链接、不写协议名，使用者看不出这受什么许可约束。
+function renderLegalCard() {
+  var b = ((state.kernel || {}).build) || {};
+  var src = b.source_url || "";
+  var lic = b.license || "";
+  var licURL = b.license_url || "";
+  if (!lic && !src) return "";
+  function row(key, val) {
+    return (
+      '<div class="kv-row"><span class="key">' + escHtml(key) +
+      '</span><span class="val">' + val + "</span></div>"
+    );
+  }
+  function a(href, text) {
+    return (
+      '<a href="' + escHtml(href) +
+      '" target="_blank" rel="noopener noreferrer">' + escHtml(text) + "</a>"
+    );
+  }
+  var rows = "";
+  if (lic) rows += row(__("许可协议", "License"), licURL ? a(licURL, lic) : escHtml(lic));
+  if (src) rows += row(__("源码仓库", "Source"), a(src, src));
+  // 网络条款只在 AGPL 系的许可下才成立，所以按标识判断，不硬写协议名。
+  var note =
+    lic && lic.toUpperCase().indexOf("AGPL") >= 0
+      ? '<p class="rt-empty">' +
+        __(
+          "网络服务条款（§13）：把修改后的版本作为网络服务对外提供时，必须向使用者提供取得对应源码的途径。",
+          "Network clause (section 13): offering a modified version as a network service requires giving users a way to obtain the Corresponding Source.",
+        ) +
+        "</p>"
+      : "";
+  return '<div class="card"><h2>' + __("开源许可", "License") + "</h2>" + rows + note + "</div>";
+}
+
 function renderOverview() {
   var s = state.status || {};
   var k = state.kernel;
@@ -1018,7 +1269,25 @@ function renderOverview() {
       "uptime",
     ) +
     statCard(__("插件", "Plugins"), (k?.plugins || []).length || 0, "plugin") +
-    statCard(__("版本", "Version"), s.version || "0.1.0", "version") +
+    statCard(
+      __("版本", "Version"),
+      (function () {
+        // 构建身份取自 /kernel 的 build（-ldflags 注入的真实版本/commit）。
+        // 旧实现用的是 /status 的 version 加一个凭空写死的 "0.1.0" 兑底 ——
+        // 拿不到数据时会向用户展示一个不存在的版本号。
+        var b = (k && k.build) || {};
+        var v = b.version || s.version || "";
+        if (!v) return "-";
+        var sha =
+          b.commit && b.commit !== "unknown" ? String(b.commit).slice(0, 7) : "";
+        return (
+          "v" + escHtml(v) +
+          '<div class="stat-sub">' + escHtml(b.kernel_name || "HomeAgent") +
+          (sha ? " · " + escHtml(sha) : "") + "</div>"
+        );
+      })(),
+      "version",
+    ) +
     "</div>";
   if (k) {
     html +=
@@ -1082,6 +1351,7 @@ function renderOverview() {
       "</span></div>" +
       "</div></div>";
   }
+  html += renderRuntimePanel();
   html +=
     '<div class="card"><h2>' +
     __("运行时", "Runtime") +
@@ -1094,6 +1364,7 @@ function renderOverview() {
     ) +
     statCard("Go " + __("版本", "Version"), k?.runtime?.go_version || "-", "") +
     "</div></div>";
+  html += renderLegalCard();
   document.getElementById("view-overview").innerHTML = html;
 }
 
@@ -5211,17 +5482,48 @@ async function connectFetchSSE(url) {
           var phase = p.phase || "";
           var tool = p.tool || "";
           if (p.channel !== "_consolidation_") {
-            if (phase === "pre_action")
+            // 阶段轨迹：本轮真实发生过什么，按阶段落到运行态面板的对应框里。
+            // 与 WebUI 同一套 g（阶段组）编号，见 rtPhaseGroup。
+            if (phase === "on_input") {
+              state.stageTrail = [];
+              rtTrailPush(0, "stage", __("输入", "input"), __("输入", "input"));
+            } else if (phase === "pre_action") {
+              rtTrailPush(
+                1,
+                "stage",
+                __("组装上下文并思考", "assemble context and think"),
+                __("思考", "think"),
+              );
               state.chatStage = __("AI 思考中...", "AI thinking...");
-            else if (phase === "before_toolcall") {
+            } else if (phase === "before_toolcall") {
+              if (tool)
+                rtTrailPush(
+                  2,
+                  tool.indexOf("output_") === 0 ? "output" : "tool",
+                  tool,
+                  rtShortTool(tool),
+                );
+              if (tool) state.toolFlash = true;
               state.chatStage = __("工具调用: ", "Tool: ") + (tool || "");
               if (tool && (state.pendingTools || []).indexOf(tool) === -1) {
                 if (!state.pendingTools) state.pendingTools = [];
                 state.pendingTools.push(tool);
                 rerenderChatIfActive();
               }
-            } else if (phase === "before_output")
+            } else if (phase === "before_output") {
+              rtTrailPush(3, "stage", __("生成回复", "generate reply"), __("生成", "gen"));
               state.chatStage = __("生成回复中...", "Generating response...");
+            } else if (phase === "after_output") {
+              rtTrailPush(4, "stage", __("本轮完成", "turn complete"), __("完成", "done"));
+            }
+            state.pipelinePhase = phase;
+            // 阶段停留一会儿就回空闲，避免留下一个永远停在 after_output 的假状态。
+            if (state.pipelineTimer) clearTimeout(state.pipelineTimer);
+            state.pipelineTimer = setTimeout(function () {
+              state.pipelinePhase = "";
+              if (state.currentView === "overview") renderOverview();
+            }, 2500);
+            if (state.currentView === "overview") renderOverview();
           }
           var badge = document.getElementById("chat-stage");
           if (badge) {

cmd/gui/renderer/style.css

@@ -2191,3 +2191,284 @@ td .switch {
 .kv-row .val .switch {
   margin-right: 4px;
 }
+
+/* ===== 运行态面板：阶段管道 + 中断队列（与 WebUI 总览同一套设计语言）=====
+   两块都统一成**等大表框**，与 KPI 卡同一种骨架。
+   此前桌面版总览只有四个数字卡：既看不到「这一轮走到哪一步」，
+   也看不到四级中断队列的积压。 */
+.stat-card .stat-sub {
+  margin-top: 4px;
+  font-size: 11px;
+  font-weight: 500;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+}
+.rt-section-title {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-secondary);
+  letter-spacing: 0.3px;
+  margin: 14px 0 8px;
+  text-transform: uppercase;
+}
+.rt-empty {
+  font-size: 12px;
+  color: var(--text-muted);
+  padding: 4px 0;
+}
+/* 行内小图标：一律 SVG，不使用 emoji/符号字符。 */
+.rt-ico {
+  width: 12px;
+  height: 12px;
+  flex: 0 0 auto;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 2;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  vertical-align: -1.5px;
+}
+.rt-pipe-row {
+  display: grid;
+  /* 100px 下限：容器再窄也要保证 5 个框一行，不留「4 个 + 1 个」的孤行 */
+  grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
+  gap: 10px;
+  margin: 2px 0 8px;
+  transition: opacity 0.3s var(--ease-out);
+}
+.rt-pipe-idle {
+  opacity: 0.55;
+}
+.rt-pipe-cell {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 11px 12px 10px;
+  border-radius: var(--radius-md);
+  background: var(--bg-input);
+  border: 1px solid var(--border-color);
+  min-width: 0;
+  transition:
+    border-color 0.25s var(--ease-out),
+    box-shadow 0.25s var(--ease-out),
+    background 0.25s var(--ease-out);
+}
+.rt-pipe-cell.active {
+  border-color: var(--accent);
+  background: var(--accent-bg);
+  box-shadow: var(--shadow-md);
+}
+.rt-pipe-head {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  min-width: 0;
+}
+.rt-pipe-head > b {
+  font-size: 13.5px;
+  font-weight: 700;
+  color: var(--text-secondary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.rt-pipe-head .rt-ico {
+  width: 15px;
+  height: 15px;
+  color: var(--text-secondary);
+}
+.rt-pipe-cell.active .rt-pipe-head > b,
+.rt-pipe-cell.active .rt-pipe-head .rt-ico {
+  color: var(--accent);
+}
+.rt-pipe-events {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  min-height: 23px;
+}
+/* 「工具」格的滚动视口：固定一行高，只露最新一条（与 WebUI 同一口径）。 */
+.rt-pipe-scroll {
+  flex-wrap: nowrap;
+  height: 23px;
+  min-height: 23px;
+  overflow: hidden;
+  align-items: center;
+}
+.rt-pipe-scroll .rt-chip {
+  flex: 0 1 auto;
+  min-width: 0;
+  max-width: none;
+}
+.rt-chip-enter {
+  animation: rt-chip-scroll-in 0.3s var(--ease-out);
+}
+@keyframes rt-chip-scroll-in {
+  from {
+    transform: translateY(115%);
+    opacity: 0;
+  }
+  to {
+    transform: translateY(0);
+    opacity: 1;
+  }
+}
+.rt-scroll-count {
+  flex: 0 0 auto;
+  margin-left: auto;
+  font-style: normal;
+  font-size: 10.5px;
+  opacity: 0.6;
+  font-variant-numeric: tabular-nums;
+}
+.rt-loop {
+  display: inline-flex;
+  color: var(--accent);
+  font-weight: 700;
+}
+.rt-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  min-width: 0;
+  max-width: 170px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 11px;
+  padding: 2px 8px;
+  border-radius: var(--radius-pill);
+  background: var(--bg-hover);
+  border: 1px solid var(--border-color);
+  color: var(--text-secondary);
+}
+.rt-chip-t {
+  font-weight: inherit;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.rt-chip-tool {
+  border-color: rgba(136, 192, 208, 0.42);
+  color: var(--frost-300);
+}
+.rt-chip-output {
+  border-color: var(--accent);
+  color: var(--accent);
+}
+.rt-chip-stage {
+  opacity: 0.7;
+}
+.rt-chip-none {
+  opacity: 0.35;
+  border-style: dashed;
+}
+.rt-chip-n {
+  font-style: normal;
+  opacity: 0.75;
+  font-variant-numeric: tabular-nums;
+}
+/* 队列：5 个等大框（L4/L3/L2/L1 + 排队），一行排开 */
+.rt-queues {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
+  gap: 10px;
+  margin-bottom: 4px;
+}
+.rt-qcell {
+  display: flex;
+  flex-direction: column;
+  gap: 7px;
+  padding: 11px 12px 10px;
+  border-radius: var(--radius-md);
+  background: var(--bg-input);
+  border: 1px solid var(--border-color);
+  min-width: 0;
+  transition:
+    border-color 0.25s var(--ease-out),
+    box-shadow 0.25s var(--ease-out);
+}
+.rt-qhead {
+  display: flex;
+  align-items: baseline;
+  gap: 7px;
+  min-width: 0;
+}
+.rt-qhead > b {
+  font-size: 16px;
+  font-weight: 800;
+  line-height: 1;
+  letter-spacing: -0.02em;
+}
+.rt-qhead > span {
+  font-size: 10.5px;
+  color: var(--text-muted);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.rt-qnum {
+  font-size: 26px;
+  font-weight: 800;
+  line-height: 1;
+  letter-spacing: -0.02em;
+  font-variant-numeric: tabular-nums;
+}
+.rt-qmeta {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 4px 8px;
+  font-size: 10.5px;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+}
+.rt-qcell.rt-lv-4 .rt-qhead > b { color: #ff5c7a; }
+.rt-qcell.rt-lv-3 .rt-qhead > b { color: #ffa657; }
+.rt-qcell.rt-lv-2 .rt-qhead > b { color: var(--sakura-400); }
+.rt-qcell.rt-lv-1 .rt-qhead > b { color: var(--frost-300); }
+.rt-qcell.rt-lv-q .rt-qhead > b { color: #a3be8c; }
+/* 有积压时整个框描边点亮：一眼看出哪条队列在堵 */
+.rt-qcell.rt-lv-4.rt-active { border-color: rgba(255, 92, 122, 0.55); }
+.rt-qcell.rt-lv-3.rt-active { border-color: rgba(255, 166, 87, 0.55); }
+.rt-qcell.rt-lv-2.rt-active { border-color: var(--sakura-400); }
+.rt-qcell.rt-lv-1.rt-active { border-color: var(--frost-300); }
+.rt-qcell.rt-lv-q.rt-active { border-color: #a3be8c; }
+/* 排队队列无级别：虚线框与四级中断区分（另一**类别**，不是另一优先级） */
+.rt-qcell.rt-qcell-queued {
+  border-style: dashed;
+}
+/* 队列格槽：固定可见的「车位」，占用多少一眼可数。
+   用进度条时队列为 0 宽度就是 0，整行只剩文字，看上去就是「这块空着」。 */
+.rt-slots {
+  display: flex;
+  align-items: stretch;
+  gap: 3px;
+  height: 16px;
+  min-width: 0;
+}
+.rt-slots > i {
+  flex: 1 1 0;
+  min-width: 3px;
+  border-radius: 3px;
+  background: rgba(255, 255, 255, 0.06);
+  border: 1px solid rgba(255, 255, 255, 0.05);
+  transition:
+    background 0.25s var(--ease-out),
+    box-shadow 0.25s var(--ease-out);
+}
+.rt-slots.rt-lv-4 > i.on { background: #ff5c7a; box-shadow: 0 0 6px rgba(255, 92, 122, 0.45); }
+.rt-slots.rt-lv-3 > i.on { background: #ffa657; box-shadow: 0 0 6px rgba(255, 166, 87, 0.4); }
+.rt-slots.rt-lv-2 > i.on { background: var(--sakura-400); box-shadow: 0 0 6px rgba(255, 127, 172, 0.4); }
+.rt-slots.rt-lv-1 > i.on { background: var(--frost-300); box-shadow: 0 0 6px rgba(136, 192, 208, 0.4); }
+.rt-slots.rt-lv-q > i.on { background: #a3be8c; box-shadow: 0 0 6px rgba(163, 190, 140, 0.4); }
+.rt-slots-more {
+  flex: 0 0 auto;
+  align-self: center;
+  margin-left: 4px;
+  font-size: 10px;
+  font-weight: 600;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+}

cmd/homed/bootstrap.go

@@ -0,0 +1,869 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
+
+	agentPkg "gitcode.com/JianFeeeee/HomeAgent/internal/agent"
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentCore "gitcode.com/JianFeeeee/HomeAgent/internal/agent/core"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	internalConfig "gitcode.com/JianFeeeee/HomeAgent/internal/config"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/events"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/ipc"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/knowledge"
+	logpkg "gitcode.com/JianFeeeee/HomeAgent/internal/log"
+	luapkg "gitcode.com/JianFeeeee/HomeAgent/internal/lua"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/document"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/media"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/pipeline"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/social"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/text"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/vector"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/nlp"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/plugin"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/recovery"
+	sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/supervisor"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/tracker"
+	"gitcode.com/JianFeeeee/HomeAgent/pkg/embedding"
+	"gitcode.com/JianFeeeee/HomeAgent/pkg/types"
+)
+
+// defaultSystemPrompt 是内置默认人格模板：不含版本号字面量，
+// 被问版本时以运行时快照为准（历史上写死版本号导致实例自称旧版本）。
+const defaultSystemPrompt = `你是 HomeAgent，一个持续运行的个人管家。
+你的每次回复会自动发送到当前输出通道（默认=输入源），无需额外工具。
+如需切换回复通道，使用 output_set_channel。
+如需异步发送消息或通知，使用 output_send 指定通道和内容。
+使用 output_list_channels 查看可用通道及其能力。
+
+可用工具列表会由系统自动传入，按需使用即可。以下是你尤其需要关注的几类工具：
+- memory_* — 图记忆（长期记忆，记录和查询个人信息/事实）
+- knowledge_* — 知识库（查阅预设知识文档）
+- doc_* — 文档记忆（近期对话的存档，查询后自动清除）
+- person_* — 人物特质与社交关系网
+- llm_* — LLM 源管理（列出/切换模型提供商）
+- output_* — 输出通道管理（切换/发送消息）
+- timer_set — 设置定时提醒
+- plgreload — 热重载插件
+- spawn_child — 生成子 Agent 异步执行独立任务（可传 max_turns 控制工具轮数，默认 5）
+
+并行策略：遇到多个互不依赖的子任务时，优先并行 spawn 多个子 Agent 而非自己串行逐个执行；
+长耗时任务（批量处理、多轮搜索汇总）也应交给子 Agent，避免阻塞当前对话。
+- describe_image — 描述用户上传的图片
+- transcribe_audio — 转写用户上传的音频
+- ocr_image — 识别图片中的文字
+
+命令与文件操作策略：
+- cmd_run 经完整 shell（bash）执行，支持管道、分号、&&、命令替换、heredoc、重定向。
+- 多步交互式程序（vim/top/ssh 会话、需要持续输入的进程）用 terminal_create 创建终端，
+  terminal_write 发送输入、terminal_read 读输出——不要用 cmd_run 硬等交互程序退出。
+- 写文件优先 files_write（原子+留档），生成多行内容时可用 heredoc 或 files_write，
+  不要用 echo 拼接长文本。
+- 读用户发来的文件用 files_read；向 webui 回传图片/文件用 output_send__webui(type=image/file)。
+
+当用户上传图片或音频时，系统会自动附着媒体内容。如果模型不支持直接处理多媒体，请使用上述工具。
+
+回复你的真实想法，用自然语言与用户交流。不要在回复中使用 emoji 表情。`
+
+// setupLogging 初始化日志：行号前缀 + 同时输出到控制台与 <data>/log/ 下的本次启动文件。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func setupLogging(dataDir string) string {
+	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
+
+	// 文件日志：同时输出到控制台和 data/log/ 目录
+	logDir := filepath.Join(dataDir, "log")
+	if err := os.MkdirAll(logDir, 0755); err != nil {
+		log.Printf("[homed] warning: cannot create log dir: %v", err)
+	} else {
+		logPath := filepath.Join(logDir, fmt.Sprintf("homed_%s.log", time.Now().Format("2006-01-02_15-04-05")))
+		logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+		if err != nil {
+			log.Printf("[homed] warning: cannot open log file: %v", err)
+		} else {
+			log.SetOutput(io.MultiWriter(os.Stderr, logFile))
+			log.Printf("[homed] logging to %s", logPath)
+		}
+	}
+
+	return logDir
+}
+
+// ensureDataDirs 建好启动期需要的全部目录，返回 agent 的 overlayfs 工作目录。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func ensureDataDirs(dataDir string) string {
+	agentWorkDir := filepath.Join(dataDir, "agentfs")
+	dirs := []string{
+		dataDir,
+		filepath.Join(dataDir, "snapshots"),
+		filepath.Join(dataDir, "plugins"),
+		filepath.Join(dataDir, "changesets"),
+		filepath.Join(dataDir, "memory"),
+		filepath.Join(dataDir, "memory", "raw"),
+		filepath.Join(dataDir, "adapters"),
+		agentWorkDir,
+	}
+	for _, d := range dirs {
+		if err := os.MkdirAll(d, 0755); err != nil {
+			log.Fatalf("create dir %s: %v", d, err)
+		}
+	}
+
+	return agentWorkDir
+}
+
+// memoryStack 聚合记忆侧组件：图库、索引器、社交图、蒸馏器。
+type memoryStack struct {
+	db        *memory.GraphDB
+	indexer   *memory.Indexer
+	social    *social.SocialStore
+	distiller *pipeline.Distiller
+}
+
+// initMemoryStack 初始化图记忆 / 索引 / 社交图 / 蒸馏管线。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func initMemoryStack(dataDir string) (*memoryStack, func()) {
+	memDB, err := memory.NewGraphDB(filepath.Join(dataDir, "memory", "graph.db"))
+	if err != nil {
+		log.Printf("[homed] warning: memory init failed: %v", err)
+		memDB = nil
+	} else {
+		log.Printf("[homed] graph memory initialized")
+	}
+	if memDB != nil {
+	}
+
+	memIdx := memory.NewIndexer(memDB)
+	memIdx.Sync() // 启动时立即同步，避免前30分钟空窗
+	socialStore := social.New(memDB)
+
+	distiller := pipeline.NewDistiller(memDB, dataDir, pipeline.DistillerConfig{
+		Interval:      10 * time.Minute,
+		RetentionDays: 7,
+		BatchSize:     50,
+	})
+	if memDB != nil {
+		distiller.Start()
+		defer distiller.Stop()
+	}
+
+	return &memoryStack{db: memDB, indexer: memIdx, social: socialStore, distiller: distiller},
+		func() {
+			// 与原 main 的两个 defer 同序（LIFO）：先停蒸馏器，再关图库。
+			if memDB != nil {
+				distiller.Stop()
+			}
+			if memDB != nil {
+				memDB.Close()
+			}
+		}
+}
+
+// startMemoryCandidateConsumer 起一个常驻 goroutine：把 eventbus 上的 memory_candidate 事件写进文本记忆并喂给蒸馏管线。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func startMemoryCandidateConsumer(ctx context.Context, iom *agentIO.IOManager, textMem *text.Memory, memDB *memory.GraphDB, distiller *pipeline.Distiller) {
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case evt, ok := <-iom.OutputChan():
+				if !ok {
+					return
+				}
+				if evt.Target == "memory" && evt.Type == "memory_candidate" {
+					source, _ := evt.Payload["source"].(string)
+					input, _ := evt.Payload["input"].(string)
+					response, _ := evt.Payload["response"].(string)
+					toolsUsed, _ := evt.Payload["tools_used"].([]string)
+					toolResults, _ := evt.Payload["tool_results"].([]interface{})
+					agentID, _ := evt.Payload["agent_id"].(string)
+
+					if input != "" && textMem != nil {
+						te := text.Event{
+							Timestamp: time.Now().Unix(),
+							Source:    source,
+							Input:     input,
+							Response:  response,
+							ToolsUsed: toolsUsed,
+							AgentID:   agentID,
+						}
+						if err := textMem.Append(te); err != nil {
+							log.Printf("[homed] text memory append: %v", err)
+						}
+					}
+
+					if input != "" && memDB != nil {
+						distiller.Append("agent", "user", input)
+					}
+					if response != "" && memDB != nil {
+						distiller.Append("agent", "assistant", response)
+					}
+
+					// 工具输出接入蒸馏管线
+					for _, tr := range toolResults {
+						if trMap, ok := tr.(map[string]interface{}); ok {
+							if text, ok := trMap["output"].(string); ok && text != "" && memDB != nil {
+								distiller.Append("agent", "tool", text)
+							}
+						}
+					}
+				}
+			}
+		}
+	}()
+}
+
+// initLLMProviders 按配置注册全部 LLM 源（每个源经 Lua 适配器协议转换），并把各适配器的并发额度汇总回 Lua VM。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func initLLMProviders(cfg *types.Config, luaVM *luapkg.VM, baseAPIKey string) *agentAPI.ProviderManager {
+	providerMgr := agentAPI.NewProviderManager()
+	adapterConcurrency := map[string]int{}
+	for _, src := range cfg.LLM.Sources {
+		if !agentAPI.IsValidSourceConfig(src.Name, src.BaseURL, src.Model, src.Adapter) {
+			log.Printf("[homed] skip invalid llm source %q (base_url=%q model=%q adapter=%q)", src.Name, src.BaseURL, src.Model, src.Adapter)
+			continue
+		}
+		key := src.APIKey
+		if key == "" {
+			key = baseAPIKey
+		}
+		luaProvider := agentAPI.NewLuaAdaptedProvider(agentAPI.BaseConfig{
+			Model:         src.Model,
+			BaseURL:       src.BaseURL,
+			APIKey:        key,
+			Temperature:   cfg.LLM.Temperature,
+			MaxTokens:     cfg.LLM.MaxTokens,
+			ContextWindow: src.ContextWindow,
+			MaxConcurrent: src.MaxConcurrent,
+			Priority:      src.Priority,
+			Vision:        src.Vision,
+			Audio:         src.Audio,
+		}, luaVM, src.Name, src.Adapter)
+		providerMgr.Register(src.Name, luaProvider)
+		if src.Adapter != "" {
+			adapterConcurrency[src.Adapter] += src.MaxConcurrent
+		}
+	}
+	luaVM.ConfigureConcurrency(adapterConcurrency)
+	if cfg.LLM.Provider != "" {
+		providerMgr.SetDefault(cfg.LLM.Provider)
+	}
+
+	return providerMgr
+}
+
+// initDocStore 启动文档记忆。flush 的唯一入口是 Stop()，所以关停时必须调用它。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func initDocStore(cfg *types.Config) (*document.Store, func()) {
+	docStore := document.NewStore(filepath.Join(cfg.Daemon.DataDir, "memory", "documents"), memory.TokenizeWords)
+	if err := docStore.Start(); err != nil {
+		log.Printf("[homed] warning: document store: %v", err)
+	}
+	// 关停时落盘。文档记忆的内存态变更（迁移结果、访问计数等）只在 flush
+	// 里写盘，而 flush 的唯一入口是 Stop()——此前全仓无人调用它，
+	// 于是迁移结果永不落盘、每次启动白算一遍。
+
+	return docStore, func() { docStore.Stop() }
+}
+
+// initMediaStore 按开关启动内容寻址的媒体存储；开不起来只告警（媒体记忆非对话必需品）。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func initMediaStore(cfgReg *internalConfig.ConfigRegistry, cfg *types.Config) (*media.Store, func()) {
+	var mediaStore *media.Store
+	if cfgReg.GetBool("core.memory.media.enabled", true) {
+		mediaDir := cfgReg.GetString("core.memory.media.dir",
+			filepath.Join(cfg.Daemon.DataDir, "memory", "media"))
+		ms, err := media.New(mediaDir)
+		if err != nil {
+			// 媒体存储开不起来不该阻止启动——它是记忆增强，不是对话必需品
+			log.Printf("[homed] warning: media store: %v（媒体记忆已禁用）", err)
+		} else {
+			mediaStore = ms
+			st := mediaStore.Stats()
+			log.Printf("[homed] media store active: %v 条 / %v 字节",
+				st["count"], st["total_bytes"])
+		}
+	}
+
+	return mediaStore, func() {
+		if mediaStore != nil {
+			mediaStore.Close()
+		}
+	}
+}
+
+// initMultimodalSpace 从公共注册表打开多模态向量 provider。返回 (空间, provider 名, 失败原因, cleanup)：后两个值只用于状态报告。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func initMultimodalSpace(cfgReg *internalConfig.ConfigRegistry) (vector.MultimodalEmbedder, string, string, func()) {
+	var multimodalSpace vector.MultimodalEmbedder
+	// 这两个值只用于状态报告（healthcheck_kernel 的 onnx 段）：
+	// 「配了哪个 provider」与「为什么没启用」，避免只能看到 false 却不知原因。
+	var mmProviderName, mmErr string
+	var closeAdapted func()
+	if mmProvider := cfgReg.GetString("core.memory.multimodal_space.provider", ""); mmProvider != "" {
+		mmProviderName = mmProvider
+		opts := map[string]string{}
+		const optPrefix = "core.memory.multimodal_space.options."
+		for _, key := range cfgReg.List("core.memory.multimodal_space.options.") {
+			opts[strings.TrimPrefix(key, optPrefix)] = cfgReg.GetString(key, "")
+		}
+		provider, err := embedding.Open(mmProvider, embedding.Config{Options: opts})
+		if err != nil {
+			mmErr = err.Error()
+			log.Printf("[homed] warning: 多模态向量 provider %q 打开失败: %v（多模态向量检索已禁用；已注册: %s）",
+				mmProvider, err, strings.Join(embedding.Names(), ", "))
+		} else if adapted, err := vector.AdaptProvider(provider); err != nil {
+			provider.Close()
+			mmErr = err.Error()
+			log.Printf("[homed] warning: 多模态向量 provider %q 元数据不合法: %v（多模态向量检索已禁用）", mmProvider, err)
+		} else {
+			multimodalSpace = adapted
+			info := provider.Info()
+			// 指纹可能很长（模型文件哈希），日志里只取前 12 个字符便于对照。
+			shortFP := info.Fingerprint
+			if len(shortFP) > 12 {
+				shortFP = shortFP[:12]
+			}
+			log.Printf("[homed] multimodal space active: provider=%s dim=%d fp=%s modalities=%v",
+				mmProvider, info.Dimension, shortFP, info.Modalities)
+		}
+	}
+
+	if closeAdapted == nil {
+		closeAdapted = func() {}
+	}
+	return multimodalSpace, mmProviderName, mmErr, closeAdapted
+}
+
+// initKnowledgeStore 启动知识库。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func initKnowledgeStore(cfg *types.Config) *knowledge.Store {
+	ks := knowledge.NewStore(filepath.Join(cfg.Daemon.DataDir, "knowledge"))
+	if err := ks.Start(); err != nil {
+		log.Printf("[homed] warning: knowledge store: %v", err)
+	} else {
+		log.Printf("[homed] knowledge store active with %d items", len(ks.List()))
+	}
+
+	return ks
+}
+
+// loadPersonality 按「个人文件 > 配置项」的优先级解析人格内容，并对腐坏内容告警。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func loadPersonality(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry) *agentPkg.Personality {
+	personalPath := filepath.Join(cfg.Daemon.DataDir, "personal", "personal.md")
+	personality, err := agentPkg.LoadPersonality(personalPath)
+	if err != nil {
+		log.Printf("[homed] warning: load personality: %v", err)
+	}
+	if personality != nil && personality.Content != "" {
+		log.Printf("[homed] 人格来源=文件 %s（优先于配置项），%d 字节", personalPath, len(personality.Content))
+		if hints := agentPkg.PersonaStaleHints(personality.Content); len(hints) > 0 {
+			log.Printf("[homed] warning: 人格文件含会腐坏的内容 %v — 建议迁到配置项 core.agent.personal_prompt"+
+				"（默认模板不含版本号，被问版本时以运行时快照为准）", hints)
+		}
+	} else if pv := cfgReg.GetString("core.agent.personal_prompt", internalConfig.DefaultPersonaPrompt); strings.TrimSpace(pv) != "" {
+		personality = &agentPkg.Personality{Content: pv, Path: "(core.agent.personal_prompt)"}
+		log.Printf("[homed] 人格来源=配置项 core.agent.personal_prompt，%d 字节", len(pv))
+	} else {
+		log.Printf("[homed] 人格来源=无（配置项为空且无人格文件）")
+	}
+
+	return personality
+}
+
+// newStageAndRegistry 建阶段管道与插件注册表，把内核依赖接到注册表上。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func newStageAndRegistry(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry, iom *agentIO.IOManager,
+	evBus *events.Bus, memDB *memory.GraphDB, textMem *text.Memory, docStore *document.Store,
+	mediaStore *media.Store, ks *knowledge.Store, providerMgr *agentAPI.ProviderManager,
+	dataDir string) (*agentCore.StageHost, *plugin.Registry) {
+	stageHost := agentCore.NewStageHost()
+
+	pluginReg := plugin.NewRegistry()
+	pluginReg.SetIOManager(iom)
+	pluginReg.SetEventBus(evBus)
+	pluginReg.SetMemory(memDB)
+	pluginReg.SetTextMemory(textMem)
+	pluginReg.SetDocStore(docStore)
+	pluginReg.SetMediaStore(mediaStore) // 插件写入的记忆也走媒体链路；nil 时静默降级
+	pluginReg.SetKnowledge(ks)
+	pluginReg.SetProviderManager(providerMgr)
+	pluginReg.SetConfigRegistry(cfgReg)
+	pluginReg.SetPluginDir(cfg.Plugin.Dir)
+	pluginReg.SetDataDir(dataDir) // 插件 SettingsAPI.DataDir() 的数据根目录
+
+	// Wire registration callbacks: plugins' RegisterTool/RegisterStage → StageHost
+	pluginReg.SetToolRegistrar(func(name string, def sdk.ToolDef, handler sdk.ToolHandler) error {
+		log.Printf("[homed] SetToolRegistrar registering tool: %s (plugin=%s)", name, def.Plugin)
+		return stageHost.RegisterTool(name, def, handler)
+	})
+	pluginReg.SetStageRegistrar(func(stage sdk.Stage, handler sdk.StageHandler) {
+		stageHost.RegisterStage(stage, handler)
+	})
+	pluginReg.SetAPIRegistrar(func(name string) error {
+		return nil
+	})
+	pluginReg.SetToolCleaner(stageHost)
+
+	return stageHost, pluginReg
+}
+
+// newMainAgent 组装主 Agent：把内核各面（IO/记忆/文档/知识/媒体/社交/文本/插件/状态）接进 AgentConfig。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func newMainAgent(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry, provider agentAPI.Provider,
+	providerMgr *agentAPI.ProviderManager, iom *agentIO.IOManager, memDB *memory.GraphDB,
+	memIdx *memory.Indexer, trk *tracker.Tracker, docStore *document.Store, ks *knowledge.Store,
+	socialStore *social.SocialStore, textMem *text.Memory, mediaStore *media.Store,
+	personality *agentPkg.Personality, pluginReg *plugin.Registry, embedder *memory.StaticEmbedder,
+	multimodalSpace vector.MultimodalEmbedder, mmProviderName, mmErr string,
+	stageHost *agentCore.StageHost, evBus *events.Bus) *agentCore.Agent {
+	sysPrompt := cfgReg.GetString("core.agent.system_prompt", defaultSystemPrompt)
+	if sysPrompt == "" {
+		sysPrompt = defaultSystemPrompt
+	}
+
+	agent := agentCore.New(agentCore.AgentConfig{
+		ID:              "main",
+		SystemPrompt:    sysPrompt,
+		Provider:        provider,
+		ProviderManager: providerMgr,
+		IO:              iom,
+		Memory:          memDB,
+		Indexer:         memIdx,
+		Tracker:         trk,
+		DocStore:        docStore,
+		Knowledge:       ks,
+		SocialStore:     socialStore,
+		TextMemory:      textMem,
+		MediaStore:      mediaStore,
+		Personality:     personality,
+		// 人格落库面：首启门禁（任何通道都问一次）与 persona_set 工具用。
+		// 与 WebUI 向导共用 internal/config 的同一份落库逻辑。
+		PersonaStore: internalConfig.RegistryPersonaStore{Reg: cfgReg},
+		PluginReg:    pluginReg,
+		PluginDir:    cfg.Plugin.Dir,
+		// DataDir：驻留子的 temp 图库锚点（<data>/residents/<id>/graph.db）。
+		// 漏接时的现象是"工具存在、可调用、但创建必失败"——只有真实二进制才看得出来。
+		DataDir:            cfg.Daemon.DataDir,
+		DistillInterval:    cfgReg.GetDuration("core.agent.distill_interval", 30*time.Minute),
+		ArchiveInterval:    cfgReg.GetDuration("core.agent.archive_interval", 60*time.Minute),
+		ReviewInterval:     cfgReg.GetDuration("core.agent.review_interval", 120*time.Minute),
+		MergeInterval:      cfgReg.GetDuration("core.agent.merge_interval", 120*time.Minute),
+		MaxToolTurns:       cfgReg.GetInt("core.agent.max_tool_turns", 10),
+		ContextSavePath:    filepath.Join(cfg.Daemon.DataDir, "memory", "context.json"),
+		EmbeddingModelPath: cfgReg.GetString("core.agent.embedding_model_path", ""),
+		Embedder:           embedder,
+		MultimodalSpace:    multimodalSpace,
+		EmbeddingProvider:  mmProviderName,
+		EmbeddingError:     mmErr,
+		StageHost:          stageHost,
+		EventBus:           evBus,
+		ThinkingEnabled:    cfg.LLM.ThinkingEnabled,
+		InputProcessing:    cfg.InputProcessing,
+	})
+
+	return agent
+}
+
+// initONNXParser 初始化依存句法分析器（内嵌 ONNX 模型，失败则退回规则引擎）。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func initONNXParser(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry) {
+	modelPath := cfgReg.GetString("core.agent.onnx_model_path", "")
+	onnxParser, err := nlp.NewONNXParser(nlp.ONNXConfig{
+		ModelPath: modelPath,
+		DataDir:   filepath.Join(cfg.Daemon.DataDir, "nlp"),
+	})
+	if err != nil {
+		log.Printf("[homed] warn: ONNX parser init: %v, using fallback", err)
+	} else {
+		nlp.SetDefaultParser(onnxParser)
+		log.Printf("[homed] dep parser initialized (model: %s)", modelPath)
+	}
+}
+
+// loadPlugins 建插件目录、按启动模式决定 allowlist，然后加载全部插件。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func loadPlugins(cfg *types.Config, cfgReg *internalConfig.ConfigRegistry, pluginReg *plugin.Registry,
+	stageHost *agentCore.StageHost, bootMode, dataDir string) {
+	// Auto-create plugins directory (without hardcoding plugin names)
+	os.MkdirAll(cfg.Plugin.Dir, 0755)
+
+	// failback 受限启动：仅装载 failback 插件集（webfetch/files/cmd 为内核内置，
+	// 此处仅控制外部插件，默认含 recoverydiag 以便直接在受限态产出恢复结论）
+	if bootMode == "failback" {
+		list := cfgReg.GetString("core.agent.failback_plugins", "webui,pluginmgr,recoverydiag")
+		// 优先使用 guard.yaml 经过 recovery 任务下发的插件集（guard 是 failback 权威）
+		if task, terr := recovery.LoadTask(recovery.TaskPath(dataDir)); terr == nil && len(task.Plugins()) > 0 {
+			list = strings.Join(task.Plugins(), ",")
+		}
+		var names []string
+		for _, s := range strings.Split(list, ",") {
+			if s = strings.TrimSpace(s); s != "" {
+				names = append(names, s)
+			}
+		}
+		pluginReg.SetLoadAllowlist(names)
+		log.Printf("[homed] failback boot: plugin allowlist = %v", names)
+	}
+
+	// Load all plugins — each scans its own dir and is loaded via factory or .so
+	if err := pluginReg.Load(cfg.Plugin.Dir); err != nil {
+		log.Printf("[homed] warning: load plugins: %v", err)
+	}
+	log.Printf("[homed] stage host ready with %d registered tools", stageHost.ToolCount())
+}
+
+// startAgentRuntime 接线技能索引、起日志管理、启动 agent，返回逆序关停的 cleanup。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func startAgentRuntime(cfgReg *internalConfig.ConfigRegistry, pluginReg *plugin.Registry,
+	agent *agentCore.Agent, logDir string, ctx context.Context) func() {
+	// 技能索引接线：skillmgr 插件实现 SkillIndexProvider 时注入 agent（方案B prompt 注入）
+	if sp := pluginReg.Get("skillmgr"); sp != nil {
+		if prov, ok := sp.(agentCore.SkillIndexProvider); ok {
+			agent.SetSkillIndexProvider(prov)
+			log.Printf("[homed] skill index wired from skillmgr plugin")
+		}
+	}
+
+	// 日志管理：层级压缩 + 保留策略
+	logManager := logpkg.NewManager(logDir, cfgReg)
+	go logManager.Start(ctx)
+
+	agent.Start()
+
+	return func() {
+		// 与原 main 的两个 defer 同序（LIFO）：先停 agent，再停日志管理。
+		agent.Stop()
+		logManager.Stop()
+	}
+}
+
+// startIPCServer 起 PING/ACK 心跳服务（含 kernel 状态快照），返回仅在启动成功后生效的 cleanup。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func startIPCServer(dataDir, bootMode string, agent *agentCore.Agent) (*ipc.Server, func()) {
+	started := false
+	ipcServer := ipc.NewServer(dataDir, func() *ipc.Status {
+		st := agent.GetKernelStatus()
+		llmOK := st != nil && st.LLM.Available
+		tools := 0
+		if st != nil {
+			tools = len(st.Tools)
+		}
+		uptime := int64(0)
+		if st != nil {
+			if d, err := time.ParseDuration(st.Uptime); err == nil {
+				uptime = int64(d.Seconds())
+			}
+		}
+		return &ipc.Status{
+			PID:       os.Getpid(),
+			Boot:      bootMode,
+			UptimeSec: uptime,
+			LLMOK:     &llmOK,
+			Tools:     tools,
+			LastDiag:  lastDiagSummary(dataDir),
+		}
+	})
+	if err := ipcServer.Start(); err != nil {
+		log.Printf("[homed] warning: ipc heartbeat server: %v", err)
+	} else {
+	}
+
+	return ipcServer, func() {
+		if started {
+			ipcServer.Stop()
+		}
+	}
+}
+
+// startSupervisorRuntime 把真实存活源与重启通道接到 supervisor 上，返回重启请求通道。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func startSupervisorRuntime(sup *supervisor.Daemon, trk *tracker.Tracker, agent *agentCore.Agent) chan struct{} {
+	sup.SetTracker(trk)
+	sup.RegisterAgent("main")
+
+	// 真实存活源 + 重启通道：daemon 心跳语义由此修正（lastHB 只在确认存活时更新），
+	// 重启动作不再空转——清理后以特殊退出码交给 guard/systemd 重建。
+	restartCh := make(chan struct{}, 1)
+	sup.SetHeartbeatSource(func(id types.AgentID) (time.Time, types.HealthStatus, error) {
+		st := agent.GetKernelStatus()
+		if st == nil {
+			return time.Time{}, types.HealthDown, fmt.Errorf("no kernel status")
+		}
+		h := types.HealthHealthy
+		if !st.LLM.Available {
+			h = types.HealthDegraded
+		}
+		return time.Now(), h, nil
+	})
+	sup.SetRestartHandler(func(id types.AgentID) {
+		select {
+		case restartCh <- struct{}{}:
+		default:
+		}
+	})
+
+	return restartCh
+}
+
+// startHeartbeat 每 5s 触碰 <data>/heartbeat（guard 据此判定 worker 存活/卡死），返回停止函数。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func startHeartbeat(dataDir string, ctx context.Context) func() {
+	// 心跳：每 5s 触碰 <data>/heartbeat，guard 据此判定工作进程是否存活/卡死
+	hbPath := filepath.Join(dataDir, "heartbeat")
+	hbStop := make(chan struct{})
+	go func() {
+		t := time.NewTicker(5 * time.Second)
+		defer t.Stop()
+		writeHB := func() {
+			if f, err := os.OpenFile(hbPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644); err == nil {
+				fmt.Fprintf(f, "t=%d\n", time.Now().Unix())
+				f.Close()
+			}
+		}
+		writeHB()
+		for {
+			select {
+			case <-t.C:
+				writeHB()
+			case <-hbStop:
+				return
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	return func() { close(hbStop) }
+}
+
+// waitForShutdown 阻塞至 SIGINT/SIGTERM 或 supervisor 请求重启，然后按原 main 的顺序清理，需要重建时以退出码交回 guard。
+//
+// 本函数体是 main() 里对应启动阶段的整块平移：语句、日志文本、错误语义不变，
+// 只把「*dataDir」变成参数、把 defer 变成由调用点注册的 cleanup。
+func waitForShutdown(ctx context.Context, dataDir string, restartCh chan struct{}, stopHeartbeat func(),
+	pluginReg *plugin.Registry, trk *tracker.Tracker, cfgReg *internalConfig.ConfigRegistry, sup *supervisor.Daemon) {
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+
+	restartRequested := false
+	select {
+	case <-sigCh:
+		log.Printf("[homed] shutting down...")
+	case <-restartCh:
+		restartRequested = true
+		log.Printf("[homed] restart requested, shutting down cleanly then exiting with code %d", exitRestartRequested)
+	}
+
+	stopHeartbeat()
+	pluginReg.StopAll()
+	if trk != nil {
+		trk.Stop()
+	}
+	if err := cfgReg.Flush(); err != nil {
+		log.Printf("[homed] flush config: %v", err)
+	}
+	sup.Shutdown()
+	log.Printf("[homed] stopped")
+
+	if restartRequested {
+		os.Exit(exitRestartRequested)
+	}
+}
+
+// initLuaVM 起 Lua VM（LLM 协议适配）；启动失败只告警，cleanup 为 no-op。
+func initLuaVM(cfg *types.Config) (*luapkg.VM, func()) {
+	luaVM := luapkg.NewVM(filepath.Join(cfg.Daemon.DataDir, "adapters"))
+	if err := luaVM.Start(); err != nil {
+		log.Printf("[homed] warning: lua vm init failed: %v", err)
+		return luaVM, func() {}
+	}
+	return luaVM, luaVM.Stop
+}
+
+// initSupervisor 起守护管理（代理生命周期管理）；起不来是致命错误。
+func initSupervisor(cfg *types.Config) *supervisor.Daemon {
+	sup := supervisor.New(cfg)
+	if err := sup.Start(); err != nil {
+		log.Fatalf("start supervisor: %v", err)
+	}
+	return sup
+}
+
+// initTracker 起 overlayfs 变更追踪；无 overlayfs 支持时降级为非致命告警。
+func initTracker(cfg *types.Config, agentWorkDir string) *tracker.Tracker {
+	trk := tracker.NewTracker(cfg.Daemon.DataDir, agentWorkDir,
+		tracker.WithKeepChangesets(100),
+		tracker.WithMaxChangesetAge(30*24*time.Hour),
+	)
+	if err := trk.Init(); err != nil {
+		log.Printf("[homed] warning: tracker init: %v", err)
+	} else {
+		if err := trk.Start(); err != nil {
+			log.Printf("[homed] warning: tracker mount overlay: %v (non-fatal: no overlayfs support?)", err)
+		} else {
+			log.Printf("[homed] change tracker active at %s", trk.MergeDir())
+		}
+	}
+	return trk
+}
+
+// initKernelAPI 建内核与插件之间的两个通道：IOManager（IO 抽象层）+ EventBus（事件总线）。
+func initKernelAPI() (*agentIO.IOManager, *events.Bus) {
+	iom := agentIO.NewIOManager()
+	evBus := events.NewBus()
+	log.Printf("[homed] kernel API ready: IOManager + EventBus")
+	return iom, evBus
+}
+
+// initTextMemory 起文本记忆；启动失败只告警，cleanup 为 no-op。
+func initTextMemory(cfg *types.Config) (*text.Memory, func()) {
+	textMem := text.New(filepath.Join(cfg.Daemon.DataDir, "memory", "text"))
+	if err := textMem.Start(); err != nil {
+		log.Printf("[homed] warning: text memory start: %v", err)
+		return textMem, func() {}
+	}
+	log.Printf("[homed] text memory active at %s", filepath.Join(cfg.Daemon.DataDir, "memory", "text"))
+	return textMem, textMem.Stop
+}
+
+// resolveBaseAPIKey 解析兜底 API key：配置项 > LLM_API_KEY > DEEPSEEK_API_KEY。
+func resolveBaseAPIKey(cfg *types.Config) string {
+	apiKey := cfg.LLM.APIKey
+	if apiKey == "" {
+		apiKey = os.Getenv("LLM_API_KEY")
+	}
+	if apiKey == "" {
+		apiKey = os.Getenv("DEEPSEEK_API_KEY")
+	}
+	return apiKey
+}
+
+// wirePluginSDK 把内核各面注入每个插件的 PluginSDK（阶段6 将替换遗留的 util.Configure）。
+func wirePluginSDK(pluginReg *plugin.Registry, luaVM *luapkg.VM, baseAPIKey string, sup *supervisor.Daemon,
+	trk *tracker.Tracker, cfg *types.Config, stageHost *agentCore.StageHost, memIdx *memory.Indexer,
+	agent *agentCore.Agent) {
+	pluginReg.SetLuaVM(luaVM)
+	pluginReg.SetBaseAPIKey(baseAPIKey)
+	pluginReg.SetSupervisor(supervisor.NewSDKAdapter(sup))
+	pluginReg.SetTracker(trk)
+	pluginReg.SetConfig(cfg)
+	pluginReg.SetStageHost(stageHost)
+	pluginReg.SetIndexer(memIdx)
+	pluginReg.SetStatusProvider(agent)
+}
+
+// resolveWebUIOverride 解析 webui 监听地址的覆盖值，空串表示不覆盖。
+//
+// 优先级：CLI --webui > 核心配置 webui.listen_addr（仅当它被改成非内置默认值）。
+// 两者都不给时由 webui 插件自己的 settings["addr"] 决定。
+//
+// 为什么不写成“内核在插件加载前 Set 插件 settings['addr']”：那时
+// config_webui 表还没建（表只在插件注册 def 时创建），PluginSettings.Set 的
+// INSERT 会失败而错误被忽略，随后插件 Start 里 RegisterDef 才建表并写入默认
+// :8080 —— 于是 CLI --webui 与 webui.listen_addr **一直是死配置**，
+// 无论怎么传都监听 :8080。覆盖值改由插件自己接收（webui.SetListenOverride）。
+func resolveWebUIOverride(cfgReg *internalConfig.ConfigRegistry, httpAddr string) string {
+	if strings.TrimSpace(httpAddr) != "" {
+		return strings.TrimSpace(httpAddr)
+	}
+	// webui.listen_addr 的播种默认值就是 ":8080"；与默认值相同视为“未配置”，
+	// 否则会把用户在设置页里改过的插件 addr 顶掉。
+	if v := strings.TrimSpace(cfgReg.GetString("webui.listen_addr", ":8080")); v != "" && v != ":8080" {
+		return v
+	}
+	return ""
+}
+
+// options 是 worker 的命令行参数。
+type options struct {
+	dataDir   string
+	httpAddr  string
+	cliSocket string
+	role      string
+	boot      string
+}
+
+// parseFlags 解析命令行参数。
+func parseFlags() options {
+	dataDir := flag.String("data", "", "data directory (default: auto-detect next to binary)")
+	httpAddr := flag.String("webui", "", "webui listen address (default: webui.listen_addr from config)")
+	cliSocket := flag.String("socket", "", "cli unix socket path (default: <data>/cli.sock)")
+	role := flag.String("role", "agent", "process role: guard (父守护) | agent (工作进程)")
+	boot := flag.String("boot", "normal", "agent boot mode: normal | failback (受限启动，仅 failback 插件集)")
+	flag.Parse()
+	return options{dataDir: *dataDir, httpAddr: *httpAddr, cliSocket: *cliSocket, role: *role, boot: *boot}
+}
+
+// compactConfigDB 在空闲页够多时压缩配置库；失败只告警（不影响启动）。
+//
+// 触发条件（见 internal/config.MaybeCompact）：空闲页 >= 1MB 且占页数 >= 25%。
+// 放在插件加载之后调用——迁移/清理大值发生在插件 Start 里，之前调用没有意义。
+func compactConfigDB(cfgReg *internalConfig.ConfigRegistry) {
+	before := int64(-1)
+	if st, err := os.Stat(cfgReg.DBPath()); err == nil {
+		before = st.Size()
+	}
+	done, err := cfgReg.MaybeCompact(1<<20, 0.25)
+	if err != nil {
+		log.Printf("[homed] warning: 配置库压缩失败: %v", err)
+		return
+	}
+	if !done {
+		return
+	}
+	after := before
+	if st, err := os.Stat(cfgReg.DBPath()); err == nil {
+		after = st.Size()
+	}
+	log.Printf("[homed] 配置库已压缩: %d -> %d 字节", before, after)
+}

cmd/homed/main.go

@@ -2,49 +2,19 @@ package main
 
 import (
 	"context"
-	"flag"
-	"fmt"
-	"io"
 	"log"
-	"os"
-	"os/signal"
 	"path/filepath"
 	"strings"
-	"syscall"
-	"time"
 
-	agentPkg "gitcode.com/JianFeeeee/HomeAgent/internal/agent"
-	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
-	agentCore "gitcode.com/JianFeeeee/HomeAgent/internal/agent/core"
-	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
 	internalConfig "gitcode.com/JianFeeeee/HomeAgent/internal/config"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/events"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/ipc"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/knowledge"
-	logpkg "gitcode.com/JianFeeeee/HomeAgent/internal/log"
-	luapkg "gitcode.com/JianFeeeee/HomeAgent/internal/lua"
 	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/document"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/media"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/pipeline"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/social"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/text"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/vector"
 	"gitcode.com/JianFeeeee/HomeAgent/internal/meta"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/nlp"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/plugin"
 	_ "gitcode.com/JianFeeeee/HomeAgent/internal/plugins"
 	_ "gitcode.com/JianFeeeee/HomeAgent/internal/plugins/clawhubadapter"
 	cli "gitcode.com/JianFeeeee/HomeAgent/internal/plugins/cli"
 	_ "gitcode.com/JianFeeeee/HomeAgent/internal/plugins/healthcheck"
 	_ "gitcode.com/JianFeeeee/HomeAgent/internal/plugins/pluginmgr"
-	_ "gitcode.com/JianFeeeee/HomeAgent/internal/plugins/webui"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/recovery"
-	sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/supervisor"
-	"gitcode.com/JianFeeeee/HomeAgent/internal/tracker"
-	"gitcode.com/JianFeeeee/HomeAgent/pkg/embedding"
-	"gitcode.com/JianFeeeee/HomeAgent/pkg/types"
+	webui "gitcode.com/JianFeeeee/HomeAgent/internal/plugins/webui"
 
 	// 空白导入内置 provider：它们各自在 init 里注册到 pkg/embedding。
 	// 想把核心换成自己的模型，只需替换这一行（或另建一个发行版 main）。
@@ -52,695 +22,164 @@ import (
 	_ "gitcode.com/JianFeeeee/HomeAgent/providers/qwen3vl"
 )
 
+// main 是 worker 进程的启动序列。
+//
+// 形状约定：本函数只保留「顺序编排 + 就地交接」——
+//   - 每个阶段一行调用，参数即该阶段的全部依赖（依赖顺序即调用顺序）；
+//   - 阶段实现体在同包 bootstrap.go，与这里的调用一一对应；
+//   - 需要逆序释放的资源由阶段函数返回 cleanup，在**原位** defer 注册，
+//     因此释放顺序与拆分前完全一致。
 func main() {
 	// 平台门放在最前面：比 flag 解析还早，因为原生 Windows 上根本不应进入任何
 	// 初始化路径（会去建共享段、拉插件进程）。理由与 WSL 指引见
 	// platform_windows.go。
 	requireSupportedPlatform()
 
-	dataDir := flag.String("data", "", "data directory (default: auto-detect next to binary)")
-	httpAddr := flag.String("webui", "", "webui listen address (default: webui.listen_addr from config)")
-	cliSocket := flag.String("socket", "", "cli unix socket path (default: <data>/cli.sock)")
-	role := flag.String("role", "agent", "process role: guard (父守护) | agent (工作进程)")
-	boot := flag.String("boot", "normal", "agent boot mode: normal | failback (受限启动，仅 failback 插件集)")
-	flag.Parse()
+	opt := parseFlags()
 
 	// 父守护模式：只负责拉起/守护 worker，不初始化 agent 内核
-	if *role == "guard" {
-		runGuard(resolveDataDir(*dataDir))
+	if opt.role == "guard" {
+		runGuard(resolveDataDir(opt.dataDir))
 		return
 	}
 
-	log.Printf("[homed] role=agent boot=%s", *boot)
+	log.Printf("[homed] role=agent boot=%s", opt.boot)
 
-	if *dataDir == "" {
-		*dataDir = resolveDataDir(*dataDir)
+	if opt.dataDir == "" {
+		opt.dataDir = resolveDataDir(opt.dataDir)
 	}
 
-	if *cliSocket == "" {
-		*cliSocket = filepath.Join(*dataDir, "cli.sock")
+	if opt.cliSocket == "" {
+		opt.cliSocket = filepath.Join(opt.dataDir, "cli.sock")
 	}
 
-	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
-
-	// 文件日志：同时输出到控制台和 data/log/ 目录
-	logDir := filepath.Join(*dataDir, "log")
-	if err := os.MkdirAll(logDir, 0755); err != nil {
-		log.Printf("[homed] warning: cannot create log dir: %v", err)
-	} else {
-		logPath := filepath.Join(logDir, fmt.Sprintf("homed_%s.log", time.Now().Format("2006-01-02_15-04-05")))
-		logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
-		if err != nil {
-			log.Printf("[homed] warning: cannot open log file: %v", err)
-		} else {
-			log.SetOutput(io.MultiWriter(os.Stderr, logFile))
-			log.Printf("[homed] logging to %s", logPath)
-		}
-	}
+	logDir := setupLogging(opt.dataDir)
 
 	log.Printf("[homed] starting %s", meta.FullVersion())
 
-	agentWorkDir := filepath.Join(*dataDir, "agentfs")
-	dirs := []string{
-		*dataDir,
-		filepath.Join(*dataDir, "snapshots"),
-		filepath.Join(*dataDir, "plugins"),
-		filepath.Join(*dataDir, "changesets"),
-		filepath.Join(*dataDir, "memory"),
-		filepath.Join(*dataDir, "memory", "raw"),
-		filepath.Join(*dataDir, "adapters"),
-		agentWorkDir,
-	}
-	for _, d := range dirs {
-		if err := os.MkdirAll(d, 0755); err != nil {
-			log.Fatalf("create dir %s: %v", d, err)
-		}
-	}
+	agentWorkDir := ensureDataDirs(opt.dataDir)
 
-	// ========================================================================
-	// 基础设施层：记忆、技能
-	// ========================================================================
+	// ---- 基础设施层：记忆、技能 ----
 
-	memDB, err := memory.NewGraphDB(filepath.Join(*dataDir, "memory", "graph.db"))
-	if err != nil {
-		log.Printf("[homed] warning: memory init failed: %v", err)
-		memDB = nil
-	} else {
-		log.Printf("[homed] graph memory initialized")
-	}
-	if memDB != nil {
-		defer memDB.Close()
-	}
+	mem, closeMem := initMemoryStack(opt.dataDir)
+	defer closeMem()
 
-	memIdx := memory.NewIndexer(memDB)
-	memIdx.Sync() // 启动时立即同步，避免前30分钟空窗
-	socialStore := social.New(memDB)
+	// ---- 配置中心（SQLite 持久化，唯一配置源） ----
 
-	distiller := pipeline.NewDistiller(memDB, *dataDir, pipeline.DistillerConfig{
-		Interval:      10 * time.Minute,
-		RetentionDays: 7,
-		BatchSize:     50,
-	})
-	if memDB != nil {
-		distiller.Start()
-		defer distiller.Stop()
-	}
-
-	// ========================================================================
-	// 配置中心（SQLite 持久化，唯一配置源）
-	// ========================================================================
-
-	cfgReg := internalConfig.NewConfigRegistry(filepath.Join(*dataDir, "config.db"))
+	cfgReg := internalConfig.NewConfigRegistry(filepath.Join(opt.dataDir, "config.db"))
 	defer cfgReg.Close()
-	cfgReg.SeedDefaults(*dataDir)
+	cfgReg.SeedDefaults(opt.dataDir)
 	// LLM 配置写前留档（config_set 写 core.llm.* 前自动快照），guard 恢复用基线
-	cfgReg.SetLLMSnapshotFile(filepath.Join(*dataDir, "llm_snapshot.json"))
+	cfgReg.SetLLMSnapshotFile(filepath.Join(opt.dataDir, "llm_snapshot.json"))
 	cfg := cfgReg.ToConfig()
 
 	// 共享词嵌入：蒸馏提取（Phase 3 TransE 验证）与 Agent 上下文复用同一实例，
 	// 避免同一模型被二次加载（约 200k×300 维 ≈ 数百 MB 内存）。
 	embedder := memory.NewStaticEmbedder(strings.Split(cfgReg.GetString("core.agent.embedding_model_path", ""), ",")...)
-	distiller.SetEmbedder(embedder)
+	mem.distiller.SetEmbedder(embedder)
 
-	// ========================================================================
-	// Lua VM（LLM 协议适配）
-	// ========================================================================
+	// ---- Lua VM（LLM 协议适配） ----
 
-	luaVM := luapkg.NewVM(filepath.Join(cfg.Daemon.DataDir, "adapters"))
-	if err := luaVM.Start(); err != nil {
-		log.Printf("[homed] warning: lua vm init failed: %v", err)
-	} else {
-		defer luaVM.Stop()
-	}
+	luaVM, closeLuaVM := initLuaVM(cfg)
+	defer closeLuaVM()
 
-	// ========================================================================
-	// 守护管理（代理生命周期管理）
-	// ========================================================================
+	// ---- 守护管理（代理生命周期管理） ----
 
-	sup := supervisor.New(cfg)
-	if err := sup.Start(); err != nil {
-		log.Fatalf("start supervisor: %v", err)
-	}
+	sup := initSupervisor(cfg)
 
-	// ========================================================================
-	// 变更追踪（overlayfs）
-	// ========================================================================
+	// ---- 变更追踪（overlayfs） ----
 
-	trk := tracker.NewTracker(cfg.Daemon.DataDir, agentWorkDir,
-		tracker.WithKeepChangesets(100),
-		tracker.WithMaxChangesetAge(30*24*time.Hour),
-	)
-	if err := trk.Init(); err != nil {
-		log.Printf("[homed] warning: tracker init: %v", err)
-	} else {
-		if err := trk.Start(); err != nil {
-			log.Printf("[homed] warning: tracker mount overlay: %v (non-fatal: no overlayfs support?)", err)
-		} else {
-			log.Printf("[homed] change tracker active at %s", trk.MergeDir())
-		}
-	}
+	trk := initTracker(cfg, agentWorkDir)
 
 	// ========================================================================
 	// 内核 API：IOManager（IO 抽象层） + EventBus（事件总线）
 	// 所有插件通过这两个通道与核心交互
 	// ========================================================================
 
-	iom := agentIO.NewIOManager()
-	evBus := events.NewBus()
-	log.Printf("[homed] kernel API ready: IOManager + EventBus")
+	iom, evBus := initKernelAPI()
 
-	// ========================================================================
-	// 文本记忆 + 记忆蒸馏管线
-	// ========================================================================
+	// ---- 文本记忆 + 记忆蒸馏管线 ----
 
-	textMem := text.New(filepath.Join(cfg.Daemon.DataDir, "memory", "text"))
-	if err := textMem.Start(); err != nil {
-		log.Printf("[homed] warning: text memory start: %v", err)
-	} else {
-		defer textMem.Stop()
-		log.Printf("[homed] text memory active at %s", filepath.Join(cfg.Daemon.DataDir, "memory", "text"))
-	}
+	textMem, closeTextMem := initTextMemory(cfg)
+	defer closeTextMem()
 
 	ctx, stop := context.WithCancel(context.Background())
 	defer stop()
 
-	go func() {
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case evt, ok := <-iom.OutputChan():
-				if !ok {
-					return
-				}
-				if evt.Target == "memory" && evt.Type == "memory_candidate" {
-					source, _ := evt.Payload["source"].(string)
-					input, _ := evt.Payload["input"].(string)
-					response, _ := evt.Payload["response"].(string)
-					toolsUsed, _ := evt.Payload["tools_used"].([]string)
-					toolResults, _ := evt.Payload["tool_results"].([]interface{})
-					agentID, _ := evt.Payload["agent_id"].(string)
+	startMemoryCandidateConsumer(ctx, iom, textMem, mem.db, mem.distiller)
 
-					if input != "" && textMem != nil {
-						te := text.Event{
-							Timestamp: time.Now().Unix(),
-							Source:    source,
-							Input:     input,
-							Response:  response,
-							ToolsUsed: toolsUsed,
-							AgentID:   agentID,
-						}
-						if err := textMem.Append(te); err != nil {
-							log.Printf("[homed] text memory append: %v", err)
-						}
-					}
+	// ---- LLM Provider 管理（多源，通过 Lua 适配器协议转换） ----
 
-					if input != "" && memDB != nil {
-						distiller.Append("agent", "user", input)
-					}
-					if response != "" && memDB != nil {
-						distiller.Append("agent", "assistant", response)
-					}
+	baseAPIKey := resolveBaseAPIKey(cfg)
 
-					// 工具输出接入蒸馏管线
-					for _, tr := range toolResults {
-						if trMap, ok := tr.(map[string]interface{}); ok {
-							if text, ok := trMap["output"].(string); ok && text != "" && memDB != nil {
-								distiller.Append("agent", "tool", text)
-							}
-						}
-					}
-				}
-			}
-		}
-	}()
-
-	// ========================================================================
-	// LLM Provider 管理（多源，通过 Lua 适配器协议转换）
-	// ========================================================================
-
-	apiKey := cfg.LLM.APIKey
-	if apiKey == "" {
-		apiKey = os.Getenv("LLM_API_KEY")
-	}
-	if apiKey == "" {
-		apiKey = os.Getenv("DEEPSEEK_API_KEY")
-	}
-	baseAPIKey := apiKey
-
-	providerMgr := agentAPI.NewProviderManager()
-	adapterConcurrency := map[string]int{}
-	for _, src := range cfg.LLM.Sources {
-		if !agentAPI.IsValidSourceConfig(src.Name, src.BaseURL, src.Model, src.Adapter) {
-			log.Printf("[homed] skip invalid llm source %q (base_url=%q model=%q adapter=%q)", src.Name, src.BaseURL, src.Model, src.Adapter)
-			continue
-		}
-		key := src.APIKey
-		if key == "" {
-			key = baseAPIKey
-		}
-		luaProvider := agentAPI.NewLuaAdaptedProvider(agentAPI.BaseConfig{
-			Model:         src.Model,
-			BaseURL:       src.BaseURL,
-			APIKey:        key,
-			Temperature:   cfg.LLM.Temperature,
-			MaxTokens:     cfg.LLM.MaxTokens,
-			ContextWindow: src.ContextWindow,
-			MaxConcurrent: src.MaxConcurrent,
-			Priority:      src.Priority,
-			Vision:        src.Vision,
-			Audio:         src.Audio,
-		}, luaVM, src.Name, src.Adapter)
-		providerMgr.Register(src.Name, luaProvider)
-		if src.Adapter != "" {
-			adapterConcurrency[src.Adapter] += src.MaxConcurrent
-		}
-	}
-	luaVM.ConfigureConcurrency(adapterConcurrency)
-	if cfg.LLM.Provider != "" {
-		providerMgr.SetDefault(cfg.LLM.Provider)
-	}
+	providerMgr := initLLMProviders(cfg, luaVM, baseAPIKey)
 	provider := providerMgr.Default()
 
 	// L1 failback：受限 worker 启动即跑恢复梯子（probe→还原DNS/proxy→还原config+ReloadFromConfig→probe），
 	// 结果以退出码 exitRecovered=43 / exitRecoveryFailed=44 交回 guard，不进入主 agent 循环。
-	if *boot == "failback" {
-		runFailbackRecovery(*dataDir, cfgReg, luaVM, providerMgr, baseAPIKey)
+	if opt.boot == "failback" {
+		runFailbackRecovery(opt.dataDir, cfgReg, luaVM, providerMgr, baseAPIKey)
 	}
 
-	// ========================================================================
-	// 文档记忆 + 知识库
-	// ========================================================================
+	// ---- 文档记忆 + 知识库 ----
 
-	docStore := document.NewStore(filepath.Join(cfg.Daemon.DataDir, "memory", "documents"), memory.TokenizeWords)
-	if err := docStore.Start(); err != nil {
-		log.Printf("[homed] warning: document store: %v", err)
-	}
-	// 关停时落盘。文档记忆的内存态变更（迁移结果、访问计数等）只在 flush
-	// 里写盘，而 flush 的唯一入口是 Stop()——此前全仓无人调用它，
-	// 于是迁移结果永不落盘、每次启动白算一遍。
-	defer docStore.Stop()
+	docStore, closeDocStore := initDocStore(cfg)
+	defer closeDocStore()
 
-	// 媒体存储（内容寻址）：记忆块的内容后端。
-	// 开关默认开；关闭后全部媒体接线静默跳过，对话行为与本特性上线前一致。
-	var mediaStore *media.Store
-	if cfgReg.GetBool("core.memory.media.enabled", true) {
-		mediaDir := cfgReg.GetString("core.memory.media.dir",
-			filepath.Join(cfg.Daemon.DataDir, "memory", "media"))
-		ms, err := media.New(mediaDir)
-		if err != nil {
-			// 媒体存储开不起来不该阻止启动——它是记忆增强，不是对话必需品
-			log.Printf("[homed] warning: media store: %v（媒体记忆已禁用）", err)
-		} else {
-			mediaStore = ms
-			defer mediaStore.Close()
-			st := mediaStore.Stats()
-			log.Printf("[homed] media store active: %v 条 / %v 字节",
-				st["count"], st["total_bytes"])
-		}
-	}
+	mediaStore, closeMediaStore := initMediaStore(cfgReg, cfg)
+	defer closeMediaStore()
 
-	// 统一多模态向量空间。
-	//
-	// 核心**不**知道任何具体模型：它只按配置里的 provider 名从公共注册表
-	// （pkg/embedding）打开一个 provider，并把 options.* 原样交给它。模型文件
-	// 布局、预处理、解码、运行时全部属于 provider 内部实现。
-	// provider 名为空时禁用多模态向量检索，退回纯 fastText 文本路径。
-	var multimodalSpace vector.MultimodalEmbedder
-	// 这两个值只用于状态报告（healthcheck_kernel 的 onnx 段）：
-	// 「配了哪个 provider」与「为什么没启用」，避免只能看到 false 却不知原因。
-	var mmProviderName, mmErr string
-	if mmProvider := cfgReg.GetString("core.memory.multimodal_space.provider", ""); mmProvider != "" {
-		mmProviderName = mmProvider
-		opts := map[string]string{}
-		const optPrefix = "core.memory.multimodal_space.options."
-		for _, key := range cfgReg.List("core.memory.multimodal_space.options.") {
-			opts[strings.TrimPrefix(key, optPrefix)] = cfgReg.GetString(key, "")
-		}
-		provider, err := embedding.Open(mmProvider, embedding.Config{Options: opts})
-		if err != nil {
-			mmErr = err.Error()
-			log.Printf("[homed] warning: 多模态向量 provider %q 打开失败: %v（多模态向量检索已禁用；已注册: %s）",
-				mmProvider, err, strings.Join(embedding.Names(), ", "))
-		} else if adapted, err := vector.AdaptProvider(provider); err != nil {
-			provider.Close()
-			mmErr = err.Error()
-			log.Printf("[homed] warning: 多模态向量 provider %q 元数据不合法: %v（多模态向量检索已禁用）", mmProvider, err)
-		} else {
-			multimodalSpace = adapted
-			defer adapted.Close()
-			info := provider.Info()
-			// 指纹可能很长（模型文件哈希），日志里只取前 12 个字符便于对照。
-			shortFP := info.Fingerprint
-			if len(shortFP) > 12 {
-				shortFP = shortFP[:12]
-			}
-			log.Printf("[homed] multimodal space active: provider=%s dim=%d fp=%s modalities=%v",
-				mmProvider, info.Dimension, shortFP, info.Modalities)
-		}
-	}
+	multimodalSpace, mmProviderName, mmErr, closeMultimodal := initMultimodalSpace(cfgReg)
+	defer closeMultimodal()
 
-	ks := knowledge.NewStore(filepath.Join(cfg.Daemon.DataDir, "knowledge"))
-	if err := ks.Start(); err != nil {
-		log.Printf("[homed] warning: knowledge store: %v", err)
-	} else {
-		log.Printf("[homed] knowledge store active with %d items", len(ks.List()))
-	}
+	ks := initKnowledgeStore(cfg)
 
-	// ========================================================================
-	// 人格设定
-	// ========================================================================
+	// ---- 人格设定 ----
 
-	// 人格来源优先级：personal/personal.md（高级覆盖，存在且非空才生效）
-	// > 配置项 core.agent.personal_prompt（默认模板 = config.DefaultPersonaPrompt）。
-	//
-	// 曾经只有「文件」一个来源且无人维护，导致人格卡写死旧版本号与已删除的 C ABI、
-	// 反过来让实例自称旧版本（v1.2.0 压测发现）。故：
-	//   - 配置项化 + 内置默认模板（不含版本号字面量）
-	//   - 文件仍在时生效，但扫到腐坏内容就在启动日志里明确告警
-	personalPath := filepath.Join(cfg.Daemon.DataDir, "personal", "personal.md")
-	personality, err := agentPkg.LoadPersonality(personalPath)
-	if err != nil {
-		log.Printf("[homed] warning: load personality: %v", err)
-	}
-	if personality != nil && personality.Content != "" {
-		log.Printf("[homed] 人格来源=文件 %s（优先于配置项），%d 字节", personalPath, len(personality.Content))
-		if hints := agentPkg.PersonaStaleHints(personality.Content); len(hints) > 0 {
-			log.Printf("[homed] warning: 人格文件含会腐坏的内容 %v — 建议迁到配置项 core.agent.personal_prompt"+
-				"（默认模板不含版本号，被问版本时以运行时快照为准）", hints)
-		}
-	} else if pv := cfgReg.GetString("core.agent.personal_prompt", internalConfig.DefaultPersonaPrompt); strings.TrimSpace(pv) != "" {
-		personality = &agentPkg.Personality{Content: pv, Path: "(core.agent.personal_prompt)"}
-		log.Printf("[homed] 人格来源=配置项 core.agent.personal_prompt，%d 字节", len(pv))
-	} else {
-		log.Printf("[homed] 人格来源=无（配置项为空且无人格文件）")
-	}
+	personality := loadPersonality(cfg, cfgReg)
 
-	// ========================================================================
-	// 阶段管道（StageHost）+ 插件系统（Registry）
-	// ========================================================================
+	// ---- 阶段管道（StageHost）+ 插件系统（Registry） ----
 
-	stageHost := agentCore.NewStageHost()
+	stageHost, pluginReg := newStageAndRegistry(cfg, cfgReg, iom, evBus, mem.db, textMem,
+		docStore, mediaStore, ks, providerMgr, opt.dataDir)
 
-	pluginReg := plugin.NewRegistry()
-	pluginReg.SetIOManager(iom)
-	pluginReg.SetEventBus(evBus)
-	pluginReg.SetMemory(memDB)
-	pluginReg.SetTextMemory(textMem)
-	pluginReg.SetDocStore(docStore)
-	pluginReg.SetMediaStore(mediaStore) // 插件写入的记忆也走媒体链路；nil 时静默降级
-	pluginReg.SetKnowledge(ks)
-	pluginReg.SetProviderManager(providerMgr)
-	pluginReg.SetConfigRegistry(cfgReg)
-	pluginReg.SetPluginDir(cfg.Plugin.Dir)
-	pluginReg.SetDataDir(*dataDir) // 插件 SettingsAPI.DataDir() 的数据根目录
+	// ---- Agent Core (需在插件加载前创建，因为插件 Configure 需要 StatusProvider) ----
 
-	// Wire registration callbacks: plugins' RegisterTool/RegisterStage → StageHost
-	pluginReg.SetToolRegistrar(func(name string, def sdk.ToolDef, handler sdk.ToolHandler) error {
-		log.Printf("[homed] SetToolRegistrar registering tool: %s (plugin=%s)", name, def.Plugin)
-		return stageHost.RegisterTool(name, def, handler)
-	})
-	pluginReg.SetStageRegistrar(func(stage sdk.Stage, handler sdk.StageHandler) {
-		stageHost.RegisterStage(stage, handler)
-	})
-	pluginReg.SetAPIRegistrar(func(name string) error {
-		return nil
-	})
-	pluginReg.SetToolCleaner(stageHost)
+	agent := newMainAgent(cfg, cfgReg, provider, providerMgr, iom, mem.db, mem.indexer, trk,
+		docStore, ks, mem.social, textMem, mediaStore, personality, pluginReg, embedder,
+		multimodalSpace, mmProviderName, mmErr, stageHost, evBus)
 
-	// ========================================================================
-	// Agent Core (需在插件加载前创建，因为插件 Configure 需要 StatusProvider)
-	// ========================================================================
-
-	defaultPrompt := `你是 HomeAgent，一个持续运行的个人管家。
-你的每次回复会自动发送到当前输出通道（默认=输入源），无需额外工具。
-如需切换回复通道，使用 output_set_channel。
-如需异步发送消息或通知，使用 output_send 指定通道和内容。
-使用 output_list_channels 查看可用通道及其能力。
-
-可用工具列表会由系统自动传入，按需使用即可。以下是你尤其需要关注的几类工具：
-- memory_* — 图记忆（长期记忆，记录和查询个人信息/事实）
-- knowledge_* — 知识库（查阅预设知识文档）
-- doc_* — 文档记忆（近期对话的存档，查询后自动清除）
-- person_* — 人物特质与社交关系网
-- llm_* — LLM 源管理（列出/切换模型提供商）
-- output_* — 输出通道管理（切换/发送消息）
-- timer_set — 设置定时提醒
-- plgreload — 热重载插件
-- spawn_child — 生成子 Agent 异步执行独立任务（可传 max_turns 控制工具轮数，默认 5）
-
-并行策略：遇到多个互不依赖的子任务时，优先并行 spawn 多个子 Agent 而非自己串行逐个执行；
-长耗时任务（批量处理、多轮搜索汇总）也应交给子 Agent，避免阻塞当前对话。
-- describe_image — 描述用户上传的图片
-- transcribe_audio — 转写用户上传的音频
-- ocr_image — 识别图片中的文字
-
-命令与文件操作策略：
-- cmd_run 经完整 shell（bash）执行，支持管道、分号、&&、命令替换、heredoc、重定向。
-- 多步交互式程序（vim/top/ssh 会话、需要持续输入的进程）用 terminal_create 创建终端，
-  terminal_write 发送输入、terminal_read 读输出——不要用 cmd_run 硬等交互程序退出。
-- 写文件优先 files_write（原子+留档），生成多行内容时可用 heredoc 或 files_write，
-  不要用 echo 拼接长文本。
-- 读用户发来的文件用 files_read；向 webui 回传图片/文件用 output_send__webui(type=image/file)。
-
-当用户上传图片或音频时，系统会自动附着媒体内容。如果模型不支持直接处理多媒体，请使用上述工具。
-
-回复你的真实想法，用自然语言与用户交流。不要在回复中使用 emoji 表情。`
-	sysPrompt := cfgReg.GetString("core.agent.system_prompt", defaultPrompt)
-	if sysPrompt == "" {
-		sysPrompt = defaultPrompt
-	}
-
-	agent := agentCore.New(agentCore.AgentConfig{
-		ID:              "main",
-		SystemPrompt:    sysPrompt,
-		Provider:        provider,
-		ProviderManager: providerMgr,
-		IO:              iom,
-		Memory:          memDB,
-		Indexer:         memIdx,
-		Tracker:         trk,
-		DocStore:        docStore,
-		Knowledge:       ks,
-		SocialStore:     socialStore,
-		TextMemory:      textMem,
-		MediaStore:      mediaStore,
-		Personality:     personality,
-		// 人格落库面：首启门禁（任何通道都问一次）与 persona_set 工具用。
-		// 与 WebUI 向导共用 internal/config 的同一份落库逻辑。
-		PersonaStore:       internalConfig.RegistryPersonaStore{Reg: cfgReg},
-		PluginReg:          pluginReg,
-		PluginDir:          cfg.Plugin.Dir,
-		DistillInterval:    cfgReg.GetDuration("core.agent.distill_interval", 30*time.Minute),
-		ArchiveInterval:    cfgReg.GetDuration("core.agent.archive_interval", 60*time.Minute),
-		ReviewInterval:     cfgReg.GetDuration("core.agent.review_interval", 120*time.Minute),
-		MergeInterval:      cfgReg.GetDuration("core.agent.merge_interval", 120*time.Minute),
-		ContextSavePath:    filepath.Join(cfg.Daemon.DataDir, "memory", "context.json"),
-		EmbeddingModelPath: cfgReg.GetString("core.agent.embedding_model_path", ""),
-		Embedder:           embedder,
-		MultimodalSpace:    multimodalSpace,
-		EmbeddingProvider:  mmProviderName,
-		EmbeddingError:     mmErr,
-		StageHost:          stageHost,
-		EventBus:           evBus,
-		ThinkingEnabled:    cfg.LLM.ThinkingEnabled,
-		InputProcessing:    cfg.InputProcessing,
-	})
-
-	// 通过 Registry 将内核依赖注入每个插件的 PluginSDK（阶段6 将替换遗留的 util.Configure）
-	pluginReg.SetLuaVM(luaVM)
-	pluginReg.SetBaseAPIKey(baseAPIKey)
-	pluginReg.SetSupervisor(supervisor.NewSDKAdapter(sup))
-	pluginReg.SetTracker(trk)
-	pluginReg.SetConfig(cfg)
-	pluginReg.SetStageHost(stageHost)
-	pluginReg.SetIndexer(memIdx)
-	pluginReg.SetStatusProvider(agent)
+	wirePluginSDK(pluginReg, luaVM, baseAPIKey, sup, trk, cfg, stageHost, mem.indexer, agent)
 
 	// 为内置插件注入内核依赖（各插件通过 init() 自注册工厂）
-	cli.DefaultSocket = *cliSocket
-	// webui 插件作为内置插件经 Registry 启动，读取自身 settings["addr"]（默认 :8080）。
-	// 保留 CLI --webui 与 webui.listen_addr 配置对监听地址的覆盖。
-	webuiListenAddr := *httpAddr
-	if webuiListenAddr == "" {
-		webuiListenAddr = cfgReg.GetString("webui.listen_addr", ":8080")
-	}
-	if ps := cfgReg.PluginConfig("webui"); ps != nil {
-		if v, _ := ps.Get("addr"); v == nil {
-			_ = ps.Set("addr", webuiListenAddr)
-		}
-	}
+	cli.DefaultSocket = opt.cliSocket
+	// webui 监听地址覆盖：必须在 loadPlugins 之前设置，插件 Start 时会读它。
+	webui.SetListenOverride(resolveWebUIOverride(cfgReg, opt.httpAddr))
 
-	// ========================================================================
-	// 依存句法分析器（内嵌 ONNX 模型 / 规则引擎）
-	// ========================================================================
+	// ---- 依存句法分析器（内嵌 ONNX 模型 / 规则引擎） ----
 
-	modelPath := cfgReg.GetString("core.agent.onnx_model_path", "")
-	onnxParser, err := nlp.NewONNXParser(nlp.ONNXConfig{
-		ModelPath: modelPath,
-		DataDir:   filepath.Join(cfg.Daemon.DataDir, "nlp"),
-	})
-	if err != nil {
-		log.Printf("[homed] warn: ONNX parser init: %v, using fallback", err)
-	} else {
-		nlp.SetDefaultParser(onnxParser)
-		log.Printf("[homed] dep parser initialized (model: %s)", modelPath)
-	}
+	initONNXParser(cfg, cfgReg)
 
-	// Auto-create plugins directory (without hardcoding plugin names)
-	os.MkdirAll(cfg.Plugin.Dir, 0755)
+	loadPlugins(cfg, cfgReg, pluginReg, stageHost, opt.boot, opt.dataDir)
 
-	// failback 受限启动：仅装载 failback 插件集（webfetch/files/cmd 为内核内置，
-	// 此处仅控制外部插件，默认含 recoverydiag 以便直接在受限态产出恢复结论）
-	if *boot == "failback" {
-		list := cfgReg.GetString("core.agent.failback_plugins", "webui,pluginmgr,recoverydiag")
-		// 优先使用 guard.yaml 经过 recovery 任务下发的插件集（guard 是 failback 权威）
-		if task, terr := recovery.LoadTask(recovery.TaskPath(*dataDir)); terr == nil && len(task.Plugins()) > 0 {
-			list = strings.Join(task.Plugins(), ",")
-		}
-		var names []string
-		for _, s := range strings.Split(list, ",") {
-			if s = strings.TrimSpace(s); s != "" {
-				names = append(names, s)
-			}
-		}
-		pluginReg.SetLoadAllowlist(names)
-		log.Printf("[homed] failback boot: plugin allowlist = %v", names)
-	}
+	// 插件加载完成后再回收空闲页：大值（如老版聊天记录）可能在这一步被搬走/删除，
+	// 而 SQLite 的 DELETE 不会缩小文件。
+	compactConfigDB(cfgReg)
 
-	// Load all plugins — each scans its own dir and is loaded via factory or .so
-	if err := pluginReg.Load(cfg.Plugin.Dir); err != nil {
-		log.Printf("[homed] warning: load plugins: %v", err)
-	}
-	log.Printf("[homed] stage host ready with %d registered tools", stageHost.ToolCount())
+	stopRuntime := startAgentRuntime(cfgReg, pluginReg, agent, logDir, ctx)
+	defer stopRuntime()
 
-	// 技能索引接线：skillmgr 插件实现 SkillIndexProvider 时注入 agent（方案B prompt 注入）
-	if sp := pluginReg.Get("skillmgr"); sp != nil {
-		if prov, ok := sp.(agentCore.SkillIndexProvider); ok {
-			agent.SetSkillIndexProvider(prov)
-			log.Printf("[homed] skill index wired from skillmgr plugin")
-		}
-	}
+	_, closeIPC := startIPCServer(opt.dataDir, opt.boot, agent)
+	defer closeIPC()
 
-	// 日志管理：层级压缩 + 保留策略
-	logManager := logpkg.NewManager(logDir, cfgReg)
-	go logManager.Start(ctx)
-	defer logManager.Stop()
-
-	agent.Start()
-	defer agent.Stop()
-
-	// PING/ACK 心跳服务：worker 监听 unix socket，guard 发 PING、worker 回 ACK
-	// （含自诊断 kernel 状态快照），替换纯文件心跳。文件心跳保留作回退。
-	ipcServer := ipc.NewServer(*dataDir, func() *ipc.Status {
-		st := agent.GetKernelStatus()
-		llmOK := st != nil && st.LLM.Available
-		tools := 0
-		if st != nil {
-			tools = len(st.Tools)
-		}
-		uptime := int64(0)
-		if st != nil {
-			if d, err := time.ParseDuration(st.Uptime); err == nil {
-				uptime = int64(d.Seconds())
-			}
-		}
-		return &ipc.Status{
-			PID:       os.Getpid(),
-			Boot:      *boot,
-			UptimeSec: uptime,
-			LLMOK:     &llmOK,
-			Tools:     tools,
-			LastDiag:  lastDiagSummary(*dataDir),
-		}
-	})
-	if err := ipcServer.Start(); err != nil {
-		log.Printf("[homed] warning: ipc heartbeat server: %v", err)
-	} else {
-		defer ipcServer.Stop()
-	}
-
-	sup.SetTracker(trk)
-	sup.RegisterAgent("main")
-
-	// 真实存活源 + 重启通道：daemon 心跳语义由此修正（lastHB 只在确认存活时更新），
-	// 重启动作不再空转——清理后以特殊退出码交给 guard/systemd 重建。
-	restartCh := make(chan struct{}, 1)
-	sup.SetHeartbeatSource(func(id types.AgentID) (time.Time, types.HealthStatus, error) {
-		st := agent.GetKernelStatus()
-		if st == nil {
-			return time.Time{}, types.HealthDown, fmt.Errorf("no kernel status")
-		}
-		h := types.HealthHealthy
-		if !st.LLM.Available {
-			h = types.HealthDegraded
-		}
-		return time.Now(), h, nil
-	})
-	sup.SetRestartHandler(func(id types.AgentID) {
-		select {
-		case restartCh <- struct{}{}:
-		default:
-		}
-	})
+	restartCh := startSupervisorRuntime(sup, trk, agent)
 
 	log.Printf("[homed] main agent started, model=%s base=%s sources=%d adapters=%d",
 		cfg.LLM.Model, cfg.LLM.BaseURL, len(cfg.LLM.Sources), len(luaVM.ListAdapters()))
 	log.Printf("[homed] kernel ready, waiting for plugin IO...")
 
-	// ========================================================================
-	// 等待退出信号
-	// ========================================================================
+	// ---- 等待退出信号 ----
 
-	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
-
-	// 心跳：每 5s 触碰 <data>/heartbeat，guard 据此判定工作进程是否存活/卡死
-	hbPath := filepath.Join(*dataDir, "heartbeat")
-	hbStop := make(chan struct{})
-	go func() {
-		t := time.NewTicker(5 * time.Second)
-		defer t.Stop()
-		writeHB := func() {
-			if f, err := os.OpenFile(hbPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644); err == nil {
-				fmt.Fprintf(f, "t=%d\n", time.Now().Unix())
-				f.Close()
-			}
-		}
-		writeHB()
-		for {
-			select {
-			case <-t.C:
-				writeHB()
-			case <-hbStop:
-				return
-			case <-ctx.Done():
-				return
-			}
-		}
-	}()
-
-	restartRequested := false
-	select {
-	case <-sigCh:
-		log.Printf("[homed] shutting down...")
-	case <-restartCh:
-		restartRequested = true
-		log.Printf("[homed] restart requested, shutting down cleanly then exiting with code %d", exitRestartRequested)
-	}
-
-	close(hbStop)
-	pluginReg.StopAll()
-	if trk != nil {
-		trk.Stop()
-	}
-	if err := cfgReg.Flush(); err != nil {
-		log.Printf("[homed] flush config: %v", err)
-	}
-	sup.Shutdown()
-	log.Printf("[homed] stopped")
-
-	if restartRequested {
-		os.Exit(exitRestartRequested)
-	}
+	stopHeartbeat := startHeartbeat(opt.dataDir, ctx)
+	waitForShutdown(ctx, opt.dataDir, restartCh, stopHeartbeat, pluginReg, trk, cfgReg, sup)
 }

cmd/ohos/HomeAgent/AppScope/app.json5

@@ -2,8 +2,8 @@
   "app": {
     "bundleName": "com.example.homeagent",
     "vendor": "HomeAgent",
-    "versionCode": 1000000,
-    "versionName": "1.0.0",
+    "versionCode": 1001001,
+    "versionName": "1.1.1",
     // 分层图标：前景是字形，背景（沉淀色）在 base/ 与 dark/ 各一份，随系统主题切换。
     // 直接指向位图会把浅色底烧进图标，深色模式下桌面和启动页都会跳脱。
     "icon": "$media:layered_image",

cmd/ohos/HomeAgent/entry/src/main/ets/common/ApiClient.ets

@@ -32,6 +32,10 @@ export class ApiClient {
     this.conn = conn;
   }
 
+  clearConnection(): void {
+    this.conn = null;
+  }
+
   getConnection(): ConnectionConfig | null {
     return this.conn;
   }

cmd/ohos/HomeAgent/entry/src/main/ets/common/AttachmentImage.ets

@@ -0,0 +1,37 @@
+/**
+ * 附件的字节获取与解码（网络 / 沙箱 I/O）。
+ *
+ * 字节走 GET <base>/files/<name> 或 /uploads/<name>（注意不带 /api/v1 前缀）。
+ * 这两条路由在后端是 requireWeb，但对 API Key 客户端同等放行，
+ * 所以带上和普通接口一样的鉴权头即可，无需 web 登录态。
+ *
+ * 从 components/Attachment.ets 抽出：缩略图与详情大图都走同一条解码路径。
+ */
+
+import { image } from '@kit.ImageKit';
+import { fileIo } from '@kit.CoreFileKit';
+import { apiClient } from './ApiClient';
+
+/** 下载并解码成 PixelMap；任何一步失败都返回 undefined（调用方显示占位）。 */
+export async function loadPixelMap(url: string): Promise<image.PixelMap | undefined> {
+  try {
+    // 本地待上传的图片：直接读沙箱文件，不走网络
+    if (url.startsWith('file://')) {
+      const path: string = url.substring(7);
+      const f = fileIo.openSync(path, fileIo.OpenMode.READ_ONLY);
+      const localSrc: image.ImageSource = image.createImageSource(f.fd);
+      const localPm: image.PixelMap = await localSrc.createPixelMap();
+      await localSrc.release();
+      fileIo.closeSync(f);
+      return localPm;
+    }
+    const abs: string = apiClient.absoluteUrl(url);
+    const resp = await apiClient.getBinary(abs, 15000);
+    const src: image.ImageSource = image.createImageSource(resp.data);
+    const pm: image.PixelMap = await src.createPixelMap();
+    await src.release();
+    return pm;
+  } catch (e) {
+    return undefined;
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/AttachmentMeta.ets

@@ -0,0 +1,103 @@
+/**
+ * 附件的解析与格式化（纯函数，无 UI、无平台 I/O）。
+ *
+ * 后端 Attachment 只有四个字段：type / url / size / name
+ * （internal/plugins/webui/handler.go），没有 mime、没有像素尺寸、没有本地路径。
+ * 所以详情页里的"尺寸/格式"必须由客户端自己解码得出，不能假装后端给了。
+ *
+ * 从 components/Attachment.ets 抽出：附件卡与附件详情都要用这几个函数，
+ * 放在 common 里两边共用，也不必让 UI 文件承担这段纯逻辑。
+ */
+
+import { ChatAttachment } from '../model/Model';
+
+/** 从后端 JSON 里解析 attachment 字段；缺字段或类型不对则返回 undefined。 */
+export function parseAttachment(raw: Object | undefined): ChatAttachment | undefined {
+  if (raw === undefined || raw === null) {
+    return undefined;
+  }
+  const o: Record<string, Object> = raw as Record<string, Object>;
+  const url: string = o['url'] as string ?? '';
+  if (url.length === 0) {
+    return undefined;
+  }
+  const t: string = o['type'] as string ?? 'file';
+  const a: ChatAttachment = {
+    type: t === 'image' ? 'image' : 'file',
+    url: url,
+    size: o['size'] as number ?? 0,
+    name: o['name'] as string ?? fileNameOf(url),
+  };
+  return a;
+}
+
+/** 由 SSE channel_output 事件构造附件（字段名与 history 不同）。 */
+export function attachmentFromChannelOutput(
+  outputType: string, url: string, size: number): ChatAttachment | undefined {
+  if (url.length === 0) {
+    return undefined;
+  }
+  if (outputType !== 'image' && outputType !== 'file') {
+    return undefined;
+  }
+  const a: ChatAttachment = {
+    type: outputType,
+    url: url,
+    size: size,
+    name: fileNameOf(url),
+  };
+  return a;
+}
+
+/** 取 URL 最后一段作为展示文件名，与后端 handler.go 的取名方式一致。 */
+export function fileNameOf(url: string): string {
+  let s: string = url;
+  const q: number = s.indexOf('?');
+  if (q >= 0) {
+    s = s.substring(0, q);
+  }
+  const i: number = s.lastIndexOf('/');
+  const name: string = i >= 0 ? s.substring(i + 1) : s;
+  return name.length > 0 ? name : '附件';
+}
+
+/** 人类可读字节数，口径对齐后端 formatBytes（KB 以上保留一位小数）。 */
+export function formatBytes(n: number): string {
+  if (n <= 0) {
+    return '';
+  }
+  if (n < 1024) {
+    return n.toString() + ' B';
+  }
+  const kb: number = n / 1024;
+  if (kb < 1024) {
+    return oneDecimal(kb) + ' KB';
+  }
+  const mb: number = kb / 1024;
+  if (mb < 1024) {
+    return oneDecimal(mb) + ' MB';
+  }
+  return oneDecimal(mb / 1024) + ' GB';
+}
+
+function oneDecimal(v: number): string {
+  return (Math.round(v * 10) / 10).toString();
+}
+
+/** 由文件名后缀猜测类型标签。后端不返回 mime，只能这样标注。 */
+export function extLabel(name: string): string {
+  const i: number = name.lastIndexOf('.');
+  if (i < 0 || i === name.length - 1) {
+    return '未知类型';
+  }
+  return name.substring(i + 1).toUpperCase();
+}
+
+/** 去掉路径分隔符，避免附件名把文件写到 filesDir 之外。 */
+export function sanitize(name: string): string {
+  let s: string = name.replace(/[\/\\:*?"<>|]/g, '_');
+  if (s.length === 0) {
+    s = 'attachment';
+  }
+  return s;
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/BridgeCaps.ets

@@ -4,16 +4,63 @@ import { pasteboard } from '@kit.BasicServicesKit';
 import { deviceInfo } from '@kit.BasicServicesKit';
 import { textToSpeech } from '@kit.CoreSpeechKit';
 import { componentSnapshot } from '@kit.ArkUI';
-import { common } from '@kit.AbilityKit';
+import { abilityAccessCtrl, common, PermissionRequestResult, Permissions } from '@kit.AbilityKit';
 
 // ===== 能力结果 =====
 
+/** 与 BridgeRouter 实际支持的本机命令保持一一对应。 */
+export const LOCAL_DEVICE_CAPS: string[] = [
+  'status',
+  'deviceinfo',
+  'screensee',
+  'screensue',
+  'clipboardsee',
+  'clipboardsue',
+  'speakeruse',
+];
+
 export interface CapResult {
   status: string; // 'ok' | 'error'
   output: string;
   error: string;
 }
 
+interface DeviceStatusPayload {
+  device_id: string;
+  status: string;
+  hostname: string;
+  platform: string;
+  arch: string;
+  uptime: number;
+}
+
+interface DeviceDetails {
+  hostname: string;
+  platform: string;
+  arch: string;
+  os_release: string;
+  version: string;
+  cpus: number;
+  brand: string;
+  manufacturer: string;
+  model: string;
+  series: string;
+  sdk_api_version: number;
+  security_patch: string;
+  abi_list: string;
+  device_type: string;
+}
+
+interface DeviceInfoPayload {
+  device_id: string;
+  name: string;
+  kind: string;
+  caps: string[];
+  info: DeviceDetails;
+}
+
+const APP_STARTED_AT: number = Date.now();
+
 function okResult(output: string): CapResult {
   const r: CapResult = { status: 'ok', output: output, error: '' };
   return r;
@@ -44,53 +91,79 @@ async function captureScreenPixelMap(): Promise<image.PixelMap> {
  * 此处回传应用自身前台画面；应用在前台运行时即为用户正在看到的界面。
  */
 export async function capScreensee(): Promise<CapResult> {
+  let full: image.PixelMap | null = null;
+  let packer: image.ImagePacker | null = null;
   try {
-    const full: image.PixelMap = await captureScreenPixelMap();
+    full = await captureScreenPixelMap();
     const info: image.ImageInfo = await full.getImageInfo();
-    const maxW: number = 720;
-    let targetW: number = info.size.width;
-    let targetH: number = info.size.height;
-    if (targetW > maxW) {
-      targetH = Math.floor(targetH * maxW / targetW);
-      targetW = maxW;
+    const maxW: number = 420;
+    const maxH: number = 640;
+    let scale: number = 1;
+    if (info.size.width > maxW) {
+      scale = maxW / info.size.width;
     }
-    let packed: ArrayBuffer;
-    if (targetW !== info.size.width) {
-      await full.scale(targetW / info.size.width, targetH / info.size.height);
+    if (info.size.height * scale > maxH) {
+      scale = maxH / info.size.height;
     }
-    const packer: image.ImagePacker = image.createImagePacker();
-    const opt: image.PackingOption = { format: 'image/jpeg', quality: 70 };
-    packed = await packer.packing(full, opt);
-    packer.release();
-    full.release();
+    if (scale < 1) {
+      await full.scale(scale, scale);
+    }
+    packer = image.createImagePacker();
+    const opt: image.PackingOption = { format: 'image/jpeg', quality: 55 };
+    const packed: ArrayBuffer = await packer.packing(full, opt);
     const helper: util.Base64Helper = new util.Base64Helper();
     const b64: string = helper.encodeToStringSync(new Uint8Array(packed));
+    if (b64.length > 950000) {
+      return errResult('当前画面数据过大，请稍后重试');
+    }
     return okResult('data:image/jpeg;base64,' + b64);
   } catch (e) {
-    const msg: string = e instanceof Error ? e.message : String(e);
-    return errResult('screensee failed: ' + msg);
+    return errResult('无法读取当前应用画面，请保持应用在前台后重试');
+  } finally {
+    if (packer !== null) {
+      packer.release();
+    }
+    if (full !== null) {
+      full.release();
+    }
   }
 }
 
 // ===== clipboardsee / clipboardsue =====
 
+const CLIPBOARD_PERMISSIONS: Array<Permissions> = ['ohos.permission.READ_PASTEBOARD'];
+
+/**
+ * READ_PASTEBOARD 是 user_grant 权限：仅在 agent 真正请求 clipboardsee 时弹出系统授权，
+ * 不在应用启动时抢先索权。已授权时系统会直接返回，不会重复打扰用户。
+ */
+async function ensureClipboardPermission(context: common.UIAbilityContext): Promise<boolean> {
+  try {
+    const atManager = abilityAccessCtrl.createAtManager();
+    const result: PermissionRequestResult =
+      await atManager.requestPermissionsFromUser(context, CLIPBOARD_PERMISSIONS);
+    return result.authResults.length > 0 && result.authResults[0] === 0;
+  } catch (e) {
+    return false;
+  }
+}
+
 export async function capClipboardSee(context: common.UIAbilityContext): Promise<CapResult> {
-  // 说明：READ_PASTEBOARD 为受限权限，调试签名无法在真机安装时授予，
-  // 这里直接尝试读取；系统拒绝时回错误信息。
+  const granted: boolean = await ensureClipboardPermission(context);
+  if (!granted) {
+    return errResult('剪贴板读取权限未授予，请在系统设置中允许后重试');
+  }
   try {
     const clip: pasteboard.SystemPasteboard = pasteboard.getSystemPasteboard();
     const has: boolean = await clip.hasData();
     if (!has) {
-      const empty: CapResult = { status: 'ok', output: '', error: '' };
-      return empty;
+      return okResult('');
     }
     const data: pasteboard.PasteData = await clip.getData();
     const txt: string = data.getPrimaryText();
-    const out: CapResult = { status: 'ok', output: txt ?? '', error: '' };
-    return out;
+    return okResult(txt ?? '');
   } catch (e) {
-    const msg: string = e instanceof Error ? e.message : String(e);
-    return errResult('clipboardsee failed (需系统剪贴板授权): ' + msg);
+    return errResult('剪贴板读取失败，请确认应用在前台并已获得系统授权');
   }
 }
 
@@ -99,10 +172,9 @@ export async function capClipboardsue(text: string): Promise<CapResult> {
     const clip: pasteboard.SystemPasteboard = pasteboard.getSystemPasteboard();
     const data: pasteboard.PasteData = pasteboard.createData(pasteboard.MIMETYPE_TEXT_PLAIN, text);
     await clip.setPasteData(data);
-    return okResult('written ' + text.length + ' chars');
+    return okResult('clipboard written');
   } catch (e) {
-    const msg: string = e instanceof Error ? e.message : String(e);
-    return errResult('clipboardsue failed: ' + msg);
+    return errResult('剪贴板写入失败，请保持应用在前台后重试');
   }
 }
 
@@ -112,13 +184,11 @@ class TtsSession {
   private engine: textToSpeech.TextToSpeechEngine | null = null;
 
   async speak(text: string): Promise<CapResult> {
+    if (text.length > 4000) {
+      return errResult('朗读内容过长，请缩短到 4000 字以内');
+    }
     try {
       if (this.engine === null) {
-        const extra: Record<string, Object> = {
-          'style': 'interaction-broadcast',
-          'locate': 'CN',
-          'name': 'EngineName',
-        };
         const params: textToSpeech.CreateEngineParams = {
           language: 'zh-CN',
           person: 0,
@@ -133,8 +203,7 @@ class TtsSession {
       this.engine.speak(text, sp);
       return okResult('speaking');
     } catch (e) {
-      const msg: string = e instanceof Error ? e.message : String(e);
-      return errResult('speakeruse failed: ' + msg);
+      return errResult('语音服务暂时不可用，请稍后重试');
     }
   }
 
@@ -156,20 +225,49 @@ export async function capSpeakerUse(text: string): Promise<CapResult> {
   return ttsSession.speak(text);
 }
 
-// ===== deviceinfo =====
+export function shutdownSpeakerUse(): void {
+  ttsSession.shutdown();
+}
 
-export function capDeviceInfo(): CapResult {
-  const lines: string[] = [];
-  lines.push('brand=' + deviceInfo.brand);
-  lines.push('manufacturer=' + deviceInfo.manufacture);
-  lines.push('model=' + deviceInfo.productModel);
-  lines.push('series=' + deviceInfo.productSeries);
-  lines.push('osFullName=' + deviceInfo.osFullName);
-  lines.push('sdkApiVersion=' + deviceInfo.sdkApiVersion.toString());
-  lines.push('securityPatch=' + deviceInfo.securityPatchTag);
-  lines.push('abiList=' + deviceInfo.abiList);
-  lines.push('deviceType=' + deviceInfo.deviceType);
-  return okResult(lines.join('\n'));
+// ===== status / deviceinfo =====
+
+export function capStatus(deviceId: string): CapResult {
+  const payload: DeviceStatusPayload = {
+    device_id: deviceId,
+    status: 'online',
+    hostname: 'ohos-phone',
+    platform: 'OpenHarmony',
+    arch: deviceInfo.abiList,
+    uptime: Math.floor((Date.now() - APP_STARTED_AT) / 1000),
+  };
+  return okResult(JSON.stringify(payload));
+}
+
+export function capDeviceInfo(deviceId: string, deviceName: string): CapResult {
+  const details: DeviceDetails = {
+    hostname: 'ohos-phone',
+    platform: 'OpenHarmony',
+    arch: deviceInfo.abiList,
+    os_release: deviceInfo.osFullName,
+    version: '1.1.1',
+    cpus: 0,
+    brand: deviceInfo.brand,
+    manufacturer: deviceInfo.manufacture,
+    model: deviceInfo.productModel,
+    series: deviceInfo.productSeries,
+    sdk_api_version: deviceInfo.sdkApiVersion,
+    security_patch: deviceInfo.securityPatchTag,
+    abi_list: deviceInfo.abiList,
+    device_type: deviceInfo.deviceType,
+  };
+  const payload: DeviceInfoPayload = {
+    device_id: deviceId,
+    name: deviceName,
+    kind: 'ohos-phone',
+    caps: LOCAL_DEVICE_CAPS,
+    info: details,
+  };
+  return okResult(JSON.stringify(payload));
 }
 
 // ===== screensue 内容解析 =====
@@ -182,14 +280,18 @@ export interface ScreensuePayload {
 
 export function parseScreensue(rawArgs: string): ScreensuePayload {
   const p: ScreensuePayload = { duration: 5, content: '' };
-  let rest: string = rawArgs.trim();
-  const tokens: string[] = rest.split(/\s+/);
-  if (tokens.length > 1 && /^\d+$/.test(tokens[0])) {
-    p.duration = parseInt(tokens[0], 10);
-    rest = tokens.slice(1).join(' ');
-  } else {
-    rest = tokens.join(' ');
+  const leadingSpaces: RegExp = new RegExp('^\\s+');
+  const firstSpace: RegExp = new RegExp('\\s');
+  let rest: string = rawArgs.replace(leadingSpaces, '');
+  const splitAt: number = rest.search(firstSpace);
+  if (splitAt > 0) {
+    const first: string = rest.substring(0, splitAt);
+    const digits: RegExp = new RegExp('^\\d+$');
+    if (digits.test(first)) {
+      p.duration = Math.min(parseInt(first, 10), 86400);
+      rest = rest.substring(splitAt).replace(leadingSpaces, '');
+    }
   }
-  p.content = rest.trim();
+  p.content = rest;
   return p;
 }

cmd/ohos/HomeAgent/entry/src/main/ets/common/BridgeProtocol.ets

@@ -0,0 +1,172 @@
+/**
+ * 设备桥协议：消息结构、帧构造与分块切片。
+ *
+ * 与 homed 的 remotedevice 插件对齐（internal/plugins/remotedevice）。
+ * 从 common/DeviceBridge.ets 抽出：这里只有"协议形状"和"帧怎么拼"，
+ * 没有任何 socket、状态机与重连逻辑 —— 那些留在 DeviceBridgeClient 里。
+ *
+ * 注意：DeviceBridgeClient 的对外方法名与语义不因本文件而改变，
+ * 各 send* 方法仍是"拼帧 + 发出去"两步，只是第一步搬到了这里。
+ */
+
+import { CapResult } from './BridgeCaps';
+
+// ===== 协议消息（与 remotedevice 插件对齐）=====
+
+export interface HelloDeviceInfo {
+  hostname: string;
+  platform: string;
+  arch: string;
+  os_release: string;
+  version: string;
+  cpus: number;
+}
+
+export interface HelloDevice {
+  device_id: string;
+  name: string;
+  kind: string;
+  authorized: boolean;
+  caps: string[];
+  info: HelloDeviceInfo;
+}
+
+export interface HelloMessage {
+  op: string;
+  device: HelloDevice;
+}
+
+export interface BindMessage {
+  op: string;
+  device_id: string;
+  token: string;
+}
+
+export interface CmdReply {
+  op: string; // 'cmd_result'
+  req_id: string;
+  status: string;
+  output: string;
+  error: string;
+}
+
+export interface DataStartMessage {
+  op: string;
+  req_id: string;
+  kind: string;
+  mime: string;
+  total: number;
+  chunk_size: number;
+}
+
+export interface DataEndMessage {
+  op: string;
+  req_id: string;
+  status: string;
+  total?: number;
+  error?: string;
+}
+
+export const CHUNK_SIZE: number = 8192;
+
+// ===== 命令处理器回调 =====
+// 返回 CapResult；二进制大结果通过 dataHandler 分块回传。
+export type BridgeCmdHandler = (reqId: string, command: string) => Promise<CapResult>;
+
+// ===== 帧构造 =====
+
+export function bridgeHelloFrame(deviceId: string, name: string, kind: string,
+                                 caps: string[], hostname: string,
+                                 authorized: boolean): string {
+  const info: HelloDeviceInfo = {
+    hostname: hostname,
+    platform: 'OpenHarmony',
+    arch: '',
+    os_release: '',
+    version: '1.1.1',
+    cpus: 0,
+  };
+  const device: HelloDevice = {
+    device_id: deviceId,
+    name: name,
+    kind: kind,
+    authorized: authorized,
+    caps: caps,
+    info: info,
+  };
+  const hello: HelloMessage = { op: 'hello', device: device };
+  return JSON.stringify(hello);
+}
+
+export function bridgeBindFrame(deviceId: string, token: string): string {
+  const bind: BindMessage = {
+    op: 'bind',
+    device_id: deviceId,
+    token: token,
+  };
+  return JSON.stringify(bind);
+}
+
+export function bridgeResultFrame(reqId: string, status: string,
+                                  output: string, errMsg: string): string {
+  const result: CmdReply = {
+    op: 'cmd_result',
+    req_id: reqId,
+    status: status,
+    output: output,
+    error: errMsg,
+  };
+  return JSON.stringify(result);
+}
+
+export function bridgeDataStartFrame(reqId: string, kind: string, mime: string,
+                                     total: number): string {
+  const startMsg: DataStartMessage = {
+    op: 'cmd_data_start',
+    req_id: reqId,
+    kind: kind,
+    mime: mime,
+    total: total,
+    chunk_size: CHUNK_SIZE,
+  };
+  return JSON.stringify(startMsg);
+}
+
+export function bridgeDataEndFrame(reqId: string): string {
+  const endMsg: DataEndMessage = {
+    op: 'cmd_data_end',
+    req_id: reqId,
+    status: 'ok',
+  };
+  return JSON.stringify(endMsg);
+}
+
+export function bridgeEventFrame(deviceId: string, eventType: string, detail: string): string {
+  const payload: Record<string, string> = { 'detail': detail };
+  const msg: Record<string, Object> = {
+    'op': 'event',
+    'device_id': deviceId,
+    'type': eventType,
+    'payload': payload,
+  };
+  return JSON.stringify(msg);
+}
+
+export function bridgeStatusFrame(deviceId: string, status: string): string {
+  const msg: Record<string, Object> = {
+    'op': 'status',
+    'device_id': deviceId,
+    'status': status,
+  };
+  return JSON.stringify(msg);
+}
+
+/** 按 CHUNK_SIZE 切二进制；切片顺序即发送顺序。 */
+export function bridgeChunkSlices(bytes: Uint8Array): Uint8Array[] {
+  const out: Uint8Array[] = [];
+  for (let off: number = 0; off < bytes.byteLength; off += CHUNK_SIZE) {
+    const end: number = Math.min(off + CHUNK_SIZE, bytes.byteLength);
+    out.push(bytes.slice(off, end));
+  }
+  return out;
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/BridgeRouter.ets

@@ -1,4 +1,4 @@
-import { deviceBridge, CmdReply } from './DeviceBridge';
+import { deviceBridge } from './DeviceBridge';
 import {
   CapResult,
   capScreensee,
@@ -6,12 +6,14 @@ import {
   capClipboardsue,
   capSpeakerUse,
   capDeviceInfo,
+  capStatus,
   parseScreensue,
   ScreensuePayload,
 } from './BridgeCaps';
+import { connStore } from './ConnStore';
 import { common } from '@kit.AbilityKit';
 
-// screensue 展示回调由 UI 层注册（Index 挂全局悬浮层）
+// screensue 展示回调由根 UI 注册：窄屏整页，宽屏右侧内容栏。
 export type ScreensueHandler = (payload: ScreensuePayload) => void;
 
 let screensueHandler: ScreensueHandler | null = null;
@@ -25,10 +27,23 @@ export function setBridgeAppContext(ctx: common.UIAbilityContext): void {
   appContext = ctx;
 }
 
-/** 解析 homeagent-* 命令：返回能力名与参数串。 */
+/** 解析裸能力名或过渡期 homeagent-* 命令；参数正文不裁剪，避免改变推送内容。 */
 function splitCapability(command: string): string[] {
-  const cmd: string = command.trim();
-  const idx: number = cmd.indexOf(' ');
+  let start: number = 0;
+  while (start < command.length && isCommandSpace(command.charAt(start))) {
+    start = start + 1;
+  }
+  let cmd: string = command.substring(start);
+  if (cmd.startsWith('homeagent-')) {
+    cmd = cmd.substring('homeagent-'.length);
+  }
+  let idx: number = -1;
+  for (let i: number = 0; i < cmd.length; i++) {
+    if (isCommandSpace(cmd.charAt(i))) {
+      idx = i;
+      break;
+    }
+  }
   if (idx < 0) {
     return [cmd];
   }
@@ -36,51 +51,73 @@ function splitCapability(command: string): string[] {
   return out;
 }
 
+function isCommandSpace(ch: string): boolean {
+  return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+}
+
+function hasArgs(args: string): boolean {
+  return args.trim().length > 0;
+}
+
 async function executeCommand(reqId: string, command: string): Promise<CapResult> {
   const parts: string[] = splitCapability(command);
   const name: string = parts[0];
   const args: string = parts.length > 1 ? parts[1] : '';
 
-  // screensee 截屏回传（data URL 走文本结果，服务端兼容）
   if (name === 'screensee') {
+    if (hasArgs(args)) {
+      return errRes('screensee 不接受额外参数');
+    }
     return capScreensee();
   }
   if (name === 'screensue') {
+    if (!hasArgs(args)) {
+      return errRes('screensue 需要展示内容');
+    }
     const payload: ScreensuePayload = parseScreensue(args);
+    if (payload.content.length === 0) {
+      return errRes('screensue 需要展示内容');
+    }
     if (screensueHandler !== null) {
       screensueHandler(payload);
-      return okRes('shown');
+      return okRes('内容已显示');
     }
-    return errRes('screensue: display layer not ready');
+    return errRes('展示界面尚未就绪，请保持应用在前台后重试');
   }
   if (name === 'clipboardsee') {
+    if (hasArgs(args)) {
+      return errRes('clipboardsee 不接受额外参数');
+    }
     if (appContext === null) {
-      return errRes('clipboardsee: app context missing');
+      return errRes('应用界面尚未就绪，请保持应用在前台后重试');
     }
     return capClipboardSee(appContext);
   }
   if (name === 'clipboardsue') {
-    if (args.length === 0) {
-      return errRes('clipboardsue: empty text');
+    if (!hasArgs(args)) {
+      return errRes('clipboardsue 需要写入文字');
     }
     return capClipboardsue(args);
   }
   if (name === 'speakeruse') {
-    if (args.length === 0) {
-      return errRes('speakeruse: empty text');
+    if (!hasArgs(args)) {
+      return errRes('speakeruse 需要朗读文字');
     }
     return capSpeakerUse(args);
   }
-  if (name === 'deviceinfo' || name === 'status') {
-    return capDeviceInfo();
+  if (name === 'status') {
+    if (hasArgs(args)) {
+      return errRes('status 不接受额外参数');
+    }
+    return capStatus(connStore.getDeviceId());
   }
-  if (name === 'camerasue') {
-    return errRes('camerasue: camera capture not supported on this build');
+  if (name === 'deviceinfo') {
+    if (hasArgs(args)) {
+      return errRes('deviceinfo 不接受额外参数');
+    }
+    return capDeviceInfo(connStore.getDeviceId(), connStore.getDeviceName());
   }
-  if (name === 'computeruse') {
-    return errRes('computeruse: not applicable to touch-only device');
-  }
-  return errRes('unsupported homeagent capability: ' + name);
+  return errRes('不支持的本机能力：' + name);
 }
 
 function okRes(output: string): CapResult {

cmd/ohos/HomeAgent/entry/src/main/ets/common/ChatFormat.ets

@@ -0,0 +1,223 @@
+/**
+ * 聊天页的纯格式化/判定逻辑（无 UI 依赖）。
+ *
+ * 从 pages/ChatPage.ets 抽出：这些函数只吃数据吐字符串/布尔，
+ * 抽出来后气泡、工具卡、渠道头像三个组件可以共用同一份口径。
+ */
+
+import { ChatMessage, ToolCallInfo } from '../model/Model';
+
+/**
+ * 由文件名后缀推断 Content-Type。
+ * 后端按 multipart 部件的 Content-Type 判定 image/file，
+ * 给错会让图片被当成普通文件（缩略图就没了）。
+ */
+export function mimeOf(name: string, isImage: boolean): string {
+  const i: number = name.lastIndexOf('.');
+  const ext: string = i >= 0 ? name.substring(i + 1).toLowerCase() : '';
+  if (ext === 'png') {
+    return 'image/png';
+  }
+  if (ext === 'jpg' || ext === 'jpeg') {
+    return 'image/jpeg';
+  }
+  if (ext === 'webp') {
+    return 'image/webp';
+  }
+  if (ext === 'gif') {
+    return 'image/gif';
+  }
+  if (ext === 'bmp') {
+    return 'image/bmp';
+  }
+  if (ext === 'heic' || ext === 'heif') {
+    return 'image/heic';
+  }
+  if (isImage) {
+    return 'image/jpeg';
+  }
+  if (ext === 'pdf') {
+    return 'application/pdf';
+  }
+  if (ext === 'txt' || ext === 'log' || ext === 'md') {
+    return 'text/plain';
+  }
+  if (ext === 'json') {
+    return 'application/json';
+  }
+  return 'application/octet-stream';
+}
+
+/** payload 字段可能是字符串、对象或数组，统一转成可展示文本。 */
+export function stringifyField(raw: Object | undefined): string {
+  if (raw === undefined || raw === null) {
+    return '';
+  }
+  if (typeof raw === 'string') {
+    return raw as string;
+  }
+  try {
+    return JSON.stringify(raw);
+  } catch (e) {
+    return String(raw);
+  }
+}
+
+/**
+ * ForEach 键：消息结构变化即换键 → 旧气泡销毁重建 → @Builder 里的
+ * if 分支重新求值。这是 ArkUI V1 渲染模型决定的：ForEach 对相同键
+ * 只更新 @Prop/@Link 绑定，不重新执行 @Builder 体，所以
+ * 「思考卡/工具卡/附件」这些用 if 包裹的条件分支在首次渲染后
+ * 永远不会再次求值——气泡里的这些面板就永远不出现。
+ *
+ * 反过来，content_delta 不进 structSig：正文文本靠 MarkdownView
+ * 的 @Prop content 响应式更新，不重建气泡 → 流式渲染平滑。
+ * 实测 SSE 里 reasoning_delta 与 content_delta 不交错（思考阶段
+ * 先于输出阶段），所以思考期间重建气泡不会打断正文流式动画。
+ */
+export function structSig(msg: ChatMessage): string {
+  let s: string = msg.id.toString();
+  const rc: string | undefined = msg.reasoningContent;
+  s += '_r' + (rc !== undefined ? rc.length.toString() : '0');
+  s += '_ro' + (msg.reasoningOpen === true ? '1' : '0');
+  const tcs: ToolCallInfo[] | undefined = msg.toolCalls;
+  if (tcs !== undefined) {
+    s += '_t' + tcs.length.toString();
+    for (let i = 0; i < tcs.length; i++) {
+      const tc: ToolCallInfo = tcs[i];
+      s += '_' + (tc.status ?? '');
+      s += '_' + (tc.open === true ? 'o' : 'c');
+      s += '_' + (tc.args !== undefined ? tc.args.length.toString() : '0');
+      s += '_' + (tc.result !== undefined ? tc.result.length.toString() : '0');
+      s += '_' + (tc.plugin ?? '');
+    }
+  } else {
+    s += '_t0';
+  }
+  s += '_a' + (msg.attachment !== undefined ? '1' : '0');
+  s += '_src' + (msg.source ?? '');
+  s += '_f' + (msg.isFinal === true ? '1' : '0');
+  s += '_s' + (msg.isStreaming === true ? '1' : '0');
+  return s;
+}
+
+/** 折叠时也要能看出思考在增长：显示字数 */
+export function reasoningLenLabel(msg: ChatMessage): string {
+  const rc: string | undefined = msg.reasoningContent;
+  if (rc === undefined || rc.length === 0) {
+    return '';
+  }
+  return rc.length.toString() + ' 字';
+}
+
+/**
+ * 是否仍在执行。
+ * 判据是 status 而不是 result：后端 status=ok 的工具也可能返回空串，
+ * 用 result 判断会让这类调用永远显示"调用中"。
+ */
+export function tcRunning(tc: ToolCallInfo): boolean {
+  const s: string | undefined = tc.status;
+  return s === undefined || s.length === 0 || s === 'running';
+}
+
+export function tcError(tc: ToolCallInfo): boolean {
+  return tc.status === 'denied' || tc.status === 'error';
+}
+
+/** 工具卡左侧色条（accent 由调用方从 palette 取） */
+export function tcLeftColor(tc: ToolCallInfo, accent: string): string {
+  if (tcError(tc)) {
+    return '#DB3694';
+  }
+  if (tcRunning(tc)) {
+    return accent;
+  }
+  return 'rgba(23, 169, 100, 0.8)';
+}
+
+/** 工具卡状态图标颜色 */
+export function tcIcoColor(tc: ToolCallInfo, accent: string): string {
+  if (tcError(tc)) {
+    return '#DB3694';
+  }
+  if (tcRunning(tc)) {
+    return accent;
+  }
+  return 'rgba(23, 169, 100, 0.9)';
+}
+
+export function tcStateLabel(tc: ToolCallInfo): string {
+  if (tc.status === 'denied') {
+    return '已拒绝';
+  }
+  if (tcRunning(tc)) {
+    return '调用中';
+  }
+  return '完成';
+}
+
+export function tcStateColor(tc: ToolCallInfo): string {
+  if (tc.status === 'denied') {
+    return '#FF9EC6';
+  }
+  if (tcRunning(tc)) {
+    return '#A3B8FF';
+  }
+  return '#6EE7A8';
+}
+
+/**
+ * 气泡最大宽度（相对 BubbleSlot 的宽度，即扣掉头像与间距后的真实可用宽）。
+ * 纯文本 78% 好看；但工具卡/思考卡是"面板"，78% 会把里面的状态文字和
+ * 参数/结果压成一团（还会被 clip 切掉），所以带卡片时放宽到 92%。
+ */
+export function bubbleMaxWidth(msg: ChatMessage): string {
+  const hasPanels: boolean =
+    (msg.toolCalls !== undefined && msg.toolCalls.length > 0) ||
+    (msg.reasoningContent !== undefined && msg.reasoningContent.length > 0);
+  return hasPanels ? '92%' : '78%';
+}
+
+/**
+ * 是否"别处来的"消息。对齐 GUI 的 source !== 'webui' 判定，但多减一项：
+ * 本机自己发的消息在后端会被写成 webui/<device_id>，那仍然是"我发的"，
+ * 不能当成渠道消息挂上别人的头像。
+ */
+export function isChannelMsg(source: string, deviceId: string): boolean {
+  if (source.length === 0 || source === 'webui') {
+    return false;
+  }
+  return source !== 'webui/' + deviceId;
+}
+
+/** 自己发的消息（右对齐、"我"头像）：渠道消息即使 role=user 也不算 */
+export function isSelfMsg(role: string, channel: boolean): boolean {
+  return role === 'user' && !channel;
+}
+
+/** 渠道名展示：webui/<id> 只显示 <id>，其余原样。 */
+export function chanLabel(src: string): string {
+  if (src.startsWith('webui/')) {
+    return src.substring(6);
+  }
+  return src;
+}
+
+/** 渠道首字母（大写），用作头像文字。 */
+export function chanLetter(src: string): string {
+  const label: string = chanLabel(src);
+  if (label.length === 0) {
+    return '?';
+  }
+  return label.substring(0, 1).toUpperCase();
+}
+
+/** 由渠道名散列出稳定色，避免每次渲染换色。 */
+export function chanColor(src: string): string {
+  const label: string = chanLabel(src);
+  let h: number = 0;
+  for (let i = 0; i < label.length; i++) {
+    h = (h * 31 + label.charCodeAt(i)) % 360;
+  }
+  return 'hsl(' + h.toString() + ', 52%, 46%)';
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/ChatHistory.ets

@@ -0,0 +1,96 @@
+/**
+ * /chat/history 响应解析（无 UI 依赖）。
+ *
+ * 从 pages/ChatPage.ets 抽出：首屏与向上翻页共用同一套解析口径，
+ * 消息 id 由调用方提供的分配器给出（页面自己维护 id 计数器）。
+ */
+
+import { ChatMessage, ToolCallInfo, ChatAttachment } from '../model/Model';
+import { parseAttachment } from './AttachmentMeta';
+import { stringifyField } from './ChatFormat';
+
+/** 分页历史解析结果：消息列表 + 服务端分页元数据 */
+export interface ParsedHistory {
+  msgs: ChatMessage[];
+  /** 本页首条在服务端全量历史中的下标，作为下次向上翻页的 before 游标 */
+  offset: number;
+  /** 服务端是否还有更早的历史 */
+  hasMore: boolean;
+}
+
+/** 解析后端 /chat/history 的响应体（含分页元数据），供首屏与翻页复用。 */
+export function parseHistoryPayload(
+  obj: Record<string, Object>, alloc: () => number): ParsedHistory {
+  const rawList: Object | undefined = obj['messages'] as Object | undefined;
+  if (rawList === undefined || rawList === null) {
+    return { msgs: [], offset: 0, hasMore: false };
+  }
+  const arr: Object[] = rawList as Object[];
+  const msgs: ChatMessage[] = [];
+  for (let i = 0; i < arr.length; i++) {
+    const item: Record<string, Object> = arr[i] as Record<string, Object>;
+    const role: string = item['role'] as string ?? '';
+    const content: string = item['content'] as string ?? '';
+    const att: ChatAttachment | undefined = parseAttachment(item['attachment']);
+    // 纯附件消息 content 可能为空，不能再按"无内容就丢弃"处理
+    if (role.length === 0 || (content.length === 0 && att === undefined)) {
+      continue;
+    }
+    const msg: ChatMessage = {
+      id: alloc(),
+      role: role,
+      content: content,
+      isFinal: true,
+    };
+    if (att !== undefined) {
+      msg.attachment = att;
+    }
+    // 后端 handler.go 保证 history 不裁剪 reasoning_content / tool_calls，
+    // 这里必须还原，否则刷新后思考与工具卡就凭空消失。
+    const rc: string = item['reasoning_content'] as string ?? '';
+    if (rc.length > 0) {
+      msg.reasoningContent = rc;
+    }
+    const tcs: ToolCallInfo[] | undefined = parseHistoryToolCalls(item['tool_calls']);
+    if (tcs !== undefined) {
+      msg.toolCalls = tcs;
+    }
+    // 渠道/设备来源：后端 ChatMsg.source，用于区分 channel_output 等非 webui 消息
+    const src: string = item['source'] as string ?? '';
+    if (src.length > 0) {
+      msg.source = src;
+    }
+    msgs.push(msg);
+  }
+  const offset: number = typeof obj['offset'] === 'number' ? obj['offset'] as number : 0;
+  const hasMore: boolean = obj['has_more'] === true;
+  return { msgs: msgs, offset: offset, hasMore: hasMore };
+}
+
+/** 后端 tool_calls 条目带 tool 和 name 两份；args/result 可能是对象也可能是字符串。 */
+export function parseHistoryToolCalls(raw: Object | undefined): ToolCallInfo[] | undefined {
+  if (raw === undefined || raw === null) {
+    return undefined;
+  }
+  const arr: Object[] = raw as Object[];
+  if (arr.length === 0) {
+    return undefined;
+  }
+  const tcs: ToolCallInfo[] = [];
+  for (let i = 0; i < arr.length; i++) {
+    const item: Record<string, Object> = arr[i] as Record<string, Object>;
+    const name: string = (item['tool'] as string ?? '') || (item['name'] as string ?? '');
+    if (name.length === 0) {
+      continue;
+    }
+    const tc: ToolCallInfo = {
+      name: name,
+      args: stringifyField(item['args']),
+      result: stringifyField(item['result']),
+      status: item['status'] as string ?? undefined,
+      plugin: item['plugin'] as string ?? undefined,
+    };
+    tcs.push(tc);
+  }
+  return tcs.length > 0 ? tcs : undefined;
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/ChatSession.ets

@@ -0,0 +1,176 @@
+/**
+ * 发送 / 中断（无 UI 依赖）。
+ *
+ * 从 pages/ChatPage.ets 抽出：POST /chat 与 POST /chat/file 的请求体、
+ * 兜底消息合并、超时口径都收在这里，输入区组件只负责把文本/附件递进来。
+ */
+
+import { ChatMessage, ChatAttachment } from '../model/Model';
+import { apiClient } from './ApiClient';
+import { connStore } from './ConnStore';
+import { userMessage, isTimeout } from './UserError';
+import { chatStore } from './ChatStore';
+import { parseAttachment } from './AttachmentMeta';
+import { http } from '@kit.NetworkKit';
+
+interface SendChatBody {
+  message: string;
+  client_msg_id: string;
+  /** 非空时后端编码 source = "webui/<device_id>"，agent 可见来源设备 */
+  device_id?: string;
+  device_name?: string;
+}
+
+/**
+ * 纯文本发送：POST /chat。
+ * 带附件的情况走 sendChatFile（后端收下附件后自己写会话并触发 agent）。
+ */
+export async function sendChatText(text: string): Promise<void> {
+  const trimmed: string = text.trim();
+  if (chatStore.isLoading()) {
+    return;
+  }
+  const cur = connStore.getCurrentConnection();
+  if (cur === null) {
+    return;
+  }
+  if (trimmed.length === 0) {
+    return;
+  }
+  // 重置 SSE 标记
+  chatStore.setSseActive(false);
+
+  const userMsg: ChatMessage = { id: chatStore.allocId(), role: 'user', content: trimmed };
+  chatStore.pushNew(userMsg);
+  chatStore.setLoading(true);
+  chatStore.setStage('等待 AI 回复...');
+  chatStore.forceRefresh();
+  chatStore.requestScroll();
+
+  const bodyObj: SendChatBody = {
+    message: trimmed,
+    client_msg_id: Date.now().toString(36),
+    // 必须带设备身份：后端没有 device_id 就把来源编码成 webui，
+    // agent 会以为消息来自网页端。device_id 非空时后端编码
+    // source = "webui/<device_id>" 并注入设备上下文。
+    device_id: connStore.ensureDeviceId(),
+    device_name: connStore.getDeviceName(),
+  };
+
+  // 如果 SSE 已连接，POST 作为触发器（响应由 SSE 推送渲染）；
+  // 仅在 SSE 未推送内容时才用 POST 响应兜底创建消息。
+  try {
+    const resp = await apiClient.postWithTimeout('/chat', bodyObj, 120000);
+
+    // SSE 已经处理了响应，跳过 POST 消息创建
+    if (chatStore.sseActive()) {
+      chatStore.setLoading(false);
+      chatStore.setStage('');
+      chatStore.forceRefresh();
+      chatStore.requestScroll();
+      return;
+    }
+
+    const parsed: Record<string, string> = JSON.parse(resp.body) as Record<string, string>;
+    const respText: string = parsed['response'] ?? '(无响应)';
+    const reasoning: string = parsed['reasoning_content'] ?? '';
+    const last: ChatMessage | null = chatStore.lastMessage();
+    if (last !== null && last.role === 'assistant' && !last.isFinal) {
+      last.content = respText;
+      last.isFinal = true;
+      last.isStreaming = false;
+      if (reasoning.length > 0 && last.reasoningContent === undefined) {
+        last.reasoningContent = reasoning;
+      }
+    } else if (last !== null && last.role === 'assistant' && last.isFinal) {
+      // 已有最终消息，合并（不应发生，但防御性处理）
+      if (respText.length > last.content.length) {
+        last.content = respText;
+      }
+    } else {
+      const msg: ChatMessage = {
+        id: chatStore.allocId(),
+        role: 'assistant',
+        content: respText,
+        isFinal: true,
+      };
+      if (reasoning.length > 0) {
+        msg.reasoningContent = reasoning;
+      }
+      chatStore.pushNew(msg);
+    }
+    chatStore.setLoading(false);
+    chatStore.setStage('');
+    chatStore.forceRefresh();
+    chatStore.requestScroll();
+  } catch (e) {
+    // 超时通常意味着后端仍在生成，不算失败；其余一律显示人话，
+    // 原始错误只进 hilog（之前把 e.message 拼进 chatStage 会把
+    // "Failed to connect to the server."、内网地址直接摆到聊天流里）。
+    if (isTimeout(e)) {
+      chatStore.setStage('请求已发送，等待回复...');
+    } else {
+      chatStore.setStage(userMessage('chat.send', e));
+    }
+    chatStore.forceRefresh();
+    chatStore.requestScroll();
+  }
+}
+
+/**
+ * 带附件发送：POST /chat/file（multipart），字段与 WebGUI 一致。
+ * 后端收下后自身会把用户消息与附件写进会话并触发 agent，
+ * 回复照常从 SSE 过来，所以这里不再走 /chat。
+ */
+export async function sendChatFile(text: string, path: string, name: string,
+                                   size: number, isImage: boolean, mime: string): Promise<void> {
+  if (connStore.getCurrentConnection() === null) {
+    return;
+  }
+  const att: ChatAttachment = {
+    type: isImage ? 'image' : 'file',
+    // 本地待上传：先用沙箱路径预览，上传成功后替换成服务端 URL
+    url: 'file://' + path,
+    size: size,
+    name: name,
+  };
+  const userMsg: ChatMessage = { id: chatStore.allocId(), role: 'user', content: text };
+  userMsg.attachment = att;
+  chatStore.pushNew(userMsg);
+  chatStore.setLoading(true);
+  chatStore.setStage('正在上传附件...');
+  chatStore.setSseActive(false);
+  chatStore.forceRefresh();
+  chatStore.requestScroll();
+
+  const parts: http.MultiFormData[] = [
+    { name: 'file', contentType: mime, remoteFileName: name, filePath: path },
+    { name: 'message', contentType: 'text/plain', data: text },
+    { name: 'client_msg_id', contentType: 'text/plain', data: Date.now().toString(36) },
+    { name: 'device_id', contentType: 'text/plain', data: connStore.ensureDeviceId() },
+    { name: 'device_name', contentType: 'text/plain', data: connStore.getDeviceName() },
+  ];
+
+  try {
+    const resp = await apiClient.postMultipart('/chat/file', parts, 180000);
+    const obj: Record<string, Object> = JSON.parse(resp.body) as Record<string, Object>;
+    const uploaded: ChatAttachment | undefined = parseAttachment(obj['file']);
+    if (uploaded !== undefined) {
+      userMsg.attachment = uploaded;
+    }
+    chatStore.setStage('等待 AI 回复...');
+  } catch (e) {
+    chatStore.setStage(userMessage('chat.upload', e));
+    chatStore.setLoading(false);
+  }
+  chatStore.forceRefresh();
+  chatStore.requestScroll();
+}
+
+export async function interruptChat(): Promise<void> {
+  try {
+    await apiClient.post('/chat/interrupt', null);
+  } catch (e) {
+    // ignore
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/ChatSse.ets

@@ -0,0 +1,196 @@
+/**
+ * SSE 事件 → 聊天流状态的翻译层（无 UI 依赖）。
+ *
+ * 从 pages/ChatPage.ets 抽出。这里只认「事件帧」与「往状态里写什么」，
+ * 具体状态由 ChatStreamSink 提供 —— 这样本文件不必 import ChatStore，
+ * 两边不会形成 ArkTS 里被拒绝的模块循环依赖。
+ */
+
+import { ChatMessage, ToolCallInfo, ChatAttachment } from '../model/Model';
+import { attachmentFromChannelOutput } from './AttachmentMeta';
+import { SseEvent } from './SseClient';
+import { stringifyField } from './ChatFormat';
+import { stageTrail } from './StageTrail';
+import { hilog } from '@kit.PerformanceAnalysisKit';
+
+/** 聊天流状态机对外暴露的最小写入面（由 common/ChatStore.ets 实现） */
+export interface ChatStreamSink {
+  allocId(): number;
+  lastMessage(): ChatMessage | null;
+  /** 取/建"未定稿的助手消息" */
+  ensureAssistant(): ChatMessage;
+  /** 取/建同名未完成工具卡 */
+  ensureToolCall(name: string): ToolCallInfo;
+  /** 追加一条新消息并播入场动画 */
+  pushNew(msg: ChatMessage): void;
+  setLoading(v: boolean): void;
+  setStage(s: string): void;
+  setSseActive(v: boolean): void;
+  /** 防抖刷新（合并高频 delta） */
+  refresh(): void;
+  /** 请求滚到底 */
+  requestScroll(): void;
+  /** sync_required：补拉历史 */
+  reloadHistory(): void;
+}
+
+export function applyChatSse(ev: SseEvent, sink: ChatStreamSink): void {
+  try {
+    // 服务端 data 字段是完整 sdk.Event：{type, source, payload, timestamp}
+    // 业务字段全部在 payload 之下，历史实现直接读顶层导致流式/思考/工具调用全部失效。
+    const frame: Record<string, Object> = JSON.parse(ev.data) as Record<string, Object>;
+    const inner: Object | undefined = frame['payload'];
+    const payload: Record<string, Object> =
+      inner !== undefined && inner !== null ? inner as Record<string, Object> : frame;
+    const frameType: string = frame['type'] as string ?? '';
+    const type: string = ev.event.length > 0 ? ev.event : frameType;
+    // 诊断只记事件类型（内容可能含隐私，不落盘）
+    hilog.debug(0x0000, 'HomeAgent', 'sse %{public}s', type);
+
+    if (type === 'agent_output') {
+      const content: string = payload['content'] as string ?? '';
+      // channel_output 携带图片/文件：url/size/output_type 三个字段在 payload 顶层，
+      // 它是一条独立的附件消息，不能合并进上一条文本气泡。
+      const kind: string = payload['kind'] as string ?? '';
+      if (kind === 'channel_output') {
+        const att: ChatAttachment | undefined = attachmentFromChannelOutput(
+          payload['output_type'] as string ?? '',
+          payload['url'] as string ?? '',
+          payload['size'] as number ?? 0);
+        if (att !== undefined) {
+          const amsg: ChatMessage = {
+            id: sink.allocId(),
+            role: 'assistant',
+            content: content,
+            isFinal: true,
+            source: 'channel',
+            attachment: att,
+          };
+          sink.pushNew(amsg);
+          sink.setLoading(false);
+          sink.setStage('');
+          sink.setSseActive(false);
+          sink.refresh();
+          sink.requestScroll();
+          return;
+        }
+      }
+      const last: ChatMessage | null = sink.lastMessage();
+      if (last !== null && last.role === 'assistant' && !last.isFinal) {
+        last.content = content;
+        last.isFinal = true;
+        last.isStreaming = false;
+      } else if (last !== null && last.role === 'assistant' && last.isFinal) {
+        // POST 已经创建了最终消息，仅合并内容（如果有增量）
+        if (content.length > last.content.length) {
+          last.content = content;
+        }
+      } else {
+        const msg: ChatMessage = {
+          id: sink.allocId(),
+          role: 'assistant',
+          content: content,
+          isFinal: true,
+        };
+        sink.pushNew(msg);
+      }
+      sink.setLoading(false);
+      sink.setStage('');
+      sink.setSseActive(false);
+      sink.refresh();
+      sink.requestScroll();
+    } else if (type === 'reasoning') {
+      const rc: string = payload['content'] as string ?? '';
+      if (rc.length > 0) {
+        sink.setStage('AI 思考中...');
+        // 聚合 reasoning 可能先于任何 delta 到达（非流式后端就只有这一条），
+        // 此时还没有"未完成的助手消息"，必须新建一条，否则思考内容直接丢失。
+        const last: ChatMessage = sink.ensureAssistant();
+        last.reasoningContent = rc;
+        sink.refresh();
+        sink.requestScroll();
+      }
+    } else if (type === 'sync_required') {
+      // 断线重连时服务端要求补拉历史（ring 里没有可重放的聚合事件）
+      sink.reloadHistory();
+    } else if (type === 'agent_error') {
+      // 后端错误一律转人话，技术细节不上 UI
+      sink.setLoading(false);
+      sink.setStage('本轮处理失败，请重试');
+      sink.refresh();
+    } else if (type === 'content_delta') {
+      const delta: string = payload['content'] as string ?? '';
+      if (delta.length > 0) {
+        sink.setSseActive(true);
+        const last: ChatMessage = sink.ensureAssistant();
+        last.content += delta;
+        sink.refresh();
+        sink.requestScroll();
+      }
+    } else if (type === 'reasoning_delta') {
+      const delta: string = payload['content'] as string ?? '';
+      if (delta.length > 0) {
+        sink.setSseActive(true);
+        sink.setStage('AI 思考中...');
+        const last: ChatMessage = sink.ensureAssistant();
+        if (last.reasoningContent === undefined) {
+          last.reasoningContent = '';
+        }
+        last.reasoningContent += delta;
+        sink.refresh();
+      }
+    } else if (type === 'tool_call') {
+      const toolName: string = payload['tool'] as string ?? '';
+      const toolStatus: string = payload['status'] as string ?? '';
+      const toolPlugin: string = payload['plugin'] as string ?? '';
+      if (toolName.length > 0) {
+        sink.setStage('工具调用: ' + toolName);
+        const target: ToolCallInfo = sink.ensureToolCall(toolName);
+        if (toolPlugin.length > 0) {
+          target.plugin = toolPlugin;
+        }
+        const argsText: string = stringifyField(payload['args']);
+        if (argsText.length > 0) {
+          target.args = argsText;
+        }
+        if (toolStatus.length > 0) {
+          // 后端只在工具执行【结束】时发 tool_call（status=ok/denied/interrupted），
+          // 所以拿到 status 就意味着这次调用已收尾，result 一并落卡。
+          target.status = toolStatus;
+          target.result = stringifyField(payload['result']);
+        } else {
+          target.status = 'running';
+        }
+        sink.refresh();
+        sink.requestScroll();
+      }
+    } else if (type === 'stage') {
+      const phase: string = payload['phase'] as string ?? '';
+      const channel: string = payload['channel'] as string ?? '';
+      const stageTool: string = payload['tool'] as string ?? '';
+      if (channel !== '_consolidation_') {
+        // 运行态面板的阶段管道靠这条轨迹活着：先喂轨迹，再管聊天侧的角标。
+        // 两者是独立消费者，轨迹不依赖任何聊天状态。
+        stageTrail.onStage(phase, stageTool);
+        if (phase === 'pre_action') {
+          sink.setStage('AI 思考中...');
+        } else if (phase === 'before_toolcall') {
+          sink.setStage('工具调用: ' + stageTool);
+          // 关键：tool_call 事件只在执行【结束】后才发，所以"调用中"这一态
+          // 必须由 before_toolcall 建卡，否则用户永远看不到工具正在跑。
+          if (stageTool.length > 0) {
+            const tc: ToolCallInfo = sink.ensureToolCall(stageTool);
+            if (tc.status === undefined) {
+              tc.status = 'running';
+            }
+          }
+        } else if (phase === 'before_output') {
+          sink.setStage('生成回复中...');
+        }
+        sink.refresh();
+      }
+    }
+  } catch (e) {
+    // ignore parse errors
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/ChatStore.ets

@@ -0,0 +1,389 @@
+/**
+ * 聊天流状态源（单例）。
+ *
+ * 从 pages/ChatPage.ets 抽出：消息数组、分页游标、"哪几条是新消息"、
+ * SSE 连接与历史拉取都属于同一个状态机；页面只剩渲染与输入。
+ *
+ * 为什么数组不进 AppStorage：StatusStore 已经踩过一次 —— 数组同步语义不可靠。
+ * 这里沿用同一套做法：数组留在 store 内部，标量走 AppStorage 广播，
+ * 另加一个自增版本号 K_CHAT_REV 通知订阅组件"重取一次快照"。
+ *
+ * 订阅组件的接法（见 components/ChatStream.ets）：
+ *   @StorageProp(K_CHAT_REV) @Watch('onRev') private rev: number = 0;
+ *   onRev(): void { this.messages = chatStore.messages(); }
+ * ForEach 拿到的仍然是"每次刷新一个新数组引用"，与拆分前
+ * （this.messages = this.messages.slice()）的渲染语义完全一致。
+ *
+ * SSE 事件的翻译在 common/ChatSse.ets：本类实现它的 ChatStreamSink 接口，
+ * 依赖方向只有"ChatStore → ChatSse"一条，不构成循环。
+ */
+
+import { ChatMessage, ToolCallInfo, ChatAttachment } from '../model/Model';
+import { SseClient, SseEvent } from './SseClient';
+import { connStore } from './ConnStore';
+import { apiClient } from './ApiClient';
+import { CHAT_PAGE_SIZE } from './Constants';
+import { ParsedHistory, parseHistoryPayload } from './ChatHistory';
+import { applyChatSse, ChatStreamSink } from './ChatSse';
+
+// ===== AppStorage 键：页面/聊天流/输入区共用 =====
+export const K_CHAT_REV: string = 'chatRev';
+export const K_CHAT_SCROLL_REV: string = 'chatScrollRev';
+export const K_CHAT_LOADING: string = 'chatBusy';
+export const K_CHAT_STAGE: string = 'chatStageText';
+export const K_CHAT_CONNECTED: string = 'chatSseUp';
+
+const SSE_RECONNECT_MS: number = 5000;
+
+class ChatStore implements ChatStreamSink {
+  private msgs: ChatMessage[] = [];
+  private nextId: number = 1;
+  private refreshTimer: number = -1;
+  private reconnectTimer: number = -1;
+  /** 分页历史：当前已加载消息在服务端全量中的起始下标 */
+  private offset: number = 0;
+  /** 是否还有更早历史可向上加载 */
+  private hasEarlier: boolean = false;
+  private loadingOlder: boolean = false;
+  /** 正在为新消息播入场动画的 id */
+  private newIds: number[] = [];
+  // SSE 正在为当前轮次推送内容时置 true，阻止 POST 响应重复创建消息
+  private sseActiveForTurn: boolean = false;
+  private sse: SseClient = new SseClient();
+
+  init(): void {
+    AppStorage.setOrCreate<boolean>(K_CHAT_LOADING, false);
+    AppStorage.setOrCreate<string>(K_CHAT_STAGE, '');
+    AppStorage.setOrCreate<boolean>(K_CHAT_CONNECTED, false);
+    AppStorage.setOrCreate<number>(K_CHAT_REV, 0);
+    AppStorage.setOrCreate<number>(K_CHAT_SCROLL_REV, 0);
+  }
+
+  // ===================== 读取 =====================
+
+  messages(): ChatMessage[] {
+    return this.msgs;
+  }
+
+  findMessage(id: number): ChatMessage | undefined {
+    for (let i = 0; i < this.msgs.length; i++) {
+      if (this.msgs[i].id === id) {
+        return this.msgs[i];
+      }
+    }
+    return undefined;
+  }
+
+  lastMessage(): ChatMessage | null {
+    if (this.msgs.length === 0) {
+      return null;
+    }
+    return this.msgs[this.msgs.length - 1];
+  }
+
+  isFresh(id: number): boolean {
+    return this.newIds.indexOf(id) >= 0;
+  }
+
+  hasMore(): boolean {
+    return this.hasEarlier;
+  }
+
+  isFetchingOlder(): boolean {
+    return this.loadingOlder;
+  }
+
+  isLoading(): boolean {
+    return AppStorage.get<boolean>(K_CHAT_LOADING) ?? false;
+  }
+
+  setLoading(v: boolean): void {
+    AppStorage.set<boolean>(K_CHAT_LOADING, v);
+  }
+
+  setStage(s: string): void {
+    AppStorage.set<string>(K_CHAT_STAGE, s);
+  }
+
+  setConnected(v: boolean): void {
+    AppStorage.set<boolean>(K_CHAT_CONNECTED, v);
+  }
+
+  sseActive(): boolean {
+    return this.sseActiveForTurn;
+  }
+
+  setSseActive(v: boolean): void {
+    this.sseActiveForTurn = v;
+  }
+
+  /** 聊天流里最后一个带附件的消息：宽屏进入 Split 时用它填充右栏 */
+  latestAttachment(): ChatAttachment | undefined {
+    for (let i = this.msgs.length - 1; i >= 0; i--) {
+      const a: ChatAttachment | undefined = this.msgs[i].attachment;
+      if (a !== undefined) {
+        return a;
+      }
+    }
+    return undefined;
+  }
+
+  // ===================== 列表变更 =====================
+
+  allocId(): number {
+    return this.nextId++;
+  }
+
+  /** 追加一条消息并播入场动画 */
+  pushNew(msg: ChatMessage): void {
+    this.msgs.push(msg);
+    this.markNew(msg.id);
+  }
+
+  /** 标记新消息，触发入场动画 */
+  markNew(msgId: number): void {
+    const arr: number[] = this.newIds.slice();
+    arr.push(msgId);
+    this.newIds = arr;
+    // 这里不切片也不广播：与拆分前一致，入场动画的开场交给紧随其后的
+    // refresh()（50ms 防抖后换新数组引用）那一次一起触发。
+    setTimeout(() => {
+      const idx: number = this.newIds.indexOf(msgId);
+      if (idx >= 0) {
+        const updated: number[] = this.newIds.slice();
+        updated.splice(idx, 1);
+        this.newIds = updated;
+        this.forceRefresh();
+      }
+    }, 250);
+  }
+
+  /**
+   * 取当前助手消息里名为 name 的未完成工具卡，没有就建一张。
+   * 顺带保证一定存在一条"未定稿的助手消息"来挂这些卡。
+   */
+  ensureToolCall(name: string): ToolCallInfo {
+    const last: ChatMessage = this.ensureAssistant();
+    if (last.toolCalls === undefined) {
+      last.toolCalls = [];
+    }
+    for (let i = 0; i < last.toolCalls.length; i++) {
+      const t: ToolCallInfo = last.toolCalls[i];
+      // 只复用"仍在执行"的同名卡：同一轮里同名工具被多次调用时，
+      // 已完成的那张不能被后来的调用覆盖。
+      const st: string | undefined = t.status;
+      if (t.name === name && (st === undefined || st.length === 0 || st === 'running')) {
+        return t;
+      }
+    }
+    const created: ToolCallInfo = { name: name, args: '' };
+    last.toolCalls.push(created);
+    return created;
+  }
+
+  /**
+   * 保证存在一条"未定稿的助手消息"，返回它。
+   * 聚合 reasoning 可能先于任何 delta 到达（非流式后端就只有这一条），
+   * 此时还没有"未完成的助手消息"，必须新建一条，否则内容直接丢失。
+   */
+  ensureAssistant(): ChatMessage {
+    const last: ChatMessage | null = this.lastMessage();
+    if (last !== null && last.role === 'assistant' && last.isFinal !== true) {
+      return last;
+    }
+    const msg: ChatMessage = {
+      id: this.allocId(),
+      role: 'assistant',
+      content: '',
+      isStreaming: true,
+      isFinal: false,
+    };
+    this.pushNew(msg);
+    return msg;
+  }
+
+  /** 流式/高频变更的通知信号：让 ChatStream 滚到底 */
+  requestScroll(): void {
+    const cur: number = AppStorage.get<number>(K_CHAT_SCROLL_REV) ?? 0;
+    AppStorage.set<number>(K_CHAT_SCROLL_REV, cur + 1);
+  }
+
+  /** 防抖刷新：合并高频 SSE delta，最多 ~20fps */
+  refresh(): void {
+    if (this.refreshTimer >= 0) {
+      return;
+    }
+    this.refreshTimer = setTimeout(() => {
+      this.refreshTimer = -1;
+      this.msgs = this.msgs.slice();
+      this.bump();
+    }, 50);
+  }
+
+  /** 强制立即刷新（用于状态切换等需要即时响应的场景） */
+  forceRefresh(): void {
+    if (this.refreshTimer >= 0) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = -1;
+    }
+    this.msgs = this.msgs.slice();
+    this.bump();
+  }
+
+  /** 明细数组不进 AppStorage，用一个自增版本号触发订阅组件重取 */
+  bump(): void {
+    const cur: number = AppStorage.get<number>(K_CHAT_REV) ?? 0;
+    AppStorage.set<number>(K_CHAT_REV, cur + 1);
+  }
+
+  cancelRefresh(): void {
+    if (this.refreshTimer >= 0) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = -1;
+    }
+  }
+
+  // ===================== 折叠开关 =====================
+
+  reasoningOpen(msgId: number): boolean {
+    const m: ChatMessage | undefined = this.findMessage(msgId);
+    return m !== undefined && m.reasoningOpen === true;
+  }
+
+  setReasoningOpen(msgId: number, open: boolean): void {
+    const m: ChatMessage | undefined = this.findMessage(msgId);
+    if (m !== undefined) {
+      m.reasoningOpen = open;
+    }
+  }
+
+  toolOpen(msgId: number, index: number): boolean {
+    const m: ChatMessage | undefined = this.findMessage(msgId);
+    if (m === undefined || m.toolCalls === undefined || index >= m.toolCalls.length) {
+      return false;
+    }
+    return m.toolCalls[index].open === true;
+  }
+
+  setToolOpen(msgId: number, index: number, open: boolean): void {
+    const m: ChatMessage | undefined = this.findMessage(msgId);
+    if (m !== undefined && m.toolCalls !== undefined && index < m.toolCalls.length) {
+      m.toolCalls[index].open = open;
+    }
+  }
+
+  // ===================== 历史 =====================
+
+  private parseHistory(obj: Record<string, Object>): ParsedHistory {
+    return parseHistoryPayload(obj, () => this.allocId());
+  }
+
+  async loadHistory(): Promise<void> {
+    try {
+      // 分段懒加载：首屏只拉最新 CHAT_PAGE_SIZE 条，向上滚动触顶再拉更早的。
+      const resp = await apiClient.getWithTimeout('/chat/history?limit=' + CHAT_PAGE_SIZE, 8000);
+      const obj: Record<string, Object> = JSON.parse(resp.body) as Record<string, Object>;
+      const parsed: ParsedHistory = this.parseHistory(obj);
+      if (parsed.msgs.length === 0) {
+        return;
+      }
+      this.msgs = parsed.msgs;
+      this.offset = parsed.offset;
+      this.hasEarlier = parsed.hasMore;
+      this.forceRefresh();
+      this.requestScroll();
+    } catch (e) {
+      // ignore history load failure
+    }
+  }
+
+  /**
+   * 向上翻页：拉 offset 之前的更早一页，前置到 messages 头部并保持滚动位置。
+   * 触顶（yOffset 接近 0）且有更早历史时由 onDidScroll 触发。
+   */
+  async loadOlder(): Promise<void> {
+    if (this.loadingOlder || !this.hasEarlier) {
+      return;
+    }
+    this.loadingOlder = true;
+    try {
+      const before: number = this.offset;
+      if (before <= 0) {
+        this.hasEarlier = false;
+        return;
+      }
+      const resp = await apiClient.getWithTimeout(
+        '/chat/history?limit=' + CHAT_PAGE_SIZE + '&before=' + before, 8000);
+      const obj: Record<string, Object> = JSON.parse(resp.body) as Record<string, Object>;
+      const parsed: ParsedHistory = this.parseHistory(obj);
+      if (parsed.msgs.length === 0) {
+        this.hasEarlier = false;
+        return;
+      }
+      // 前置插入新页（更早的在前），追加到当前列表头部；id 用新分配的避免与新消息撞号
+      this.msgs = parsed.msgs.concat(this.msgs);
+      this.offset = parsed.offset;
+      this.hasEarlier = parsed.hasMore;
+      this.bump();
+    } catch (e) {
+      // 失败保留 hasEarlier，允许下次滚动重试
+    } finally {
+      this.loadingOlder = false;
+    }
+  }
+
+  /** sync_required：断线重连后服务端要求补拉历史 */
+  reloadHistory(): void {
+    this.loadHistory();
+  }
+
+  // ===================== SSE 连接 =====================
+
+  connect(): void {
+    const cur = connStore.getCurrentConnection();
+    if (cur === null) {
+      return;
+    }
+    this.sse.close();
+    this.sse.connect(cur, '/chat/events',
+      (ev: SseEvent) => {
+        applyChatSse(ev, this);
+      },
+      () => {
+        this.setConnected(false);
+        this.scheduleReconnect();
+      },
+      () => {
+        this.setConnected(true);
+      }).catch(() => {
+      this.setConnected(false);
+      this.scheduleReconnect();
+    });
+  }
+
+  scheduleReconnect(): void {
+    if (this.reconnectTimer >= 0) {
+      return;
+    }
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = -1;
+      this.connect();
+    }, SSE_RECONNECT_MS);
+  }
+
+  cancelReconnect(): void {
+    if (this.reconnectTimer >= 0) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = -1;
+    }
+  }
+
+  /** 页面消失：断线、停表，避免后台空转 */
+  disconnect(): void {
+    this.cancelReconnect();
+    this.sse.close();
+    this.cancelRefresh();
+  }
+}
+
+export const chatStore: ChatStore = new ChatStore();

cmd/ohos/HomeAgent/entry/src/main/ets/common/DeviceBridge.ets

@@ -1,75 +1,8 @@
 import { webSocket } from '@kit.NetworkKit';
-import { DeviceInfo } from '../model/Model';
 import { CapResult } from './BridgeCaps';
-
-// ===== 协议消息（与 remotedevice 插件对齐）=====
-
-interface HelloDeviceInfo {
-  hostname: string;
-  platform: string;
-  arch: string;
-  os_release: string;
-  version: string;
-  cpus: number;
-}
-
-interface HelloDevice {
-  device_id: string;
-  name: string;
-  kind: string;
-  authorized: boolean;
-  caps: string[];
-  info: HelloDeviceInfo;
-}
-
-interface HelloMessage {
-  op: string;
-  device: HelloDevice;
-}
-
-interface BindMessage {
-  op: string;
-  device_id: string;
-  token: string;
-}
-
-interface CmdMessage {
-  op: string;
-  req_id: string;
-  command: string;
-  cmd_type: string;
-}
-
-export interface CmdReply {
-  op: string; // 'cmd_result'
-  req_id: string;
-  status: string;
-  output: string;
-  error: string;
-}
-
-interface DataStartMessage {
-  op: string;
-  req_id: string;
-  kind: string;
-  mime: string;
-  total: number;
-  chunk_size: number;
-}
-
-interface DataEndMessage {
-  op: string;
-  req_id: string;
-  status: string;
-  total?: number;
-  error?: string;
-}
-
-const CHUNK_SIZE: number = 8192;
-
-// ===== 命令处理器回调 =====
-// 返回 CapResult；二进制大结果通过 dataHandler 分块回传。
-export type BridgeCmdHandler = (reqId: string, command: string) => Promise<CapResult>;
+import { BridgeCmdHandler, bridgeHelloFrame, bridgeBindFrame, bridgeResultFrame,
+  bridgeDataStartFrame, bridgeDataEndFrame, bridgeEventFrame, bridgeStatusFrame,
+  bridgeChunkSlices } from './BridgeProtocol';
 
 export class DeviceBridgeClient {
   private ws: webSocket.WebSocket = webSocket.createWebSocket();
@@ -81,14 +14,15 @@ export class DeviceBridgeClient {
   private caps: string[] = [];
   private hostname: string = 'ohos';
   private connected: boolean = false;
-  private everConnected: boolean = false;
+  private bound: boolean = false;
   private manualClose: boolean = false;
   private reconnectTimer: number = -1;
+  private connectionGeneration: number = 0;
   private cmdHandler: BridgeCmdHandler | null = null;
   private onStateChange: ((open: boolean) => void) | null = null;
 
   isConnected(): boolean {
-    return this.connected;
+    return this.connected && this.bound;
   }
 
   getDeviceId(): string {
@@ -117,37 +51,40 @@ export class DeviceBridgeClient {
   }
 
   private async openAndRegister(authorized: boolean): Promise<void> {
-    // 每次连接使用新的 WebSocket 实例，避免旧实例事件残留
     try {
       this.ws.off('open');
       this.ws.off('message');
       this.ws.off('close');
       this.ws.off('error');
+      this.ws.close().catch(() => {
+        // ignore stale socket close failure
+      });
     } catch (e) {
-      // ignore
+      // ignore stale socket cleanup failure
     }
-    this.ws = webSocket.createWebSocket();
-    this.bindWsEvents(authorized);
-    // 鉴权必须走请求头，不能拼 ?token= ：
-    //   1) webui 的 /api/v1/device/* 反代包在 requireAPI 里，
-    //      validAPIKey 只认 X-API-Key 头或 Authorization: Bearer，
-    //      查询参数一律视为未授权 → 握手被 401 顶掉，
-    //      表现为 NETSTACK 日志 "Lws client connection error HS: ws upgrade unauthorized"。
-    //   2) 反代到 remotedevice 时会自行注入网关的 ws_token；
-    //      如果我们再带 ?token=<webui apiKey>，remotedevice 的 ServeWS
-    //      会拿它和 ws_token 比对并 401。留空反而放行。
+    this.connectionGeneration = this.connectionGeneration + 1;
+    const generation: number = this.connectionGeneration;
+    const socket: webSocket.WebSocket = webSocket.createWebSocket();
+    this.ws = socket;
+    this.connected = false;
+    this.bound = false;
+    this.bindWsEvents(socket, authorized, generation);
     const opts: webSocket.WebSocketRequestOptions = {
       header: this.authHeader(),
     };
     try {
-      await this.ws.connect(this.url, opts);
+      await socket.connect(this.url, opts);
     } catch (e) {
-      this.connected = false;
-      this.scheduleReconnect();
+      if (generation === this.connectionGeneration && !this.manualClose) {
+        this.connected = false;
+        this.bound = false;
+        this.notifyState(false);
+        this.scheduleReconnect();
+      }
     }
   }
 
-  /** 握手请求头：X-API-Key + Authorization 双写，兼容不同后端校验实现。 */
+  /** WebUI 用 API key 验证外层连接，并由反代向设备网关注入其内部 token。 */
   private authHeader(): Record<string, string> {
     const h: Record<string, string> = {};
     if (this.token.length > 0) {
@@ -157,38 +94,48 @@ export class DeviceBridgeClient {
     return h;
   }
 
-  private bindWsEvents(authorized: boolean): void {
-    this.ws.on('open', (err: Error, value: Object) => {
+  private bindWsEvents(socket: webSocket.WebSocket, authorized: boolean, generation: number): void {
+    socket.on('open', (err: Error, value: Object) => {
+      if (generation !== this.connectionGeneration || this.manualClose) {
+        socket.close().catch(() => {
+          // ignore stale socket close failure
+        });
+        return;
+      }
       this.connected = true;
-      this.everConnected = true;
-      this.cancelReconnect();
+      this.bound = false;
       this.sendHello(authorized);
       this.sendBind();
-      if (this.onStateChange !== null) {
-        this.onStateChange(true);
-      }
     });
-    this.ws.on('message', (err: Error, value: string | ArrayBuffer) => {
-      if (typeof value === 'string') {
+    socket.on('message', (err: Error, value: string | ArrayBuffer) => {
+      if (generation === this.connectionGeneration && typeof value === 'string') {
         this.handleTextFrame(value);
       }
     });
-    this.ws.on('close', (err: Error, value: webSocket.CloseResult) => {
-      this.connected = false;
-      if (this.onStateChange !== null) {
-        this.onStateChange(false);
-      }
-      this.scheduleReconnect();
+    socket.on('close', (err: Error, value: webSocket.CloseResult) => {
+      this.handleSocketEnd(generation);
     });
-    this.ws.on('error', (err: Error) => {
-      this.connected = false;
-      if (this.onStateChange !== null) {
-        this.onStateChange(false);
-      }
-      this.scheduleReconnect();
+    socket.on('error', (err: Error) => {
+      this.handleSocketEnd(generation);
     });
   }
 
+  private handleSocketEnd(generation: number): void {
+    if (generation !== this.connectionGeneration) {
+      return;
+    }
+    this.connected = false;
+    this.bound = false;
+    this.notifyState(false);
+    this.scheduleReconnect();
+  }
+
+  private notifyState(open: boolean): void {
+    if (this.onStateChange !== null) {
+      this.onStateChange(open);
+    }
+  }
+
   private scheduleReconnect(): void {
     if (this.manualClose || this.reconnectTimer >= 0) {
       return;
@@ -211,18 +158,20 @@ export class DeviceBridgeClient {
     }
   }
 
-  /** 更新本地授权状态并立即重新 hello 同步到服务端。 */
+  /** 更新本地授权状态并在已绑定连接上同步到服务端。 */
   updateAuthorized(authorized: boolean): void {
     this.lastAuthorized = authorized;
-    if (this.connected) {
+    if (this.connected && this.bound) {
       this.sendHello(authorized);
     }
   }
 
   disconnect(): void {
     this.manualClose = true;
+    this.connectionGeneration = this.connectionGeneration + 1;
     this.cancelReconnect();
     this.connected = false;
+    this.bound = false;
     try {
       this.ws.off('open');
       this.ws.off('message');
@@ -234,40 +183,17 @@ export class DeviceBridgeClient {
     } catch (e) {
       // ignore
     }
-    if (this.onStateChange !== null) {
-      this.onStateChange(false);
-    }
+    this.notifyState(false);
   }
 
   private sendHello(authorized: boolean): void {
     this.lastAuthorized = authorized;
-    const info: HelloDeviceInfo = {
-      hostname: this.hostname,
-      platform: 'OpenHarmony',
-      arch: '',
-      os_release: '',
-      version: '1.1.0',
-      cpus: 0,
-    };
-    const device: HelloDevice = {
-      device_id: this.deviceId,
-      name: this.name,
-      kind: this.kind,
-      authorized: authorized,
-      caps: this.caps,
-      info: info,
-    };
-    const hello: HelloMessage = { op: 'hello', device: device };
-    this.send(JSON.stringify(hello));
+    this.send(bridgeHelloFrame(this.deviceId, this.name, this.kind, this.caps,
+      this.hostname, authorized));
   }
 
   private sendBind(): void {
-    const bind: BindMessage = {
-      op: 'bind',
-      device_id: this.deviceId,
-      token: this.token,
-    };
-    this.send(JSON.stringify(bind));
+    this.send(bridgeBindFrame(this.deviceId, this.token));
   }
 
   // ===== 命令处理 =====
@@ -280,67 +206,64 @@ export class DeviceBridgeClient {
       return;
     }
     const op: string = obj['op'] as string ?? '';
-    if (op === 'cmd') {
-      const reqId: string = obj['req_id'] as string ?? '';
-      const command: string = obj['command'] as string ?? '';
-      if (reqId.length === 0 || command.length === 0) {
-        return;
-      }
-      if (!this.lastAuthorized) {
-        this.sendResult(reqId, 'error', '', '设备未授权：请在设备页开启远程控制授权');
-        return;
-      }
-      this.dispatchCommand(reqId, command);
-    } else if (op === 'hello_ack' || op === 'bind_ack') {
-      if (this.onAck !== null) {
-        this.onAck(op);
+    if (op === 'bind_ack') {
+      const accepted: boolean = obj['ok'] === true;
+      if (accepted && this.connected && !this.manualClose) {
+        this.bound = true;
+        this.cancelReconnect();
+        this.notifyState(true);
+      } else {
+        this.bound = false;
+        this.notifyState(false);
+        try {
+          this.ws.close().catch(() => {
+            // ignore bind rejection close failure
+          });
+        } catch (e) {
+          this.scheduleReconnect();
+        }
       }
+      return;
     }
+    if (op !== 'cmd' || !this.bound) {
+      return;
+    }
+    const reqId: string = obj['req_id'] as string ?? '';
+    const command: string = obj['command'] as string ?? '';
+    if (reqId.length === 0 || command.length === 0) {
+      return;
+    }
+    if (!this.lastAuthorized) {
+      this.sendResult(reqId, 'error', '', '设备未授权：请在设备页开启远程控制授权');
+      return;
+    }
+    this.dispatchCommand(reqId, command);
   }
 
-  onAck: ((op: string) => void) | null = null;
-
   private dispatchCommand(reqId: string, command: string): void {
     if (this.cmdHandler === null) {
-      this.sendResult(reqId, 'error', '', 'no capability handler registered');
+      this.sendResult(reqId, 'error', '', '本机能力尚未就绪，请保持应用在前台后重试');
       return;
     }
     const handler: BridgeCmdHandler = this.cmdHandler;
     handler(reqId, command).then((res: CapResult) => {
       this.sendResult(reqId, res.status, res.output, res.error);
     }).catch((e: Object) => {
-      const msg: string = e instanceof Error ? e.message : String(e);
-      this.sendResult(reqId, 'error', '', msg);
+      this.sendResult(reqId, 'error', '', '本机能力执行失败，请稍后重试');
     });
   }
 
   sendResult(reqId: string, status: string, output: string, errMsg: string): void {
-    const result: CmdReply = {
-      op: 'cmd_result',
-      req_id: reqId,
-      status: status,
-      output: output,
-      error: errMsg,
-    };
-    this.send(JSON.stringify(result));
+    this.send(bridgeResultFrame(reqId, status, output, errMsg));
   }
 
   // ===== 二进制分块回传（协议与 GUI 客户端一致）=====
 
   sendDataChunked(reqId: string, kind: string, mime: string, bytes: Uint8Array): void {
-    const startMsg: DataStartMessage = {
-      op: 'cmd_data_start',
-      req_id: reqId,
-      kind: kind,
-      mime: mime,
-      total: bytes.byteLength,
-      chunk_size: CHUNK_SIZE,
-    };
-    this.send(JSON.stringify(startMsg));
-    for (let off: number = 0; off < bytes.byteLength; off += CHUNK_SIZE) {
-      const end: number = Math.min(off + CHUNK_SIZE, bytes.byteLength);
-      const view: Uint8Array = bytes.slice(off, end);
-      const ab: ArrayBuffer = view.buffer as ArrayBuffer;
+    this.send(bridgeDataStartFrame(reqId, kind, mime, bytes.byteLength));
+    const chunks: Uint8Array[] = bridgeChunkSlices(bytes);
+    for (let i = 0; i < chunks.length; i++) {
+      const ab: ArrayBuffer = chunks[i].buffer as ArrayBuffer;
       try {
         this.ws.send(ab).catch(() => {
           // ignore per-chunk failure; end frame reports error below
@@ -349,32 +272,15 @@ export class DeviceBridgeClient {
         break;
       }
     }
-    const endMsg: DataEndMessage = {
-      op: 'cmd_data_end',
-      req_id: reqId,
-      status: 'ok',
-    };
-    this.send(JSON.stringify(endMsg));
+    this.send(bridgeDataEndFrame(reqId));
   }
 
   sendEvent(eventType: string, detail: string): void {
-    const payload: Record<string, string> = { 'detail': detail };
-    const msg: Record<string, Object> = {
-      'op': 'event',
-      'device_id': this.deviceId,
-      'type': eventType,
-      'payload': payload,
-    };
-    this.send(JSON.stringify(msg));
+    this.send(bridgeEventFrame(this.deviceId, eventType, detail));
   }
 
   sendStatus(status: string): void {
-    const msg: Record<string, Object> = {
-      'op': 'status',
-      'device_id': this.deviceId,
-      'status': status,
-    };
-    this.send(JSON.stringify(msg));
+    this.send(bridgeStatusFrame(this.deviceId, status));
   }
 
   send(text: string): void {
@@ -388,7 +294,3 @@ export class DeviceBridgeClient {
 }
 
 export const deviceBridge: DeviceBridgeClient = new DeviceBridgeClient();
-
-export function parseDevicesPayload(jsonStr: string): DeviceInfo[] {
-  return [];
-}

cmd/ohos/HomeAgent/entry/src/main/ets/common/DeviceBridgeSession.ets

@@ -0,0 +1,105 @@
+import { common } from '@kit.AbilityKit';
+import { deviceBridge } from './DeviceBridge';
+import { installCmdRouter, setBridgeAppContext } from './BridgeRouter';
+import { LOCAL_DEVICE_CAPS, shutdownSpeakerUse } from './BridgeCaps';
+import { connStore } from './ConnStore';
+import { ConnectionConfig } from '../model/Model';
+
+export { LOCAL_DEVICE_CAPS } from './BridgeCaps';
+
+let bridgeStarting: boolean = false;
+let foregroundActive: boolean = false;
+let rootUIReady: boolean = false;
+let bridgeGeneration: number = 0;
+let stateTrackingReady: boolean = false;
+
+function ensureBridgeStateTracking(): void {
+  if (stateTrackingReady) {
+    return;
+  }
+  stateTrackingReady = true;
+  AppStorage.setOrCreate<boolean>('deviceBridgeConnected', false);
+  deviceBridge.setStateListener((open: boolean) => {
+    AppStorage.set<boolean>('deviceBridgeConnected', open);
+  });
+}
+
+/** 把当前后端 HTTP 地址转换为同源设备桥 WebSocket 地址。 */
+export function deviceGatewayUrl(base: string): string {
+  let trimmed: string = base.trim();
+  while (trimmed.length > 0 && trimmed.charAt(trimmed.length - 1) === '/') {
+    trimmed = trimmed.substring(0, trimmed.length - 1);
+  }
+  let scheme: string = 'ws://';
+  let rest: string = trimmed;
+  if (trimmed.startsWith('https://')) {
+    scheme = 'wss://';
+    rest = trimmed.substring('https://'.length);
+  } else if (trimmed.startsWith('http://')) {
+    rest = trimmed.substring('http://'.length);
+  } else if (trimmed.startsWith('wss://')) {
+    scheme = 'wss://';
+    rest = trimmed.substring('wss://'.length);
+  } else if (trimmed.startsWith('ws://')) {
+    rest = trimmed.substring('ws://'.length);
+  }
+  return scheme + rest + '/api/v1/device/ws';
+}
+
+/**
+ * 应用进入前台后建立全局设备桥。它不再依赖用户先打开“设备”Tab，
+ * 因而 screensue、clipboardsee 等前台能力从主页面加载后即可接收。
+ */
+export async function startForegroundBridge(context: common.UIAbilityContext): Promise<void> {
+  foregroundActive = true;
+  setBridgeAppContext(context);
+  installCmdRouter();
+  ensureBridgeStateTracking();
+  if (!rootUIReady || deviceBridge.isConnected() || bridgeStarting) {
+    return;
+  }
+  const cur: ConnectionConfig | null = connStore.getCurrentConnection();
+  if (cur === null || cur.url.length === 0 || cur.apiKey.length === 0) {
+    return;
+  }
+  bridgeStarting = true;
+  bridgeGeneration = bridgeGeneration + 1;
+  const generation: number = bridgeGeneration;
+  const deviceId: string = connStore.ensureDeviceId();
+  try {
+    await deviceBridge.connect(
+      deviceGatewayUrl(cur.url), cur.apiKey, deviceId,
+      LOCAL_DEVICE_CAPS, 'ohos-phone', connStore.getDeviceAuth(), connStore.getDeviceName());
+    if (!foregroundActive || generation !== bridgeGeneration) {
+      deviceBridge.disconnect();
+    }
+  } catch (e) {
+    // DeviceBridge 自己会安排重连；前台启动不弹技术错误打扰用户。
+  }
+  if (generation === bridgeGeneration) {
+    bridgeStarting = false;
+  }
+}
+
+/** 根页面挂载完成后才连接，避免首条 screensue 到达时展示层尚未注册。 */
+export function markForegroundBridgeUIReady(context: common.UIAbilityContext): void {
+  rootUIReady = true;
+  startForegroundBridge(context);
+}
+
+/** 后台不接受需要前台 UI/剪贴板授权的命令。 */
+export function stopForegroundBridge(): void {
+  foregroundActive = false;
+  bridgeGeneration = bridgeGeneration + 1;
+  bridgeStarting = false;
+  shutdownSpeakerUse();
+  deviceBridge.disconnect();
+}
+
+/** 连接配置切换或修改后立即让设备桥使用新地址和 Token。 */
+export async function restartForegroundBridge(context: common.UIAbilityContext): Promise<void> {
+  bridgeGeneration = bridgeGeneration + 1;
+  bridgeStarting = false;
+  deviceBridge.disconnect();
+  await startForegroundBridge(context);
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/DeviceModel.ets

@@ -0,0 +1,73 @@
+/**
+ * 设备页的纯逻辑：本机 device_id 兜底与在线设备列表解析。
+ *
+ * 从 pages/DevicePage.ets 抽出（非 UI，可被其它页面/桥复用）。
+ */
+
+import { DeviceInfo } from '../model/Model';
+import { connStore } from './ConnStore';
+
+// ===== 二级页面路由 id（页面与一级入口列表共用）=====
+export const SUB_NONE: string = '';
+export const SUB_LOCAL: string = 'local';
+export const SUB_CAPS: string = 'caps';
+export const SUB_GATEWAY: string = 'gateway';
+export const SUB_LIST: string = 'list';
+
+/**
+ * 本机 device_id：桥里已有就用桥的，其次读持久化，都没有则生成一个并落盘。
+ * 生成后必须持久化，否则每次冷启动换 id，网关侧会累积成一堆幽灵设备。
+ *
+ * 判定顺序与原 DevicePage.aboutToAppear 一致：桥的 id 优先于持久化的 id。
+ */
+export function resolveDeviceId(bridgeId: string): string {
+  let id: string = bridgeId;
+  if (id.length === 0) {
+    id = connStore.getDeviceId();
+  }
+  if (id.length === 0) {
+    id = 'ohos-' + Date.now().toString(36);
+    try {
+      connStore.saveDeviceId(id);
+    } catch (e) {
+      // ignore persist failure
+    }
+  }
+  return id;
+}
+
+/**
+ * 解析 /device/online 响应体。
+ *
+ * apiClient 已自动前置 /api/v1，调用方只写其后的部分
+ * （否则会拼成 /api/v1/api/v1/device/online 并 404）。
+ */
+export function parseOnlineDevices(parsed: Record<string, Object>): DeviceInfo[] {
+  const devs: Object = parsed['devices'];
+  const list: DeviceInfo[] = [];
+  if (devs === undefined || devs === null) {
+    return list;
+  }
+  const arr: Object[] = devs as Object[];
+  for (let i = 0; i < arr.length; i++) {
+    const d: Record<string, Object> = arr[i] as Record<string, Object>;
+    const capsArr: Object = d['caps'];
+    const caps: string[] = [];
+    if (capsArr !== undefined && capsArr !== null) {
+      const cArr: Object[] = capsArr as Object[];
+      for (let j = 0; j < cArr.length; j++) {
+        caps.push(cArr[j] as string);
+      }
+    }
+    const info: DeviceInfo = {
+      deviceId: d['device_id'] as string ?? '',
+      name: d['name'] as string ?? '',
+      kind: d['kind'] as string ?? '',
+      online: true,
+      authorized: d['authorized'] as boolean ?? false,
+      caps: caps,
+    };
+    list.push(info);
+  }
+  return list;
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/MarkdownParser.ets

@@ -0,0 +1,282 @@
+/**
+ * Markdown 解析器（无 UI 依赖）。
+ *
+ * 从 components/StaticMarkdown.ets 抽出：解析与渲染分家后，
+ * 解析规则可以单独被复用/测试，渲染组件也回到可读长度。
+ *
+ * 覆盖：标题、段落、代码围栏、无序/有序列表、引用块、分隔线、表格，
+ * 以及行内的粗体/斜体/行内代码/链接。
+ */
+
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+export interface MdBlock {
+  type: string; // 'heading' | 'code' | 'list' | 'ol' | 'blockquote' | 'hr' | 'table' | 'para'
+  level?: number;
+  items?: string[];
+  text?: string;
+  lang?: string;
+  codeLines?: string[];
+  headers?: string[];
+  rows?: string[][];
+}
+
+export interface MdSpan {
+  text: string;
+  bold?: boolean;
+  italic?: boolean;
+  code?: boolean;
+  link?: boolean;
+  linkUrl?: string;
+}
+
+// ── Inline parser ──────────────────────────────────────────────────────────────
+
+export function parseInline(text: string): MdSpan[] {
+  const spans: MdSpan[] = [];
+  let i: number = 0;
+  while (i < text.length) {
+    // Inline code (backtick)
+    if (text[i] === '`') {
+      const end: number = text.indexOf('`', i + 1);
+      if (end > i) {
+        spans.push({ text: text.substring(i + 1, end), code: true });
+        i = end + 1;
+        continue;
+      }
+    }
+    // Bold: **text**
+    if (text[i] === '*' && i + 1 < text.length && text[i + 1] === '*') {
+      const end: number = text.indexOf('**', i + 2);
+      if (end > i + 1) {
+        spans.push({ text: text.substring(i + 2, end), bold: true });
+        i = end + 2;
+        continue;
+      }
+    }
+    // Italic: *text* (single asterisk)
+    if (text[i] === '*' && (i + 1 >= text.length || text[i + 1] !== '*')) {
+      const end: number = text.indexOf('*', i + 1);
+      if (end > i) {
+        spans.push({ text: text.substring(i + 1, end), italic: true });
+        i = end + 1;
+        continue;
+      }
+    }
+    // Link: [text](url)
+    if (text[i] === '[') {
+      const cb: number = text.indexOf(']', i + 1);
+      if (cb > i && cb + 1 < text.length && text[cb + 1] === '(') {
+        const cp: number = text.indexOf(')', cb + 2);
+        if (cp > cb + 1) {
+          spans.push({ text: text.substring(i + 1, cb), link: true, linkUrl: text.substring(cb + 2, cp) });
+          i = cp + 1;
+          continue;
+        }
+      }
+    }
+    // Plain run
+    let j: number = i + 1;
+    while (j < text.length && text[j] !== '`' && text[j] !== '*' && text[j] !== '[') {
+      j++;
+    }
+    spans.push({ text: text.substring(i, j) });
+    i = j;
+  }
+  return spans;
+}
+
+// ── Block parser helpers ───────────────────────────────────────────────────────
+
+function isHr(line: string): boolean {
+  if (line.length < 3) {
+    return false;
+  }
+  const ch: string = line[0];
+  if (ch !== '-' && ch !== '*' && ch !== '_') {
+    return false;
+  }
+  for (let k = 0; k < line.length; k++) {
+    if (line[k] !== ch) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isOlStart(line: string): boolean {
+  if (line.length < 3) {
+    return false;
+  }
+  let k: number = 0;
+  while (k < line.length && line[k] >= '0' && line[k] <= '9') {
+    k++;
+  }
+  return k > 0 && k + 1 < line.length && line[k] === '.' && line[k + 1] === ' ';
+}
+
+function isTableSep(line: string): boolean {
+  if (!line.includes('-')) {
+    return false;
+  }
+  for (let k = 0; k < line.length; k++) {
+    const c: string = line[k];
+    if (c !== '|' && c !== '-' && c !== ':' && c !== ' ' && c !== '\t') {
+      return false;
+    }
+  }
+  return true;
+}
+
+/** 表格行 → 单元格数组（去掉首尾空串产生的空单元格）。 */
+function parseTableRow(row: string): string[] {
+  const cells: string[] = [];
+  const parts: string[] = row.split('|');
+  for (let p = 0; p < parts.length; p++) {
+    const c: string = parts[p].trim();
+    if (c.length > 0) {
+      cells.push(c);
+    }
+  }
+  return cells;
+}
+
+// ── Block parser ───────────────────────────────────────────────────────────────
+
+export function parseBlocks(content: string): MdBlock[] {
+  if (content.length === 0) {
+    return [];
+  }
+  const lines: string[] = content.split('\n');
+  const blocks: MdBlock[] = [];
+  let i: number = 0;
+
+  while (i < lines.length) {
+    const line: string = lines[i];
+
+    // Empty line
+    if (line.trim().length === 0) {
+      i++;
+      continue;
+    }
+
+    // Code fence
+    if (line.startsWith('```')) {
+      const langEnd: number = line.indexOf('`', 3);
+      const lang: string = langEnd > 3 ? line.substring(3, langEnd).trim() : '';
+      const codeLines: string[] = [];
+      i++;
+      while (i < lines.length && !lines[i].trimStart().startsWith('```')) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) {
+        i++;
+      }
+      blocks.push({ type: 'code', lang: lang, codeLines: codeLines });
+      continue;
+    }
+
+    // Heading
+    if (line.startsWith('#')) {
+      let level: number = 0;
+      while (level < line.length && line[level] === '#') {
+        level++;
+      }
+      if (level <= 6 && level < line.length && line[level] === ' ') {
+        blocks.push({ type: 'heading', level: level, text: line.substring(level + 1).trim() });
+        i++;
+        continue;
+      }
+    }
+
+    // Horizontal rule
+    if (isHr(line.trim())) {
+      blocks.push({ type: 'hr' });
+      i++;
+      continue;
+    }
+
+    // Unordered list
+    if ((line.startsWith('- ') || line.startsWith('* ')) && !line.startsWith('- [')) {
+      const items: string[] = [];
+      while (i < lines.length && (lines[i].startsWith('- ') || lines[i].startsWith('* ')) && !lines[i].startsWith('- [')) {
+        items.push(lines[i].substring(2));
+        i++;
+      }
+      blocks.push({ type: 'list', items: items });
+      continue;
+    }
+
+    // Ordered list
+    if (isOlStart(line)) {
+      const items: string[] = [];
+      while (i < lines.length && isOlStart(lines[i])) {
+        const dotIdx: number = lines[i].indexOf('. ');
+        items.push(lines[i].substring(dotIdx + 2));
+        i++;
+      }
+      blocks.push({ type: 'ol', items: items });
+      continue;
+    }
+
+    // Blockquote
+    if (line.startsWith('> ')) {
+      const qLines: string[] = [];
+      while (i < lines.length && lines[i].startsWith('> ')) {
+        qLines.push(lines[i].substring(2));
+        i++;
+      }
+      blocks.push({ type: 'blockquote', text: qLines.join('\n') });
+      continue;
+    }
+
+    // Table
+    if (line.trimStart().startsWith('|') && !isTableSep(line)) {
+      const tLines: string[] = [];
+      while (i < lines.length && lines[i].trimStart().startsWith('|')) {
+        tLines.push(lines[i]);
+        i++;
+      }
+      if (tLines.length >= 2) {
+        const headers: string[] = parseTableRow(tLines[0]);
+        const rows: string[][] = [];
+        for (let k = 1; k < tLines.length; k++) {
+          if (!isTableSep(tLines[k].trim())) {
+            rows.push(parseTableRow(tLines[k]));
+          }
+        }
+        if (headers.length > 0) {
+          blocks.push({ type: 'table', headers: headers, rows: rows });
+        }
+      }
+      continue;
+    }
+
+    // Paragraph: collect consecutive non-special lines
+    {
+      const paraLines: string[] = [];
+      while (i < lines.length) {
+        const ln: string = lines[i];
+        if (ln.trim().length === 0) {
+          break;
+        }
+        if (ln.startsWith('```') || ln.startsWith('#') || isHr(ln.trim())) {
+          break;
+        }
+        if (ln.startsWith('- ') || ln.startsWith('* ') || isOlStart(ln) || ln.startsWith('> ')) {
+          break;
+        }
+        if (ln.trimStart().startsWith('|') && !isTableSep(ln)) {
+          break;
+        }
+        paraLines.push(ln);
+        i++;
+      }
+      if (paraLines.length > 0) {
+        blocks.push({ type: 'para', text: paraLines.join('\n') });
+      }
+    }
+  }
+  return blocks;
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/PluginApi.ets

@@ -0,0 +1,174 @@
+/**
+ * 插件数据获取（无 UI 依赖）。
+ *
+ * 从 pages/PluginsPage.ets 抽出：三处接口的取数、合并口径与字段解析
+ * 都放在这里，页面只负责把结果落到 @State。
+ *
+ * 数据源对齐 WebGUI renderPlugins：
+ *  - GET /kernel           → plugins[{name,loaded}]（含全部内置插件）+ tools（按 plugin 归属）
+ *  - GET /plugins          → 已安装外部插件元数据（version/description 等）
+ *  - GET /plugins/disabled → {disabled:[{name,...}]}
+ * 三方按名称合并去重排序。
+ */
+
+import { apiClient } from './ApiClient';
+import { PluginRow, PluginDetail, emptyPluginDetail } from '../model/Model';
+
+/** 拉取并合并插件列表；失败时抛错，由调用方转成人话提示。 */
+export async function fetchPluginRows(): Promise<PluginRow[]> {
+  // ---- kernel: loaded plugins + tool ownership ----
+  const loadedMap: Map<string, boolean> = new Map<string, boolean>();
+  const toolsByPlugin: Map<string, string[]> = new Map<string, string[]>();
+  const kResp = await apiClient.getWithTimeout('/kernel', 12000);
+  const kernelObj: Record<string, Object> = JSON.parse(kResp.body) as Record<string, Object>;
+  const kpRaw: Object | undefined = kernelObj['plugins'];
+  if (kpRaw !== undefined && kpRaw !== null) {
+    const kpArr: Object[] = kpRaw as Object[];
+    for (let i = 0; i < kpArr.length; i++) {
+      const item: Record<string, Object> = kpArr[i] as Record<string, Object>;
+      const n: string = item['name'] as string ?? '';
+      if (n.length === 0) {
+        continue;
+      }
+      loadedMap.set(n, item['loaded'] as boolean ?? true);
+    }
+  }
+  const tRaw: Object | undefined = kernelObj['tools'];
+  if (tRaw !== undefined && tRaw !== null) {
+    const tArr: Object[] = tRaw as Object[];
+    for (let i = 0; i < tArr.length; i++) {
+      const item: Record<string, Object> = tArr[i] as Record<string, Object>;
+      const tn: string = item['name'] as string ?? '';
+      const owner: string = item['plugin'] as string ?? '';
+      if (tn.length === 0 || owner.length === 0) {
+        continue;
+      }
+      let list: string[] | undefined = toolsByPlugin.get(owner);
+      if (list === undefined) {
+        list = [];
+        toolsByPlugin.set(owner, list);
+      }
+      // 每插件最多展示 8 个工具名，避免卡片过长
+      if (list.length < 8) {
+        list.push(tn);
+      }
+    }
+  }
+
+  // ---- installed external plugins metadata ----
+  const externalMeta: Map<string, Record<string, Object>> = new Map<string, Record<string, Object>>();
+  try {
+    const pResp = await apiClient.getWithTimeout('/plugins', 10000);
+    const bodyTrim = pResp.body.trim();
+    let arr: Object[] = [];
+    if (bodyTrim.length > 0 && bodyTrim.charAt(0) === '[') {
+      arr = JSON.parse(pResp.body) as Object[];
+    } else {
+      const obj: Record<string, Object> = JSON.parse(pResp.body) as Record<string, Object>;
+      const rawList: Object = obj['plugins'] ?? obj['data'];
+      if (rawList !== undefined && rawList !== null) {
+        arr = rawList as Object[];
+      }
+    }
+    for (let i = 0; i < arr.length; i++) {
+      const item: Record<string, Object> = arr[i] as Record<string, Object>;
+      const n: string = item['name'] as string ?? '';
+      if (n.length > 0) {
+        externalMeta.set(n, item);
+      }
+    }
+  } catch (e) {
+    // 外部列表失败不阻塞内置展示
+  }
+
+  // ---- disabled list ----
+  const disabledNames: Set<string> = new Set<string>();
+  try {
+    const dResp = await apiClient.getWithTimeout('/plugins/disabled', 8000);
+    const dObj: Record<string, Object> = JSON.parse(dResp.body) as Record<string, Object>;
+    const dArr: Object | undefined = dObj['disabled'];
+    if (dArr !== undefined && dArr !== null) {
+      const items: Object[] = dArr as Object[];
+      for (let di = 0; di < items.length; di++) {
+        const dItem: Record<string, Object> = items[di] as Record<string, Object>;
+        const dn: string = dItem['name'] as string ?? '';
+        if (dn.length > 0) {
+          disabledNames.add(dn);
+        }
+      }
+    }
+  } catch (e) {
+    // disabled endpoint may not exist; ignore
+  }
+
+  // ---- merge: allNames sorted（与 GUI 一致）----
+  const allNames: Set<string> = new Set<string>();
+  loadedMap.forEach((v: boolean, k: string) => {
+    allNames.add(k);
+  });
+  externalMeta.forEach((v: Record<string, Object>, k: string) => {
+    allNames.add(k);
+  });
+  disabledNames.forEach((n: string) => {
+    allNames.add(n);
+  });
+  const names: string[] = Array.from(allNames);
+  names.sort();
+
+  const rows: PluginRow[] = [];
+  for (let i = 0; i < names.length; i++) {
+    const name: string = names[i];
+    const meta: Record<string, Object> | undefined = externalMeta.get(name);
+    const tools: string[] | undefined = toolsByPlugin.get(name);
+    const row: PluginRow = {
+      name: name,
+      loaded: loadedMap.get(name) ?? false,
+      disabled: disabledNames.has(name),
+      external: externalMeta.has(name),
+      version: meta !== undefined ? meta['version'] as string ?? '' : '',
+      description: meta !== undefined ? meta['description'] as string ?? '' : '',
+      tools: tools,
+    };
+    rows.push(row);
+  }
+  return rows;
+}
+
+function strArray(raw: Object | undefined): string[] {
+  const out: string[] = [];
+  if (raw === undefined || raw === null) {
+    return out;
+  }
+  const arr: Object[] = raw as Object[];
+  for (let i = 0; i < arr.length; i++) {
+    const s: string = arr[i] as string ?? '';
+    if (s.length > 0) {
+      out.push(s);
+    }
+  }
+  return out;
+}
+
+/**
+ * GET /plugins/{name} —— 后端返回插件清单字段。
+ * WebGUI 只是把它 JSON.stringify 进 <pre>，这里逐字段结构化展示。
+ * 内置插件不在 /plugins 里，取不到详情时由调用方退回列表已有信息。
+ */
+export async function fetchPluginDetail(name: string): Promise<PluginDetail> {
+  const resp = await apiClient.getWithTimeout('/plugins/' + name, 10000);
+  const o: Record<string, Object> = JSON.parse(resp.body) as Record<string, Object>;
+  const d: PluginDetail = emptyPluginDetail();
+  d.name = o['name'] as string ?? name;
+  d.version = o['version'] as string ?? '';
+  d.description = o['description'] as string ?? '';
+  d.author = o['author'] as string ?? '';
+  d.license = o['license'] as string ?? '';
+  d.homepage = o['homepage'] as string ?? '';
+  d.repository = o['repository'] as string ?? '';
+  d.entry = o['entry'] as string ?? '';
+  d.minVersion = o['min_version'] as string ?? '';
+  d.deprecated = o['deprecated'] as boolean ?? false;
+  d.tags = strArray(o['tags']);
+  d.files = strArray(o['files']);
+  return d;
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/PluginStatus.ets

@@ -0,0 +1,78 @@
+/**
+ * 插件状态展示口径（纯函数，无 UI 依赖）。
+ *
+ * 从 pages/PluginsPage.ets 抽出：列表行与详情页共用同一套状态判定/文案/配色，
+ * 抽成模块后两处不会再各写一份。
+ *
+ * 状态口径与 WebGUI 一致：已加载绿 / 禁用待生效黄 / 已禁用红 / 未加载灰。
+ */
+
+import { PluginRow } from '../model/Model';
+
+/** 'loaded' | 'pending' | 'disabled' | 'notloaded' */
+export function pluginStatusOf(plugin: PluginRow): string {
+  if (plugin.loaded && !plugin.disabled) {
+    return 'loaded'; // 已加载
+  }
+  if (plugin.loaded && plugin.disabled) {
+    return 'pending'; // 运行中(禁用待生效)
+  }
+  if (plugin.disabled) {
+    return 'disabled'; // 已禁用
+  }
+  return 'notloaded'; // 未加载
+}
+
+export function pluginStatusText(plugin: PluginRow): string {
+  const s: string = pluginStatusOf(plugin);
+  if (s === 'loaded') {
+    return '已加载';
+  }
+  if (s === 'pending') {
+    return '待生效';
+  }
+  if (s === 'disabled') {
+    return '已禁用';
+  }
+  return '未加载';
+}
+
+/** 状态点颜色；未加载态用主题里的弱化色（mutedColor 由调用方从 palette 取）。 */
+export function pluginStatusColor(plugin: PluginRow, mutedColor: string): string {
+  const s: string = pluginStatusOf(plugin);
+  if (s === 'loaded') {
+    return '#17A964';
+  }
+  if (s === 'pending') {
+    return '#D99A2B';
+  }
+  if (s === 'disabled') {
+    return '#E84026';
+  }
+  return mutedColor;
+}
+
+/** 列表行副标题：状态 + 内置/外部 + 工具数，一行灰字，不用徽标 */
+export function pluginRowSubtitle(plugin: PluginRow): string {
+  const parts: string[] = [];
+  parts.push(pluginStatusText(plugin));
+  parts.push(plugin.external ? '外部' : '内置');
+  if (plugin.tools !== undefined && plugin.tools.length > 0) {
+    parts.push(plugin.tools.length.toString() + ' 工具');
+  }
+  return parts.join(' · ');
+}
+
+/** 详情页状态行：状态 + 内置/外部 + 已废弃 + 工具数（顺序与原实现一致） */
+export function pluginDetailStatusLine(row: PluginRow, deprecated: boolean): string {
+  const parts: string[] = [];
+  parts.push(pluginStatusText(row));
+  parts.push(row.external ? '外部' : '内置');
+  if (deprecated) {
+    parts.push('已废弃');
+  }
+  if (row.tools !== undefined && row.tools.length > 0) {
+    parts.push(row.tools.length.toString() + ' 个工具');
+  }
+  return parts.join(' · ');
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/SettingsModel.ets

@@ -0,0 +1,313 @@
+/**
+ * 设置数据模型与纯解析逻辑（无 UI 依赖）。
+ *
+ * 从 pages/SettingsPage.ets 抽出：/settings 的响应解析、key 分区归类、
+ * 分页取项都是纯函数，页面只负责把结果落到 @State。
+ */
+
+/** One settings key card rendered in the editor list. */
+export interface SettingEntry {
+  key: string;
+  displayName: string;
+  description: string;
+  type: string; // bool | int | duration | select | password | text | string
+  options: string[];
+  value: string; // raw string value as stored by backend
+  dirty: boolean;
+}
+
+export interface SettingsSection {
+  id: string;
+  title: string;
+  count: number;
+}
+
+export interface SettingMetaRaw {
+  key: string;
+  type: string;
+  displayName: string;
+  description: string;
+  category: string;
+  options: string[];
+}
+
+export const SETTINGS_PAGE_SIZE: number = 40;
+
+/**
+ * 二级页面标识。
+ * 一级入口列表（components/SettingsRootEntries.ets）与页面路由表分开成文件后，
+ * 这些 id 必须只有一个来源 —— 否则改一处就会"点了没反应"。
+ */
+export const SUB_NONE: string = '';
+export const SUB_STATUS: string = 'status';
+export const SUB_CONNECTIONS: string = 'connections';
+export const SUB_APPEARANCE: string = 'appearance';
+export const SUB_BACKEND: string = 'backend';
+export const SUB_SECTION: string = 'section';
+
+/** /settings 响应解析结果 */
+export interface ParsedSettings {
+  meta: Record<string, SettingMetaRaw>;
+  values: Record<string, string>;
+}
+
+/** 分区统计结果 */
+export interface SectionStats {
+  sections: SettingsSection[];
+  /** plugin.* 配置项总数（编辑入口在插件详情页，这里只用于提示去向） */
+  pluginKeyCount: number;
+  /** 涉及的插件个数 */
+  pluginConfigCount: number;
+}
+
+/**
+ * 解析 GET /settings 响应：meta 定义 + 当前值。
+ * 值统一转成字符串（后端可能给 bool/number/嵌套对象）。
+ */
+export function parseSettingsPayload(body: string): ParsedSettings {
+  const obj: Record<string, Object> = JSON.parse(body) as Record<string, Object>;
+  const metaStore: Record<string, SettingMetaRaw> = {};
+  const valuesStore: Record<string, string> = {};
+
+  const rawMeta: Object | undefined = obj['meta'];
+  if (rawMeta !== undefined && rawMeta !== null) {
+    const mObj: Record<string, Object> = rawMeta as Record<string, Object>;
+    for (const mk of Object.keys(mObj)) {
+      const item: Record<string, Object> = mObj[mk] as Record<string, Object>;
+      const optsArr: Object | undefined = item['options'];
+      const opts: string[] = [];
+      if (optsArr !== undefined && optsArr !== null) {
+        const oa: Object[] = optsArr as Object[];
+        for (let i = 0; i < oa.length; i++) {
+          opts.push(oa[i] as string);
+        }
+      }
+      const meta: SettingMetaRaw = {
+        key: item['key'] as string ?? mk,
+        type: item['type'] as string ?? 'string',
+        displayName: item['display_name'] as string ?? '',
+        description: item['description'] as string ?? '',
+        category: item['category'] as string ?? '',
+        options: opts,
+      };
+      metaStore[mk] = meta;
+    }
+  }
+
+  const rawVals: Object | undefined = obj['settings'];
+  if (rawVals !== undefined && rawVals !== null) {
+    const vObj: Record<string, Object> = rawVals as Record<string, Object>;
+    for (const vk of Object.keys(vObj)) {
+      if (vk.length === 0) {
+        continue;
+      }
+      const val: Object = vObj[vk];
+      let strVal: string;
+      if (typeof val === 'string') {
+        strVal = val as string;
+      } else if (typeof val === 'boolean' || typeof val === 'number') {
+        strVal = String(val);
+      } else {
+        strVal = JSON.stringify(val);
+      }
+      valuesStore[vk] = strVal;
+    }
+  }
+
+  const parsed: ParsedSettings = { meta: metaStore, values: valuesStore };
+  return parsed;
+}
+
+export function metaCategory(metaStore: Record<string, SettingMetaRaw>, key: string): string {
+  const m: SettingMetaRaw | undefined = metaStore[key];
+  return m !== undefined && m.category.length > 0 ? m.category : '';
+}
+
+export function categoryTitle(cat: string): string {
+  const map: Record<string, string> = {
+    'agent': '智能体',
+    'daemon': '守护进程',
+    'llm': '大模型',
+    'sources': '数据源',
+    'input': '输入',
+    'paths': '路径',
+    'resources': '资源',
+    'defaults': '默认值',
+    'snapshot': '快照',
+    'rollback': '回滚',
+  };
+  const t: string | undefined = map[cat];
+  return t !== undefined ? t : cat;
+}
+
+/**
+ * 把 key 归到分区：
+ *  - core.*   → 'core/<category>'，展示在「核心」二级页下
+ *  - plugin.* → 'plugin/<name>'，仅用于计数；实际编辑在插件详情页里，
+ *               不在这里列出（否则同一批 key 会有两个入口）
+ *  - 其余     → 'other'
+ */
+export function buildSections(
+  valuesStore: Record<string, string>, metaStore: Record<string, SettingMetaRaw>): SectionStats {
+  const ids: string[] = [];
+  const counts: Record<string, number> = {};
+  const titles: Record<string, string> = {};
+  let pluginKeys: number = 0;
+  const plugNames: string[] = [];
+  for (const key of Object.keys(valuesStore)) {
+    if (key.startsWith('plugin.')) {
+      // 插件配置不在这里列：它属于插件本身，入口在「插件 → 详情 → 插件配置」。
+      // 这里只统计，用于提示有多少项在那边。
+      pluginKeys = pluginKeys + 1;
+      const rest: string = key.substring('plugin.'.length);
+      const dot: number = rest.indexOf('.');
+      const plugName: string = dot > 0 ? rest.substring(0, dot) : rest;
+      if (plugName.length > 0 && plugNames.indexOf(plugName) < 0) {
+        plugNames.push(plugName);
+      }
+      continue;
+    }
+    let secId: string;
+    if (key.startsWith('core.')) {
+      const cat: string = metaCategory(metaStore, key);
+      secId = cat.length > 0 ? 'core/' + cat : 'core/misc';
+      if (titles[secId] === undefined) {
+        titles[secId] = cat.length > 0 ? categoryTitle(cat) : '未分类';
+      }
+    } else {
+      secId = 'other';
+      if (titles[secId] === undefined) {
+        titles[secId] = '其他';
+      }
+    }
+    if (counts[secId] === undefined) {
+      counts[secId] = 0;
+      ids.push(secId);
+    }
+    counts[secId] = counts[secId] + 1;
+  }
+  ids.sort((a: string, b: string): number => a.localeCompare(b));
+  const secs: SettingsSection[] = [];
+  for (const id of ids) {
+    secs.push({ id: id, title: titles[id] ?? id, count: counts[id] ?? 0 });
+  }
+  const stats: SectionStats = {
+    sections: secs,
+    pluginKeyCount: pluginKeys,
+    pluginConfigCount: plugNames.length,
+  };
+  return stats;
+}
+
+export function pickInitialSection(sections: SettingsSection[]): string {
+  for (let i = 0; i < sections.length; i++) {
+    if (sections[i].id === 'core/agent') {
+      return 'core/agent';
+    }
+  }
+  return sections.length > 0 ? sections[0].id : 'core';
+}
+
+export function keyInSection(
+  metaStore: Record<string, SettingMetaRaw>, key: string, secId: string): boolean {
+  if (secId === 'other') {
+    return !key.startsWith('core.') && !key.startsWith('plugin.');
+  }
+  if (secId.startsWith('core/')) {
+    if (!key.startsWith('core.')) {
+      return false;
+    }
+    const cat: string = secId.substring('core/'.length);
+    return cat === 'misc'
+      ? metaCategory(metaStore, key).length === 0
+      : metaCategory(metaStore, key) === cat;
+  }
+  if (secId.startsWith('plugin/')) {
+    const p: string = secId.substring('plugin/'.length);
+    return key.startsWith('plugin.' + p + '.');
+  }
+  return false;
+}
+
+export function activeSectionTitle(sections: SettingsSection[], secId: string): string {
+  for (let i = 0; i < sections.length; i++) {
+    if (sections[i].id === secId) {
+      return sections[i].title;
+    }
+  }
+  return '配置项';
+}
+
+/** 某个分区的配置项（按 key 字典序，最多 PAGE_SIZE*4 项） */
+export function buildEntries(
+  valuesStore: Record<string, string>,
+  metaStore: Record<string, SettingMetaRaw>,
+  secId: string): SettingEntry[] {
+  const entries: SettingEntry[] = [];
+  const keys: string[] = Object.keys(valuesStore).filter((k: string): boolean => {
+    return keyInSection(metaStore, k, secId);
+  });
+  keys.sort((a: string, b: string): number => a.localeCompare(b));
+  const limit: number = Math.min(keys.length, SETTINGS_PAGE_SIZE * 4);
+  for (let i = 0; i < limit; i++) {
+    const key: string = keys[i];
+    const meta: SettingMetaRaw | undefined = metaStore[key];
+    const entry: SettingEntry = {
+      key: key,
+      displayName: meta !== undefined && meta.displayName.length > 0 ? meta.displayName : key,
+      description: meta !== undefined ? meta.description : '',
+      type: meta !== undefined ? meta.type : 'string',
+      options: meta !== undefined ? meta.options : [],
+      value: valuesStore[key] ?? '',
+      dirty: false,
+    };
+    entries.push(entry);
+  }
+  return entries;
+}
+
+/** 覆盖某个 entry 的 value/dirty，返回新数组（保持 @State 数组替换语义） */
+export function withEntryMarked(
+  entries: SettingEntry[], key: string, value: string, dirty: boolean): SettingEntry[] {
+  const next: SettingEntry[] = [];
+  for (let i = 0; i < entries.length; i++) {
+    const e: SettingEntry = entries[i];
+    if (e.key === key) {
+      const copy: SettingEntry = {
+        key: e.key,
+        displayName: e.displayName,
+        description: e.description,
+        type: e.type,
+        options: e.options,
+        value: value,
+        dirty: dirty,
+      };
+      next.push(copy);
+    } else {
+      next.push(e);
+    }
+  }
+  return next;
+}
+
+/**
+ * 从 picker 返回的 URI 里取图片后缀（带点）。
+ * Image 组件依赖后缀选择解码器；沙箱里存成无后缀文件会静默解码失败，
+ * 用户看到的就是"背景图设置了却不生效"。取不到后缀时兜底 .jpg。
+ */
+export function imageExt(uri: string): string {
+  let s: string = uri;
+  const q: number = s.indexOf('?');
+  if (q >= 0) {
+    s = s.substring(0, q);
+  }
+  const dot: number = s.lastIndexOf('.');
+  const slash: number = s.lastIndexOf('/');
+  if (dot > slash && dot < s.length - 1) {
+    const ext: string = s.substring(dot).toLowerCase();
+    if (ext.length <= 5) {
+      return ext;
+    }
+  }
+  return '.jpg';
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/StageTrail.ets

@@ -0,0 +1,180 @@
+/**
+ * 阶段轨迹（单例）：本轮对话在七个内核阶段里真实发生过什么。
+ *
+ * 由 ChatSse 在收到 `stage` 事件时喂入，运行态面板读取。
+ * 为什么不放进 StatusStore：轨迹来自 SSE 流、与 /status、/kernel 的轮询无关，
+ * 两者的生命周期和失败模式都不一样，混在一个数据源里会互相拖累
+ * （SSE 断连不该让状态卡变空，状态轮询失败也不该清掉轨迹）。
+ *
+ * 七阶段归并成五格（与内核 sdk.Stage 的顺序一致）：
+ * 一轮里工具调用会反复回到「行动后」，线性滑块本身就是错的表述，
+ * 所以画成 输入 → 行动 ⇄(工具) → 输出 → 结束，工具那格带循环标记。
+ */
+
+/** 一个阶段组 */
+export interface StageGroup {
+  /** 0 输入 / 1 行动 / 2 工具 / 3 输出 / 4 结束 */
+  group: number;
+  label: string;
+  en: string;
+}
+
+/** 轨迹里的一条事件 */
+export interface StageEvent {
+  group: number;
+  /** 'stage' | 'tool' | 'output' */
+  kind: string;
+  label: string;
+  short: string;
+  count: number;
+}
+
+/** 阶段组定义，索引即 group */
+export const STAGE_GROUPS: StageGroup[] = [
+  { group: 0, label: '输入', en: 'in' },
+  { group: 1, label: '行动', en: 'act' },
+  { group: 2, label: '工具', en: 'tool' },
+  { group: 3, label: '输出', en: 'out' },
+  { group: 4, label: '结束', en: 'done' },
+];
+
+/** 当前阶段（SSE 驱动）。空串 = 空闲。 */
+export const K_STAGE_PHASE: string = 'stagePhase';
+/** 轨迹版本号：数组不进 AppStorage，靠它触发订阅组件重取快照 */
+export const K_STAGE_REV: string = 'stageRev';
+
+/** 阶段停留多久后回「空闲」——否则会留下一个永远停在 after_output 的假状态 */
+const IDLE_AFTER_MS: number = 2500;
+const MAX_ITEMS: number = 24;
+
+/** rtShortTool 把 `qq_get_message` / `output_send__qq` 压成尾段短名 */export function shortTool(name: string): string {
+  let n: string = name;
+  const i: number = n.lastIndexOf('__');
+  if (i >= 0) {
+    n = n.substring(i + 2);
+  }
+  return n.length > 14 ? n.substring(0, 13) + '…' : n;
+}
+
+class StageTrail {
+  private items: StageEvent[] = [];
+  private timerId: number = -1;
+
+  init(): void {
+    AppStorage.setOrCreate<string>(K_STAGE_PHASE, '');
+    AppStorage.setOrCreate<number>(K_STAGE_REV, 0);
+  }
+
+  /** 只给订阅组件读；调用方不要持有它 */
+  snapshot(): StageEvent[] {
+    return this.items;
+  }
+
+  currentPhase(): string {
+    return AppStorage.get<string>(K_STAGE_PHASE) ?? '';
+  }
+
+  /** 按阶段分组取条目 */
+  eventsOf(group: number): StageEvent[] {
+    const out: StageEvent[] = [];
+    for (let i = 0; i < this.items.length; i++) {
+      const e: StageEvent = this.items[i];
+      if (e.group === group) {
+        out.push(e);
+      }
+    }
+    return out;
+  }
+
+  /**
+   * 收到一条 stage 事件。phase 取值与内核一致：
+   * on_input / pre_action / post_action / before_toolcall / after_toolcall /
+   * before_output / after_output。
+   */
+  onStage(phase: string, tool: string): void {
+    if (phase.length === 0) {
+      return;
+    }
+    if (phase === 'on_input') {
+      // 新的一轮：清空上一轮的轨迹
+      this.items = [];
+      this.push(0, 'stage', '输入', '输入');
+    } else if (phase === 'pre_action') {
+      this.push(1, 'stage', '组装上下文并思考', '思考');
+    } else if (phase === 'before_toolcall' && tool.length > 0) {
+      // output_* 是输出通道工具，与普通工具用不同配色区分
+      const kind: string = tool.indexOf('output_') === 0 ? 'output' : 'tool';
+      this.push(2, kind, tool, shortTool(tool));
+    } else if (phase === 'before_output') {
+      this.push(3, 'stage', '生成回复', '生成');
+    } else if (phase === 'after_output') {
+      this.push(4, 'stage', '本轮完成', '完成');
+    } else {
+      // post_action / after_toolcall 不单独记：它们与相邻格重复，
+      // 逐条记会把轨迹刷成噪音。
+      AppStorage.set<string>(K_STAGE_PHASE, phase);
+      this.armIdleTimer();
+      return;
+    }
+    AppStorage.set<string>(K_STAGE_PHASE, phase);
+    this.armIdleTimer();
+    this.bump();
+  }
+
+  private push(group: number, kind: string, label: string, short: string): void {
+    // 同一阶段重复出现的同一条（如同一工具连调 3 次）只累加计数，不刷屏
+    const n: number = this.items.length;
+    if (n > 0) {
+      const last: StageEvent = this.items[n - 1];
+      if (last.group === group && last.kind === kind && last.short === short) {
+        last.count = last.count + 1;
+        return;
+      }
+    }
+    this.items.push({ group: group, kind: kind, label: label, short: short, count: 1 });
+    if (this.items.length > MAX_ITEMS) {
+      this.items.shift();
+    }
+  }
+
+  private armIdleTimer(): void {
+    if (this.timerId !== -1) {
+      clearTimeout(this.timerId);
+    }
+    this.timerId = setTimeout(() => {
+      this.timerId = -1;
+      AppStorage.set<string>(K_STAGE_PHASE, '');
+      this.bump();
+    }, IDLE_AFTER_MS);
+  }
+
+  private bump(): void {
+    const cur: number = AppStorage.get<number>(K_STAGE_REV) ?? 0;
+    AppStorage.set<number>(K_STAGE_REV, cur + 1);
+  }
+}
+
+export const stageTrail: StageTrail = new StageTrail();
+
+/**
+ * 内核的七个阶段归并到五个展示格。顺序与 sdk.Stage 一致，
+ * 所以「当前阶段」直接看返回值是不是当前格。空闲返回 -1。
+ */
+export function phaseGroup(phase: string): number {
+  if (phase === 'on_input') {
+    return 0;
+  }
+  if (phase === 'pre_action' || phase === 'post_action') {
+    return 1;
+  }
+  if (phase === 'before_toolcall' || phase === 'after_toolcall') {
+    return 2;
+  }
+  if (phase === 'before_output') {
+    return 3;
+  }
+  if (phase === 'after_output') {
+    return 4;
+  }
+  return -1;
+}

cmd/ohos/HomeAgent/entry/src/main/ets/common/StatusStore.ets

@@ -27,6 +27,68 @@ export interface StatGroup {
   fields: StatField[];
 }
 
+// ===== 运行态快照（/runtime）=====
+//
+// 与 StatGroup 的分工：明细卡回答「内核有哪些东西、多少」，
+// 运行态回答「现在在干什么」——四级中断队列积压多少、有几个驻留子。
+// 两者数据源不同（/kernel vs /runtime），所以分开取、分开存。
+
+/** 一条队列（四级中断之一，或排队队列） */
+export interface RuntimeQueue {
+  /** 4/3/2/1；0 表示排队队列（无级别） */
+  lv: number;
+  name: string;
+  desc: string;
+  depth: number;
+  registered: number;
+  preempted: number;
+}
+
+/** 一次刷新的运行态快照 */
+export interface RuntimeSnapshot {
+  /** 排队队列深度（无级别，纯 FIFO） */
+  ready: number;
+  pending: number;
+  stack: number;
+  maxStack: number;
+  subagents: number;
+  /** 格槽数（按全场最大深度缩放，至少 5） */
+  slots: number;
+  /** 五条队列：L4/L3/L2/L1 + 排队 */
+  queues: RuntimeQueue[];
+}
+
+interface LevelDef {
+  lv: number;
+  name: string;
+  desc: string;
+}
+
+/** 四级中断的定义（顺序即 L4→L1） */
+const LEVEL_DEFS: LevelDef[] = [
+  { lv: 4, name: 'L4', desc: '内核独占' },
+  { lv: 3, name: 'L3', desc: '交互' },
+  { lv: 2, name: 'L2', desc: '消息' },
+  { lv: 1, name: 'L1', desc: '后台' },
+];
+
+/** JSON 数组里按下标取数：越界/类型不符都当 0 */
+function numAt(arr: Object[] | undefined, i: number): number {
+  if (arr === undefined || arr === null || i < 0 || i >= arr.length) {
+    return 0;
+  }
+  const v: number = arr[i] as number;
+  return isNaN(v) ? 0 : v;
+}
+
+/** 格槽数：按全场最大深度缩放，至少 5 格（0 时也要有可见形状）、最多 16 格 */
+function clampSlots(maxQ: number): number {
+  if (maxQ < 5) {
+    return 5;
+  }
+  return maxQ > 16 ? 16 : maxQ;
+}
+
 // ===== AppStorage 键：摘要卡与明细页共用 =====
 export const K_UP: string = 'statUp';
 export const K_VERSION: string = 'statVersion';
@@ -37,10 +99,14 @@ export const K_TOOLS: string = 'statTools';
 export const K_ERR: string = 'statErr';
 export const K_LOADING: string = 'statLoading';
 export const K_REV: string = 'statRev';
+/** 内核身份副行：内核名 · commit。版本号光有一个号码分不清是哪个内核、哪次构建。 */
+export const K_BUILD: string = 'statBuildSub';
 
 class StatusStore {
   /** 明细分组：只有明细页读它，不进 AppStorage（数组同步语义太脆） */
   private groups: StatGroup[] = [];
+  /** 运行态快照：同上，靠 K_REV 触发订阅组件重取 */
+  private runtimeSnapshot: RuntimeSnapshot | undefined = undefined;
 
   init(): void {
     AppStorage.setOrCreate<boolean>(K_UP, false);
@@ -52,12 +118,17 @@ class StatusStore {
     AppStorage.setOrCreate<string>(K_ERR, '');
     AppStorage.setOrCreate<boolean>(K_LOADING, false);
     AppStorage.setOrCreate<number>(K_REV, 0);
+    AppStorage.setOrCreate<string>(K_BUILD, '');
   }
 
   getGroups(): StatGroup[] {
     return this.groups;
   }
 
+  getRuntime(): RuntimeSnapshot | undefined {
+    return this.runtimeSnapshot;
+  }
+
   isUp(): boolean {
     return AppStorage.get<boolean>(K_UP) ?? false;
   }
@@ -67,8 +138,11 @@ class StatusStore {
       this.fail(noConnectionMessage());
       return;
     }
-    AppStorage.setOrCreate<boolean>(K_LOADING, true);
-    AppStorage.setOrCreate<string>(K_ERR, '');
+    // setOrCreate 只负责首次建键，键已存在时不会覆盖旧值。
+    // init() 已把所有键种好，刷新阶段必须用 set，否则摘要卡会永远停在
+    // 版本 "-"、插件 0 的初始状态。
+    AppStorage.set<boolean>(K_LOADING, true);
+    AppStorage.set<string>(K_ERR, '');
     try {
       const resp = await apiClient.getWithTimeout('/status', 8000);
       const obj: Record<string, Object> = JSON.parse(resp.body) as Record<string, Object>;
@@ -79,10 +153,10 @@ class StatusStore {
       const agents: number = obj['agents'] as number ?? 0;
       const startedAt: string = obj['startedAt'] as string ?? '';
 
-      AppStorage.setOrCreate<boolean>(K_UP, true);
-      AppStorage.setOrCreate<string>(K_VERSION, version);
-      AppStorage.setOrCreate<number>(K_AGENTS, agents);
-      AppStorage.setOrCreate<string>(K_STARTED, startedAt);
+      AppStorage.set<boolean>(K_UP, true);
+      AppStorage.set<string>(K_VERSION, version);
+      AppStorage.set<number>(K_AGENTS, agents);
+      AppStorage.set<string>(K_STARTED, startedAt);
 
       const systemFields: StatField[] = [
         { label: '版本', value: version },
@@ -98,12 +172,13 @@ class StatusStore {
       ];
 
       await this.collectKernel(groups);
+      await this.collectRuntime();
       this.groups = groups;
       this.bump();
     } catch (e) {
       this.fail(userMessage('status.refresh', e));
     }
-    AppStorage.setOrCreate<boolean>(K_LOADING, false);
+    AppStorage.set<boolean>(K_LOADING, false);
   }
 
   /** /kernel 可能不存在（旧后端），失败不影响 /status 已取到的部分 */
@@ -119,8 +194,8 @@ class StatusStore {
       const pluginCount: number = pluginsArr !== undefined ? pluginsArr.length : 0;
       const toolCount: number = toolsArr !== undefined ? toolsArr.length : 0;
 
-      AppStorage.setOrCreate<number>(K_PLUGINS, pluginCount);
-      AppStorage.setOrCreate<number>(K_TOOLS, toolCount);
+      AppStorage.set<number>(K_PLUGINS, pluginCount);
+      AppStorage.set<number>(K_TOOLS, toolCount);
 
       const kernelFields: StatField[] = [
         { label: 'Agent ID', value: agentId },
@@ -130,8 +205,66 @@ class StatusStore {
       if (startTime.length > 0) {
         kernelFields.push({ label: '内核启动', value: formatTime(startTime) });
       }
+
+      // 构建身份：版本 / commit / SDK 兼容都取自 /kernel 的 build（-ldflags 注入）。
+      // 为何不能只用 /status 的 version：那里只有一个版本号，分不清是哪个内核、
+      // 哪次构建；许可标识更是完全没有。
+      const build: Record<string, Object> | undefined = k['build'] as Record<string, Object>;
+      let lic: string = '';
+      let licURL: string = '';
+      let srcURL: string = '';
+      if (build !== undefined && build !== null) {
+        const bVer: string = build['version'] as string ?? '';
+        const bCommit: string = build['commit'] as string ?? '';
+        const bName: string = build['kernel_name'] as string ?? 'HomeAgent';
+        const bSdk: string = build['sdk_compatible'] as string ?? '';
+        const bTime: string = build['build_time'] as string ?? '';
+        lic = build['license'] as string ?? '';
+        licURL = build['license_url'] as string ?? '';
+        srcURL = build['source_url'] as string ?? '';
+        if (bVer.length > 0) {
+          AppStorage.set<string>(K_VERSION, 'v' + bVer);
+          kernelFields.push({ label: '内核版本', value: 'v' + bVer });
+        }
+        let sub: string = bName;
+        if (bCommit.length > 0 && bCommit !== 'unknown') {
+          sub = sub + ' · ' + bCommit.substring(0, 7);
+        }
+        AppStorage.set<string>(K_BUILD, sub);
+        if (bCommit.length > 0) {
+          kernelFields.push({ label: 'Commit', value: bCommit });
+        }
+        if (bSdk.length > 0) {
+          kernelFields.push({ label: 'SDK 兼容', value: bSdk });
+        }
+        if (bTime.length > 0 && bTime !== 'unknown') {
+          kernelFields.push({ label: '构建时间', value: formatTime(bTime) });
+        }
+      }
       groups.push({ title: '内核', fields: kernelFields });
 
+      // 开源许可：只给一个源码链接、不写协议名，使用者看不出这受什么许可约束，
+      // 也看不出网络服务场景下的 §13 义务。
+      const legalFields: StatField[] = [];
+      if (lic.length > 0) {
+        legalFields.push({ label: '许可协议', value: lic });
+      }
+      if (licURL.length > 0) {
+        legalFields.push({ label: '协议全文', value: licURL });
+      }
+      if (srcURL.length > 0) {
+        legalFields.push({ label: '源码仓库', value: srcURL });
+      }
+      if (legalFields.length > 0) {
+        if (lic.toUpperCase().indexOf('AGPL') >= 0) {
+          legalFields.push({
+            label: '网络条款',
+            value: '把修改后的版本作为网络服务对外提供时，必须向使用者提供取得对应源码的途径（§13）',
+          });
+        }
+        groups.push({ title: '开源许可', fields: legalFields });
+      }
+
       // LLM：provider / 可用源 / 是否可用
       const llm: Record<string, Object> | undefined = k['llm'] as Record<string, Object>;
       if (llm !== undefined && llm !== null) {
@@ -218,18 +351,98 @@ class StatusStore {
     }
   }
 
+  /**
+   * 取运行态快照（/runtime）。失败不影响已经取到的明细分组：
+   * 旧后端可能没有这个端点，那时面板显示「运行态数据不可用」即可。
+   */
+  private async collectRuntime(): Promise<void> {
+    try {
+      const resp = await apiClient.getWithTimeout('/runtime', 8000);
+      const r: Record<string, Object> = JSON.parse(resp.body) as Record<string, Object>;
+
+      const sc: Record<string, Object> | undefined = r['scheduler'] as Record<string, Object>;
+      const residents: Object[] | undefined = r['residents'] as Object[];
+
+      let ready: number = 0;
+      let pending: number = 0;
+      let stack: number = 0;
+      let maxStack: number = 4;
+      let qArr: Object[] | undefined = undefined;
+      let regArr: Object[] | undefined = undefined;
+      let preArr: Object[] | undefined = undefined;
+      if (sc !== undefined && sc !== null) {
+        ready = sc['ready_queue_depth'] as number ?? 0;
+        pending = sc['pending_interrupts'] as number ?? 0;
+        stack = sc['suspend_stack'] as number ?? 0;
+        maxStack = sc['max_suspend_depth'] as number ?? 4;
+        qArr = sc['interrupt_queues'] as Object[];
+        regArr = sc['interrupts_by_level'] as Object[];
+        preArr = sc['preempts_by_level'] as Object[];
+      }
+
+      // 四级语义引用内核的定义（internal/agent/core/scheduler.go），
+      // 前端只负责把它们画出来，不自己起名字。
+      const queues: RuntimeQueue[] = [];
+      let maxQ: number = 1;
+      for (let i = 0; i < LEVEL_DEFS.length; i++) {
+        const d: LevelDef = LEVEL_DEFS[i];
+        const depth: number = numAt(qArr, d.lv);
+        if (depth > maxQ) {
+          maxQ = depth;
+        }
+        queues.push({
+          lv: d.lv,
+          name: d.name,
+          desc: d.desc,
+          depth: depth,
+          registered: numAt(regArr, d.lv),
+          preempted: numAt(preArr, d.lv),
+        });
+      }
+      if (ready > maxQ) {
+        maxQ = ready;
+      }
+      // 第五条：排队队列。它不是优先级，而是另一**类别**（排队 vs 中断），
+      // 所以 lv 用 0 标记「无级别」。
+      queues.push({
+        lv: 0,
+        name: '排队',
+        desc: 'FIFO',
+        depth: ready,
+        registered: 0,
+        preempted: 0,
+      });
+
+      const subagents: number = residents !== undefined && residents !== null
+        ? residents.length : 0;
+
+      this.runtimeSnapshot = {
+        ready: ready,
+        pending: pending,
+        stack: stack,
+        maxStack: maxStack,
+        subagents: subagents,
+        slots: clampSlots(maxQ),
+        queues: queues,
+      };
+    } catch (e) {
+      // /runtime 不可用（旧后端）：保留上一次快照，不清空
+    }
+  }
+
   private fail(msg: string): void {
-    AppStorage.setOrCreate<string>(K_ERR, msg);
-    AppStorage.setOrCreate<boolean>(K_UP, false);
-    AppStorage.setOrCreate<boolean>(K_LOADING, false);
+    AppStorage.set<string>(K_ERR, msg);
+    AppStorage.set<boolean>(K_UP, false);
+    AppStorage.set<boolean>(K_LOADING, false);
     this.groups = [];
+    this.runtimeSnapshot = undefined;
     this.bump();
   }
 
   /** 明细数组不进 AppStorage，用一个自增版本号触发订阅组件重取 */
   private bump(): void {
     const cur: number = AppStorage.get<number>(K_REV) ?? 0;
-    AppStorage.setOrCreate<number>(K_REV, cur + 1);
+    AppStorage.set<number>(K_REV, cur + 1);
   }
 }
 

cmd/ohos/HomeAgent/entry/src/main/ets/components/AppearancePane.ets

@@ -0,0 +1,265 @@
+/**
+ * 「外观」二级页面：主题三选一 + 自定义背景图。
+ *
+ * 从 pages/SettingsPage.ets 抽出。
+ * themeMode / bgImage / bgOpacity 用 @Link 与一级页面共享（一级页的
+ * 外观行要显示当前主题名，两边必须是同一份数据）。
+ */
+
+import { connStore } from '../common/ConnStore';
+import { AppSettings, emptySettings } from '../model/Model';
+import { applyThemeMode } from '../common/Constants';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_MD,
+  ANIM_NORMAL } from '../common/Constants';
+import { imageExt } from '../common/SettingsModel';
+import { userMessage } from '../common/UserError';
+import { SubPageLayer, PlainCard } from './SubPage';
+import { MotionBase } from './MotionBase';
+import { picker, fileIo } from '@kit.CoreFileKit';
+import { common } from '@kit.AbilityKit';
+
+@Component
+export struct AppearancePane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Link themeMode: string;
+  @Link bgImage: string;
+  @Link bgOpacity: number;
+  onBack?: () => void;
+  onToast?: (msg: string, isError: boolean) => void;
+  @State pickingBg: boolean = false;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  private toast(msg: string, isError: boolean): void {
+    const cb: ((m: string, e: boolean) => void) | undefined = this.onToast;
+    if (cb !== undefined) {
+      cb(msg, isError);
+    }
+  }
+
+  private applyTheme(mode: string): void {
+    this.themeMode = mode;
+    this.persistSettings();
+    // 立即翻转全局主题标志，整个 UI 随之切换
+    applyThemeMode(mode);
+  }
+
+  private async pickBackgroundImage(): Promise<void> {
+    if (this.pickingBg) {
+      return;
+    }
+    this.pickingBg = true;
+    try {
+      const options = new picker.PhotoSelectOptions();
+      options.MIMEType = picker.PhotoViewMIMETypes.IMAGE_TYPE;
+      options.maxSelectNumber = 1;
+      const photoPicker = new picker.PhotoViewPicker();
+      const result = await photoPicker.select(options);
+      if (result.photoUris.length === 0) {
+        return;
+      }
+      const srcUri: string = result.photoUris[0];
+      const ctx = getContext(this) as common.UIAbilityContext;
+      // 文件名带时间戳：Image 组件按 src 字符串做内存缓存，
+      // 每次都写同一个 bg_image 会让第二次换图看起来"没生效"。
+      // 后缀必须保留：Image 组件按扩展名挑选解码器，无后缀的沙箱文件会解码失败，
+      // 表现就是"设置了背景图但没生效"（onError 里能看到 decode 失败）。
+      const destPath: string = ctx.filesDir + '/bg_' + Date.now().toString(36) + imageExt(srcUri);
+      const srcFile = fileIo.openSync(srcUri, fileIo.OpenMode.READ_ONLY);
+      const destFile = fileIo.openSync(destPath,
+        fileIo.OpenMode.READ_WRITE | fileIo.OpenMode.CREATE | fileIo.OpenMode.TRUNC);
+      fileIo.copyFileSync(srcFile.fd, destFile.fd);
+      fileIo.closeSync(srcFile);
+      fileIo.closeSync(destFile);
+      this.removeOldBgFile();
+      // Image 只认带协议头的沙箱 URI，裸路径会被当成资源名而静默失败
+      this.bgImage = 'file://' + destPath;
+      this.persistSettings();
+      this.toast('背景图已设置', false);
+    } catch (e) {
+      this.toast(userMessage('settings.pickBg', e), true);
+    }
+    this.pickingBg = false;
+  }
+
+  /** 删除上一张背景图文件，避免沙箱里越攒越多 */
+  private removeOldBgFile(): void {
+    const old: string = this.bgImage;
+    if (old.length === 0) {
+      return;
+    }
+    const path: string = old.startsWith('file://') ? old.substring(7) : old;
+    try {
+      fileIo.unlinkSync(path);
+    } catch (e) {
+      // 文件可能已不存在，忽略
+    }
+  }
+
+  private clearBackgroundImage(): void {
+    this.removeOldBgFile();
+    this.bgImage = '';
+    this.persistSettings();
+    this.toast('已清除背景图', false);
+  }
+
+  private onBgOpacityChange(value: number): void {
+    this.bgOpacity = value / 100;
+    this.persistSettings();
+  }
+
+  private persistSettings(): void {
+    const s: AppSettings = emptySettings();
+    const old: AppSettings = connStore.getSettings();
+    s.lang = old.lang;
+    s.theme = this.themeMode.length > 0 ? this.themeMode : (old.theme.length > 0 ? old.theme : 'system');
+    s.currentConnId = old.currentConnId;
+    s.bgImage = this.bgImage;
+    s.bgOpacity = this.bgOpacity;
+    connStore.saveSettings(s);
+    AppStorage.set<string>('bgImage', this.bgImage);
+    AppStorage.set<number>('bgOpacity', this.bgOpacity);
+  }
+
+  @Builder
+  ThemeOption(label: string, mode: string) {
+    // 按压缩放由 MotionBase 统一；flexWeight: 1 让三枚选项在 Row 里继续等分。
+    MotionBase({ pressEnabled: true, flexWeight: 1 }) {
+      Column() {
+        Text(label)
+          .fontSize(12)
+          .fontColor(this.themeMode === mode ? Color.White : this.palette().textSecondary)
+          // 子节点的颜色迁移要自己声明：父容器的 .animation() 不下传
+          .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut })
+      }
+      .justifyContent(FlexAlign.Center)
+      .width('100%')
+      .height(34)
+      .borderRadius(RADIUS_MD)
+      .backgroundColor(this.themeMode === mode ? this.palette().accent : this.palette().bgHover)
+      // 三选一的选中态迁移：底色与描边一起过渡。写在 .border 之后、
+      // 覆盖它上面的所有状态驱动属性。
+      .border({
+        width: 1,
+        color: this.themeMode === mode ? this.palette().accent : this.palette().btnGhostBorder,
+      })
+      .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut })
+      .onClick(() => {
+        this.applyTheme(mode);
+      })
+    }
+  }
+
+  build() {
+    SubPageLayer({
+      title: '外观',
+      tab: 3,
+      onBack: () => {
+        const cb: (() => void) | undefined = this.onBack;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+    }) {
+      Column() {
+        PlainCard({ caption: '主题' }) {
+          Row({ space: 8 }) {
+            this.ThemeOption('跟随系统', 'system')
+            this.ThemeOption('浅色', 'light')
+            this.ThemeOption('深色', 'dark')
+          }
+          .width('100%')
+
+          Text(this.themeMode === 'system'
+            ? '当前跟随系统，系统切换深浅色时自动跟随'
+            : (this.themeMode === 'dark' ? '当前强制深色主题' : '当前强制浅色主题'))
+            .fontSize(11)
+            .fontColor(this.palette().textMuted)
+            .margin({ top: 10 })
+        }
+
+        PlainCard({ caption: '背景图' }) {
+          Row() {
+            Column() {
+              Text('自定义背景图')
+                .fontSize(14)
+                .fontColor(this.palette().textPrimary)
+              Text(this.bgImage.length > 0 ? '已设置背景图' : '未设置背景图')
+                .fontSize(11)
+                .fontColor(this.palette().textMuted)
+                .margin({ top: 2 })
+            }
+            .alignItems(HorizontalAlign.Start)
+            .layoutWeight(1)
+
+            if (this.bgImage.length > 0) {
+              Button('更换')
+                .height(28)
+                .fontSize(12)
+                .backgroundColor(Color.Transparent)
+                .border({ width: 1, color: this.palette().btnGhostBorder })
+                .fontColor(this.palette().textSecondary)
+                .margin({ right: 6 })
+                .onClick(() => {
+                  this.pickBackgroundImage();
+                })
+              Button('清除')
+                .height(28)
+                .fontSize(12)
+                .backgroundColor(Color.Transparent)
+                .border({ width: 1, color: 'rgba(232, 64, 38, 0.45)' })
+                .fontColor('#E84026')
+                .onClick(() => {
+                  this.clearBackgroundImage();
+                })
+            } else {
+              Button(this.pickingBg ? '选择中...' : '选择图片')
+                .height(28)
+                .fontSize(12)
+                .backgroundColor(this.palette().accent)
+                .fontColor(Color.White)
+                .onClick(() => {
+                  this.pickBackgroundImage();
+                })
+            }
+          }
+          .width('100%')
+
+          if (this.bgImage.length > 0) {
+            Row() {
+              Text('透明度')
+                .fontSize(11)
+                .fontColor(this.palette().textMuted)
+              Slider({
+                value: Math.round(this.bgOpacity * 100),
+                min: 5,
+                max: 60,
+                step: 1,
+              })
+                .layoutWeight(1)
+                .selectedColor(this.palette().accent)
+                .trackColor(this.palette().bgHover)
+                .margin({ left: 8, right: 8 })
+                .onChange((v: number, mode: SliderChangeMode) => {
+                  if (mode === SliderChangeMode.Moving || mode === SliderChangeMode.Click) {
+                    this.onBgOpacityChange(v);
+                  }
+                })
+              Text(Math.round(this.bgOpacity * 100).toString() + '%')
+                .fontSize(11)
+                .fontColor(this.palette().textSecondary)
+                .width(32)
+            }
+            .width('100%')
+            .alignItems(VerticalAlign.Center)
+            .margin({ top: 12 })
+          }
+        }
+      }
+      .width('100%')
+      .alignItems(HorizontalAlign.Start)
+    }
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/Attachment.ets

@@ -4,107 +4,20 @@ import { common } from '@kit.AbilityKit';
 import { apiClient } from '../common/ApiClient';
 import { userMessage } from '../common/UserError';
 import { ChatAttachment } from '../model/Model';
+import { extLabel, formatBytes, sanitize } from '../common/AttachmentMeta';
+import { loadPixelMap } from '../common/AttachmentImage';
 import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_LG, RADIUS_MD, RADIUS_SM, ANIM_FAST, ANIM_NORMAL, ANIM_ENTER } from '../common/Constants';
 import { COLOR_ERROR } from '../common/Constants';
 import { MotionBase } from './MotionBase';
 import { PlainCard } from './SubPage';
 
 /**
- * 附件解析与展示。
+ * 附件 UI：气泡内的附件卡 + 附件详情二级页内容。
  *
- * 后端 Attachment 只有四个字段：type / url / size / name
- * （internal/plugins/webui/handler.go），没有 mime、没有像素尺寸、没有本地路径。
- * 所以详情页里的"尺寸/格式"必须由客户端自己解码得出，不能假装后端给了。
+ * 解析/格式化（parseAttachment、formatBytes、extLabel…）在 common/AttachmentMeta.ets，
+ * 字节获取与解码在 common/AttachmentImage.ets —— 这里只留 UI。
  *
- * 字节走 GET <base>/files/<name> 或 /uploads/<name>（注意不带 /api/v1 前缀）。
- * 这两条路由在后端是 requireWeb，但对 API Key 客户端同等放行，
- * 所以带上和普通接口一样的鉴权头即可，无需 web 登录态。
- */
-
-/** 从后端 JSON 里解析 attachment 字段；缺字段或类型不对则返回 undefined。 */
-export function parseAttachment(raw: Object | undefined): ChatAttachment | undefined {
-  if (raw === undefined || raw === null) {
-    return undefined;
-  }
-  const o: Record<string, Object> = raw as Record<string, Object>;
-  const url: string = o['url'] as string ?? '';
-  if (url.length === 0) {
-    return undefined;
-  }
-  const t: string = o['type'] as string ?? 'file';
-  const a: ChatAttachment = {
-    type: t === 'image' ? 'image' : 'file',
-    url: url,
-    size: o['size'] as number ?? 0,
-    name: o['name'] as string ?? fileNameOf(url),
-  };
-  return a;
-}
-
-/** 由 SSE channel_output 事件构造附件（字段名与 history 不同）。 */
-export function attachmentFromChannelOutput(
-  outputType: string, url: string, size: number): ChatAttachment | undefined {
-  if (url.length === 0) {
-    return undefined;
-  }
-  if (outputType !== 'image' && outputType !== 'file') {
-    return undefined;
-  }
-  const a: ChatAttachment = {
-    type: outputType,
-    url: url,
-    size: size,
-    name: fileNameOf(url),
-  };
-  return a;
-}
-
-/** 取 URL 最后一段作为展示文件名，与后端 handler.go 的取名方式一致。 */
-export function fileNameOf(url: string): string {
-  let s: string = url;
-  const q: number = s.indexOf('?');
-  if (q >= 0) {
-    s = s.substring(0, q);
-  }
-  const i: number = s.lastIndexOf('/');
-  const name: string = i >= 0 ? s.substring(i + 1) : s;
-  return name.length > 0 ? name : '附件';
-}
-
-/** 人类可读字节数，口径对齐后端 formatBytes（KB 以上保留一位小数）。 */
-export function formatBytes(n: number): string {
-  if (n <= 0) {
-    return '';
-  }
-  if (n < 1024) {
-    return n.toString() + ' B';
-  }
-  const kb: number = n / 1024;
-  if (kb < 1024) {
-    return oneDecimal(kb) + ' KB';
-  }
-  const mb: number = kb / 1024;
-  if (mb < 1024) {
-    return oneDecimal(mb) + ' MB';
-  }
-  return oneDecimal(mb / 1024) + ' GB';
-}
-
-function oneDecimal(v: number): string {
-  return (Math.round(v * 10) / 10).toString();
-}
-
-/** 由文件名后缀猜测类型标签。后端不返回 mime，只能这样标注。 */
-export function extLabel(name: string): string {
-  const i: number = name.lastIndexOf('.');
-  if (i < 0 || i === name.length - 1) {
-    return '未知类型';
-  }
-  return name.substring(i + 1).toUpperCase();
-}
-
-/**
- * 气泡内的附件卡：图片显示缩略图，文件显示一枚文件条。
+ * 附件卡：图片显示缩略图，文件显示一枚文件条。
  * 点击进入附件详情二级页面（WebGUI 是新开标签页，移动端改为二级页）。
  */
 @Component
@@ -428,36 +341,3 @@ export struct AttachmentDetailContent {
     return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
   }
 }
-
-/** 下载并解码成 PixelMap；任何一步失败都返回 undefined（调用方显示占位）。 */
-async function loadPixelMap(url: string): Promise<image.PixelMap | undefined> {
-  try {
-    // 本地待上传的图片：直接读沙箱文件，不走网络
-    if (url.startsWith('file://')) {
-      const path: string = url.substring(7);
-      const f = fileIo.openSync(path, fileIo.OpenMode.READ_ONLY);
-      const localSrc: image.ImageSource = image.createImageSource(f.fd);
-      const localPm: image.PixelMap = await localSrc.createPixelMap();
-      await localSrc.release();
-      fileIo.closeSync(f);
-      return localPm;
-    }
-    const abs: string = apiClient.absoluteUrl(url);
-    const resp = await apiClient.getBinary(abs, 15000);
-    const src: image.ImageSource = image.createImageSource(resp.data);
-    const pm: image.PixelMap = await src.createPixelMap();
-    await src.release();
-    return pm;
-  } catch (e) {
-    return undefined;
-  }
-}
-
-/** 去掉路径分隔符，避免附件名把文件写到 filesDir 之外。 */
-function sanitize(name: string): string {
-  let s: string = name.replace(/[\/\\:*?"<>|]/g, '_');
-  if (s.length === 0) {
-    s = 'attachment';
-  }
-  return s;
-}

cmd/ohos/HomeAgent/entry/src/main/ets/components/BackendSettingsPane.ets

@@ -0,0 +1,172 @@
+/**
+ * 「核心配置」相关的两个二级页面：分类列表 + 某个分类的配置项。
+ *
+ * 从 pages/SettingsPage.ets 抽出。
+ * 取数/分区/落库都留在页面（它同时要显示"几个分类 · 几项"和错误态），
+ * 这里只负责渲染与把用户动作转成回调。
+ */
+
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE } from '../common/Constants';
+import { SettingsSection, SettingEntry, activeSectionTitle } from '../common/SettingsModel';
+import { SubPageLayer, NavGroup, NavRow, PlainCard } from './SubPage';
+import { SettingsEntryCard } from './SettingsEntryCard';
+
+@Component
+export struct BackendSectionsPane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop sections: SettingsSection[] = [];
+  @Prop pluginKeyCount: number = 0;
+  @Prop pluginConfigCount: number = 0;
+  @Prop busy: boolean = false;
+  @Prop errorText: string = '';
+  @Prop activeSection: string = '';
+  /** 宽屏右栏正显示分区明细时高亮左侧对应行 */
+  @Prop highlightRows: boolean = false;
+  onBack?: () => void;
+  onRefresh?: () => void;
+  onOpenSection?: (id: string) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    SubPageLayer({
+      title: '核心配置',
+      tab: 3,
+      onBack: () => {
+        const cb: (() => void) | undefined = this.onBack;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+      showRefresh: true,
+      onRefresh: () => {
+        const cb: (() => void) | undefined = this.onRefresh;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+    }) {
+      Column() {
+        if (this.errorText.length > 0) {
+          PlainCard({ caption: '状态' }) {
+            Text(this.errorText)
+              .fontSize(12)
+              .fontColor('#E84026')
+          }
+        }
+
+        NavGroup({ caption: '核心' }) {
+          ForEach(this.sections, (sec: SettingsSection, idx: number) => {
+            NavRow({
+              icon: $r('app.media.ic_tune'),
+              title: sec.title,
+              subtitle: sec.count.toString() + ' 项配置',
+              showDivider: idx < this.sections.length - 1,
+              selected: this.highlightRows && this.activeSection === sec.id,
+              onTap: () => {
+                const cb: ((id: string) => void) | undefined = this.onOpenSection;
+                if (cb !== undefined) {
+                  cb(sec.id);
+                }
+              },
+            })
+          }, (sec: SettingsSection) => sec.id + sec.count.toString())
+        }
+
+        // 插件配置不在这里编辑：入口在插件页的详情里，这里只指路，避免两处重复入口
+        if (this.pluginKeyCount > 0) {
+          Text('插件的 ' + this.pluginKeyCount.toString() + ' 项配置（' +
+            this.pluginConfigCount.toString() + ' 个插件）在「插件 → 选择插件 → 插件配置」中修改。')
+            .fontSize(12)
+            .fontColor(this.palette().textMuted)
+            .width('100%')
+            .padding({ left: 4, right: 4 })
+        }
+
+        if (this.sections.length === 0 && !this.busy) {
+          Text('未获取到配置分类。检查后端连接后点击刷新。')
+            .fontSize(12)
+            .fontColor(this.palette().textMuted)
+            .padding({ left: 4 })
+        }
+      }
+      .width('100%')
+      .alignItems(HorizontalAlign.Start)
+    }
+  }
+}
+
+@Component
+export struct SectionEntriesPane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop sections: SettingsSection[] = [];
+  @Prop activeSection: string = '';
+  @Prop entries: SettingEntry[] = [];
+  @Prop busy: boolean = false;
+  onBack?: () => void;
+  onRefresh?: () => void;
+  onSaveValue?: (key: string, value: string) => void;
+  onSaveCurrent?: (key: string) => void;
+  onEdit?: (key: string, value: string) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    SubPageLayer({
+      title: activeSectionTitle(this.sections, this.activeSection),
+      tab: 3,
+      onBack: () => {
+        const cb: (() => void) | undefined = this.onBack;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+      showRefresh: true,
+      onRefresh: () => {
+        const cb: (() => void) | undefined = this.onRefresh;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+    }) {
+      Column() {
+        ForEach(this.entries, (entry: SettingEntry) => {
+          SettingsEntryCard({
+            entry: entry,
+            onSaveValue: (key: string, value: string) => {
+              const cb: ((k: string, v: string) => void) | undefined = this.onSaveValue;
+              if (cb !== undefined) {
+                cb(key, value);
+              }
+            },
+            onSaveCurrent: (key: string) => {
+              const cb: ((k: string) => void) | undefined = this.onSaveCurrent;
+              if (cb !== undefined) {
+                cb(key);
+              }
+            },
+            onEdit: (key: string, value: string) => {
+              const cb: ((k: string, v: string) => void) | undefined = this.onEdit;
+              if (cb !== undefined) {
+                cb(key, value);
+              }
+            },
+          })
+        }, (entry: SettingEntry) => entry.key + '|' + entry.value + '|' + (entry.dirty ? 'd' : 'c'))
+
+        if (!this.busy && this.entries.length === 0) {
+          Text('该分区暂无配置项')
+            .fontSize(12)
+            .fontColor(this.palette().textMuted)
+            .padding(16)
+        }
+      }
+      .width('100%')
+      .alignItems(HorizontalAlign.Start)
+    }
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/ChatAttachBar.ets

@@ -0,0 +1,139 @@
+/**
+ * 输入区上方的两个悬浮条：加号菜单（图片/文件）与待发送附件预览。
+ *
+ * 从 components/ChatComposer.ets 拆出 —— 两者都是"输入区上方的独立浮层"，
+ * 数据与动作全部由输入区传入。
+ */
+
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_MD, RADIUS_PILL,
+  ANIM_NORMAL } from '../common/Constants';
+import { MotionBase } from './MotionBase';
+import { formatBytes } from '../common/AttachmentMeta';
+
+/** 加号菜单：两枚独立的玻璃胶囊，和输入区其他组件同一套视觉语言 */
+@Component
+export struct ChatAttachMenu {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  onPickImage?: () => void;
+  onPickFile?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  @Builder
+  AttachOption(icon: Resource, label: string, tap: () => void) {
+    // 按压反馈交给 MotionBase：每个实例自带独立按压态，
+    // 修掉了原先两枚胶囊共用一个 @State、按一枚两枚同时缩放的问题。
+    MotionBase({ pressEnabled: true, fillWidth: false }) {
+      Row({ space: 6 }) {
+        Image(icon)
+          .width(15)
+          .height(15)
+          .fillColor(this.palette().textSecondary)
+          .draggable(false)
+        Text(label)
+          .fontSize(12)
+          .fontColor(this.palette().textPrimary)
+      }
+      .padding({ left: 12, right: 14, top: 8, bottom: 8 })
+      .backgroundColor(this.palette().navBarBg)
+      .borderRadius(RADIUS_PILL)
+      .border({ width: 1, color: this.palette().navBarBorder })
+      .shadow({ radius: 20, color: this.palette().shadow, offsetY: 6 })
+      .onClick(tap)
+    }
+  }
+
+  build() {
+    // 外层撑满并左对齐：菜单要出现在加号正上方，而不是跟着悬浮区右对齐
+    Row() {
+      Row({ space: 8 }) {
+        this.AttachOption($r('app.media.ic_image'), '图片', () => {
+          const cb: (() => void) | undefined = this.onPickImage;
+          if (cb !== undefined) {
+            cb();
+          }
+        })
+        this.AttachOption($r('app.media.ic_file'), '文件', () => {
+          const cb: (() => void) | undefined = this.onPickFile;
+          if (cb !== undefined) {
+            cb();
+          }
+        })
+      }
+    }
+    .width('100%')
+    .justifyContent(FlexAlign.Start)
+    .margin({ bottom: 8 })
+    .hitTestBehavior(HitTestMode.Transparent)
+    // 加号菜单由 if 控制，进出场只能靠 transition；配合 toggle 处的
+    // animateTo，展开时两枚胶囊从加号上方浮起而不是硬闪出来。
+    .transition(TransitionEffect.OPACITY.combine(TransitionEffect.translate({ y: 12 })).animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut }))
+  }
+}
+
+/** 待发送附件预览条：缩略信息 + 一个移除按钮 */
+@Component
+export struct ChatPendingChip {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop name: string = '';
+  @Prop byteSize: number = 0;
+  @Prop isImage: boolean = false;
+  @Prop uploading: boolean = false;
+  onRemove?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    // 按压反馈交给 MotionBase（全宽预览条）
+    MotionBase({ pressEnabled: true }) {
+      Row({ space: 8 }) {
+        Image(this.isImage ? $r('app.media.ic_image') : $r('app.media.ic_file'))
+          .width(15)
+          .height(15)
+          .fillColor(this.palette().accent)
+          .draggable(false)
+        Column({ space: 1 }) {
+          Text(this.name)
+            .fontSize(12)
+            .fontColor(this.palette().textPrimary)
+            .maxLines(1)
+            .textOverflow({ overflow: TextOverflow.Ellipsis })
+          Text(this.uploading ? '上传中...' : formatBytes(this.byteSize))
+            .fontSize(10)
+            .fontColor(this.palette().textMuted)
+        }
+        .alignItems(HorizontalAlign.Start)
+        .layoutWeight(1)
+        if (this.uploading) {
+          LoadingProgress()
+            .width(14)
+            .height(14)
+            .color(this.palette().accent)
+        } else {
+          Image($r('app.media.ic_close'))
+            .width(13)
+            .height(13)
+            .fillColor(this.palette().textMuted)
+            .draggable(false)
+            .onClick(() => {
+              const cb: (() => void) | undefined = this.onRemove;
+              if (cb !== undefined) {
+                cb();
+              }
+            })
+        }
+      }
+      .width('100%')
+      .padding({ left: 12, right: 12, top: 8, bottom: 8 })
+      .margin({ bottom: 8 })
+      .backgroundColor(this.palette().navBarBg)
+      .borderRadius(RADIUS_MD)
+      .border({ width: 1, color: this.palette().navBarBorder })
+      .shadow({ radius: 20, color: this.palette().shadow, offsetY: 6 })
+    }
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/ChatBubble.ets

@@ -0,0 +1,247 @@
+/**
+ * 单条聊天气泡（含头像、渠道名、思考卡、工具卡、附件卡、正文）。
+ *
+ * 从 pages/ChatPage.ets 抽出（原来是 Avatar / ChanAvatar / BubbleSlot /
+ * MessageBubble / BubbleBody 五个 @Builder）。
+ *
+ * 传参约定：一切都在构造时快照进来。ForEach 的键（structSig）只在
+ * 消息"结构"变化时改变（新增思考/工具/附件/来源、定稿），结构一变
+ * 气泡就整条重建，因此结构类字段不需要二次更新；唯一会在键不变时
+ * 持续变化的是正文 content，所以它单独用基本类型 @Prop 传（与
+ * MarkdownView 的 @Prop content 走同一条响应式链路，流式渲染不变）。
+ */
+
+import { ChatMessage, ToolCallInfo, ChatAttachment } from '../model/Model';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_MD, RADIUS_PILL,
+  ANIM_NORMAL } from '../common/Constants';
+import { bubbleMaxWidth, chanColor, chanLabel, chanLetter } from '../common/ChatFormat';
+import { AttachmentCard } from './Attachment';
+import { MarkdownView } from './MarkdownView';
+import { ChatReasoningCard, ChatToolCard } from './ChatToolCard';
+
+@Component
+export struct ChatBubble {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop msgId: number = 0;
+  @Prop role: string = '';
+  /** 正文：唯一会在 ForEach 键不变时持续变化的字段 */
+  @Prop content: string = '';
+  @Prop isStreaming: boolean = false;
+  @Prop isFinal: boolean = false;
+  @Prop reasoningContent: string = '';
+  @Prop reasoningOpen: boolean = false;
+  @Prop toolCalls: ToolCallInfo[] = [];
+  @Prop attachment: ChatAttachment | undefined = undefined;
+  @Prop source: string = '';
+  /** 是否"别处来的"消息（渠道/设备） */
+  @Prop channel: boolean = false;
+  /** 是否自己发的（右对齐、"我"头像） */
+  @Prop mine: boolean = false;
+  /** 入场动画阶段 */
+  @Prop fresh: boolean = false;
+  onOpenAttachment?: (att: ChatAttachment) => void;
+  onToggleReasoning?: (msgId: number) => void;
+  onToggleTool?: (msgId: number, index: number) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  /** 思考卡/工具卡是否是"面板"：气泡宽度要放宽，见 common/ChatFormat */
+  private maxWidth(): string {
+    const msg: ChatMessage = {
+      id: this.msgId,
+      role: this.role,
+      content: this.content,
+      toolCalls: this.toolCalls,
+    };
+    if (this.reasoningContent.length > 0) {
+      msg.reasoningContent = this.reasoningContent;
+    }
+    return bubbleMaxWidth(msg);
+  }
+
+  @Builder
+  Avatar() {
+    Text(this.role === 'user' ? '我' : 'AI')
+      .fontSize(11)
+      .fontWeight(FontWeight.Bold)
+      .fontColor(this.role === 'user' ? this.palette().msgUserText : this.palette().accent)
+      .textAlign(TextAlign.Center)
+      .width(28)
+      .height(28)
+      .borderRadius(RADIUS_PILL)
+      .backgroundColor(this.role === 'user' ? this.palette().msgUserBg : this.palette().accentBg)
+      .margin({ top: 2 })
+  }
+
+  @Builder
+  ChanAvatar() {
+    Text(chanLetter(this.source))
+      .fontSize(12)
+      .fontWeight(FontWeight.Bold)
+      .fontColor(Color.White)
+      .textAlign(TextAlign.Center)
+      .width(28)
+      .height(28)
+      .borderRadius(RADIUS_PILL)
+      .backgroundColor(chanColor(this.source))
+      .margin({ top: 2 })
+  }
+
+  /**
+   * 气泡占位槽 —— 分栏右侧被切掉的根因就在这里。
+   *
+   * 原来 BubbleBody 直接放进 Row，它的 constraintSize maxWidth 是百分比
+   * （78% / 92%）。百分比是相对【父节点外框】解析的，而这个 Row 自带
+   * 左右 8 的 padding、外层列表 Column 又有左右 14 的 padding，
+   * 于是 92% 算出来的宽度里包含了这些 padding，再加上 28 的头像和 8 的
+   * 间距，一行的总宽就超过了可用内容宽。窄屏因为整体够宽看不出来，
+   * 分栏后左栏只有 420vp，溢出的十几 vp 直接被栏宽裁掉 —— 表现为
+   * 消息右侧被切了一条（这与 MarkdownView 里 width('100%') 溢出 12vp
+   * 被 clip 的问题是同一个成因）。
+   *
+   * 修法同 MarkdownView：用 layoutWeight(1) 拿"剩余空间"而不是百分比。
+   * 槽自身无 padding，外框宽 == 内容宽 == 头像与间距之外的真实可用宽度，
+   * 气泡的百分比再相对它解析，无论栏宽多少都不可能溢出。
+   */
+  @Builder
+  BubbleSlot() {
+    Column() {
+      this.BubbleBody()
+    }
+    .layoutWeight(1)
+    .alignItems(this.mine ? HorizontalAlign.End : HorizontalAlign.Start)
+  }
+
+  @Builder
+  BubbleBody() {
+    Column() {
+      // 渠道来源名（对齐 GUI 的 msg-chan-name）：只有别处来的消息才显示
+      if (this.channel) {
+        Text(chanLabel(this.source))
+          .fontSize(10)
+          .fontWeight(FontWeight.Medium)
+          .fontColor(this.palette().textMuted)
+          .margin({ bottom: 4 })
+      }
+
+      // Reasoning card (assistant only)
+      if (this.role === 'assistant' && this.reasoningContent.length > 0) {
+        ChatReasoningCard({
+          content: this.reasoningContent,
+          open: this.reasoningOpen,
+          sweeping: this.isFinal !== true && this.isStreaming === true,
+          fresh: this.fresh,
+          onToggle: () => {
+            const cb: ((id: number) => void) | undefined = this.onToggleReasoning;
+            if (cb !== undefined) {
+              cb(this.msgId);
+            }
+          },
+        })
+      }
+
+      // 附件卡（图片缩略图 / 文件条），点击进入附件详情二级页
+      if (this.attachment !== undefined) {
+        AttachmentCard({
+          att: this.attachment,
+          mine: this.role === 'user',
+          onTap: () => {
+            const a: ChatAttachment | undefined = this.attachment;
+            const cb: ((att: ChatAttachment) => void) | undefined = this.onOpenAttachment;
+            if (a !== undefined && cb !== undefined) {
+              cb(a);
+            }
+          },
+        })
+      }
+
+      // Content bubble — 对齐 WebGUI bubbleGrow + textFadeIn
+      if (this.content.length > 0) {
+        if (this.role === 'assistant') {
+          MarkdownView({
+            content: this.content,
+            isStreaming: this.isStreaming === true,
+            isDark: this.isDark,
+          })
+        } else {
+          Text(this.content)
+            .fontSize(15)
+            .lineHeight(24)
+            .fontColor(this.palette().msgBubbleText)
+            .textAlign(TextAlign.Start)
+            .wordBreak(WordBreak.BREAK_ALL)
+            .constraintSize({ maxWidth: '100%' })
+            .margin({ top: this.attachment !== undefined ? 8 : 0 })
+        }
+      }
+
+      // Tool cards
+      if (this.toolCalls.length > 0) {
+        Column() {
+          ForEach(this.toolCalls, (tc: ToolCallInfo, tci: number) => {
+            ChatToolCard({
+              tc: tc,
+              index: tci,
+              onToggle: (index: number) => {
+                const cb: ((id: number, i: number) => void) | undefined = this.onToggleTool;
+                if (cb !== undefined) {
+                  cb(this.msgId, index);
+                }
+              },
+            })
+          }, (tc: ToolCallInfo, tci: number) => tci.toString() + tc.name)
+        }
+        // 不写 width('100%')：百分比会按气泡外框解析而溢出 12vp 被 clip。
+        // 让它自适应，最大宽约束由气泡内容框向下传递，ChatToolCard 内部用 layoutWeight 取满。
+        .alignItems(HorizontalAlign.Start)
+        .margin({ top: this.content.length > 0 ? 6 : 0 })
+      }
+    }
+    .constraintSize({ maxWidth: this.maxWidth() })
+    .clip(true)
+    .padding({ left: 12, right: 12, top: 9, bottom: 9 })
+    .backgroundColor(this.role === 'user' ? this.palette().msgUserBubbleBg : this.palette().msgAssistantBubbleBg)
+    .borderRadius({
+      topLeft: RADIUS_MD,
+      topRight: RADIUS_MD,
+      bottomLeft: this.role === 'assistant' ? 4 : RADIUS_MD,
+      bottomRight: this.role === 'user' ? 4 : RADIUS_MD,
+    })
+    .border({ width: 1, color: this.role === 'user' ? this.palette().msgUserBubbleBorder : this.palette().msgAssistantBubbleBorder })
+    .shadow({ radius: 8, color: this.palette().shadow, offsetY: 2 })
+    .alignItems(HorizontalAlign.Start)
+    // bubbleGrow: 气泡入场缩放效果
+    .scale({
+      x: this.fresh ? 0.95 : 1,
+      y: this.fresh ? 0.95 : 1,
+    })
+    .animation({ duration: 200, curve: Curve.EaseOut })
+  }
+
+  build() {
+    Row({ space: 8 }) {
+      if (this.channel) {
+        this.ChanAvatar()
+        this.BubbleSlot()
+      } else if (this.role === 'user') {
+        this.BubbleSlot()
+        this.Avatar()
+      } else {
+        this.Avatar()
+        this.BubbleSlot()
+      }
+    }
+    .width('100%')
+    .alignItems(VerticalAlign.Top)
+    // 槽已经用 layoutWeight 吃掉了剩余宽度，这里的对齐实际不再参与分配，
+    // 保留是为了兜底：若某处布局退化成非加权分配，方向也仍然正确。
+    .justifyContent(this.mine ? FlexAlign.End : FlexAlign.Start)
+    .padding({ left: 8, right: 8, top: 3, bottom: 3 })
+    // 入场动画：对齐 WebGUI viewIn (opacity 0 -> 1, translateY 6 -> 0)
+    .opacity(this.fresh ? 0 : 1)
+    .translate({ y: this.fresh ? 8 : 0 })
+    .animation({ duration: 180, curve: Curve.EaseOut })
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/ChatComposer.ets

@@ -0,0 +1,361 @@
+/**
+ * 悬浮输入区：加号菜单 + 待发送附件预览 + 输入行（含发送/中断）。
+ *
+ * 从 pages/ChatPage.ets 抽出（原来是 ChatBody 的层2 + AttachMenu /
+ * AttachOption / PendingAttachmentChip 三个 @Builder，外加选图/选文件、
+ * 沙箱落盘、带附件发送这一整套方法）。
+ *
+ * 输入区自己持有文本与附件状态；只有会影响【列表底部留白】的三项
+ * （inputMultiLine / attachMenuOpen / pendingName）用 @Link 与页面共享。
+ */
+
+import { ChatMessage } from '../model/Model';
+import { userMessage } from '../common/UserError';
+import { connStore } from '../common/ConnStore';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, ANIM_FAST, ANIM_NORMAL } from '../common/Constants';
+import { mimeOf } from '../common/ChatFormat';
+import { chatStore, K_CHAT_LOADING } from '../common/ChatStore';
+import { sendChatText, sendChatFile, interruptChat } from '../common/ChatSession';
+import { fileNameOf } from '../common/AttachmentMeta';
+import { ChatAttachMenu, ChatPendingChip } from './ChatAttachBar';
+import { NavFloatOverlay, FloatIconButton } from './PageTopBar';
+import { picker, fileIo } from '@kit.CoreFileKit';
+import { common } from '@kit.AbilityKit';
+import { MeasureOptions } from '@ohos.measure';
+
+/** 输入框字号与内边距：文字测量必须和 TextArea 的实际排版参数一致 */
+const INPUT_FONT_SIZE: number = 14;
+const INPUT_INNER_PAD: number = 16;
+/** 单行态左右让位：左边加号 42+8，右边发送键 44+8 */
+const INPUT_LEFT_GAP: number = 50;
+const INPUT_RIGHT_GAP: number = 52;
+
+@Component
+export struct ChatComposer {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @StorageProp(K_CHAT_LOADING) private loading: boolean = false;
+  /** 输入框是否已进入多行态（页面用它算列表底部留白） */
+  @Link inputMultiLine: boolean;
+  /** 加号菜单是否展开（同上） */
+  @Link attachMenuOpen: boolean;
+  /** 待发送附件的展示名（同上） */
+  @Link pendingName: string;
+  @State inputText: string = '';
+  @State pendingSize: number = 0;
+  @State pendingIsImage: boolean = false;
+  @State uploading: boolean = false;
+  private pendingPath: string = '';
+  private pendingMime: string = '';
+  /** 底部固定行的实测宽度：用于文字测量，判断是否需要换行 */
+  private inputRowWidth: number = 0;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  /** 输入框底：高不透明度 + blur，保证背景内容不会透过输入文字 */
+  private inputSolidBg(): string {
+    return this.isDark ? 'rgba(28, 28, 30, 0.94)' : 'rgba(245, 245, 247, 0.92)';
+  }
+
+  /**
+   * 由【文本本身】判断输入框是否需要换行，而不是回读控件高度。
+   *
+   * 用 MeasureUtils 在单行态可用宽度下测量文字：宽度超了就是多行。
+   * 测量宽度恒定取单行态（窄）宽度，与控件当前实际宽度无关，
+   * 所以"多行时变宽"不会反过来改变判定结果 —— 没有反馈环，也就不抖。
+   */
+  private recomputeMultiLine(text: string): void {
+    const avail: number = this.inputRowWidth - INPUT_LEFT_GAP - INPUT_RIGHT_GAP
+      - INPUT_INNER_PAD * 2;
+    if (avail <= 0) {
+      return;
+    }
+    let multi: boolean = text.indexOf('\n') >= 0;
+    if (!multi && text.length > 0) {
+      const opt: MeasureOptions = {
+        textContent: text,
+        fontSize: INPUT_FONT_SIZE,
+      };
+      const size: SizeOptions = this.getUIContext().getMeasureUtils().measureTextSize(opt);
+      // measureTextSize 返回 px，可用宽度是 vp，换算后再比
+      const widthVp: number = this.getUIContext().px2vp(size.width as number);
+      multi = widthVp > avail;
+    }
+    if (multi !== this.inputMultiLine) {
+      this.getUIContext().animateTo({ duration: 260, curve: Curve.Friction }, () => {
+        this.inputMultiLine = multi;
+      });
+    }
+  }
+
+  // ===================== 附件：选择与上传 =====================
+
+  /** 从图库挑一张图 */
+  private async pickImage(): Promise<void> {
+    this.getUIContext().animateTo({ duration: ANIM_NORMAL, curve: Curve.EaseOut }, () => {
+      this.attachMenuOpen = false;
+    });
+    try {
+      const options = new picker.PhotoSelectOptions();
+      options.MIMEType = picker.PhotoViewMIMETypes.IMAGE_TYPE;
+      options.maxSelectNumber = 1;
+      const photoPicker = new picker.PhotoViewPicker();
+      const result = await photoPicker.select(options);
+      if (result.photoUris.length === 0) {
+        return;
+      }
+      this.stagePickedFile(result.photoUris[0], true);
+    } catch (e) {
+      chatStore.setStage(userMessage('chat.pickImage', e));
+      chatStore.forceRefresh();
+    }
+  }
+
+  /** 从文件管理器挑一个文件 */
+  private async pickFile(): Promise<void> {
+    this.getUIContext().animateTo({ duration: ANIM_NORMAL, curve: Curve.EaseOut }, () => {
+      this.attachMenuOpen = false;
+    });
+    try {
+      const options = new picker.DocumentSelectOptions();
+      options.maxSelectNumber = 1;
+      const docPicker = new picker.DocumentViewPicker();
+      const uris: string[] = await docPicker.select(options);
+      if (uris.length === 0) {
+        return;
+      }
+      this.stagePickedFile(uris[0], false);
+    } catch (e) {
+      chatStore.setStage(userMessage('chat.pickFile', e));
+      chatStore.forceRefresh();
+    }
+  }
+
+  /**
+   * 把 picker 给的 URI 复制到应用沙箱。
+   * http 的 multiFormDataList.filePath 只能读应用自己的沙箱路径，
+   * 直接把 picker 的 media:// URI 交过去会读不到内容。
+   */
+  private stagePickedFile(srcUri: string, isImage: boolean): void {
+    try {
+      const ctx = getContext(this) as common.UIAbilityContext;
+      const name: string = fileNameOf(srcUri);
+      const destPath: string = ctx.filesDir + '/up_' + Date.now().toString(36) + '_' + name;
+      const srcFile = fileIo.openSync(srcUri, fileIo.OpenMode.READ_ONLY);
+      const destFile = fileIo.openSync(destPath,
+        fileIo.OpenMode.READ_WRITE | fileIo.OpenMode.CREATE | fileIo.OpenMode.TRUNC);
+      fileIo.copyFileSync(srcFile.fd, destFile.fd);
+      fileIo.closeSync(srcFile);
+      fileIo.closeSync(destFile);
+      const stat = fileIo.statSync(destPath);
+      this.clearPendingFile();
+      this.pendingPath = destPath;
+      this.pendingName = name;
+      this.pendingSize = stat.size;
+      this.pendingIsImage = isImage;
+      this.pendingMime = mimeOf(name, isImage);
+    } catch (e) {
+      chatStore.setStage(userMessage('chat.stageFile', e));
+    }
+    chatStore.forceRefresh();
+  }
+
+  /** 丢弃待发送附件，并删掉沙箱里的临时副本 */
+  private clearPendingFile(): void {
+    if (this.pendingPath.length > 0) {
+      try {
+        fileIo.unlinkSync(this.pendingPath);
+      } catch (e) {
+        // 已不存在，忽略
+      }
+    }
+    this.pendingPath = '';
+    this.pendingName = '';
+    this.pendingSize = 0;
+    this.pendingIsImage = false;
+    this.pendingMime = '';
+  }
+
+  /** 发送：有附件走 multipart（POST /chat/file），否则走 POST /chat */
+  private async send(): Promise<void> {
+    if (this.loading || this.uploading) {
+      return;
+    }
+    // 没连后端时直接返回、且不清输入/不动附件：与拆分前 sendChat 的守卫顺序一致
+    if (connStore.getCurrentConnection() === null) {
+      return;
+    }
+    const text: string = this.inputText.trim();
+    if (this.pendingPath.length > 0) {
+      const path: string = this.pendingPath;
+      const name: string = this.pendingName;
+      const size: number = this.pendingSize;
+      const isImage: boolean = this.pendingIsImage;
+      const mime: string = this.pendingMime;
+      this.inputText = '';
+      this.inputMultiLine = false;
+      this.uploading = true;
+      await sendChatFile(text, path, name, size, isImage, mime);
+      this.uploading = false;
+      this.clearPendingFile();
+      chatStore.forceRefresh();
+      chatStore.requestScroll();
+      return;
+    }
+    if (text.length === 0) {
+      return;
+    }
+    this.inputText = '';
+    this.inputMultiLine = false;
+    await sendChatText(text);
+  }
+
+  // ===================== UI =====================
+
+  build() {
+    NavFloatOverlay({ tab: 0 }) {
+      // 加号展开的两个选项（图片 / 文件），点一次收起
+      if (this.attachMenuOpen) {
+        ChatAttachMenu({
+          onPickImage: () => {
+            this.pickImage();
+          },
+          onPickFile: () => {
+            this.pickFile();
+          },
+        })
+      }
+
+      // 待发送附件预览（选好图片/文件、还没点发送时显示）
+      if (this.pendingName.length > 0) {
+        ChatPendingChip({
+          name: this.pendingName,
+          byteSize: this.pendingSize,
+          isImage: this.pendingIsImage,
+          uploading: this.uploading,
+          onRemove: () => {
+            this.clearPendingFile();
+            chatStore.forceRefresh();
+          },
+        })
+      }
+
+      // Stack 而不是 Column：加号与发送按钮钉死在底部这一行不动，
+      // 输入框是浮在它们上面的独立层，超过一行就往上长并展开到整行宽度。
+      Stack({ alignContent: Alignment.Bottom }) {
+        // 底层：固定不动的一行 —— 左加号（图片/文件）、右发送/中断按钮
+        Row() {
+          FloatIconButton({
+            icon: $r('app.media.ic_plus'),
+            onTap: () => {
+              // 菜单展开会同时改变列表底部留白，用 animateTo 把
+              // 列表内边距和菜单进出场拉到同一个时钟上。
+              this.getUIContext().animateTo({ duration: ANIM_NORMAL, curve: Curve.EaseOut }, () => {
+                this.attachMenuOpen = !this.attachMenuOpen;
+              });
+            },
+          })
+          Blank()
+          if (this.loading) {
+            Button() {
+              Image($r('app.media.ic_stop'))
+                .width(16)
+                .height(16)
+                .fillColor(Color.White)
+            }
+              .width(44)
+              .height(44)
+              .type(ButtonType.Circle)
+              .backgroundColor('#77809A')
+              // 发送/中断切换是 if 分支整体替换，用 transition 淡入淡出
+              .transition(TransitionEffect.OPACITY.combine(TransitionEffect.scale({ x: 0.9, y: 0.9 })).animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+              .onClick(() => {
+                interruptChat();
+              })
+          } else {
+            Button() {
+              Image($r('app.media.ic_send'))
+                .width(18)
+                .height(18)
+                .fillColor(Color.White)
+            }
+              .width(44)
+              .height(44)
+              .type(ButtonType.Circle)
+              .backgroundColor(this.palette().accent)
+              .enabled(this.inputText.trim().length > 0 || this.pendingPath.length > 0)
+              .transition(TransitionEffect.OPACITY.combine(TransitionEffect.scale({ x: 0.9, y: 0.9 })).animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+              .onClick(() => {
+                this.send();
+              })
+          }
+        }
+        .width('100%')
+        .height(44)
+        .alignItems(VerticalAlign.Center)
+        .onAreaChange((_o: Area, n: Area) => {
+          // 这一行高度恒为 44、宽度恒为 100%，测量它不会形成反馈环。
+          const w: number = n.width as number;
+          if (Math.abs(w - this.inputRowWidth) > 0.5) {
+            this.inputRowWidth = w;
+            this.recomputeMultiLine(this.inputText);
+          }
+        })
+
+        // 上层：输入框。
+        // 单行时左右让出加号(42+8)与发送键(44+8)的位置，与它们同处一行；
+        // 多行时整体上移 52 抬到那一行之上，并铺满整行宽度。
+        //
+        // 之前"只上移不变宽"是因为宽度被钉死了：让宽度跟着实测高度变会形成
+        // 布局反馈环（变宽→文字回落成一行→变窄→又折行），卡在半弹出态抖动。
+        // 现在改用 MeasureUtils 直接量文字：始终按【窄宽度】测量是否需要换行，
+        // 判定输入只依赖文本内容，与控件实际宽度无关，所以变宽也不会自激。
+        Row() {
+          TextArea({
+            placeholder: '输入消息...',
+            text: this.inputText,
+          })
+            .layoutWeight(1)
+            // 不写死高度：单行 44，随文字换行自动增高，最多约 5 行后内部滚动
+            .constraintSize({ minHeight: 44, maxHeight: 168 })
+            .fontSize(INPUT_FONT_SIZE)
+            .fontColor(this.palette().textPrimary)
+            .placeholderFont({ size: 13 })
+            .placeholderColor(this.palette().textMuted)
+            .backgroundColor(this.inputSolidBg())
+            .backdropBlur(24)
+            .borderRadius(22)
+            .border({ width: 1, color: this.palette().glassBorder })
+            .padding({
+              left: INPUT_INNER_PAD,
+              right: INPUT_INNER_PAD,
+              top: 11,
+              bottom: 11,
+            })
+            .enterKeyType(EnterKeyType.Send)
+            .onChange((value: string) => {
+              this.inputText = value;
+              this.recomputeMultiLine(value);
+            })
+            .onSubmit(() => {
+              this.send();
+            })
+        }
+        .width('100%')
+        // 多行时必须显式写 0：给 .padding() 传 undefined 在增量更新时会被当作
+        // "不修改该属性"，旧的左右 50/52 留在原地 —— 这就是"只上移不变宽"。
+        .padding(this.inputMultiLine
+          ? { left: 0, right: 0 }
+          : { left: INPUT_LEFT_GAP, right: INPUT_RIGHT_GAP })
+        .margin({ bottom: this.inputMultiLine ? 52 : 0 })
+        // 关键：这层 Row 铺满整宽，它的左右 padding 正好压在加号与发送键上方。
+        // 不设 None 的话 padding 区域仍属于 Row，会把点击吞掉 —— 发送键点不动。
+        // None = 自身不响应、子节点（TextArea）照常响应，触摸落到下层那一行。
+        .hitTestBehavior(HitTestMode.None)
+        .animation({ duration: 260, curve: Curve.Friction })
+      }
+      .width('100%')
+    }
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/ChatStream.ets

@@ -0,0 +1,210 @@
+/**
+ * 聊天消息流：列表 + 顶栏遮罩 + 底部淡出遮罩 + 滚动/懒加载。
+ *
+ * 从 pages/ChatPage.ets 抽出（原来是 ChatBody 里除悬浮输入区之外的三层）。
+ * 消息数组来自 common/ChatStore.ets：用版本号 K_CHAT_REV 订阅，
+ * 版本变化时重取一次快照（数组引用每次都是新的，ForEach 的渲染语义
+ * 与拆分前 this.messages = this.messages.slice() 完全一致）。
+ */
+
+import { ChatMessage } from '../model/Model';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, ANIM_FAST } from '../common/Constants';
+import { navBar } from '../common/NavBarController';
+import { ChatAttachment } from '../model/Model';
+import { chatStore, K_CHAT_REV, K_CHAT_SCROLL_REV, K_CHAT_LOADING, K_CHAT_STAGE } from '../common/ChatStore';
+import { isChannelMsg, isSelfMsg, structSig } from '../common/ChatFormat';
+import { connStore } from '../common/ConnStore';
+import { ChatBubble } from './ChatBubble';
+import { PageTopBar } from './PageTopBar';
+
+@Component
+export struct ChatStream {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @StorageProp(K_CHAT_LOADING) private loading: boolean = false;
+  @StorageProp(K_CHAT_STAGE) private stage: string = '';
+  /** 数组快照的订阅信号 */
+  @StorageProp(K_CHAT_REV) @Watch('onChatRev') private rev: number = 0;
+  /** "滚到底"请求信号 */
+  @StorageProp(K_CHAT_SCROLL_REV) @Watch('onScrollReq') private scrollRev: number = 0;
+  @State messages: ChatMessage[] = [];
+  /** 列表底部留白：随输入区展开/加号菜单/待发送附件变化 */
+  @Prop bottomPad: number = 210;
+  onOpenAttachment?: (att: ChatAttachment) => void;
+
+  private scroller: Scroller = new Scroller();
+  private autoScrolling: boolean = false;
+  private navHidden: boolean = false;
+
+  aboutToAppear(): void {
+    this.messages = chatStore.messages();
+  }
+
+  private onChatRev(): void {
+    this.messages = chatStore.messages();
+  }
+
+  private onScrollReq(): void {
+    this.scrollToBottom();
+  }
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  /**
+   * 底部淡出遮罩的两个端色：背景底色的全不透明 / 全透明版本。
+   * bgPrimary 是 6 位十六进制，这里手拼 8 位 ARGB —— 与 PageTopBar
+   * 顶部淡出用的是同一手法，保证上下两端的融入观感一致。
+   */
+  private opaqueBottomBg(): string {
+    return '#FF' + this.palette().bgPrimary.substring(1);
+  }
+
+  private transparentBottomBg(): string {
+    return '#00' + this.palette().bgPrimary.substring(1);
+  }
+
+  private scrollToBottom(): void {
+    this.autoScrolling = true;
+    setTimeout(() => {
+      this.scroller.scrollEdge(Edge.Bottom);
+    }, 50);
+    setTimeout(() => {
+      this.autoScrolling = false;
+      this.navHidden = false;
+      navBar.setVisible(true);
+    }, 450);
+  }
+
+  /**
+   * 滚动回调：只设置普通标志位，仅在状态翻转时通知 navBar，
+   * 不在回调里做任何耗时操作。navBar.setVisible 内部已去重，
+   * 而布局（padding）不再依赖 navVisible，故翻转只触发 GPU 变换，
+   * 不会引起布局回流——这是滑动流畅的关键。
+   */
+  private handleScrollDirection(yOffset: number, state: ScrollState): void {
+    if (this.autoScrolling) {
+      return;
+    }
+    // 触顶（近顶部 60vp）且服务端还有更早历史 → 向上懒加载下一页
+    if (yOffset < 60 && chatStore.hasMore()) {
+      chatStore.loadOlder();
+    }
+    if (state === ScrollState.Idle) {
+      if (this.navHidden) {
+        this.navHidden = false;
+        navBar.setVisible(true);
+      }
+    } else {
+      // Scroll / Fling：向下/惯性滚动时隐藏导航与输入栏
+      if (!this.navHidden) {
+        this.navHidden = true;
+        navBar.setVisible(false);
+      }
+    }
+  }
+
+  build() {
+    Stack({ alignContent: Alignment.Bottom }) {
+      // 层1：消息列表（铺满全屏，内容从顶栏遮罩下方穿过时逐渐淡出）
+      Column() {
+        Scroll(this.scroller) {
+          Column() {
+            ForEach(this.messages, (msg: ChatMessage, idx: number) => {
+              ChatBubble({
+                msgId: msg.id,
+                role: msg.role,
+                content: msg.content,
+                isStreaming: msg.isStreaming === true,
+                isFinal: msg.isFinal === true,
+                reasoningContent: msg.reasoningContent ?? '',
+                reasoningOpen: msg.reasoningOpen === true,
+                toolCalls: msg.toolCalls ?? [],
+                attachment: msg.attachment,
+                source: msg.source ?? '',
+                channel: isChannelMsg(msg.source ?? '', connStore.ensureDeviceId()),
+                mine: isSelfMsg(msg.role, isChannelMsg(msg.source ?? '', connStore.ensureDeviceId())),
+                fresh: chatStore.isFresh(msg.id),
+                onOpenAttachment: (att: ChatAttachment) => {
+                  const cb: ((a: ChatAttachment) => void) | undefined = this.onOpenAttachment;
+                  if (cb !== undefined) {
+                    cb(att);
+                  }
+                },
+                onToggleReasoning: (id: number) => {
+                  // 在 animateTo 里翻转：展开/收起时 chevron 走已有 .animation，
+                  // 面板节点在 animateTo 帧内获得默认过渡，不会再硬切。
+                  this.getUIContext().animateTo({ duration: 220, curve: Curve.EaseOut }, () => {
+                    chatStore.setReasoningOpen(id, !chatStore.reasoningOpen(id));
+                    chatStore.forceRefresh();
+                  });
+                },
+                onToggleTool: (id: number, index: number) => {
+                  this.getUIContext().animateTo({ duration: 220, curve: Curve.EaseOut }, () => {
+                    chatStore.setToolOpen(id, index, !chatStore.toolOpen(id, index));
+                    chatStore.forceRefresh();
+                  });
+                },
+              })
+            }, (msg: ChatMessage, idx: number) => structSig(msg))
+
+            if (this.loading) {
+              Row({ space: 8 }) {
+                LoadingProgress()
+                  .width(16)
+                  .height(16)
+                  .color(this.palette().accent)
+                Text(this.stage.length > 0 ? this.stage : '处理中...')
+                  .fontSize(12)
+                  .fontColor(this.palette().textMuted)
+              }
+              .width('100%')
+              .justifyContent(FlexAlign.Start)
+              .padding({ left: 52, top: 6, bottom: 6 })
+              // if 控制的节点无法用 .animation() 做进出场（那只驱动自身属性的增量更新）；
+              // 用 transition 才能让"处理中"这条在出现和消失时都淡入淡出。
+              .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+            }
+          }
+          .width('100%')
+          .padding({
+            left: 14,
+            right: 14,
+            top: 76,
+            bottom: this.bottomPad,
+          })
+        }
+        .width('100%')
+        .height('100%')
+        .scrollBar(BarState.Off)
+        .edgeEffect(EdgeEffect.Spring)
+        .align(Alignment.Top)
+        .onDidScroll((xOffset: number, yOffset: number, state: ScrollState) => {
+          this.handleScrollDirection(yOffset, state);
+        })
+      }
+      .width('100%')
+      .height('100%')
+
+      // 层1.5：顶栏遮罩（自身撑满并顶部对齐，全链路 hitTest None，触摸完全穿透）
+      PageTopBar({ title: '聊天' })
+
+      // 层1.6：底部淡出遮罩 —— 滚动内容接近悬浮输入区/底部导航时逐渐隐入背景，
+      // 而不是在玻璃后面清晰可见（PageTopBar 顶部淡出手法的镜像，方向相反）。
+      Column()
+        .width('100%')
+        .height(170)
+        .linearGradient({
+          direction: GradientDirection.Bottom,
+          colors: [
+            [this.transparentBottomBg(), 0.0],
+            [this.opaqueBottomBg(), 0.6],
+            [this.opaqueBottomBg(), 1.0],
+          ],
+        })
+        .hitTestBehavior(HitTestMode.None)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/ChatToolCard.ets

@@ -0,0 +1,253 @@
+/**
+ * 气泡内的两张"面板"卡：思考过程卡 + 工具调用卡。
+ *
+ * 从 pages/ChatPage.ets 抽出（原来分别是 ReasoningCard / ToolCard 两个 @Builder）。
+ * 折叠状态与开关动作都交回调用方（状态在 chatStore 里，且展开/收起要在
+ * animateTo 帧内完成 —— 那需要组件上下文）。
+ */
+
+import { ToolCallInfo } from '../model/Model';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_SM,
+  ANIM_NORMAL } from '../common/Constants';
+import { tcRunning, tcError, tcLeftColor, tcIcoColor, tcStateLabel, tcStateColor } from '../common/ChatFormat';
+
+@Component
+export struct ChatReasoningCard {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  /** 思考正文（已折叠时也带着，展开不再请求） */
+  @Prop content: string = '';
+  @Prop open: boolean = false;
+  /** 流式中：显示转圈 + 扫光条 */
+  @Prop sweeping: boolean = false;
+  /** 入场动画阶段：扫光条起始偏移靠它切换 */
+  @Prop fresh: boolean = false;
+  onToggle?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    // 两层结构，原因见 ChatBubble 的布局说明：
+    // 外层 Row 是"外观壳"（虚线边框 / 底色 / 圆角），不设百分比宽度，
+    // 靠内层 layoutWeight(1) 把气泡内容框的剩余宽度吃满；
+    // 内层 holder Column 自身无 padding，所以它的子节点写 width('100%')
+    // 才有正确的解析基准，不会再溢出到气泡外被 clip 切掉。
+    Row() {
+      Column() {
+        Row({ space: 7 }) {
+          Image($r('app.media.ic_sparkle'))
+            .width(12)
+            .height(12)
+            .fillColor(this.palette().accent)
+          Text('思考过程')
+            .fontSize(11)
+            .fontWeight(FontWeight.Medium)
+            .fontColor(this.palette().textPrimary)
+          // 流式思考时给出明确进度指示，而不是一张看不出在动的折叠卡
+          if (this.sweeping) {
+            LoadingProgress()
+              .width(11)
+              .height(11)
+              .color(this.palette().accent)
+          }
+          Blank()
+          Text(this.content.length > 0 ? this.content.length.toString() + ' 字' : '')
+            .fontSize(9.5)
+            .fontColor(this.palette().textMuted)
+          Image($r('app.media.ic_chevron_down'))
+            .width(14)
+            .height(14)
+            .fillColor(this.palette().textMuted)
+            .rotate({ angle: this.open ? 180 : 0 })
+            .animation({ duration: 200, curve: Curve.EaseOut })
+        }
+        .width('100%')
+        .padding({ left: 10, right: 10, top: 6, bottom: 6 })
+        .onClick(() => {
+          const cb: (() => void) | undefined = this.onToggle;
+          if (cb !== undefined) {
+            cb();
+          }
+        })
+
+        if (this.open) {
+          Text(this.content)
+            .fontSize(11.5)
+            .lineHeight(17)
+            .fontColor(this.palette().textTertiary)
+            .width('100%')
+            .padding({ left: 10, right: 10, bottom: 8 })
+            .maxLines(24)
+            .textOverflow({ overflow: TextOverflow.Ellipsis })
+            .wordBreak(WordBreak.BREAK_ALL)
+            // 面板内容靠 if 挂载：用 transition 在展开/收起时淡入淡出
+            .transition(TransitionEffect.OPACITY.combine(TransitionEffect.translate({ y: -6 })).animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut }))
+        }
+
+        // 流式思考中：扫光动画条（对齐 WebGUI reasoningSweep）
+        if (this.sweeping) {
+          Stack() {
+            Row()
+              .height(2)
+              .borderRadius(2)
+              .width('200%')
+              .linearGradient({
+                angle: 90,
+                colors: [
+                  ['rgba(255,255,255,0.01)', 0],
+                  [this.palette().accent, 0.35],
+                  ['rgba(255,255,255,0.01)', 0.5],
+                  [this.palette().accent, 0.65],
+                  ['rgba(255,255,255,0.01)', 1],
+                ],
+              })
+              .opacity(0.7)
+              .translate({ x: this.fresh ? '0%' : '-50%' })
+              .animation({ duration: 1200, curve: Curve.Linear })
+          }
+          .width('100%')
+          .clip(true)
+          .height(2)
+          .margin({ top: 6 })
+        }
+      }
+      .layoutWeight(1)
+      .alignItems(HorizontalAlign.Start)
+    }
+    .alignItems(VerticalAlign.Top)
+    .margin({ bottom: 6 })
+    .borderRadius(RADIUS_SM)
+    .backgroundColor(this.palette().bgHover)
+    .border({ width: 1, color: this.palette().kvBorder, style: BorderStyle.Dashed })
+  }
+}
+
+@Component
+export struct ChatToolCard {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop tc: ToolCallInfo;
+  /** 在所属消息 toolCalls 里的下标：开关动作要交回调用方按 (msgId, index) 定位 */
+  @Prop index: number = 0;
+  onToggle?: (index: number) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    // 同 ChatReasoningCard：外层 Row 只做外观，内层 layoutWeight(1) 取真实内容宽
+    Row() {
+      Column() {
+        Row({ space: 6 }) {
+          if (tcError(this.tc)) {
+            Image($r('app.media.ic_error'))
+              .width(13).height(13)
+              .fillColor(tcIcoColor(this.tc, this.palette().accent))
+          } else if (tcRunning(this.tc)) {
+            LoadingProgress()
+              .width(12).height(12)
+              .color(tcIcoColor(this.tc, this.palette().accent))
+          } else {
+            Image($r('app.media.ic_check'))
+              .width(13).height(13)
+              .fillColor(tcIcoColor(this.tc, this.palette().accent))
+          }
+          Text(this.tc.name)
+            .fontSize(11)
+            .fontWeight(FontWeight.Medium)
+            .fontColor(this.palette().textPrimary)
+            .maxLines(1)
+            .textOverflow({ overflow: TextOverflow.Ellipsis })
+            // 名字可长可短，必须让它占剩余宽度并可收缩，
+            // 否则右侧状态文字会被挤出气泡（78% 宽度 + clip 直接切掉）
+            .layoutWeight(1)
+          if (this.tc.plugin !== undefined && this.tc.plugin.length > 0) {
+            Text(this.tc.plugin)
+              .fontSize(9.5)
+              .fontColor(this.palette().textMuted)
+              .maxLines(1)
+              .flexShrink(0)
+          }
+          // 状态徽标去掉，只留一行小字（用户要求"去掉所有状态徽标"）
+          Text(tcStateLabel(this.tc))
+            .fontSize(9.5)
+            .fontWeight(FontWeight.Medium)
+            .fontColor(tcStateColor(this.tc))
+            .flexShrink(0)
+          Image($r('app.media.ic_chevron_down'))
+            .width(13).height(13)
+            .fillColor(this.palette().textMuted)
+            .flexShrink(0)
+            .rotate({ angle: this.tc.open === true ? 180 : 0 })
+            .animation({ duration: 150, curve: Curve.EaseOut })
+        }
+        .width('100%')
+        .alignItems(VerticalAlign.Center)
+        .onClick(() => {
+          const cb: ((index: number) => void) | undefined = this.onToggle;
+          if (cb !== undefined) {
+            cb(this.index);
+          }
+        })
+
+        if (this.tc.open === true) {
+          Column() {
+            if (this.tc.args.length > 0 && this.tc.args !== '{}') {
+              Text('参数')
+                .fontSize(9.5).fontWeight(FontWeight.Medium)
+                .fontColor(this.palette().textMuted)
+                .margin({ top: 6, bottom: 2 })
+              Text(this.tc.args)
+                .fontSize(11)
+                .fontColor(this.palette().preText)
+                .backgroundColor(this.palette().preBg)
+                .borderRadius(4)
+                .padding({ left: 7, right: 7, top: 5, bottom: 5 })
+                .width('100%')
+                .textAlign(TextAlign.Start)
+                .wordBreak(WordBreak.BREAK_ALL)
+            }
+            if (this.tc.result !== undefined && this.tc.result.length > 0) {
+              Text('结果')
+                .fontSize(9.5).fontWeight(FontWeight.Medium)
+                .fontColor(this.palette().textMuted)
+                .margin({ top: 6, bottom: 2 })
+              Text(this.tc.result)
+                .fontSize(11)
+                .fontColor(this.palette().preText)
+                .backgroundColor(this.palette().preBg)
+                .borderRadius(4)
+                .padding({ left: 7, right: 7, top: 5, bottom: 5 })
+                .width('100%')
+                .textAlign(TextAlign.Start)
+                .wordBreak(WordBreak.BREAK_ALL)
+                .maxLines(8)
+                .textOverflow({ overflow: TextOverflow.Ellipsis })
+            }
+          }
+          .width('100%')
+          .alignItems(HorizontalAlign.Start)
+          // 展开内容整体用 if 挂载：transition 让参数/结果随 chevron 一起淡入
+          .transition(TransitionEffect.OPACITY.combine(TransitionEffect.translate({ y: -6 })).animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut }))
+        }
+      }
+      .layoutWeight(1)
+      .alignItems(HorizontalAlign.Start)
+    }
+    .alignItems(VerticalAlign.Top)
+    .padding({ left: 10, right: 10, top: 7, bottom: 7 })
+    .margin({ bottom: 4 })
+    .borderRadius(RADIUS_SM)
+    .backgroundColor(this.palette().bgHover)
+    .border({
+      width: { left: 3, top: 1, right: 1, bottom: 1 },
+      color: {
+        left: tcLeftColor(this.tc, this.palette().accent),
+        top: this.palette().kvBorder,
+        right: this.palette().kvBorder,
+        bottom: this.palette().kvBorder,
+      },
+    })
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/ConnectionsPane.ets

@@ -0,0 +1,347 @@
+/**
+ * 「后端连接」二级页面。
+ *
+ * 从 pages/SettingsPage.ets 抽出：连接列表 UI、增删改表单与其状态、
+ * 以及切换连接后必须做的连带动作（刷新 ApiClient / 重启前台桥）
+ * 都属于这一个功能域，收在一个组件里。
+ *
+ * connections / currentId 用 @Link 与一级页面共享：一级页的入口行
+ * 要显示"几个连接配置"和当前连接名，两边必须是同一份数据。
+ */
+
+import { apiClient } from '../common/ApiClient';
+import { connStore } from '../common/ConnStore';
+import { restartForegroundBridge } from '../common/DeviceBridgeSession';
+import { ConnectionConfig } from '../model/Model';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_MD, RADIUS_SM } from '../common/Constants';
+import { SubPageLayer, PlainCard } from './SubPage';
+import { common } from '@kit.AbilityKit';
+
+@Component
+export struct ConnectionsPane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Link connections: ConnectionConfig[];
+  @Link currentId: string;
+  onBack?: () => void;
+  onToast?: (msg: string, isError: boolean) => void;
+  @State showAddForm: boolean = false;
+  @State addFormVisible: boolean = false;
+  /**
+   * 表单当前在编辑哪条连接：空串表示新建。
+   *
+   * 之前只有"添加"入口，ConnStore.updateConnection 写好了却没有任何调用者，
+   * 于是地址填错的连接只能删掉重建（API Key 也得重敲）。同一套表单
+   * 靠这个 id 区分保存走 add 还是 update。
+   */
+  @State editingId: string = '';
+  @State editUrl: string = '';
+  @State editApiKey: string = '';
+  @State editName: string = '';
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  private toast(msg: string, isError: boolean): void {
+    const cb: ((m: string, e: boolean) => void) | undefined = this.onToast;
+    if (cb !== undefined) {
+      cb(msg, isError);
+    }
+  }
+
+  private currentConnName(): string {
+    for (let i = 0; i < this.connections.length; i++) {
+      if (this.connections[i].id === this.currentId) {
+        return this.connections[i].name;
+      }
+    }
+    return '未配置';
+  }
+
+  private selectConnection(id: string): void {
+    connStore.setCurrent(id).then(() => {
+      const cur: ConnectionConfig | null = connStore.getCurrentConnection();
+      if (cur !== null) {
+        apiClient.setConnection(cur);
+      }
+      this.connections = connStore.getConnections();
+      restartForegroundBridge(getContext(this) as common.UIAbilityContext);
+      this.toast('已切换连接', false);
+    });
+  }
+
+  private addConnection(): void {
+    const name: string = this.editName.trim();
+    const url: string = this.editUrl.trim();
+    const apiKey: string = this.editApiKey.trim();
+    if (name.length === 0 || url.length === 0) {
+      this.toast('名称和地址不能为空', true);
+      return;
+    }
+    if (this.editingId.length > 0) {
+      this.updateConnection(this.editingId, name, url, apiKey);
+      return;
+    }
+    connStore.addConnection(name, url, apiKey).then(() => {
+      this.closeConnForm();
+      const cur = connStore.getCurrentConnection();
+      if (cur !== null) {
+        apiClient.setConnection(cur);
+      }
+      this.connections = connStore.getConnections();
+      restartForegroundBridge(getContext(this) as common.UIAbilityContext);
+      this.toast('连接已添加', false);
+    });
+  }
+
+  /**
+   * 保存对已有连接的修改。
+   *
+   * 修改当前生效的连接后必须重新 setConnection：ApiClient 持有的是
+   * ConnectionConfig 的引用快照，不刷新的话后续请求还会打到旧地址。
+   */
+  private updateConnection(id: string, name: string, url: string, apiKey: string): void {
+    connStore.updateConnection(id, name, url, apiKey).then(() => {
+      this.closeConnForm();
+      const cur = connStore.getCurrentConnection();
+      if (cur !== null) {
+        apiClient.setConnection(cur);
+      }
+      this.connections = connStore.getConnections();
+      restartForegroundBridge(getContext(this) as common.UIAbilityContext);
+      this.toast('连接已更新', false);
+    });
+  }
+
+  /** 打开表单：id 为空是新建，非空是编辑并回填原值（API Key 一并带出，避免用户重敲）。 */
+  private openConnForm(conn: ConnectionConfig | null): void {
+    this.showAddForm = true;
+    this.addFormVisible = false;
+    if (conn === null) {
+      this.editingId = '';
+      this.editName = '';
+      this.editUrl = '';
+      this.editApiKey = '';
+    } else {
+      this.editingId = conn.id;
+      this.editName = conn.name;
+      this.editUrl = conn.url;
+      this.editApiKey = conn.apiKey;
+    }
+    setTimeout(() => {
+      this.addFormVisible = true;
+    }, 30);
+  }
+
+  private closeConnForm(): void {
+    this.showAddForm = false;
+    this.addFormVisible = false;
+    this.editingId = '';
+    this.editName = '';
+    this.editUrl = '';
+    this.editApiKey = '';
+  }
+
+  private deleteConnection(id: string): void {
+    connStore.deleteConnection(id).then(() => {
+      this.connections = connStore.getConnections();
+      const cur: ConnectionConfig | null = connStore.getCurrentConnection();
+      if (cur !== null) {
+        apiClient.setConnection(cur);
+      } else {
+        apiClient.clearConnection();
+      }
+      restartForegroundBridge(getContext(this) as common.UIAbilityContext);
+      this.toast('连接已删除', false);
+    });
+  }
+
+  build() {
+    SubPageLayer({
+      title: '后端连接',
+      tab: 3,
+      onBack: () => {
+        const cb: (() => void) | undefined = this.onBack;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+    }) {
+      Column() {
+        PlainCard({ caption: '当前连接' }) {
+          Row() {
+            Column({ space: 3 }) {
+              Text(this.currentConnName())
+                .fontSize(15)
+                .fontColor(this.palette().textPrimary)
+              Text(this.currentId.length > 0 ? '已激活，用于所有请求' : '尚未选择连接')
+                .fontSize(11)
+                .fontColor(this.palette().textMuted)
+            }
+            .layoutWeight(1)
+            .alignItems(HorizontalAlign.Start)
+
+            Button('+ 添加')
+              .height(30)
+              .fontSize(12)
+              .backgroundColor(this.palette().accent)
+              .fontColor(Color.White)
+              .onClick(() => {
+                this.openConnForm(null);
+              })
+          }
+          .width('100%')
+          .alignItems(VerticalAlign.Center)
+
+          if (this.showAddForm) {
+            Column() {
+              Text(this.editingId.length > 0 ? '编辑连接' : '新建连接')
+                .fontSize(12)
+                .fontColor(this.palette().textSecondary)
+                .margin({ bottom: 10 })
+              TextInput({ placeholder: '名称 (如 HomeAgent)', text: this.editName })
+                .height(36).fontSize(13).fontColor(this.palette().textPrimary)
+                .placeholderColor(this.palette().textMuted).backgroundColor(this.palette().bgInput)
+                .borderRadius(RADIUS_SM).border({ width: 1, color: this.palette().border })
+                .margin({ bottom: 10 })
+                .onChange((v: string) => {
+                  this.editName = v;
+                })
+              TextInput({ placeholder: '地址 (域名或 http://192.168.1.100:8080)', text: this.editUrl })
+                .height(36).fontSize(13).fontColor(this.palette().textPrimary)
+                .placeholderColor(this.palette().textMuted).backgroundColor(this.palette().bgInput)
+                .borderRadius(RADIUS_SM).border({ width: 1, color: this.palette().border })
+                .margin({ bottom: 10 })
+                .onChange((v: string) => {
+                  this.editUrl = v;
+                })
+              TextInput({ placeholder: 'API Key (可选)', text: this.editApiKey })
+                .height(36).fontSize(13).fontColor(this.palette().textPrimary)
+                .placeholderColor(this.palette().textMuted).backgroundColor(this.palette().bgInput)
+                .borderRadius(RADIUS_SM).border({ width: 1, color: this.palette().border })
+                .type(InputType.Password).margin({ bottom: 12 })
+                .onChange((v: string) => {
+                  this.editApiKey = v;
+                })
+
+              Row() {
+                Button('取消')
+                  .height(30)
+                  .fontSize(12)
+                  .backgroundColor(Color.Transparent)
+                  .border({ width: 1, color: this.palette().btnGhostBorder })
+                  .fontColor(this.palette().textSecondary)
+                  .onClick(() => {
+                    this.closeConnForm();
+                  })
+                Blank()
+                Button('保存')
+                  .height(30)
+                  .fontSize(12)
+                  .backgroundColor(this.palette().accent)
+                  .fontColor(Color.White)
+                  .onClick(() => {
+                    this.addConnection();
+                  })
+              }
+              .width('100%')
+            }
+            .width('100%')
+            .padding(12)
+            .borderRadius(RADIUS_MD)
+            .backgroundColor(this.palette().bgHover)
+            .border({ width: 1, color: this.palette().kvBorder })
+            .margin({ top: 12 })
+            .alignItems(HorizontalAlign.Start)
+            .opacity(this.addFormVisible ? 1 : 0)
+            .translate({ y: this.addFormVisible ? 0 : 12 })
+            .animation({ duration: 220, curve: Curve.EaseOut })
+          }
+        }
+
+        PlainCard({ caption: '全部连接' }) {
+          if (this.connections.length === 0) {
+            Text('暂无连接。点击上方“添加”配置后端地址。')
+              .fontSize(12)
+              .fontColor(this.palette().textMuted)
+          }
+          ForEach(this.connections, (conn: ConnectionConfig) => {
+            Row() {
+              Circle({ width: 8, height: 8 })
+                .fill(conn.id === this.currentId ? this.palette().accent : '#77809A')
+                .margin({ right: 10 })
+              Column() {
+                Text(conn.name)
+                  .fontSize(13)
+                  .fontColor(this.palette().textPrimary)
+                  .maxLines(1)
+                  .textOverflow({ overflow: TextOverflow.Ellipsis })
+                Text(conn.url)
+                  .fontSize(11)
+                  .fontColor(this.palette().textMuted)
+                  .maxLines(1)
+                  .textOverflow({ overflow: TextOverflow.Ellipsis })
+              }
+              .layoutWeight(1)
+              .alignItems(HorizontalAlign.Start)
+
+              if (conn.id !== this.currentId) {
+                Button('切换')
+                  .height(26)
+                  .fontSize(11)
+                  .backgroundColor(Color.Transparent)
+                  .border({ width: 1, color: this.palette().btnGhostBorder })
+                  .fontColor(this.palette().textSecondary)
+                  .margin({ right: 6 })
+                  .onClick(() => {
+                    this.selectConnection(conn.id);
+                  })
+              } else {
+                Text('使用中')
+                  .fontSize(11)
+                  .fontColor(this.palette().accent)
+                  .padding({ left: 8, right: 8, top: 2, bottom: 2 })
+                  .borderRadius(RADIUS_SM)
+                  .backgroundColor(this.palette().accentBg)
+                  .margin({ right: 6 })
+              }
+              Button('编辑')
+                .height(26)
+                .fontSize(11)
+                .backgroundColor(Color.Transparent)
+                .border({ width: 1, color: this.palette().btnGhostBorder })
+                .fontColor(this.palette().textSecondary)
+                .margin({ right: 6 })
+                .onClick(() => {
+                  this.openConnForm(conn);
+                })
+              Button('删除')
+                .height(26)
+                .fontSize(11)
+                .backgroundColor(Color.Transparent)
+                .border({ width: 1, color: 'rgba(232, 64, 38, 0.45)' })
+                .fontColor('#E84026')
+                .onClick(() => {
+                  this.deleteConnection(conn.id);
+                })
+            }
+            .width('100%')
+            .padding(10)
+            .borderRadius(RADIUS_SM)
+            .backgroundColor(this.palette().bgHover)
+            .border({
+              width: { left: 3 },
+              color: conn.id === this.currentId ? this.palette().accent : Color.Transparent,
+            })
+            .margin({ bottom: 6 })
+            // 键里带上 name/url：ForEach 对相同键只更新绑定、不重跑 @Builder 体，
+            // 只用 id 做键时改完地址这一行还显示旧值。行内没有 TextInput，
+            // 因此把可变字段放进键不会有"编辑时焦点被销毁"的副作用。
+          }, (conn: ConnectionConfig) => conn.id + '|' + conn.name + '|' + conn.url)
+        }
+      }
+      .width('100%')
+      .alignItems(HorizontalAlign.Start)
+    }
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/DevicePanes.ets

@@ -0,0 +1,316 @@
+/**
+ * 设备页的四个二级页面内容：本机设备 / 设备能力 / 设备通道 / 接入的设备。
+ *
+ * 从 pages/DevicePage.ets 抽出（原来是 LocalDeviceContent / CapsContent /
+ * GatewayContent / OnlineDevicesContent 四个 @Builder + KvRow）。
+ * 每个面板自带 SubPageLayer 外壳（标题、所属 Tab、返回、刷新），
+ * 页面只保留路由分发 —— 与 SettingsPage 拆出的三个 Pane 同一套做法。
+ */
+
+import { DeviceInfo } from '../model/Model';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, ANIM_FAST, ANIM_NORMAL,
+  ANIM_ENTER } from '../common/Constants';
+import { LOCAL_DEVICE_CAPS } from '../common/DeviceBridgeSession';
+import { MotionBase } from './MotionBase';
+import { PlainCard, SubPageLayer } from './SubPage';
+
+/** 通用 KV 行（面板之间共用） */
+@Component
+export struct DeviceKvRow {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop label: string = '';
+  @Prop value: string = '';
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    Row() {
+      Text(this.label)
+        .fontSize(13)
+        .fontColor(this.palette().textSecondary)
+      Blank()
+      Text(this.value)
+        .fontSize(13)
+        .fontColor(this.palette().textPrimary)
+        .maxLines(1)
+        .textOverflow({ overflow: TextOverflow.Ellipsis })
+    }
+    .width('100%')
+    .padding({ top: 8, bottom: 8 })
+    .border({ width: { bottom: 1 }, color: this.palette().kvBorder })
+  }
+}
+
+/** 二级：本机设备（基本信息 + 远程控制授权） */
+@Component
+export struct DeviceLocalPane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop deviceId: string = '';
+  @Prop authorized: boolean = false;
+  onBack?: () => void;
+  onToggleAuth?: (on: boolean) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    SubPageLayer({
+      title: '本机设备',
+      tab: 2,
+      onBack: () => {
+        const cb: (() => void) | undefined = this.onBack;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+    }) {
+      PlainCard({ caption: '基本信息' }) {
+        DeviceKvRow({ label: '设备 ID', value: this.deviceId.length > 0 ? this.deviceId : '未注册' })
+        DeviceKvRow({ label: '名称', value: 'HomeAgent OHOS' })
+        DeviceKvRow({ label: '类型', value: 'phone' })
+      }
+
+      PlainCard({ caption: '权限控制' }) {
+        Row() {
+          Column({ space: 2 }) {
+            Text('允许 agent 控制本机')
+              .fontSize(14)
+              .fontColor(this.palette().textPrimary)
+            Text('授权后 agent 可调用下方能力；截屏仅捕获本应用画面，剪贴板读取需系统弹窗确认。')
+              .fontSize(11)
+              .fontColor(this.palette().textMuted)
+              .margin({ top: 4 })
+          }
+          .layoutWeight(1)
+          .alignItems(HorizontalAlign.Start)
+
+          Toggle({ type: ToggleType.Switch, isOn: this.authorized })
+            .selectedColor(this.palette().accent)
+            .onChange((on: boolean) => {
+              const cb: ((on: boolean) => void) | undefined = this.onToggleAuth;
+              if (cb !== undefined) {
+                cb(on);
+              }
+            })
+        }
+        .width('100%')
+        .alignItems(VerticalAlign.Center)
+
+        Row() {
+          Circle({ width: 8, height: 8 })
+            .fill(this.authorized ? '#17A964' : '#E84026')
+            .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut })
+            .margin({ right: 8 })
+          Text(this.authorized ? '已授权 — agent 可远程调用能力' : '未授权 — agent 将拒绝远程命令')
+            .fontSize(12)
+            .fontColor(this.authorized ? '#17A964' : this.palette().textMuted)
+            .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut })
+        }
+        .width('100%')
+        .margin({ top: 12 })
+        .padding({ left: 4 })
+      }
+    }
+  }
+}
+
+/** 二级：设备能力（本机能被 agent 调用的能力清单） */
+@Component
+export struct DeviceCapsPane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  onBack?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    SubPageLayer({
+      title: '设备能力',
+      tab: 2,
+      onBack: () => {
+        const cb: (() => void) | undefined = this.onBack;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+    }) {
+      PlainCard({ caption: '能力清单' }) {
+        Text('agent 通过设备桥可调用的本机能力：')
+          .fontSize(12)
+          .fontColor(this.palette().textMuted)
+          .margin({ bottom: 10 })
+
+        Flex({ wrap: FlexWrap.Wrap }) {
+          ForEach(LOCAL_DEVICE_CAPS, (cap: string) => {
+            Text(cap)
+              .fontSize(11)
+              .fontColor(this.palette().accent)
+              .padding({ left: 8, right: 8, top: 4, bottom: 4 })
+              .borderRadius(999)
+              .backgroundColor(this.palette().bgHover)
+              .border({ width: 1, color: this.palette().glassBorder })
+              .margin({ right: 6, bottom: 6 })
+          }, (cap: string) => cap)
+        }
+        .width('100%')
+      }
+    }
+  }
+}
+
+/** 二级：设备通道（网关地址 / Token / 连接状态） */
+@Component
+export struct DeviceGatewayPane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop bridgeUrl: string = '';
+  @Prop bridgeToken: string = '';
+  @Prop bridgeConnected: boolean = false;
+  onBack?: () => void;
+  onRefresh?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    SubPageLayer({
+      title: '设备通道',
+      tab: 2,
+      onBack: () => {
+        const cb: (() => void) | undefined = this.onBack;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+    }) {
+      PlainCard({ caption: '连接信息' }) {
+        DeviceKvRow({ label: '网关地址', value: this.bridgeUrl.length > 0 ? this.bridgeUrl : '-' })
+        DeviceKvRow({ label: 'Token', value: this.bridgeToken.length > 0 ? '已从连接继承' : '未配置' })
+        DeviceKvRow({ label: '状态', value: this.bridgeConnected ? '已连接' : '未连接' })
+      }
+
+      PlainCard({ caption: '操作' }) {
+        Row() {
+          Blank()
+          MotionBase({ pressEnabled: true, fillWidth: false }) {
+            Button('刷新设备')
+              .height(34)
+              .fontSize(12)
+              .backgroundColor(Color.Transparent)
+              .border({ width: 1, color: this.palette().btnGhostBorder })
+              .fontColor(this.palette().textSecondary)
+              .onClick(() => {
+                const cb: (() => void) | undefined = this.onRefresh;
+                if (cb !== undefined) {
+                  cb();
+                }
+              })
+          }
+        }
+        .width('100%')
+
+        Text('设备通道由应用前台生命周期统一管理；切换连接配置后会自动使用新地址和 Token。')
+          .fontSize(11)
+          .fontColor(this.palette().textMuted)
+          .margin({ top: 10 })
+      }
+    }
+  }
+}
+
+/** 二级：接入的设备（网关侧在线设备列表） */
+@Component
+export struct DeviceListPane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop devices: DeviceInfo[] = [];
+  onBack?: () => void;
+  onRefresh?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    SubPageLayer({
+      title: '接入的设备',
+      tab: 2,
+      showRefresh: true,
+      onBack: () => {
+        const cb: (() => void) | undefined = this.onBack;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+      onRefresh: () => {
+        const cb: (() => void) | undefined = this.onRefresh;
+        if (cb !== undefined) {
+          cb();
+        }
+      },
+    }) {
+      DeviceOnlineList({ devices: this.devices })
+    }
+  }
+}
+
+/** 在线设备列表本体（抽出来只是为了让 DeviceListPane 的 build 更短） */
+@Component
+struct DeviceOnlineList {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop devices: DeviceInfo[] = [];
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    Column() {
+      if (this.devices.length === 0) {
+        Text('暂无其他设备。电脑 GUI 或 CLI 连接同一网关后会出现在这里。')
+          .fontSize(12)
+          .fontColor(this.palette().textMuted)
+          .padding({ left: 4 })
+          .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+      }
+
+      ForEach(this.devices, (dev: DeviceInfo) => {
+        // PlainCard 是自定义组件，transition 不能直接挂在它上面（会生成 __Common__ 包装），
+        // 所以用一个无 padding、满宽的 Column 承载入场动画，布局不受影响。
+        Column() {
+          PlainCard({ caption: '' }) {
+            Row() {
+              Circle({ width: 8, height: 8 })
+                .fill(dev.online ? '#17A964' : '#77809A')
+                .margin({ right: 10 })
+              Column() {
+                Text(dev.name.length > 0 ? dev.name : dev.deviceId)
+                  .fontSize(14)
+                  .fontColor(this.palette().textPrimary)
+                Text(dev.kind + (dev.authorized ? ' · 已授权' : ' · 未授权'))
+                  .fontSize(11)
+                  .fontColor(dev.authorized ? '#17A964' : this.palette().textMuted)
+              }
+              .layoutWeight(1)
+              .alignItems(HorizontalAlign.Start)
+
+              Text(dev.caps.length.toString() + ' 能力')
+                .fontSize(10)
+                .fontColor(this.palette().textMuted)
+            }
+            .width('100%')
+          }
+        }
+        .width('100%')
+        .transition(TransitionEffect.OPACITY
+          .combine(TransitionEffect.translate({ y: 12 }))
+          .animation({ duration: ANIM_ENTER, curve: Curve.EaseOut }))
+      }, (dev: DeviceInfo) => dev.deviceId + dev.online.toString())
+    }
+    .width('100%')
+    .alignItems(HorizontalAlign.Start)
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/DeviceRootEntries.ets

@@ -0,0 +1,92 @@
+/**
+ * 设备页一级入口列表（本机 / 通道两组）。
+ *
+ * 从 pages/DevicePage.ets 抽出（原来是 RootEntries 一个 @Builder）。
+ * 宽屏高亮由组件自己读 AppStorage 的 isWideScreen 决定，
+ * 页面只负责给 activeSub 与四个打开动作。
+ */
+
+import { LOCAL_DEVICE_CAPS } from '../common/DeviceBridgeSession';
+import { SUB_CAPS, SUB_GATEWAY, SUB_LIST, SUB_LOCAL } from '../common/DeviceModel';
+import { NavGroup, NavRow } from './SubPage';
+
+@Component
+export struct DeviceRootEntries {
+  /** 宽屏：左边一级界面（含底部导航栏），右边二级界面 */
+  @StorageProp('isWideScreen') private isWide: boolean = false;
+  /** 当前右栏展示的二级页面 id，用于宽屏下高亮左侧入口行 */
+  @Prop activeSub: string = '';
+  @Prop deviceId: string = '';
+  @Prop bridgeConnected: boolean = false;
+  @Prop bridgeUrl: string = '';
+  @Prop loadingDevices: boolean = false;
+  @Prop deviceCount: number = 0;
+  onOpen?: (id: string) => void;
+
+  private capsCount(): number {
+    return LOCAL_DEVICE_CAPS.length;
+  }
+
+  private open(id: string): void {
+    const cb: ((id: string) => void) | undefined = this.onOpen;
+    if (cb !== undefined) {
+      cb(id);
+    }
+  }
+
+  build() {
+    // 一级入口列表整体作为一个容器根节点：@Component 的 build() 只允许一个根，
+    // 页面侧仍是 `.padding(...)` 的 Column，逐项布局与拆分前一致。
+    Column() {
+      NavGroup({ caption: '本机' }) {
+        NavRow({
+          icon: $r('app.media.ic_phone'),
+          title: '本机设备',
+          subtitle: this.deviceId.length > 0 ? this.deviceId : '未注册',
+          value: this.bridgeConnected ? '在线' : '离线',
+          selected: this.isWide && this.activeSub === SUB_LOCAL,
+          onTap: () => {
+            this.open(SUB_LOCAL);
+          },
+        })
+        NavRow({
+          icon: $r('app.media.ic_bolt'),
+          title: '设备能力',
+          subtitle: this.capsCount().toString() + ' 项能力',
+          value: '',
+          showDivider: false,
+          selected: this.isWide && this.activeSub === SUB_CAPS,
+          onTap: () => {
+            this.open(SUB_CAPS);
+          },
+        })
+      }
+
+      NavGroup({ caption: '通道' }) {
+        NavRow({
+          icon: $r('app.media.ic_gateway'),
+          title: '设备通道',
+          subtitle: this.bridgeUrl.length > 0 ? '网关已配置' : '未配置',
+          value: this.bridgeConnected ? '已连接' : '未连接',
+          selected: this.isWide && this.activeSub === SUB_GATEWAY,
+          onTap: () => {
+            this.open(SUB_GATEWAY);
+          },
+        })
+        NavRow({
+          icon: $r('app.media.ic_devices_multi'),
+          title: '接入的设备',
+          subtitle: this.loadingDevices ? '加载中...' : '当前在线',
+          value: this.deviceCount.toString() + ' 台',
+          showDivider: false,
+          selected: this.isWide && this.activeSub === SUB_LIST,
+          onTap: () => {
+            this.open(SUB_LIST);
+          },
+        })
+      }
+    }
+    .width('100%')
+    .alignItems(HorizontalAlign.Start)
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/PluginDetailPane.ets

@@ -0,0 +1,291 @@
+/**
+ * 插件详情（二级页面内容）。
+ *
+ * 从 pages/PluginsPage.ets 抽出。
+ * WebGUI 这里只有一个 JSON.stringify 的 <pre>，
+ * 移植时改成结构化卡片：状态 / 清单字段 / 工具 / 配置 / 操作。
+ */
+
+import { PluginRow, PluginDetail } from '../model/Model';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_SM,
+  ANIM_FAST, COLOR_ERROR } from '../common/Constants';
+import { pluginDetailStatusLine, pluginStatusColor } from '../common/PluginStatus';
+import { PlainCard } from './SubPage';
+import { SettingsEditor } from './SettingsEditor';
+
+@Component
+export struct PluginDetailPane {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop detail: PluginDetail;
+  /** 当前查看详情的插件名（可能还没拿到 detail.name） */
+  @Prop activeName: string = '';
+  @Prop busy: boolean = false;
+  @Prop errorText: string = '';
+  /** 一级列表里对应的那一行；取不到详情时用它兜底，也为操作按钮提供状态 */
+  @Prop row: PluginRow | undefined = undefined;
+  onToggle?: () => void;
+  onRemove?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  // ---- 取值助手：ArkTS 禁止非空断言，统一在这里做 null 收敛 ----
+
+  private hasManifest(): boolean {
+    return this.detail.author.length > 0 || this.detail.license.length > 0 ||
+      this.detail.homepage.length > 0 || this.detail.repository.length > 0 ||
+      this.detail.entry.length > 0 || this.detail.minVersion.length > 0;
+  }
+
+  private isBuiltin(): boolean {
+    const r: PluginRow | undefined = this.row;
+    return r !== undefined ? !r.external : false;
+  }
+
+  private isDisabled(): boolean {
+    const r: PluginRow | undefined = this.row;
+    return r !== undefined ? r.disabled : false;
+  }
+
+  private tools(): string[] {
+    const r: PluginRow | undefined = this.row;
+    if (r === undefined) {
+      return [];
+    }
+    return r.tools ?? [];
+  }
+
+  private statusLine(): string {
+    const r: PluginRow | undefined = this.row;
+    return r !== undefined ? pluginDetailStatusLine(r, this.detail.deprecated) : '未加载';
+  }
+
+  private statusColor(): string {
+    const r: PluginRow | undefined = this.row;
+    return r !== undefined ? pluginStatusColor(r, this.palette().textMuted) : this.palette().textMuted;
+  }
+
+  /** 明细行：值为空时整行不渲染，避免详情页出现一排 "-" */
+  @Builder
+  KvRow(label: string, value: string) {
+    if (value.length > 0) {
+      Row() {
+        Text(label)
+          .fontSize(13)
+          .fontColor(this.palette().textSecondary)
+          .layoutWeight(1)
+        Text(value)
+          .fontSize(13)
+          .fontColor(this.palette().textPrimary)
+          .textAlign(TextAlign.End)
+          .maxLines(2)
+          .textOverflow({ overflow: TextOverflow.Ellipsis })
+          .constraintSize({ maxWidth: 220 })
+          .margin({ left: 16 })
+      }
+      .width('100%')
+      .padding({ top: 8, bottom: 8 })
+      .alignItems(VerticalAlign.Top)
+    }
+  }
+
+  /** 详情页状态行：同样去掉徽标，一个状态点 + 一行纯文字 */
+  @Builder
+  Badges() {
+    Row({ space: 6 }) {
+      Circle({ width: 7, height: 7 })
+        .fill(this.statusColor())
+      Text(this.statusLine())
+        .fontSize(12)
+        .fontColor(this.palette().textSecondary)
+        .layoutWeight(1)
+        .maxLines(1)
+        .textOverflow({ overflow: TextOverflow.Ellipsis })
+    }
+    .width('100%')
+    .alignItems(VerticalAlign.Center)
+  }
+
+  /** 工具清单来自一级列表已合并的 kernel.tools（按 plugin 归属） */
+  @Builder
+  ToolsCard() {
+    if (this.tools().length > 0) {
+      PlainCard({ caption: '注册的工具 (' + this.tools().length.toString() + ')' }) {
+        Flex({ wrap: FlexWrap.Wrap }) {
+          ForEach(this.tools(), (tool: string) => {
+            Text(tool)
+              .fontSize(11)
+              .fontColor('#4A90D9')
+              .padding({ left: 8, right: 8, top: 3, bottom: 3 })
+              .borderRadius(RADIUS_SM)
+              .backgroundColor(this.palette().frostSoftBg)
+              .margin({ right: 5, bottom: 5 })
+          }, (tool: string) => tool)
+        }
+      }
+    }
+  }
+
+  @Builder
+  ActionsCard() {
+    if (this.activeName.length > 0) {
+      PlainCard({ caption: '操作' }) {
+        Row() {
+          Button(this.isDisabled() ? '启用' : '禁用')
+            .height(34)
+            .fontSize(12)
+            .backgroundColor(Color.Transparent)
+            .border({
+              width: 1,
+              color: this.isDisabled()
+                ? this.palette().btnGhostBorder : 'rgba(217, 154, 43, 0.5)',
+            })
+            .fontColor(this.isDisabled()
+              ? this.palette().textSecondary : '#D99A2B')
+            .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
+            .onClick(() => {
+              const cb: (() => void) | undefined = this.onToggle;
+              if (cb !== undefined) {
+                cb();
+              }
+            })
+          Blank()
+          if (!this.isBuiltin()) {
+            Button('卸载')
+              .height(34)
+              .fontSize(12)
+              .backgroundColor(Color.Transparent)
+              .border({ width: 1, color: 'rgba(232, 64, 38, 0.45)' })
+              .fontColor(COLOR_ERROR)
+              .onClick(() => {
+                const cb: (() => void) | undefined = this.onRemove;
+                if (cb !== undefined) {
+                  cb();
+                }
+              })
+              .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+          }
+        }
+        .width('100%')
+      }
+    }
+  }
+
+  build() {
+    // 单一根节点：与原来作为 @Builder 直接铺在 SubPageLayer 的 Column 里同构，
+    // 保持 alignItems Start，避免文本被默认居中对齐。
+    Column() {
+    if (this.busy) {
+      Row() {
+        LoadingProgress()
+          .width(26)
+          .height(26)
+          .color(this.palette().accent)
+      }
+      .width('100%')
+      .justifyContent(FlexAlign.Center)
+      .padding({ top: 30, bottom: 30 })
+      .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+    }
+
+    if (this.errorText.length > 0) {
+      Text(this.errorText)
+        .fontSize(12)
+        .fontColor(COLOR_ERROR)
+        .padding({ left: 4, bottom: 12 })
+        .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+    }
+
+    // 概览卡：名称、版本、状态徽标、描述
+    PlainCard({ caption: '概览' }) {
+      Row({ space: 8 }) {
+        Text(this.detail.name.length > 0 ? this.detail.name : this.activeName)
+          .fontSize(17)
+          .fontWeight(FontWeight.Bold)
+          .fontColor(this.palette().textPrimary)
+          .layoutWeight(1)
+          .maxLines(1)
+          .textOverflow({ overflow: TextOverflow.Ellipsis })
+        if (this.detail.version.length > 0) {
+          Text('v' + this.detail.version)
+            .fontSize(12)
+            .fontColor(this.palette().textSecondary)
+        }
+      }
+      .width('100%')
+      .margin({ bottom: 10 })
+
+      this.Badges()
+
+      if (this.detail.description.length > 0) {
+        Text(this.detail.description)
+          .fontSize(13)
+          .fontColor(this.palette().textSecondary)
+          .width('100%')
+          .margin({ top: 10 })
+      }
+    }
+
+    // 清单卡：只有真拿到字段才出卡，否则会留一张空壳（内置插件没有清单文件）
+    if (this.hasManifest()) {
+      PlainCard({ caption: '清单' }) {
+        this.KvRow('作者', this.detail.author)
+        this.KvRow('许可证', this.detail.license)
+        this.KvRow('主页', this.detail.homepage)
+        this.KvRow('仓库', this.detail.repository)
+        this.KvRow('入口', this.detail.entry)
+        this.KvRow('最低内核版本', this.detail.minVersion)
+      }
+    }
+
+    if (this.detail.tags.length > 0) {
+      PlainCard({ caption: '标签' }) {
+        Flex({ wrap: FlexWrap.Wrap }) {
+          ForEach(this.detail.tags, (t: string) => {
+            Text(t)
+              .fontSize(10)
+              .fontColor('#4A90D9')
+              .padding({ left: 8, right: 8, top: 3, bottom: 3 })
+              .borderRadius(RADIUS_SM)
+              .backgroundColor(this.palette().frostSoftBg)
+              .margin({ right: 5, bottom: 5 })
+          }, (t: string) => t)
+        }
+      }
+    }
+
+    this.ToolsCard()
+
+    // 插件配置：plugin.<name>.* 从后端 /settings?prefix= 取，就地编辑。
+    // 这些 key 属于插件本身，之前被平铺在「设置 → 后端配置」里，
+    // 现在归位到插件详情页 —— 「插件的设计页面就是插件的详情页」。
+    if (this.activeName.length > 0) {
+      PlainCard({ caption: '插件配置' }) {
+        SettingsEditor({
+          prefix: 'plugin.' + this.activeName + '.',
+          emptyHint: '该插件没有暴露可配置项',
+        })
+      }
+    }
+
+    if (this.detail.files.length > 0) {
+      PlainCard({ caption: '文件 (' + this.detail.files.length.toString() + ')' }) {
+        ForEach(this.detail.files, (f: string) => {
+          Text(f)
+            .fontSize(12)
+            .fontColor(this.palette().textSecondary)
+            .width('100%')
+            .maxLines(1)
+            .textOverflow({ overflow: TextOverflow.Ellipsis })
+            .margin({ bottom: 4 })
+        }, (f: string) => f)
+      }
+    }
+
+    this.ActionsCard()
+    }
+    .width('100%')
+    .alignItems(HorizontalAlign.Start)
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/PluginListView.ets

@@ -0,0 +1,166 @@
+/**
+ * 插件一级列表（列表卡 + 三种占位态）。
+ *
+ * 从 pages/PluginsPage.ets 抽出：列表只负责"选谁"，
+ * 描述/工具/启停全部下沉到详情页。
+ */
+
+import { PluginRow } from '../model/Model';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_LG, RADIUS_MD,
+  ANIM_FAST, ANIM_ENTER } from '../common/Constants';
+import { pluginRowSubtitle, pluginStatusColor } from '../common/PluginStatus';
+import { noConnectionMessage } from '../common/UserError';
+import { MotionBase } from './MotionBase';
+
+/**
+ * 单个插件行卡。
+ *
+ * 外层 Column 只为承载 transition：.transition() 不能直接挂在自定义组件
+ * 调用点上（会生成 __Common__ 包装节点）。按压缩放由 MotionBase 统一提供，
+ * 每行自带独立按压态，不再需要 pressedName 这种"哪一行被按"的手工记账。
+ */
+@Component
+export struct PluginListCard {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop plugin: PluginRow;
+  /** 是否当前选中（宽屏高亮左侧列表项）。单独用基本类型传，选中态变更才能触发更新 */
+  @Prop active: boolean = false;
+  onTap?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    Column() {
+      MotionBase({ pressEnabled: true }) {
+        Row() {
+          Column({ space: 3 }) {
+            Row({ space: 6 }) {
+              Text(this.plugin.name)
+                .fontSize(15)
+                .fontWeight(this.active ? FontWeight.Medium : FontWeight.Normal)
+                .fontColor(this.active ? this.palette().accent : this.palette().textPrimary)
+                .maxLines(1)
+                .textOverflow({ overflow: TextOverflow.Ellipsis })
+                .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
+              if (this.plugin.version !== undefined && this.plugin.version.length > 0) {
+                Text('v' + this.plugin.version)
+                  .fontSize(10)
+                  .fontColor(this.palette().textMuted)
+              }
+            }
+            // 徽标全部去掉（用户要求）：状态用一个 3vp 圆点表达，
+            // 其余信息退化为一行灰字副标题 —— 列表只负责"选谁"，细节看详情页。
+            Row({ space: 6 }) {
+              Circle({ width: 6, height: 6 })
+                .fill(pluginStatusColor(this.plugin, this.palette().textMuted))
+              Text(pluginRowSubtitle(this.plugin))
+                .fontSize(11)
+                .fontColor(this.palette().textMuted)
+                .maxLines(1)
+                .textOverflow({ overflow: TextOverflow.Ellipsis })
+                .layoutWeight(1)
+            }
+            .width('100%')
+            .alignItems(VerticalAlign.Center)
+          }
+          .layoutWeight(1)
+          .alignItems(HorizontalAlign.Start)
+
+          Image($r('app.media.ic_chevron_right'))
+            .width(15)
+            .height(15)
+            .fillColor(this.active ? this.palette().accent : this.palette().textMuted)
+            .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
+            .draggable(false)
+        }
+        .width('100%')
+        .padding(14)
+        .borderRadius(RADIUS_LG)
+        .backgroundColor(this.active ? this.palette().accentBg : this.palette().bgCard)
+        .border({
+          width: 1,
+          color: this.active ? this.palette().accent : this.palette().glassBorder,
+        })
+        // 选中态的底色/描边渐变：MotionBase 的 .animation() 到不了这里
+        .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
+        .alignItems(VerticalAlign.Center)
+        .onClick(() => {
+          const cb: (() => void) | undefined = this.onTap;
+          if (cb !== undefined) {
+            cb();
+          }
+        })
+      }
+    }
+    .width('100%')
+    .margin({ bottom: 10 })
+    // ForEach key 含 loaded/disabled：启停会整行重挂载，靠 transition 变成交叉淡入
+    .transition(TransitionEffect.OPACITY
+      .combine(TransitionEffect.translate({ y: 12 }))
+      .animation({ duration: ANIM_ENTER, curve: Curve.EaseOut }))
+  }
+}
+
+/**
+ * 一级列表整体：占位态 + 行卡 ForEach。
+ * 取数留在页面里，这里只吃数据。
+ */
+@Component
+export struct PluginListView {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop plugins: PluginRow[] = [];
+  @Prop busy: boolean = false;
+  @Prop activeName: string = '';
+  @Prop hasConn: boolean = false;
+  onSelect?: (name: string) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    Column() {
+      // ── 加载中 / 未配置 / 空列表三种占位态 ──
+      if (this.busy && this.plugins.length === 0) {
+        LoadingProgress()
+          .width(32)
+          .height(32)
+          .color(this.palette().accent)
+          .margin({ top: 40 })
+          .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+      }
+
+      if (!this.hasConn) {
+        Text(noConnectionMessage())
+          .fontSize(13)
+          .fontColor(this.palette().textMuted)
+          .padding(20)
+          .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+      }
+
+      if (!this.busy && this.plugins.length === 0 && this.hasConn) {
+        Text('暂无已加载插件')
+          .fontSize(13)
+          .fontColor(this.palette().textMuted)
+          .padding(20)
+          .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
+      }
+
+      ForEach(this.plugins, (plugin: PluginRow) => {
+        PluginListCard({
+          plugin: plugin,
+          active: this.activeName === plugin.name,
+          onTap: () => {
+            const cb: ((name: string) => void) | undefined = this.onSelect;
+            if (cb !== undefined) {
+              cb(plugin.name);
+            }
+          },
+        })
+      }, (plugin: PluginRow) => plugin.name + (plugin.loaded ? 'L' : '') + (plugin.disabled ? 'D' : ''))
+    }
+    .width('100%')
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/PluginsOverlays.ets

@@ -0,0 +1,65 @@
+/**
+ * 安装表单悬浮卡。
+ *
+ * 从 pages/PluginsPage.ets 抽出（浮在内容之上的独立图层，与列表/详情无关）。
+ * 轻提示条与设置页共用，见 components/ToastBar.ets。
+ */
+
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_MD, RADIUS_SM,
+  ANIM_ENTER } from '../common/Constants';
+
+/** 安装表单：悬浮在安装按钮上方的一张玻璃卡（点悬浮按钮开合） */
+@Component
+export struct PluginInstallForm {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop url: string = '';
+  onUrlChange?: (v: string) => void;
+  onInstall?: () => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    Row() {
+      TextInput({ placeholder: '.hmap 包下载 URL', text: this.url })
+        .layoutWeight(1)
+        .height(36)
+        .fontSize(14)
+        .fontColor(this.palette().textPrimary)
+        .placeholderColor(this.palette().textMuted)
+        .backgroundColor(this.palette().bgInput)
+        .borderRadius(RADIUS_SM)
+        .border({ width: 1, color: this.palette().border })
+        .onChange((v: string) => {
+          const cb: ((v: string) => void) | undefined = this.onUrlChange;
+          if (cb !== undefined) {
+            cb(v);
+          }
+        })
+      Button('安装')
+        .height(36)
+        .fontSize(12)
+        .backgroundColor(this.palette().accent)
+        .fontColor('#FFFFFF')
+        .margin({ left: 6 })
+        .onClick(() => {
+          const cb: (() => void) | undefined = this.onInstall;
+          if (cb !== undefined) {
+            cb();
+          }
+        })
+    }
+    .width('100%')
+    .padding(10)
+    .margin({ bottom: 10 })
+    .backgroundColor(this.palette().navBarBg)
+    .borderRadius(RADIUS_MD)
+    .border({ width: 1, color: this.palette().navBarBorder })
+    .shadow({ radius: 20, color: this.palette().shadow, offsetY: 6 })
+    .alignItems(VerticalAlign.Center)
+    .transition(TransitionEffect.OPACITY
+      .combine(TransitionEffect.translate({ y: 12 }))
+      .animation({ duration: ANIM_ENTER, curve: Curve.EaseOut }))
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/RuntimePanel.ets

@@ -0,0 +1,385 @@
+import {
+  ThemePalette, DARK_PALETTE, LIGHT_PALETTE,
+  RADIUS_SM, RADIUS_MD, ANIM_FAST,
+  COLOR_ACCENT, COLOR_EMERALD, COLOR_FROST_300,
+} from '../common/Constants';
+import { statusStore, RuntimeSnapshot, RuntimeQueue, K_REV } from '../common/StatusStore';
+import {
+  stageTrail, StageEvent, StageGroup, STAGE_GROUPS, phaseGroup,
+  K_STAGE_PHASE, K_STAGE_REV,
+} from '../common/StageTrail';
+
+/** 四级中断 + 排队的配色：与 WebUI 总览同一套（级别色贯穿框头、槽位、描边） */
+const LV_COLORS: string[] = ['#A3BE8C', '#4A90D9', '#0A59F7', '#FFA657', '#FF5C7A'];
+/** 阶段管道里的「工具」格（循环格）：一轮内可能调几十次，只露最新一条 */
+const TOOL_GROUP: number = 2;
+/** 索引 = lv（0 排队 / 1 L1 / 2 L2 / 3 L3 / 4 L4） */
+function lvColor(lv: number): string {
+  if (lv < 0 || lv > 4) {
+    return COLOR_ACCENT;
+  }
+  return LV_COLORS[lv];
+}
+
+/**
+ * 运行态面板：阶段管道 + 中断队列。
+ *
+ * 与 WebUI / 桌面版同一套设计语言：**等大表框**。
+ * 此前鸿蒙端完全没有运行态展示（「状态」Tab 已并入设置页 + 二级明细），
+ * 这里补在二级明细页顶部。
+ *
+ * 两块数据来源不同：
+ *  - 队列 / 计数：StatusStore 轮询 /runtime，靠 K_REV 通知；
+ *  - 阶段 + 本轮轨迹：StageTrail 由 SSE 的 stage 事件喂入，靠 K_STAGE_REV 通知。
+ */
+@Component
+export struct RuntimePanel {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  /** 宽屏（平板/折叠）5 框一行；手机 3+2。窄屏硬塞 5 框会把标签挤成省略号。 */
+  @StorageProp('isWideScreen') private isWide: boolean = false;
+  @StorageProp(K_REV) @Watch('onStatusRev') private statusRev: number = 0;
+  @StorageProp(K_STAGE_REV) @Watch('onStageRev') private stageRev: number = 0;
+  @StorageProp(K_STAGE_PHASE) private phase: string = '';
+  @State private snap: RuntimeSnapshot | undefined = undefined;
+  /** 格槽下标：ArkUI 的 ForEach 遍历的是数组，所以把「几格」摊成下标数组 */
+  @State private slotIdx: number[] = [];
+  @State private trail: StageEvent[] = [];
+
+  aboutToAppear(): void {
+    this.pull();
+  }
+
+  private onStatusRev(): void {
+    this.pull();
+  }
+
+  private onStageRev(): void {
+    this.trail = stageTrail.snapshot();
+  }
+
+  private pull(): void {
+    const s: RuntimeSnapshot | undefined = statusStore.getRuntime();
+    this.snap = s;
+    if (s !== undefined) {
+      const idx: number[] = [];
+      for (let i = 0; i < s.slots; i++) {
+        idx.push(i);
+      }
+      this.slotIdx = idx;
+    } else {
+      this.slotIdx = [];
+    }
+    this.trail = stageTrail.snapshot();
+  }
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  /** 该阶段本轮发生的事件 */
+  private eventsOf(group: number): StageEvent[] {
+    const out: StageEvent[] = [];
+    for (let i = 0; i < this.trail.length; i++) {
+      const e: StageEvent = this.trail[i];
+      if (e.group === group) {
+        out.push(e);
+      }
+    }
+    return out;
+  }
+
+  /** 该阶段本轮事件的**最后一条**（最新）。没有则 undefined。 */
+  private latestEvent(group: number): StageEvent | undefined {
+    let out: StageEvent | undefined = undefined;
+    for (let i = 0; i < this.trail.length; i++) {
+      const e: StageEvent = this.trail[i];
+      if (e.group === group) {
+        out = e;
+      }
+    }
+    return out;
+  }
+
+  /** 该阶段本轮事件条数合计（同一工具连调会累加到 count 上） */
+  private totalCount(group: number): number {
+    let n: number = 0;
+    for (let i = 0; i < this.trail.length; i++) {
+      const e: StageEvent = this.trail[i];
+      if (e.group === group) {
+        n += e.count;
+      }
+    }
+    return n;
+  }
+
+  @Builder
+  tile(label: string, value: string, warn: boolean) {
+    Column({ space: 2 }) {
+      Text(value)
+        .fontSize(20)
+        .fontWeight(FontWeight.Bold)
+        .fontColor(warn ? this.palette().accent : this.palette().textPrimary)
+        .maxLines(1)
+      Text(label)
+        .fontSize(11)
+        .fontColor(this.palette().textMuted)
+        .maxLines(1)
+    }
+    .layoutWeight(1)
+    .alignItems(HorizontalAlign.Start)
+    .padding({ left: 10, right: 10, top: 9, bottom: 9 })
+    .borderRadius(RADIUS_SM)
+    .backgroundColor(this.palette().bgHover)
+  }
+
+  /** 阶段管道的一格 */
+  @Builder
+  stageCell(g: StageGroup, active: boolean) {
+    Column({ space: 6 }) {
+      Row({ space: 5 }) {
+        // 用一个几何圆点而非图标：本项目没有为「阶段」准备的图形资源，
+        // 而猜 sys.media.* 名称会直接编译不过；也不允许用 emoji 充当图标。
+        // 不用 Circle().fill()：那是 SDK 26 起的 API，本工程兼容版本是 6.1.1(24)。
+        Row()
+          .width(7)
+          .height(7)
+          .borderRadius(4)
+          .backgroundColor(active ? this.palette().accent : this.palette().textMuted)
+        Text(g.label)
+          .fontSize(11)
+          .fontWeight(FontWeight.Bold)
+          .fontColor(active ? this.palette().accent : this.palette().textSecondary)
+          .maxLines(1)
+          .textOverflow({ overflow: TextOverflow.Ellipsis })
+      }
+      .width('100%')
+
+      // 本阶段本轮发生的事件；没有就给一个弱化的「无」，让框不空着。
+      //
+      // 「工具」格是循环格：一轮里可能调几十次工具/输出通道。把每一次都追加成
+      // 一行，这格会被撑成长条，反而看不出「现在在调什么」。所以它只保留**最新
+      // 一条**，右侧给本轮累计次数（与 WebUI/桌面版同一口径）。
+      Column({ space: 3 }) {
+        if (g.group === TOOL_GROUP) {
+          if (this.eventsOf(g.group).length > 0) {
+            Row({ space: 3 }) {
+              Text(this.latestEvent(g.group)?.short ?? '')
+                .fontSize(9)
+                .fontColor(this.latestEvent(g.group)?.kind === 'output' ? this.palette().accent
+                  : (this.latestEvent(g.group)?.kind === 'tool' ? COLOR_FROST_300 : this.palette().textSecondary))
+                .maxLines(1)
+                .textOverflow({ overflow: TextOverflow.Ellipsis })
+                .layoutWeight(1)
+              Text('x' + this.totalCount(g.group).toString())
+                .fontSize(9)
+                .fontColor(this.palette().textMuted)
+            }
+            .width('100%')
+          } else {
+            Text('无')
+              .fontSize(9)
+              .fontColor(this.palette().textMuted)
+              .opacity(0.5)
+          }
+        } else {
+          ForEach(this.eventsOf(g.group), (e: StageEvent) => {
+            Row({ space: 3 }) {
+              Text(e.short)
+                .fontSize(9)
+                .fontColor(e.kind === 'output' ? this.palette().accent
+                  : (e.kind === 'tool' ? COLOR_FROST_300 : this.palette().textSecondary))
+                .maxLines(1)
+                .textOverflow({ overflow: TextOverflow.Ellipsis })
+              if (e.count > 1) {
+                Text('x' + e.count.toString())
+                  .fontSize(9)
+                  .fontColor(this.palette().textMuted)
+              }
+            }
+            .width('100%')
+          }, (e: StageEvent, i: number) => i.toString() + ':' + e.short)
+
+          if (this.eventsOf(g.group).length === 0) {
+            Text('无')
+              .fontSize(9)
+              .fontColor(this.palette().textMuted)
+              .opacity(0.5)
+          }
+        }
+      }
+      .width('100%')
+      .alignItems(HorizontalAlign.Start)
+    }
+    .layoutWeight(1)
+    .alignItems(HorizontalAlign.Start)
+    .padding({ left: 8, right: 8, top: 9, bottom: 9 })
+    .borderRadius(RADIUS_SM)
+    .backgroundColor(active ? this.palette().accentBg : this.palette().bgHover)
+    .border({ width: 1, color: active ? this.palette().accent : this.palette().glassBorder })
+    .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
+  }
+
+  /** 中断队列的一格 */
+  @Builder
+  queueCell(q: RuntimeQueue) {
+    Column({ space: 5 }) {
+      Row({ space: 4 }) {
+        Text(q.name)
+          .fontSize(13)
+          .fontWeight(FontWeight.Bold)
+          .fontColor(lvColor(q.lv))
+          .maxLines(1)
+        Text(q.desc)
+          .fontSize(9)
+          .fontColor(this.palette().textMuted)
+          .maxLines(1)
+          .textOverflow({ overflow: TextOverflow.Ellipsis })
+      }
+      .width('100%')
+      .alignItems(VerticalAlign.Bottom)
+
+      Text(q.depth.toString())
+        .fontSize(20)
+        .fontWeight(FontWeight.Bold)
+        .fontColor(this.palette().textPrimary)
+        .maxLines(1)
+
+      // 格槽：固定可见的「车位」。用进度条时深度为 0 宽度就是 0，
+      // 整格只剩文字，看上去就是「这块空着」。
+      Row({ space: 2 }) {
+        ForEach(this.slotIdx, (i: number) => {
+          Row()
+            .layoutWeight(1)
+            .height(11)
+            .borderRadius(2)
+            .backgroundColor(i < q.depth ? lvColor(q.lv) : this.palette().bgHover)
+        }, (i: number) => q.lv.toString() + '-' + i.toString())
+      }
+      .width('100%')
+
+      if (q.lv > 0) {
+        Text(q.registered.toString() + ' 登记 · ' + q.preempted.toString() + ' 抢占')
+          .fontSize(9)
+          .fontColor(this.palette().textMuted)
+          .maxLines(1)
+      } else {
+        Text('无级别')
+          .fontSize(9)
+          .fontColor(this.palette().textMuted)
+          .maxLines(1)
+      }
+    }
+    .layoutWeight(1)
+    .alignItems(HorizontalAlign.Start)
+    .padding({ left: 8, right: 8, top: 9, bottom: 9 })
+    .borderRadius(RADIUS_SM)
+    .backgroundColor(this.palette().bgHover)
+    .border({
+      width: 1,
+      color: q.depth > 0 ? lvColor(q.lv) : this.palette().glassBorder,
+      style: q.lv === 0 ? BorderStyle.Dashed : BorderStyle.Solid,
+    })
+    .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
+  }
+
+  build() {
+    Column() {
+      Text('运行态')
+        .fontSize(15)
+        .fontWeight(FontWeight.Medium)
+        .fontColor(this.palette().textPrimary)
+        .margin({ bottom: 8 })
+
+      if (this.snap === undefined) {
+        Text('运行态数据不可用')
+          .fontSize(12)
+          .fontColor(this.palette().textMuted)
+          .padding({ top: 4, bottom: 4 })
+      } else {
+        // 四个数字块
+        Row({ space: 8 }) {
+          this.tile('排队', this.snap.ready.toString(), this.snap.ready > 0)
+          this.tile('中断', this.snap.pending.toString(), this.snap.pending > 0)
+          this.tile('栈', this.snap.stack.toString() + '/' + this.snap.maxStack.toString(),
+            this.snap.stack > 0)
+          this.tile('子代理', this.snap.subagents.toString(), false)
+        }
+        .width('100%')
+
+        // 阶段管道：等大表框，事件落在所属阶段那一格
+        Text('阶段管道')
+          .fontSize(12)
+          .fontWeight(FontWeight.Medium)
+          .fontColor(this.palette().textSecondary)
+          .margin({ top: 14, bottom: 6 })
+        if (this.isWide) {
+          Row({ space: 6 }) {
+            ForEach(STAGE_GROUPS, (g: StageGroup) => {
+              this.stageCell(g, phaseGroup(this.phase) === g.group)
+            }, (g: StageGroup) => 'w' + g.group.toString())
+          }
+          .width('100%')
+          .alignItems(VerticalAlign.Top)
+        } else {
+          Row({ space: 6 }) {
+            ForEach(STAGE_GROUPS.slice(0, 3), (g: StageGroup) => {
+              this.stageCell(g, phaseGroup(this.phase) === g.group)
+            }, (g: StageGroup) => 'n0' + g.group.toString())
+          }
+          .width('100%')
+          .alignItems(VerticalAlign.Top)
+          Row({ space: 6 }) {
+            ForEach(STAGE_GROUPS.slice(3), (g: StageGroup) => {
+              this.stageCell(g, phaseGroup(this.phase) === g.group)
+            }, (g: StageGroup) => 'n1' + g.group.toString())
+            // 占位：第二行只有 2 格，补一格位置让框宽与第一行对齐
+            Row().layoutWeight(1)
+          }
+          .width('100%')
+          .alignItems(VerticalAlign.Top)
+          .margin({ top: 6 })
+        }
+
+        // 中断队列：五个等大表框（L4/L3/L2/L1 + 排队）
+        Text('队列')
+          .fontSize(12)
+          .fontWeight(FontWeight.Medium)
+          .fontColor(this.palette().textSecondary)
+          .margin({ top: 14, bottom: 6 })
+        if (this.isWide) {
+          Row({ space: 6 }) {
+            ForEach(this.snap.queues, (q: RuntimeQueue) => {
+              this.queueCell(q)
+            }, (q: RuntimeQueue) => 'wq' + q.lv.toString())
+          }
+          .width('100%')
+          .alignItems(VerticalAlign.Top)
+        } else {
+          Row({ space: 6 }) {
+            ForEach(this.snap.queues.slice(0, 3), (q: RuntimeQueue) => {
+              this.queueCell(q)
+            }, (q: RuntimeQueue) => 'nq0' + q.lv.toString())
+          }
+          .width('100%')
+          .alignItems(VerticalAlign.Top)
+          Row({ space: 6 }) {
+            ForEach(this.snap.queues.slice(3), (q: RuntimeQueue) => {
+              this.queueCell(q)
+            }, (q: RuntimeQueue) => 'nq1' + q.lv.toString())
+            Row().layoutWeight(1)
+          }
+          .width('100%')
+          .alignItems(VerticalAlign.Top)
+          .margin({ top: 6 })
+        }
+      }
+    }
+    .width('100%')
+    .alignItems(HorizontalAlign.Start)
+    .padding(16)
+    .margin({ bottom: 14 })
+    .borderRadius(RADIUS_MD)
+    .backgroundColor(this.palette().bgCard)
+    .border({ width: 1, color: this.palette().glassBorder })
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/ScreensuePage.ets

@@ -0,0 +1,103 @@
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, ANIM_NORMAL } from '../common/Constants';
+import { GradientBackground } from './GradientBackground';
+import { PageTopBar } from './PageTopBar';
+import { MotionBase } from './MotionBase';
+
+/**
+ * agent 主动推送的前台内容页。
+ *
+ * 调用方负责决定页面宽度：窄屏占满窗口，宽屏只占右侧内容栏，
+ * 从而让左侧一级页面和主导航保持可见、可操作。
+ */
+@Component
+export struct ScreensuePage {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop pushedText: string = '';
+  @Prop countdown: number = 0;
+  onClose: () => void = () => {
+  };
+
+  build() {
+    Stack({ alignContent: Alignment.Bottom }) {
+      GradientBackground()
+
+      Scroll() {
+        Column({ space: 14 }) {
+          Row({ space: 8 }) {
+            Circle({ width: 8, height: 8 })
+              .fill(this.palette().accent)
+            Text('agent 推送')
+              .fontSize(12)
+              .fontWeight(FontWeight.Medium)
+              .fontColor(this.palette().textSecondary)
+            Blank()
+            if (this.countdown > 0) {
+              Text(this.countdown.toString() + 's')
+                .fontSize(12)
+                .fontColor(this.palette().textMuted)
+            } else {
+              Text('常驻')
+                .fontSize(12)
+                .fontColor(this.palette().textMuted)
+            }
+          }
+          .width('100%')
+
+          Column() {
+            Text(this.pushedText)
+              .fontSize(16)
+              .lineHeight(25)
+              .fontColor(this.palette().textPrimary)
+              .width('100%')
+              .textAlign(TextAlign.Start)
+              .copyOption(CopyOptions.LocalDevice)
+          }
+          .width('100%')
+          .padding(18)
+          .borderRadius(18)
+          .backgroundColor(this.palette().bgCard)
+          .border({ width: 1, color: this.palette().glassBorder })
+          .alignItems(HorizontalAlign.Start)
+        }
+        .width('100%')
+        .padding({ left: 18, right: 18, top: 82, bottom: 96 })
+        .alignItems(HorizontalAlign.Start)
+      }
+      .width('100%')
+      .height('100%')
+      .scrollBar(BarState.Auto)
+      .align(Alignment.Top)
+
+      PageTopBar({ title: '推送内容' })
+
+      Row() {
+        MotionBase({ pressEnabled: true, fillWidth: false }) {
+          Button('关闭')
+            .height(42)
+            .padding({ left: 22, right: 22 })
+            .fontSize(14)
+            .fontWeight(FontWeight.Medium)
+            .fontColor(Color.White)
+            .backgroundColor(this.palette().accent)
+            .borderRadius(21)
+            .onClick(() => {
+              this.onClose();
+            })
+        }
+      }
+      .width('100%')
+      .padding({ left: 18, right: 18, bottom: 22 })
+      .justifyContent(FlexAlign.End)
+      .transition(TransitionEffect.OPACITY
+        .combine(TransitionEffect.translate({ y: 18 }))
+        .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut }))
+    }
+    .width('100%')
+    .height('100%')
+    .backgroundColor(this.palette().bgPrimary)
+  }
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/SettingsEntryCard.ets

@@ -0,0 +1,215 @@
+/**
+ * 单个配置项卡片。
+ *
+ * 从 pages/SettingsPage.ets 抽出：按 type 分发控件（bool/select/password/text/其他），
+ * 值的保存与「未保存」标记交回页面（页面上持有 valuesStore 与 entries）。
+ */
+
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_MD, RADIUS_SM,
+  ANIM_FAST, ANIM_NORMAL } from '../common/Constants';
+import { SettingEntry } from '../common/SettingsModel';
+
+@Component
+export struct SettingsEntryCard {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop entry: SettingEntry;
+  /** bool 开关 / select 选项：值已知，直接落库 */
+  onSaveValue?: (key: string, value: string) => void;
+  /** 输入类控件的保存：由页面取该 key 的最新编辑值再落库 */
+  onSaveCurrent?: (key: string) => void;
+  /** 输入框内容变化：只更新本地标记，不请求 */
+  onEdit?: (key: string, value: string) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  private saveValue(value: string): void {
+    const cb: ((key: string, value: string) => void) | undefined = this.onSaveValue;
+    if (cb !== undefined) {
+      cb(this.entry.key, value);
+    }
+  }
+
+  private saveCurrent(): void {
+    const cb: ((key: string) => void) | undefined = this.onSaveCurrent;
+    if (cb !== undefined) {
+      cb(this.entry.key);
+    }
+  }
+
+  private editValue(value: string): void {
+    const cb: ((key: string, value: string) => void) | undefined = this.onEdit;
+    if (cb !== undefined) {
+      cb(this.entry.key, value);
+    }
+  }
+
+  build() {
+    Column() {
+      Row() {
+        Text(this.entry.displayName)
+          .fontSize(13)
+          .fontWeight(FontWeight.Medium)
+          .fontColor(this.palette().textPrimary)
+          .maxLines(2)
+          .textOverflow({ overflow: TextOverflow.Ellipsis })
+          .layoutWeight(1)
+        Text(this.entry.dirty ? '未保存' : this.entry.type)
+          .fontSize(10)
+          .fontColor(this.entry.dirty ? '#D99A2B' : this.palette().textMuted)
+          .padding({ left: 6, right: 6, top: 1, bottom: 1 })
+          .borderRadius(RADIUS_SM)
+          .backgroundColor(this.entry.dirty ? 'rgba(217, 154, 43, 0.16)' : this.palette().bgHover)
+      }
+      .width('100%')
+
+      Text(this.entry.key)
+        .fontSize(10)
+        .fontColor(this.palette().textMuted)
+        .maxLines(1)
+        .textOverflow({ overflow: TextOverflow.Ellipsis })
+        .margin({ top: 1 })
+
+      if (this.entry.description.length > 0) {
+        Text(this.entry.description)
+          .fontSize(11)
+          .fontColor(this.palette().textSecondary)
+          .maxLines(3)
+          .textOverflow({ overflow: TextOverflow.Ellipsis })
+          .margin({ top: 3 })
+      }
+
+      // control row per type
+      if (this.entry.type === 'bool') {
+        Row() {
+          Text(this.entry.value === 'true' ? 'true' : 'false')
+            .fontSize(12)
+            .fontColor(this.entry.value === 'true' ? '#17A964' : this.palette().textMuted)
+            .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut })
+          Blank()
+          Toggle({ type: ToggleType.Switch, isOn: this.entry.value === 'true' })
+            .selectedColor(this.palette().accent)
+            .onChange((on: boolean) => {
+              this.saveValue(on ? 'true' : 'false');
+            })
+        }
+        .width('100%')
+        .margin({ top: 8 })
+      } else if (this.entry.type === 'select' && this.entry.options.length > 0) {
+        Flex({
+          direction: FlexDirection.Row,
+          justifyContent: FlexAlign.Start,
+          alignItems: ItemAlign.Center,
+          wrap: FlexWrap.Wrap,
+        }) {
+          ForEach(this.entry.options, (opt: string) => {
+            Button(opt)
+              .height(26)
+              .fontSize(11)
+              .margin({ right: 6, bottom: 6 })
+              .backgroundColor(this.entry.value === opt ? this.palette().accent : this.palette().bgHover)
+              .fontColor(this.entry.value === opt ? Color.White : this.palette().textSecondary)
+              // 选中项迁移：底色与字色一起过渡，避免整排选项同时硬切
+              .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
+              .onClick(() => {
+                this.saveValue(opt);
+              })
+          }, (opt: string) => opt)
+        }
+        .width('100%')
+        .margin({ top: 8 })
+      } else if (this.entry.type === 'password') {
+        Row() {
+          TextInput({ text: this.entry.value })
+            .height(36)
+            .fontSize(13)
+            .fontColor(this.palette().textPrimary)
+            .placeholderColor(this.palette().textMuted)
+            .backgroundColor(this.palette().bgInput)
+            .borderRadius(RADIUS_SM)
+            .border({ width: 1, color: this.palette().border })
+            .type(InputType.Password)
+            .layoutWeight(1)
+            .onChange((v: string) => {
+              this.editValue(v);
+            })
+          Button('保存')
+            .height(30)
+            .fontSize(12)
+            .backgroundColor(this.entry.dirty ? '#D99A2B' : this.palette().accent)
+            .fontColor(Color.White)
+            .margin({ left: 8 })
+            .onClick(() => {
+              this.saveCurrent();
+            })
+        }
+        .width('100%')
+        .margin({ top: 8 })
+      } else if (this.entry.type === 'text') {
+        TextArea({ text: this.entry.value })
+          .width('100%')
+          .fontSize(13)
+          .fontColor(this.palette().textPrimary)
+          .backgroundColor(this.palette().bgInput)
+          .borderRadius(RADIUS_SM)
+          .border({ width: 1, color: this.palette().border })
+          .constraintSize({ minHeight: 60, maxHeight: 200 })
+          .margin({ top: 8 })
+          .onChange((v: string) => {
+            this.editValue(v);
+          })
+        Row() {
+          Blank()
+          Button('保存')
+            .height(30)
+            .fontSize(12)
+            .backgroundColor(this.entry.dirty ? '#D99A2B' : this.palette().accent)
+            .fontColor(Color.White)
+            .onClick(() => {
+              this.saveCurrent();
+            })
+        }
+        .width('100%')
+        .margin({ top: 6 })
+      } else {
+        // string / int / duration
+        Row() {
+          TextInput({ text: this.entry.value })
+            .height(36)
+            .fontSize(13)
+            .fontColor(this.palette().textPrimary)
+            .placeholderColor(this.palette().textMuted)
+            .backgroundColor(this.palette().bgInput)
+            .borderRadius(RADIUS_SM)
+            .border({ width: 1, color: this.palette().border })
+            .layoutWeight(1)
+            .onChange((v: string) => {
+              this.editValue(v);
+            })
+          Button('保存')
+            .height(30)
+            .fontSize(12)
+            .backgroundColor(this.entry.dirty ? '#D99A2B' : this.palette().accent)
+            .fontColor(Color.White)
+            .margin({ left: 8 })
+            .onClick(() => {
+              this.saveCurrent();
+            })
+        }
+        .width('100%')
+        .margin({ top: 8 })
+      }
+    }
+    .width('100%')
+    .padding(14)
+    .borderRadius(RADIUS_MD)
+    .backgroundColor(this.palette().bgCard)
+    .border({
+      width: 1,
+      color: this.entry.dirty ? '#D99A2B' : this.palette().glassBorder,
+    })
+    .margin({ bottom: 10 })
+    .alignItems(HorizontalAlign.Start)
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/SettingsHome.ets

@@ -0,0 +1,95 @@
+/**
+ * 设置一级页的页面骨架：滚动区 + 顶栏 + 悬浮区 + 轻提示。
+ *
+ * 从 pages/SettingsPage.ets 抽出：页面本身只剩数据流与导航表，
+ * 这一层是纯布局 —— 所有计数/文案都由页面算好传进来。
+ */
+
+import { handleNavOnScroll } from '../common/NavBarController';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE } from '../common/Constants';
+import { PageTopBar, NavFloatOverlay, NavFloatRow } from './PageTopBar';
+import { SettingsRootEntries } from './SettingsRootEntries';
+import { ToastBar } from './ToastBar';
+
+@Component
+export struct SettingsHome {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  /** 一级入口列表所需的计数/文案（见 SettingsRootEntries） */
+  @Prop connCount: number = 0;
+  @Prop connName: string = '';
+  @Prop sectionCount: number = 0;
+  @Prop coreKeys: number = 0;
+  @Prop busy: boolean = false;
+  @Prop errorText: string = '';
+  @Prop themeLabel: string = '';
+  @Prop activeSub: string = '';
+  @Prop isWide: boolean = false;
+  /** 保存进行中：悬浮区显示转圈 */
+  @Prop savingCount: number = 0;
+  @Prop toastMsg: string = '';
+  @Prop toastIsError: boolean = false;
+  onOpen?: (id: string) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    Stack({ alignContent: Alignment.Bottom }) {
+      Column() {
+        Scroll() {
+          Column() {
+            SettingsRootEntries({
+              connCount: this.connCount,
+              connName: this.connName,
+              sectionCount: this.sectionCount,
+              coreKeys: this.coreKeys,
+              busy: this.busy,
+              errorText: this.errorText,
+              themeLabel: this.themeLabel,
+              activeSub: this.activeSub,
+              isWide: this.isWide,
+              onOpen: (id: string) => {
+                const cb: ((id: string) => void) | undefined = this.onOpen;
+                if (cb !== undefined) {
+                  cb(id);
+                }
+              },
+            })
+          }
+          .width('100%')
+          .padding({ left: 16, right: 16, top: 76, bottom: 174 })
+        }
+        .width('100%')
+        .height('100%')
+        .scrollBar(BarState.Off)
+        .align(Alignment.Top)
+        .onDidScroll((xOffset: number, yOffset: number, state: ScrollState) => {
+          handleNavOnScroll(state);
+        })
+      }
+      .width('100%')
+      .height('100%')
+
+      PageTopBar({ title: '设置' })
+
+      // 一级悬浮区：仅在保存进行中显示一个转圈；
+      // 已保存/未保存的常驻徽标按用户要求去掉（保存本来就是即时的，不需要状态吊牌）
+      NavFloatOverlay({ tab: 3 }) {
+        NavFloatRow() {
+          if (this.savingCount > 0) {
+            LoadingProgress()
+              .width(14)
+              .height(14)
+              .color(this.palette().accent)
+          }
+        }
+      }
+
+      ToastBar({ msg: this.toastMsg, isError: this.toastIsError })
+    }
+    .width('100%')
+    .height('100%')
+    .backgroundColor(Color.Transparent)
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/SettingsRootEntries.ets

@@ -0,0 +1,100 @@
+/**
+ * 设置一级页的入口列表。
+ *
+ * 从 pages/SettingsPage.ets 抽出：纯展示 + 跳转回调，
+ * 所有计数/文案由页面算好传进来（页面才是这些状态的持有者）。
+ */
+
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE } from '../common/Constants';
+import { SUB_STATUS, SUB_CONNECTIONS, SUB_BACKEND, SUB_SECTION, SUB_APPEARANCE } from '../common/SettingsModel';
+import { StatusSummaryCard } from './StatusCards';
+import { NavGroup, NavRow } from './SubPage';
+
+@Component
+export struct SettingsRootEntries {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  /** 连接配置条数 */
+  @Prop connCount: number = 0;
+  /** 当前生效连接的展示名 */
+  @Prop connName: string = '';
+  /** 后端配置：分类数 / 核心项数 / 是否加载中 / 错误文案 */
+  @Prop sectionCount: number = 0;
+  @Prop coreKeys: number = 0;
+  @Prop busy: boolean = false;
+  @Prop errorText: string = '';
+  /** 当前主题的中文名（一级行右侧摘要值） */
+  @Prop themeLabel: string = '';
+  /** 宽屏分栏时用来高亮右栏对应的入口行 */
+  @Prop activeSub: string = '';
+  @Prop isWide: boolean = false;
+  onOpen?: (id: string) => void;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  private open(id: string): void {
+    const cb: ((id: string) => void) | undefined = this.onOpen;
+    if (cb !== undefined) {
+      cb(id);
+    }
+  }
+
+  build() {
+    Column() {
+      // 运行状态摘要（原「状态」Tab）：整卡可点，进入明细二级页
+      StatusSummaryCard({
+        onTap: () => {
+          this.open(SUB_STATUS);
+        },
+      })
+
+      NavGroup({ caption: '连接' }) {
+        NavRow({
+          icon: $r('app.media.ic_link'),
+          title: '后端连接',
+          subtitle: this.connCount.toString() + ' 个连接配置',
+          value: this.connName,
+          selected: this.isWide && this.activeSub === SUB_CONNECTIONS,
+          onTap: () => {
+            this.open(SUB_CONNECTIONS);
+          },
+        })
+        NavRow({
+          icon: $r('app.media.ic_tune'),
+          title: '核心配置',
+          subtitle: this.sectionCount.toString() + ' 个分类 · ' + this.coreKeys.toString() + ' 项',
+          value: this.busy ? '加载中' : (this.errorText.length > 0 ? '不可用' : ''),
+          showDivider: false,
+          selected: this.isWide && (this.activeSub === SUB_BACKEND || this.activeSub === SUB_SECTION),
+          onTap: () => {
+            this.open(SUB_BACKEND);
+          },
+        })
+      }
+
+      NavGroup({ caption: '个性化' }) {
+        NavRow({
+          icon: $r('app.media.ic_theme'),
+          title: '外观',
+          subtitle: '主题与背景图',
+          value: this.themeLabel,
+          showDivider: false,
+          selected: this.isWide && this.activeSub === SUB_APPEARANCE,
+          onTap: () => {
+            this.open(SUB_APPEARANCE);
+          },
+        })
+      }
+
+      if (this.errorText.length > 0) {
+        Text(this.errorText)
+          .fontSize(12)
+          .fontColor('#E84026')
+          .padding({ left: 4, right: 4 })
+      }
+    }
+    .width('100%')
+    .alignItems(HorizontalAlign.Start)
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/components/StaticMarkdown.ets

@@ -4,285 +4,13 @@
  * Parses once in aboutToAppear, builds a component tree with no timers — instant rendering.
  * Uses Span children inside Text for inline bold/italic/code/link formatting.
  *
- * Covers: headings, paragraphs, code fences, unordered/ordered lists,
- * blockquotes, horizontal rules, tables, and inline bold/italic/code/links.
+ * 解析规则在 common/MarkdownParser.ets（已抽出，见那里）；
+ * 本文件只负责把 MdBlock 渲染成 ArkUI 组件树。
  */
 
 import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE } from '../common/Constants';
 import { RADIUS_SM } from '../common/Constants';
-
-// ── Types ──────────────────────────────────────────────────────────────────────
-
-export interface MdBlock {
-  type: string; // 'heading' | 'code' | 'list' | 'ol' | 'blockquote' | 'hr' | 'table' | 'para'
-  level?: number;
-  items?: string[];
-  text?: string;
-  lang?: string;
-  codeLines?: string[];
-  headers?: string[];
-  rows?: string[][];
-}
-
-export interface MdSpan {
-  text: string;
-  bold?: boolean;
-  italic?: boolean;
-  code?: boolean;
-  link?: boolean;
-  linkUrl?: string;
-}
-
-// ── Inline parser ──────────────────────────────────────────────────────────────
-
-export function parseInline(text: string): MdSpan[] {
-  const spans: MdSpan[] = [];
-  let i: number = 0;
-  while (i < text.length) {
-    // Inline code (backtick)
-    if (text[i] === '`') {
-      const end: number = text.indexOf('`', i + 1);
-      if (end > i) {
-        spans.push({ text: text.substring(i + 1, end), code: true });
-        i = end + 1;
-        continue;
-      }
-    }
-    // Bold: **text**
-    if (text[i] === '*' && i + 1 < text.length && text[i + 1] === '*') {
-      const end: number = text.indexOf('**', i + 2);
-      if (end > i + 1) {
-        spans.push({ text: text.substring(i + 2, end), bold: true });
-        i = end + 2;
-        continue;
-      }
-    }
-    // Italic: *text* (single asterisk)
-    if (text[i] === '*' && (i + 1 >= text.length || text[i + 1] !== '*')) {
-      const end: number = text.indexOf('*', i + 1);
-      if (end > i) {
-        spans.push({ text: text.substring(i + 1, end), italic: true });
-        i = end + 1;
-        continue;
-      }
-    }
-    // Link: [text](url)
-    if (text[i] === '[') {
-      const cb: number = text.indexOf(']', i + 1);
-      if (cb > i && cb + 1 < text.length && text[cb + 1] === '(') {
-        const cp: number = text.indexOf(')', cb + 2);
-        if (cp > cb + 1) {
-          spans.push({ text: text.substring(i + 1, cb), link: true, linkUrl: text.substring(cb + 2, cp) });
-          i = cp + 1;
-          continue;
-        }
-      }
-    }
-    // Plain run
-    let j: number = i + 1;
-    while (j < text.length && text[j] !== '`' && text[j] !== '*' && text[j] !== '[') {
-      j++;
-    }
-    spans.push({ text: text.substring(i, j) });
-    i = j;
-  }
-  return spans;
-}
-
-// ── Block parser helpers ───────────────────────────────────────────────────────
-
-function isHr(line: string): boolean {
-  if (line.length < 3) {
-    return false;
-  }
-  const ch: string = line[0];
-  if (ch !== '-' && ch !== '*' && ch !== '_') {
-    return false;
-  }
-  for (let k = 0; k < line.length; k++) {
-    if (line[k] !== ch) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function isOlStart(line: string): boolean {
-  if (line.length < 3) {
-    return false;
-  }
-  let k: number = 0;
-  while (k < line.length && line[k] >= '0' && line[k] <= '9') {
-    k++;
-  }
-  return k > 0 && k + 1 < line.length && line[k] === '.' && line[k + 1] === ' ';
-}
-
-function isTableSep(line: string): boolean {
-  if (!line.includes('-')) {
-    return false;
-  }
-  for (let k = 0; k < line.length; k++) {
-    const c: string = line[k];
-    if (c !== '|' && c !== '-' && c !== ':' && c !== ' ' && c !== '\t') {
-      return false;
-    }
-  }
-  return true;
-}
-
-// ── Block parser ───────────────────────────────────────────────────────────────
-
-export function parseBlocks(content: string): MdBlock[] {
-  if (content.length === 0) {
-    return [];
-  }
-  const lines: string[] = content.split('\n');
-  const blocks: MdBlock[] = [];
-  let i: number = 0;
-
-  while (i < lines.length) {
-    const line: string = lines[i];
-
-    // Empty line
-    if (line.trim().length === 0) {
-      i++;
-      continue;
-    }
-
-    // Code fence
-    if (line.startsWith('```')) {
-      const langEnd: number = line.indexOf('`', 3);
-      const lang: string = langEnd > 3 ? line.substring(3, langEnd).trim() : '';
-      const codeLines: string[] = [];
-      i++;
-      while (i < lines.length && !lines[i].trimStart().startsWith('```')) {
-        codeLines.push(lines[i]);
-        i++;
-      }
-      if (i < lines.length) {
-        i++;
-      }
-      blocks.push({ type: 'code', lang: lang, codeLines: codeLines });
-      continue;
-    }
-
-    // Heading
-    if (line.startsWith('#')) {
-      let level: number = 0;
-      while (level < line.length && line[level] === '#') {
-        level++;
-      }
-      if (level <= 6 && level < line.length && line[level] === ' ') {
-        blocks.push({ type: 'heading', level: level, text: line.substring(level + 1).trim() });
-        i++;
-        continue;
-      }
-    }
-
-    // Horizontal rule
-    if (isHr(line.trim())) {
-      blocks.push({ type: 'hr' });
-      i++;
-      continue;
-    }
-
-    // Unordered list
-    if ((line.startsWith('- ') || line.startsWith('* ')) && !line.startsWith('- [')) {
-      const items: string[] = [];
-      while (i < lines.length && (lines[i].startsWith('- ') || lines[i].startsWith('* ')) && !lines[i].startsWith('- [')) {
-        items.push(lines[i].substring(2));
-        i++;
-      }
-      blocks.push({ type: 'list', items: items });
-      continue;
-    }
-
-    // Ordered list
-    if (isOlStart(line)) {
-      const items: string[] = [];
-      while (i < lines.length && isOlStart(lines[i])) {
-        const dotIdx: number = lines[i].indexOf('. ');
-        items.push(lines[i].substring(dotIdx + 2));
-        i++;
-      }
-      blocks.push({ type: 'ol', items: items });
-      continue;
-    }
-
-    // Blockquote
-    if (line.startsWith('> ')) {
-      const qLines: string[] = [];
-      while (i < lines.length && lines[i].startsWith('> ')) {
-        qLines.push(lines[i].substring(2));
-        i++;
-      }
-      blocks.push({ type: 'blockquote', text: qLines.join('\n') });
-      continue;
-    }
-
-    // Table
-    if (line.trimStart().startsWith('|') && !isTableSep(line)) {
-      const tLines: string[] = [];
-      while (i < lines.length && lines[i].trimStart().startsWith('|')) {
-        tLines.push(lines[i]);
-        i++;
-      }
-      if (tLines.length >= 2) {
-        const parseRow = (row: string): string[] => {
-          const cells: string[] = [];
-          const parts: string[] = row.split('|');
-          for (let p = 0; p < parts.length; p++) {
-            const c: string = parts[p].trim();
-            if (c.length > 0) {
-              cells.push(c);
-            }
-          }
-          return cells;
-        };
-        const headers: string[] = parseRow(tLines[0]);
-        const rows: string[][] = [];
-        for (let k = 1; k < tLines.length; k++) {
-          if (!isTableSep(tLines[k].trim())) {
-            rows.push(parseRow(tLines[k]));
-          }
-        }
-        if (headers.length > 0) {
-          blocks.push({ type: 'table', headers: headers, rows: rows });
-        }
-      }
-      continue;
-    }
-
-    // Paragraph: collect consecutive non-special lines
-    {
-      const paraLines: string[] = [];
-      while (i < lines.length) {
-        const ln: string = lines[i];
-        if (ln.trim().length === 0) {
-          break;
-        }
-        if (ln.startsWith('```') || ln.startsWith('#') || isHr(ln.trim())) {
-          break;
-        }
-        if (ln.startsWith('- ') || ln.startsWith('* ') || isOlStart(ln) || ln.startsWith('> ')) {
-          break;
-        }
-        if (ln.trimStart().startsWith('|') && !isTableSep(ln)) {
-          break;
-        }
-        paraLines.push(ln);
-        i++;
-      }
-      if (paraLines.length > 0) {
-        blocks.push({ type: 'para', text: paraLines.join('\n') });
-      }
-    }
-  }
-  return blocks;
-}
-
-// ── Component ──────────────────────────────────────────────────────────────────
+import { MdBlock, MdSpan, parseBlocks, parseInline } from '../common/MarkdownParser';
 
 @Component
 export struct StaticMarkdownView {

cmd/ohos/HomeAgent/entry/src/main/ets/components/StatusCards.ets

@@ -2,9 +2,10 @@ import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_LG, RADIUS_SM,
   ANIM_FAST, ANIM_NORMAL, ANIM_ENTER } from '../common/Constants';
 import { COLOR_ACCENT, COLOR_SUCCESS, COLOR_CYAN, COLOR_ERROR } from '../common/Constants';
 import { MotionBase } from './MotionBase';
+import { RuntimePanel } from './RuntimePanel';
 import {
   statusStore, StatGroup, StatField, compactDuration,
-  K_UP, K_VERSION, K_STARTED, K_AGENTS, K_PLUGINS, K_TOOLS, K_ERR, K_LOADING, K_REV,
+  K_UP, K_VERSION, K_STARTED, K_AGENTS, K_PLUGINS, K_TOOLS, K_ERR, K_LOADING, K_REV, K_BUILD,
 } from '../common/StatusStore';
 
 /**
@@ -19,6 +20,8 @@ export struct StatusSummaryCard {
   @StorageProp('themeIsDark') private isDark: boolean = true;
   @StorageProp(K_UP) private up: boolean = false;
   @StorageProp(K_VERSION) private version: string = '-';
+  /** 内核名 · commit。与版本号分开一行：版本号本身没有内核身份。 */
+  @StorageProp(K_BUILD) private buildSub: string = '';
   @StorageProp(K_STARTED) private startedAt: string = '';
   @StorageProp(K_AGENTS) private agents: number = 0;
   @StorageProp(K_PLUGINS) private plugins: number = 0;
@@ -130,14 +133,24 @@ export struct StatusSummaryCard {
           Text('版本')
             .fontSize(12)
             .fontColor(this.palette().textMuted)
-          Text(this.version)
-            .fontSize(12)
-            .fontWeight(FontWeight.Medium)
-            .fontColor(this.palette().textSecondary)
-            .layoutWeight(1)
-            .maxLines(1)
-            .textOverflow({ overflow: TextOverflow.Ellipsis })
-            .margin({ left: 10 })
+          Column() {
+            Text(this.version)
+              .fontSize(12)
+              .fontWeight(FontWeight.Medium)
+              .fontColor(this.palette().textSecondary)
+              .maxLines(1)
+              .textOverflow({ overflow: TextOverflow.Ellipsis })
+            // 内核名 + commit：光有版本号会分不清是哪个内核、哪次构建
+            Text(this.buildSub)
+              .fontSize(10)
+              .fontColor(this.palette().textMuted)
+              .maxLines(1)
+              .textOverflow({ overflow: TextOverflow.Ellipsis })
+              .visibility(this.buildSub.length > 0 ? Visibility.Visible : Visibility.None)
+          }
+          .alignItems(HorizontalAlign.Start)
+          .layoutWeight(1)
+          .margin({ left: 10 })
           Text('明细')
             .fontSize(12)
             .fontColor(this.palette().accent)
@@ -271,6 +284,11 @@ export struct StatusDetailContent {
       // 于是 31 个插件在 203 个工具旁边只剩一条短线 —— 读数没有意义。
       // 数量本身已在摘要卡上以图标+数字直观呈现，这里不再重复。
 
+      // 运行态面板（阶段管道 + 中断队列）放在明细页最前：
+      // 明细卡回答「内核有哪些东西、多少」，运行态回答「现在在干什么」，
+      // 后者是进这个页面最先想看的。
+      RuntimePanel()
+
       ForEach(this.groups, (g: StatGroup) => {
         Column() {
           Text(g.title)

cmd/ohos/HomeAgent/entry/src/main/ets/components/SubPage.ets

@@ -13,7 +13,11 @@ import { GradientBackground } from './GradientBackground';
 export const KEY_SUBPAGE_OPEN: string = 'subPageOpen';
 
 export function markSubPageOpen(open: boolean): void {
-  AppStorage.setOrCreate<boolean>(KEY_SUBPAGE_OPEN, open);
+  if (AppStorage.has(KEY_SUBPAGE_OPEN)) {
+    AppStorage.set<boolean>(KEY_SUBPAGE_OPEN, open);
+  } else {
+    AppStorage.setOrCreate<boolean>(KEY_SUBPAGE_OPEN, open);
+  }
 }
 
 /** pushPathByName 的参数载体：ArkTS 不允许把 string 断言成 object */

cmd/ohos/HomeAgent/entry/src/main/ets/components/ToastBar.ets

@@ -0,0 +1,48 @@
+/**
+ * 右下角轻提示条（设置页与插件页共用）。
+ *
+ * 两处原本各写一份，只有"描边"这一处不同：设置页无描边，插件页有。
+ * 用 bordered 表达这个差异（width 0 的边框不占位、不可见）。
+ *
+ * 配色由调用方决定：颜色标志必须在调用方落 animateTo 之前先写好，
+ * 否则第一帧会用上一条 toast 的配色。
+ */
+
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, RADIUS_MD, ANIM_NORMAL } from '../common/Constants';
+
+@Component
+export struct ToastBar {
+  @StorageProp('themeIsDark') private isDark: boolean = true;
+  @Prop msg: string = '';
+  @Prop isError: boolean = false;
+  /** 是否带一圈语义色描边（插件页用，设置页不用） */
+  @Prop bordered: boolean = false;
+
+  private palette(): ThemePalette {
+    return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
+  }
+
+  build() {
+    if (this.msg.length > 0) {
+      Row() {
+        Text(this.msg)
+          .fontSize(13)
+          .fontColor(this.isError ? this.palette().toastErrorText : this.palette().toastText)
+          .padding({ left: 20, right: 20, top: 10, bottom: 10 })
+          .borderRadius(RADIUS_MD)
+          .backgroundColor(this.isError ? this.palette().toastErrorBg : this.palette().toastBg)
+          .border({
+            width: this.bordered ? 1 : 0,
+            color: this.isError ? 'rgba(232, 64, 38, 0.3)' : 'rgba(23, 169, 100, 0.3)',
+          })
+      }
+      .width('100%')
+      .justifyContent(FlexAlign.End)
+      .padding({ right: 20 })
+      .margin({ bottom: 166 })
+      .transition(TransitionEffect.OPACITY
+        .combine(TransitionEffect.translate({ y: 12 }))
+        .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut }))
+    }
+  }
+}

cmd/ohos/HomeAgent/entry/src/main/ets/entryability/EntryAbility.ets

@@ -4,6 +4,7 @@ import { BusinessError } from '@kit.BasicServicesKit';
 import { connStore } from '../common/ConnStore';
 import { apiClient } from '../common/ApiClient';
 import { themeIsDark, seedTheme, seedSystemIsDark, resolveIsDark, applyThemeMode } from '../common/Constants';
+import { startForegroundBridge, stopForegroundBridge } from '../common/DeviceBridgeSession';
 
 /** Read the persisted theme mode ('system'|'dark'|'light'), defaulting to 'system'. */
 function storedThemeMode(): string {
@@ -31,6 +32,7 @@ export default class EntryAbility extends UIAbility {
   }
 
   onDestroy(): void {
+    stopForegroundBridge();
     console.info('[HomeAgent] ability onDestroy');
   }
 
@@ -86,6 +88,7 @@ export default class EntryAbility extends UIAbility {
             apiClient.setConnection(cur);
           }
           this.reapplyStoredTheme();
+          startForegroundBridge(this.context);
           startUI();
         }).catch(() => {
           startUI();
@@ -107,6 +110,7 @@ export default class EntryAbility extends UIAbility {
         // init 之后持久化的主题模式才可读，这里按存量设置重新解析并刷新系统栏
         this.reapplyStoredTheme();
         this.applySystemBar();
+        startForegroundBridge(this.context);
         startUI();
       }).catch((e: Error) => {
         console.error('[HomeAgent] connStore init failed: ' + e.message);
@@ -129,10 +133,12 @@ export default class EntryAbility extends UIAbility {
   }
 
   onForeground(): void {
+    startForegroundBridge(this.context);
     console.info('[HomeAgent] ability onForeground');
   }
 
   onBackground(): void {
+    stopForegroundBridge();
     console.info('[HomeAgent] ability onBackground');
   }
 }

cmd/ohos/HomeAgent/entry/src/main/ets/pages/DevicePage.ets

@@ -1,35 +1,28 @@
 import { deviceBridge } from '../common/DeviceBridge';
-import { installCmdRouter, registerScreensueHandler, setBridgeAppContext } from '../common/BridgeRouter';
 import { connStore } from '../common/ConnStore';
 import { apiClient } from '../common/ApiClient';
-import { noConnectionMessage } from '../common/UserError';
 import { handleNavOnScroll } from '../common/NavBarController';
 import { registerNavStack, unregisterNavStack } from '../common/NavStackRegistry';
 import { DeviceInfo } from '../model/Model';
-import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, WIDE_NAV_BAR_WIDTH, WIDE_MIN_CONTENT, ANIM_FAST, ANIM_NORMAL, ANIM_ENTER } from '../common/Constants';
-import { MotionBase } from '../components/MotionBase';
-import { common } from '@kit.AbilityKit';
+import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, WIDE_NAV_BAR_WIDTH,
+  WIDE_MIN_CONTENT, ANIM_NORMAL, ANIM_ENTER } from '../common/Constants';
+import { deviceGatewayUrl } from '../common/DeviceBridgeSession';
+import { DeviceRootEntries } from '../components/DeviceRootEntries';
+import { DeviceLocalPane, DeviceCapsPane, DeviceGatewayPane, DeviceListPane } from '../components/DevicePanes';
 import { PageTopBar, NavFloatOverlay, NavFloatRow, FloatIconButton } from '../components/PageTopBar';
-import { SubPageLayer, NavGroup, NavRow, PlainCard, markSubPageOpen, subPageParam } from '../components/SubPage';
-
-// 本机声明的能力（与 BridgeRouter 支持的命令一一对应）
-const LOCAL_CAPS: string[] = [
-  'status',
-  'deviceinfo',
-  'screensee',
-  'screensue',
-  'clipboardsee',
-  'clipboardsue',
-  'speakeruse',
-];
-
-/** 二级页面标识 */
-const SUB_NONE: string = '';
-const SUB_LOCAL: string = 'local';
-const SUB_CAPS: string = 'caps';
-const SUB_GATEWAY: string = 'gateway';
-const SUB_LIST: string = 'list';
+import { markSubPageOpen, subPageParam } from '../components/SubPage';
+import { parseOnlineDevices, resolveDeviceId, SUB_CAPS, SUB_GATEWAY, SUB_LIST,
+  SUB_LOCAL, SUB_NONE } from '../common/DeviceModel';
 
+/**
+ * 设备页：只做"页面壳"。
+ *
+ * 拆分后的分工（拆分前这里是 560 行的单文件）：
+ *  - 一级入口列表（本机/通道两组）        → components/DeviceRootEntries.ets
+ *  - 四个二级页面内容（本机/能力/通道/列表）→ components/DevicePanes.ets
+ *  - device_id 兜底与在线设备解析          → common/DeviceModel.ets（路由 id 也在那）
+ * 本文件保留：导航栈与二级页分发、授权开关、toast、设备列表拉取与生命周期。
+ */
 @Component
 export struct DevicePage {
   @StorageProp('themeIsDark') private isDark: boolean = true;
@@ -39,56 +32,28 @@ export struct DevicePage {
   @StorageProp('isWideScreen') private isWide: boolean = false;
   /** 当前右栏展示的二级页面 id，用于宽屏下高亮左侧入口行 */
   @State activeSub: string = SUB_NONE;
-  @State bridgeConnected: boolean = false;
+  @StorageProp('deviceBridgeConnected') private bridgeConnected: boolean = false;
   @State bridgeUrl: string = '';
   @State bridgeToken: string = '';
   @State deviceId: string = '';
   @State authorized: boolean = false;
   @State devices: DeviceInfo[] = [];
   @State loadingDevices: boolean = false;
-  @State lastError: string = '';
   @State toastMsg: string = '';
   @State toastIsError: boolean = false;
   /** 二级页面导航栈：系统返回手势/三键返回直接作用于它 */
   private navStack: NavPathStack = new NavPathStack();
-  private autoConnectTried: boolean = false;
 
   aboutToAppear(): void {
-    this.deviceId = deviceBridge.getDeviceId();
-    if (this.deviceId.length === 0) {
-      this.deviceId = connStore.getDeviceId();
-    }
-    if (this.deviceId.length === 0) {
-      this.deviceId = 'ohos-' + Date.now().toString(36);
-      try {
-        connStore.saveDeviceId(this.deviceId);
-      } catch (e) {
-        // ignore
-      }
-    }
+    // id 判定顺序：桥里的 id 优先于持久化的 id，都没有才生成并落盘
+    this.deviceId = resolveDeviceId(deviceBridge.getDeviceId());
     this.authorized = connStore.getDeviceAuth();
     // Gateway URL derives from current connection
     const cur = connStore.getCurrentConnection();
     if (cur !== null) {
-      this.bridgeUrl = this.gatewayUrlOf(cur.url);
+      this.bridgeUrl = deviceGatewayUrl(cur.url);
       this.bridgeToken = cur.apiKey;
     }
-    installCmdRouter();
-    try {
-      setBridgeAppContext(getContext(this) as common.UIAbilityContext);
-    } catch (e) {
-      // ignore context errors
-    }
-    deviceBridge.setStateListener((open: boolean) => {
-      this.getUIContext().animateTo({ duration: ANIM_NORMAL, curve: Curve.EaseOut }, () => {
-        this.bridgeConnected = open;
-      });
-      if (open) {
-        this.lastError = '';
-        this.showToast('设备网关已连接', false);
-        this.refreshDevices();
-      }
-    });
     this.refreshDevices();
     // 登记导航栈：返回手势由 Index.onBackPress 按当前 Tab 精确派发过来
     registerNavStack(2, this.navStack, () => {
@@ -104,37 +69,6 @@ export struct DevicePage {
     return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
   }
 
-  /**
-   * 把后端 HTTP 地址转成设备桥的 WebSocket 地址。
-   *
-   * 关键：@ohos.net.webSocket 只接受 ws:// / wss:// 协议头，
-   * 直接把 http:// 传进 connect() 会在 native 层报
-   * "protocol failed" + "ParseUrl failed"（NETSTACK websocket_exec.cpp），
-   * 表现为设备通道永远连不上。所以这里必须做协议替换。
-   */
-  private gatewayUrlOf(base: string): string {
-    let trimmed: string = base.trim();
-    while (trimmed.length > 0 && trimmed.charAt(trimmed.length - 1) === '/') {
-      trimmed = trimmed.substring(0, trimmed.length - 1);
-    }
-    let scheme: string = 'ws://';
-    let rest: string = trimmed;
-    if (trimmed.startsWith('https://')) {
-      scheme = 'wss://';
-      rest = trimmed.substring('https://'.length);
-    } else if (trimmed.startsWith('http://')) {
-      scheme = 'ws://';
-      rest = trimmed.substring('http://'.length);
-    } else if (trimmed.startsWith('wss://')) {
-      scheme = 'wss://';
-      rest = trimmed.substring('wss://'.length);
-    } else if (trimmed.startsWith('ws://')) {
-      scheme = 'ws://';
-      rest = trimmed.substring('ws://'.length);
-    }
-    return scheme + rest + '/api/v1/device/ws';
-  }
-
   /**
    * 打开二级页面。
    *
@@ -170,45 +104,9 @@ export struct DevicePage {
       // ignore persist failure
     }
     deviceBridge.updateAuthorized(on);
-    if (!this.bridgeConnected) {
-      this.connectBridge();
-    }
     this.showToast(on ? '已授权，agent 可下发能力命令' : '已取消授权', false);
   }
 
-  // ===================== gateway connection =====================
-
-  private async connectBridge(): Promise<void> {
-    if (this.bridgeUrl.length === 0 || this.bridgeToken.length === 0) {
-      this.lastError = noConnectionMessage();
-      return;
-    }
-    this.lastError = '';
-    if (this.deviceId.length === 0) {
-      this.deviceId = 'ohos-' + Date.now().toString(36);
-    }
-    try {
-      connStore.saveDeviceId(this.deviceId);
-    } catch (e) {
-      // ignore
-    }
-    const name: string = 'HomeAgent OHOS';
-    await deviceBridge.connect(
-      this.bridgeUrl, this.bridgeToken, this.deviceId,
-      LOCAL_CAPS, 'ohos-phone', this.authorized, name);
-  }
-
-  /** 首次进入自动尝试连接（静默，失败不打扰）。 */
-  private maybeAutoConnect(): void {
-    if (this.autoConnectTried || this.bridgeConnected) {
-      return;
-    }
-    this.autoConnectTried = true;
-    if (this.bridgeUrl.length > 0 && this.bridgeToken.length > 0) {
-      this.connectBridge();
-    }
-  }
-
   private showToast(msg: string, isError: boolean): void {
     // 颜色标记必须在动画闭包外先落定，否则第一帧用的还是上一条 toast 的配色
     this.toastIsError = isError;
@@ -231,31 +129,7 @@ export struct DevicePage {
       const resp = await apiClient.get('/device/online');
       if (resp.status >= 200 && resp.status < 300) {
         const parsed: Record<string, Object> = JSON.parse(resp.body) as Record<string, Object>;
-        const devs: Object = parsed['devices'];
-        const list: DeviceInfo[] = [];
-        if (devs !== undefined && devs !== null) {
-          const arr: Object[] = devs as Object[];
-          for (let i = 0; i < arr.length; i++) {
-            const d: Record<string, Object> = arr[i] as Record<string, Object>;
-            const capsArr: Object = d['caps'];
-            const caps: string[] = [];
-            if (capsArr !== undefined && capsArr !== null) {
-              const cArr: Object[] = capsArr as Object[];
-              for (let j = 0; j < cArr.length; j++) {
-                caps.push(cArr[j] as string);
-              }
-            }
-            const info: DeviceInfo = {
-              deviceId: d['device_id'] as string ?? '',
-              name: d['name'] as string ?? '',
-              kind: d['kind'] as string ?? '',
-              online: true,
-              authorized: d['authorized'] as boolean ?? false,
-              caps: caps,
-            };
-            list.push(info);
-          }
-        }
+        const list: DeviceInfo[] = parseOnlineDevices(parsed);
         this.getUIContext().animateTo({ duration: ANIM_ENTER, curve: Curve.EaseOut }, () => {
           this.devices = list;
         });
@@ -275,7 +149,17 @@ export struct DevicePage {
         Column() {
           Scroll() {
             Column() {
-              this.RootEntries()
+              DeviceRootEntries({
+                activeSub: this.activeSub,
+                deviceId: this.deviceId,
+                bridgeConnected: this.bridgeConnected,
+                bridgeUrl: this.bridgeUrl,
+                loadingDevices: this.loadingDevices,
+                deviceCount: this.devices.length,
+                onOpen: (id: string) => {
+                  this.openSub(id);
+                },
+              })
             }
             .width('100%')
             .padding({ left: 16, right: 16, top: 76, bottom: 174 })
@@ -287,9 +171,6 @@ export struct DevicePage {
           .onDidScroll((xOffset: number, yOffset: number, state: ScrollState) => {
             handleNavOnScroll(state);
           })
-          .onAppear(() => {
-            this.maybeAutoConnect();
-          })
         }
         .width('100%')
         .height('100%')
@@ -349,61 +230,58 @@ export struct DevicePage {
     })
   }
 
-  /** 二级页面路由表 */
+  /**
+   * 二级页面路由表。
+   * 每个面板自带 SubPageLayer 外壳（标题/所属 Tab/返回/刷新），这里只做分发。
+   */
   @Builder
   SubDestination(name: string, param: object) {
     NavDestination() {
       if (name === SUB_LOCAL) {
-        SubPageLayer({
-          title: '本机设备',
-          tab: 2,
+        DeviceLocalPane({
+          deviceId: this.deviceId,
+          authorized: this.authorized,
           onBack: () => {
             this.closeSub();
           },
-        }) {
-          this.LocalDeviceContent()
-        }
+          onToggleAuth: (on: boolean) => {
+            this.toggleAuthorized(on);
+          },
+        })
       } else if (name === SUB_CAPS) {
-        SubPageLayer({
-          title: '设备能力',
-          tab: 2,
+        DeviceCapsPane({
           onBack: () => {
             this.closeSub();
           },
-        }) {
-          this.CapsContent()
-        }
+        })
       } else if (name === SUB_GATEWAY) {
-        SubPageLayer({
-          title: '设备通道',
-          tab: 2,
+        DeviceGatewayPane({
+          bridgeUrl: this.bridgeUrl,
+          bridgeToken: this.bridgeToken,
+          bridgeConnected: this.bridgeConnected,
           onBack: () => {
             this.closeSub();
           },
-        }) {
-          this.GatewayContent()
-        }
-      } else if (name === SUB_LIST) {
-        SubPageLayer({
-          title: '接入的设备',
-          tab: 2,
-          onBack: () => {
-            this.closeSub();
-          },
-          showRefresh: true,
           onRefresh: () => {
             this.refreshDevices();
           },
-        }) {
-          this.OnlineDevicesContent()
-        }
+        })
+      } else if (name === SUB_LIST) {
+        DeviceListPane({
+          devices: this.devices,
+          onBack: () => {
+            this.closeSub();
+          },
+          onRefresh: () => {
+            this.refreshDevices();
+          },
+        })
       }
     }
     .hideTitleBar(true)
     .backgroundColor(Color.Transparent)
   }
 
-
   @Builder
   Toast() {
     if (this.toastMsg.length > 0) {
@@ -424,269 +302,6 @@ export struct DevicePage {
         .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut }))
     }
   }
-
-  // ===================== 一级入口列表 =====================
-
-  @Builder
-  RootEntries() {
-    NavGroup({ caption: '本机' }) {
-      NavRow({
-        icon: $r('app.media.ic_phone'),
-        title: '本机设备',
-        subtitle: this.deviceId.length > 0 ? this.deviceId : '未注册',
-        value: this.bridgeConnected ? '在线' : '离线',
-        selected: this.isWide && this.activeSub === SUB_LOCAL,
-        onTap: () => {
-          this.openSub(SUB_LOCAL);
-        },
-      })
-      NavRow({
-        icon: $r('app.media.ic_bolt'),
-        title: '设备能力',
-        subtitle: this.capsCount().toString() + ' 项能力',
-        value: '',
-        showDivider: false,
-        selected: this.isWide && this.activeSub === SUB_CAPS,
-        onTap: () => {
-          this.openSub(SUB_CAPS);
-        },
-      })
-    }
-
-    NavGroup({ caption: '通道' }) {
-      NavRow({
-        icon: $r('app.media.ic_gateway'),
-        title: '设备通道',
-        subtitle: this.bridgeUrl.length > 0 ? '网关已配置' : '未配置',
-        value: this.bridgeConnected ? '已连接' : '未连接',
-        selected: this.isWide && this.activeSub === SUB_GATEWAY,
-        onTap: () => {
-          this.openSub(SUB_GATEWAY);
-        },
-      })
-      NavRow({
-        icon: $r('app.media.ic_devices_multi'),
-        title: '接入的设备',
-        subtitle: this.loadingDevices ? '加载中...' : '当前在线',
-        value: this.devices.length.toString() + ' 台',
-        showDivider: false,
-        selected: this.isWide && this.activeSub === SUB_LIST,
-        onTap: () => {
-          this.openSub(SUB_LIST);
-        },
-      })
-    }
-  }
-
-  private capsCount(): number {
-    return LOCAL_CAPS.length;
-  }
-
-  // ===================== 二级：本机设备 =====================
-
-  @Builder
-  LocalDeviceContent() {
-    PlainCard({ caption: '基本信息' }) {
-      this.KvRow('设备 ID', this.deviceId.length > 0 ? this.deviceId : '未注册')
-      this.KvRow('名称', 'HomeAgent OHOS')
-      this.KvRow('类型', 'phone')
-    }
-
-    PlainCard({ caption: '权限控制' }) {
-      Row() {
-        Column({ space: 2 }) {
-          Text('允许 agent 控制本机')
-            .fontSize(14)
-            .fontColor(this.palette().textPrimary)
-          Text('授权后 agent 可调用下方能力；截屏仅捕获本应用画面，剪贴板读取需系统弹窗确认。')
-            .fontSize(11)
-            .fontColor(this.palette().textMuted)
-            .margin({ top: 4 })
-        }
-        .layoutWeight(1)
-        .alignItems(HorizontalAlign.Start)
-
-        Toggle({ type: ToggleType.Switch, isOn: this.authorized })
-          .selectedColor(this.palette().accent)
-          .onChange((on: boolean) => {
-            this.toggleAuthorized(on);
-          })
-      }
-      .width('100%')
-      .alignItems(VerticalAlign.Center)
-
-      Row() {
-        Circle({ width: 8, height: 8 })
-          .fill(this.authorized ? '#17A964' : '#E84026')
-          .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut })
-          .margin({ right: 8 })
-        Text(this.authorized ? '已授权 — agent 可远程调用能力' : '未授权 — agent 将拒绝远程命令')
-          .fontSize(12)
-          .fontColor(this.authorized ? '#17A964' : this.palette().textMuted)
-          .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut })
-      }
-      .width('100%')
-      .margin({ top: 12 })
-      .padding({ left: 4 })
-    }
-  }
-
-  // ===================== 二级：设备能力 =====================
-
-  @Builder
-  CapsContent() {
-    PlainCard({ caption: '能力清单' }) {
-      Text('agent 通过设备桥可调用的本机能力：')
-        .fontSize(12)
-        .fontColor(this.palette().textMuted)
-        .margin({ bottom: 10 })
-
-      Flex({ wrap: FlexWrap.Wrap }) {
-        ForEach(LOCAL_CAPS, (cap: string) => {
-          Text(cap)
-            .fontSize(11)
-            .fontColor(this.palette().accent)
-            .padding({ left: 8, right: 8, top: 4, bottom: 4 })
-            .borderRadius(999)
-            .backgroundColor(this.palette().bgHover)
-            .border({ width: 1, color: this.palette().glassBorder })
-            .margin({ right: 6, bottom: 6 })
-        }, (cap: string) => cap)
-      }
-      .width('100%')
-    }
-  }
-
-  // ===================== 二级：设备通道 =====================
-
-  @Builder
-  GatewayContent() {
-    PlainCard({ caption: '连接信息' }) {
-      this.KvRow('网关地址', this.bridgeUrl.length > 0 ? this.bridgeUrl : '-')
-      this.KvRow('Token', this.bridgeToken.length > 0 ? '已从连接继承' : '未配置')
-      this.KvRow('状态', this.bridgeConnected ? '已连接' : '未连接')
-    }
-
-    if (this.lastError.length > 0) {
-      Text(this.lastError)
-        .fontSize(12)
-        .fontColor('#E84026')
-        .padding({ left: 4 })
-        .transition(TransitionEffect.OPACITY
-          .combine(TransitionEffect.translate({ y: -8 }))
-          .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut }))
-    }
-
-    PlainCard({ caption: '操作' }) {
-      Row() {
-        // 缩放反馈由 MotionBase 统一；连接态的底色/字色切换仍需按钮自己缓动，
-        // 因为父容器的 .animation() 到不了子节点。
-        MotionBase({ pressEnabled: true, fillWidth: false }) {
-          Button(this.bridgeConnected ? '断开' : '连接网关')
-            .height(34)
-            .fontSize(12)
-            .backgroundColor(this.bridgeConnected ? Color.Transparent : this.palette().accent)
-            .fontColor(this.bridgeConnected ? this.palette().textSecondary : Color.White)
-            .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
-            .border({
-              width: this.bridgeConnected ? 1 : 0,
-              color: this.palette().btnGhostBorder,
-            })
-            .onClick(() => {
-              if (this.bridgeConnected) {
-                deviceBridge.disconnect();
-              } else {
-                this.connectBridge();
-              }
-            })
-        }
-        Blank()
-        MotionBase({ pressEnabled: true, fillWidth: false }) {
-          Button('刷新设备')
-            .height(34)
-            .fontSize(12)
-            .backgroundColor(Color.Transparent)
-            .border({ width: 1, color: this.palette().btnGhostBorder })
-            .fontColor(this.palette().textSecondary)
-            .onClick(() => {
-              this.refreshDevices();
-            })
-        }
-      }
-      .width('100%')
-
-      Text('进入本页自动连接；断开后每 5 秒自动重连。hello 登记能力与授权状态，bind 携带 Token 完成身份绑定。')
-        .fontSize(11)
-        .fontColor(this.palette().textMuted)
-        .margin({ top: 10 })
-    }
-  }
-
-  // ===================== 二级：接入的设备 =====================
-
-  @Builder
-  OnlineDevicesContent() {
-    if (this.devices.length === 0) {
-      Text('暂无其他设备。电脑 GUI 或 CLI 连接同一网关后会出现在这里。')
-        .fontSize(12)
-        .fontColor(this.palette().textMuted)
-        .padding({ left: 4 })
-        .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
-    }
-
-    ForEach(this.devices, (dev: DeviceInfo) => {
-      // PlainCard 是自定义组件，transition 不能直接挂在它上面（会生成 __Common__ 包装），
-      // 所以用一个无 padding、满宽的 Column 承载入场动画，布局不受影响。
-      Column() {
-        PlainCard({ caption: '' }) {
-          Row() {
-            Circle({ width: 8, height: 8 })
-              .fill(dev.online ? '#17A964' : '#77809A')
-              .margin({ right: 10 })
-            Column() {
-              Text(dev.name.length > 0 ? dev.name : dev.deviceId)
-                .fontSize(14)
-                .fontColor(this.palette().textPrimary)
-              Text(dev.kind + (dev.authorized ? ' · 已授权' : ' · 未授权'))
-                .fontSize(11)
-                .fontColor(dev.authorized ? '#17A964' : this.palette().textMuted)
-            }
-            .layoutWeight(1)
-            .alignItems(HorizontalAlign.Start)
-
-            Text(dev.caps.length.toString() + ' 能力')
-              .fontSize(10)
-              .fontColor(this.palette().textMuted)
-          }
-          .width('100%')
-        }
-      }
-      .width('100%')
-      .transition(TransitionEffect.OPACITY
-        .combine(TransitionEffect.translate({ y: 12 }))
-        .animation({ duration: ANIM_ENTER, curve: Curve.EaseOut }))
-    }, (dev: DeviceInfo) => dev.deviceId + dev.online.toString())
-  }
-
-  // ===================== 通用 KV 行 =====================
-
-  @Builder
-  KvRow(k: string, v: string) {
-    Row() {
-      Text(k)
-        .fontSize(13)
-        .fontColor(this.palette().textSecondary)
-      Blank()
-      Text(v)
-        .fontSize(13)
-        .fontColor(this.palette().textPrimary)
-        .maxLines(1)
-        .textOverflow({ overflow: TextOverflow.Ellipsis })
-    }
-    .width('100%')
-    .padding({ top: 8, bottom: 8 })
-    .border({ width: { bottom: 1 }, color: this.palette().kvBorder })
-  }
 }
 
 const RADIUS_MD: number = 10;

cmd/ohos/HomeAgent/entry/src/main/ets/pages/Index.ets

@@ -11,7 +11,9 @@ import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, WIDE_MIN_WIDTH, WIDE_NAV_BAR
 import { ANIM_NORMAL, ANIM_SLOW } from '../common/Constants';
 import { MotionBase } from '../components/MotionBase';
 import { GradientBackground } from '../components/GradientBackground';
-import { registerScreensueHandler, installCmdRouter } from '../common/BridgeRouter';
+import { ScreensuePage } from '../components/ScreensuePage';
+import { registerScreensueHandler } from '../common/BridgeRouter';
+import { markForegroundBridgeUIReady } from '../common/DeviceBridgeSession';
 import { ScreensuePayload, snapshotComponentId } from '../common/BridgeCaps';
 import { window, display } from '@kit.ArkUI';
 import { common } from '@kit.AbilityKit';
@@ -110,14 +112,14 @@ struct Index {
     this.syncSystemBar();
     // 动态读取状态栏/导航栏避让区，实现真正的沉浸式布局（替换硬编码 top:44）
     this.resolveSafeArea();
-    // 设备桥：注册命令路由与 screensue 悬浮层回调
-    installCmdRouter();
+    // 根 UI 只负责 screensue 呈现；命令路由由前台全局设备桥安装。
     registerScreensueHandler((payload: ScreensuePayload) => {
       this.showScreensue(payload);
     });
+    markForegroundBridgeUIReady(getContext(this) as common.UIAbilityContext);
   }
 
-  /** agent 下发的 screensue 内容展示（悬浮卡片，倒计时自动关闭；0=常驻）。 */
+  /** agent 下发的 screensue 内容展示（窄屏整页、宽屏右栏；0=常驻）。 */
   private showScreensue(payload: ScreensuePayload): void {
     this.screensueText = payload.content;
     this.screensueCountdown = payload.duration;
@@ -218,7 +220,7 @@ struct Index {
   private updateWideScreen(w: number): void {
     const wide: boolean = w >= WIDE_MIN_WIDTH;
     if (wide !== this.isWide) {
-      AppStorage.setOrCreate<boolean>('isWideScreen', wide);
+      AppStorage.set<boolean>('isWideScreen', wide);
     }
   }
 
@@ -230,6 +232,10 @@ struct Index {
    * 的根因。这里按 currentTab 显式选栈，行为对所有页面一致。
    */
   onBackPress(): boolean {
+    if (this.screensueVisible) {
+      this.closeScreensue();
+      return true;
+    }
     return handleBackPress(this.currentTab, this.isWide);
   }
 
@@ -339,51 +345,42 @@ struct Index {
       // 导航栏本身不吃触摸空白区，避免遮住下层内容点击
       .hitTestBehavior(HitTestMode.Transparent)
 
-      // screensue 悬浮层：agent 推送给用户看的内容（置顶展示）
+      // screensue 是前台内容页：窄屏覆盖整页；宽屏仅覆盖右侧内容栏，
+      // 左侧一级页面与主导航保持可见、可操作。
       if (this.screensueVisible) {
-        Column() {
+        if (this.isWide) {
           Row() {
-            Circle({ width: 8, height: 8 })
-              .fill(this.palette().accent)
-            Text('agent 推送')
-              .fontSize(12)
-              .fontWeight(FontWeight.Medium)
-              .fontColor(this.palette().textSecondary)
-              .margin({ left: 8 })
-            Blank()
-            if (this.screensueCountdown > 0) {
-              Text(this.screensueCountdown.toString() + 's')
-                .fontSize(11)
-                .fontColor(this.palette().textMuted)
-            }
-            Text('关闭')
-              .fontSize(12)
-              .fontColor(this.palette().accent)
-              .padding({ left: 10, right: 2, top: 4, bottom: 4 })
-              .onClick(() => {
+            Column()
+              .width(WIDE_NAV_BAR_WIDTH)
+              .height('100%')
+              .hitTestBehavior(HitTestMode.None)
+
+            ScreensuePage({
+              pushedText: this.screensueText,
+              countdown: this.screensueCountdown,
+              onClose: () => {
                 this.closeScreensue();
-              })
+              },
+            })
+              .layoutWeight(1)
+              .height('100%')
+              .padding({ top: this.topInset })
           }
           .width('100%')
-          .margin({ bottom: 10 })
-
-          Scroll() {
-            Text(this.screensueText)
-              .fontSize(15)
-              .fontColor(this.palette().textPrimary)
-              .width('100%')
-          }
-          .constraintSize({ maxHeight: 320 })
-          .scrollBar(BarState.Auto)
-          .align(Alignment.Top)
+          .height('100%')
+          .hitTestBehavior(HitTestMode.Transparent)
+        } else {
+          ScreensuePage({
+            pushedText: this.screensueText,
+            countdown: this.screensueCountdown,
+            onClose: () => {
+              this.closeScreensue();
+            },
+          })
+            .width('100%')
+            .height('100%')
+            .padding({ top: this.topInset })
         }
-        .width('86%')
-        .padding(18)
-        .borderRadius(18)
-        .backgroundColor(this.palette().bgCard)
-
-        .border({ width: 1, color: this.palette().glassBorder })
-        .shadow({ radius: 32, color: this.palette().shadow, offsetY: 10 })
       }
     }
     .width('100%')

cmd/ohos/HomeAgent/entry/src/main/ets/pages/PluginsPage.ets

@@ -1,24 +1,26 @@
 import { apiClient } from '../common/ApiClient';
-import { userMessage, noConnectionMessage } from '../common/UserError';
+import { userMessage } from '../common/UserError';
 import { handleNavOnScroll } from '../common/NavBarController';
 import { registerNavStack, unregisterNavStack } from '../common/NavStackRegistry';
 import { PluginRow, PluginDetail, emptyPluginDetail } from '../model/Model';
 import { ThemePalette, DARK_PALETTE, LIGHT_PALETTE, WIDE_NAV_BAR_WIDTH, WIDE_MIN_CONTENT } from '../common/Constants';
-import { RADIUS_LG, RADIUS_MD, RADIUS_SM, RADIUS_PILL, COLOR_ERROR } from '../common/Constants';
-import { ANIM_FAST, ANIM_NORMAL, ANIM_ENTER } from '../common/Constants';
-import { MotionBase } from '../components/MotionBase';
-import { PageTopBar, NavFloatOverlay, NavFloatRow, GlassShell, FloatIconButton } from '../components/PageTopBar';
-import { SubPageLayer, PlainCard, markSubPageOpen, subPageParam } from '../components/SubPage';
-import { SettingsEditor } from '../components/SettingsEditor';
-
-interface InstallBody {
-  url: string;
-}
+import { ANIM_NORMAL, ANIM_ENTER } from '../common/Constants';
+import { PageTopBar, NavFloatOverlay, NavFloatRow, FloatIconButton } from '../components/PageTopBar';
+import { SubPageLayer, markSubPageOpen, subPageParam } from '../components/SubPage';
+import { PluginDetailPane } from '../components/PluginDetailPane';
+import { PluginListView } from '../components/PluginListView';
+import { PluginInstallForm } from '../components/PluginsOverlays';
+import { ToastBar } from '../components/ToastBar';
+import { fetchPluginRows, fetchPluginDetail } from '../common/PluginApi';
 
 /** 二级页面标识：插件详情 */
 const SUB_NONE: string = '';
 const SUB_DETAIL: string = 'detail';
 
+interface InstallBody {
+  url: string;
+}
+
 @Component
 export struct PluginsPage {
   @StorageProp('themeIsDark') private isDark: boolean = true;
@@ -58,134 +60,14 @@ export struct PluginsPage {
     return this.isDark ? DARK_PALETTE : LIGHT_PALETTE;
   }
 
-  /**
-   * 数据源对齐 WebGUI renderPlugins：
-   *  - GET /kernel          → plugins[{name,loaded}]（含全部内置插件）+ tools（按 plugin 归属）
-   *  - GET /plugins         → 已安装外部插件元数据（version/description 等）
-   *  - GET /plugins/disabled → {disabled:[{name,...}]}
-   * 三方按名称合并去重排序。
-   */
+  /** 取数口径见 common/PluginApi.ets；这里只负责把结果落到 @State。 */
   private async loadPlugins(): Promise<void> {
     if (!apiClient.hasConnection()) {
       return;
     }
     this.loading = true;
     try {
-      // ---- kernel: loaded plugins + tool ownership ----
-      const kResp = await apiClient.getWithTimeout('/kernel', 12000);
-      const kernelObj: Record<string, Object> = JSON.parse(kResp.body) as Record<string, Object>;
-      const loadedMap: Map<string, boolean> = new Map<string, boolean>();
-      const kpRaw: Object | undefined = kernelObj['plugins'];
-      if (kpRaw !== undefined && kpRaw !== null) {
-        const kpArr: Object[] = kpRaw as Object[];
-        for (let i = 0; i < kpArr.length; i++) {
-          const item: Record<string, Object> = kpArr[i] as Record<string, Object>;
-          const n: string = item['name'] as string ?? '';
-          if (n.length === 0) {
-            continue;
-          }
-          loadedMap.set(n, item['loaded'] as boolean ?? true);
-        }
-      }
-      const toolsByPlugin: Map<string, string[]> = new Map<string, string[]>();
-      const tRaw: Object | undefined = kernelObj['tools'];
-      if (tRaw !== undefined && tRaw !== null) {
-        const tArr: Object[] = tRaw as Object[];
-        for (let i = 0; i < tArr.length; i++) {
-          const item: Record<string, Object> = tArr[i] as Record<string, Object>;
-          const tn: string = item['name'] as string ?? '';
-          const owner: string = item['plugin'] as string ?? '';
-          if (tn.length === 0 || owner.length === 0) {
-            continue;
-          }
-          let list: string[] | undefined = toolsByPlugin.get(owner);
-          if (list === undefined) {
-            list = [];
-            toolsByPlugin.set(owner, list);
-          }
-          // 每插件最多展示 8 个工具名，避免卡片过长
-          if (list.length < 8) {
-            list.push(tn);
-          }
-        }
-      }
-
-      // ---- installed external plugins metadata ----
-      const externalMeta: Map<string, Record<string, Object>> = new Map<string, Record<string, Object>>();
-      try {
-        const pResp = await apiClient.getWithTimeout('/plugins', 10000);
-        const bodyTrim = pResp.body.trim();
-        let arr: Object[] = [];
-        if (bodyTrim.length > 0 && bodyTrim.charAt(0) === '[') {
-          arr = JSON.parse(pResp.body) as Object[];
-        } else {
-          const obj: Record<string, Object> = JSON.parse(pResp.body) as Record<string, Object>;
-          const rawList: Object = obj['plugins'] ?? obj['data'];
-          if (rawList !== undefined && rawList !== null) {
-            arr = rawList as Object[];
-          }
-        }
-        for (let i = 0; i < arr.length; i++) {
-          const item: Record<string, Object> = arr[i] as Record<string, Object>;
-          const n: string = item['name'] as string ?? '';
-          if (n.length > 0) {
-            externalMeta.set(n, item);
-          }
-        }
-      } catch (e) {
-        // 外部列表失败不阻塞内置展示
-      }
-
-      // ---- disabled list ----
-      const disabledNames: Set<string> = new Set<string>();
-      try {
-        const dResp = await apiClient.getWithTimeout('/plugins/disabled', 8000);
-        const dObj: Record<string, Object> = JSON.parse(dResp.body) as Record<string, Object>;
-        const dArr: Object | undefined = dObj['disabled'];
-        if (dArr !== undefined && dArr !== null) {
-          const items: Object[] = dArr as Object[];
-          for (let di = 0; di < items.length; di++) {
-            const dItem: Record<string, Object> = items[di] as Record<string, Object>;
-            const dn: string = dItem['name'] as string ?? '';
-            if (dn.length > 0) {
-              disabledNames.add(dn);
-            }
-          }
-        }
-      } catch (e) {
-        // disabled endpoint may not exist; ignore
-      }
-
-      // ---- merge: allNames sorted（与 GUI 一致）----
-      const allNames: Set<string> = new Set<string>();
-      loadedMap.forEach((v: boolean, k: string) => {
-        allNames.add(k);
-      });
-      externalMeta.forEach((v: Record<string, Object>, k: string) => {
-        allNames.add(k);
-      });
-      disabledNames.forEach((n: string) => {
-        allNames.add(n);
-      });
-      const names: string[] = Array.from(allNames);
-      names.sort();
-
-      const rows: PluginRow[] = [];
-      for (let i = 0; i < names.length; i++) {
-        const name: string = names[i];
-        const meta: Record<string, Object> | undefined = externalMeta.get(name);
-        const tools: string[] | undefined = toolsByPlugin.get(name);
-        const row: PluginRow = {
-          name: name,
-          loaded: loadedMap.get(name) ?? false,
-          disabled: disabledNames.has(name),
-          external: externalMeta.has(name),
-          version: meta !== undefined ? meta['version'] as string ?? '' : '',
-          description: meta !== undefined ? meta['description'] as string ?? '' : '',
-          tools: tools,
-        };
-        rows.push(row);
-      }
+      const rows: PluginRow[] = await fetchPluginRows();
       // 列表整体重建（ForEach key 含 loaded/disabled，启停会整行重挂载）：
       // 放进 animateTo 让新旧行走 transition 交叉淡入，而不是硬切一帧。
       this.getUIContext().animateTo({ duration: ANIM_ENTER, curve: Curve.EaseOut }, () => {
@@ -199,20 +81,6 @@ export struct PluginsPage {
     });
   }
 
-  /** 徽标状态：与 GUI 一致 —— 已加载绿 / 禁用待生效黄 / 已禁用红 / 未加载灰。 */
-  private statusOf(plugin: PluginRow): string {
-    if (plugin.loaded && !plugin.disabled) {
-      return 'loaded'; // 已加载
-    }
-    if (plugin.loaded && plugin.disabled) {
-      return 'pending'; // 运行中(禁用待生效)
-    }
-    if (plugin.disabled) {
-      return 'disabled'; // 已禁用
-    }
-    return 'notloaded'; // 未加载
-  }
-
   private async togglePlugin(plugin: PluginRow): Promise<void> {
     const name: string = plugin.name;
     const action: string = plugin.disabled ? 'enable' : 'disable';
@@ -280,29 +148,14 @@ export struct PluginsPage {
   }
 
   /**
-   * GET /plugins/{name} —— 后端返回插件清单字段。
-   * WebGUI 只是把它 JSON.stringify 进 <pre>，这里逐字段结构化展示。
+   * 详情数据落地。
    * 内置插件不在 /plugins 里，取不到详情时退回用列表已有的信息。
    */
   private async loadDetail(name: string): Promise<void> {
     this.detailLoading = true;
     this.detailError = '';
     try {
-      const resp = await apiClient.getWithTimeout('/plugins/' + name, 10000);
-      const o: Record<string, Object> = JSON.parse(resp.body) as Record<string, Object>;
-      const d: PluginDetail = emptyPluginDetail();
-      d.name = o['name'] as string ?? name;
-      d.version = o['version'] as string ?? '';
-      d.description = o['description'] as string ?? '';
-      d.author = o['author'] as string ?? '';
-      d.license = o['license'] as string ?? '';
-      d.homepage = o['homepage'] as string ?? '';
-      d.repository = o['repository'] as string ?? '';
-      d.entry = o['entry'] as string ?? '';
-      d.minVersion = o['min_version'] as string ?? '';
-      d.deprecated = o['deprecated'] as boolean ?? false;
-      d.tags = this.strArray(o['tags']);
-      d.files = this.strArray(o['files']);
+      const d: PluginDetail = await fetchPluginDetail(name);
       // 详情字段一次性落地：条件卡片在 animateTo 帧内挂载，V1 给它们默认透明度过渡
       this.getUIContext().animateTo({ duration: ANIM_ENTER, curve: Curve.EaseOut }, () => {
         this.detail = d;
@@ -327,21 +180,6 @@ export struct PluginsPage {
     });
   }
 
-  private strArray(raw: Object | undefined): string[] {
-    const out: string[] = [];
-    if (raw === undefined || raw === null) {
-      return out;
-    }
-    const arr: Object[] = raw as Object[];
-    for (let i = 0; i < arr.length; i++) {
-      const s: string = arr[i] as string ?? '';
-      if (s.length > 0) {
-        out.push(s);
-      }
-    }
-    return out;
-  }
-
   private findRow(name: string): PluginRow | null {
     for (let i = 0; i < this.plugins.length; i++) {
       if (this.plugins[i].name === name) {
@@ -387,8 +225,15 @@ export struct PluginsPage {
         Column() {
           Scroll() {
             Column() {
-              this.ListStates()
-              this.PluginList()
+              PluginListView({
+                plugins: this.plugins,
+                busy: this.loading,
+                activeName: this.activeName,
+                hasConn: apiClient.hasConnection(),
+                onSelect: (name: string) => {
+                  this.openDetail(name);
+                },
+              })
             }
             .width('100%')
             .padding({ left: 16, right: 16, top: 76, bottom: 174 })
@@ -411,7 +256,15 @@ export struct PluginsPage {
         // 安装表单以悬浮卡形式浮在按钮上方，不再占用列表顶部一行。
         NavFloatOverlay({ tab: 1 }) {
           if (this.showInstallForm) {
-            this.InstallForm()
+            PluginInstallForm({
+              url: this.installUrl,
+              onUrlChange: (v: string) => {
+                this.installUrl = v;
+              },
+              onInstall: () => {
+                this.installPlugin();
+              },
+            })
           }
           NavFloatRow() {
             FloatIconButton({
@@ -441,7 +294,7 @@ export struct PluginsPage {
           }
         }
 
-        this.Toast()
+        ToastBar({ msg: this.toastMsg, isError: this.toastIsError, bordered: true })
       }
       .width('100%')
       .height('100%')
@@ -493,503 +346,29 @@ export struct PluginsPage {
             this.loadDetail(this.activeName);
           },
         }) {
-          this.DetailContent()
+          PluginDetailPane({
+            detail: this.detail,
+            activeName: this.activeName,
+            busy: this.detailLoading,
+            errorText: this.detailError,
+            row: this.activeRow() ?? undefined,
+            onToggle: () => {
+              const r: PluginRow | null = this.activeRow();
+              if (r !== null) {
+                this.togglePlugin(r);
+              }
+            },
+            onRemove: () => {
+              const r: PluginRow | null = this.activeRow();
+              if (r !== null) {
+                this.removePlugin(r);
+              }
+            },
+          })
         }
       }
     }
     .hideTitleBar(true)
     .backgroundColor(Color.Transparent)
   }
-
-  /** 安装表单：悬浮在安装按钮上方的一张玻璃卡（点悬浮按钮开合） */
-  @Builder
-  InstallForm() {
-    Row() {
-      TextInput({ placeholder: '.hmap 包下载 URL', text: this.installUrl })
-        .layoutWeight(1)
-        .height(36)
-        .fontSize(14)
-        .fontColor(this.palette().textPrimary)
-        .placeholderColor(this.palette().textMuted)
-        .backgroundColor(this.palette().bgInput)
-        .borderRadius(RADIUS_SM)
-        .border({ width: 1, color: this.palette().border })
-        .onChange((v: string) => {
-          this.installUrl = v;
-        })
-      Button('安装')
-        .height(36)
-        .fontSize(12)
-        .backgroundColor(this.palette().accent)
-        .fontColor('#FFFFFF')
-        .margin({ left: 6 })
-        .onClick(() => {
-          this.installPlugin();
-        })
-    }
-    .width('100%')
-    .padding(10)
-    .margin({ bottom: 10 })
-    .backgroundColor(this.palette().navBarBg)
-    .borderRadius(RADIUS_MD)
-    .border({ width: 1, color: this.palette().navBarBorder })
-    .shadow({ radius: 20, color: this.palette().shadow, offsetY: 6 })
-    .alignItems(VerticalAlign.Center)
-    .transition(TransitionEffect.OPACITY
-      .combine(TransitionEffect.translate({ y: 12 }))
-      .animation({ duration: ANIM_ENTER, curve: Curve.EaseOut }))
-  }
-
-  /** 加载中 / 未配置 / 空列表三种占位态 */
-  @Builder
-  ListStates() {
-    if (this.loading && this.plugins.length === 0) {
-      LoadingProgress()
-        .width(32)
-        .height(32)
-        .color(this.palette().accent)
-        .margin({ top: 40 })
-        .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
-    }
-
-    if (!apiClient.hasConnection()) {
-      Text(noConnectionMessage())
-        .fontSize(13)
-        .fontColor(this.palette().textMuted)
-        .padding(20)
-        .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
-    }
-
-    if (!this.loading && this.plugins.length === 0 && apiClient.hasConnection()) {
-      Text('暂无已加载插件')
-        .fontSize(13)
-        .fontColor(this.palette().textMuted)
-        .padding(20)
-        .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
-    }
-  }
-
-  /**
-   * 一级列表：每个插件一张紧凑卡（名称 + 状态徽标 + 右尖角）。
-   * 描述、工具清单、启停/卸载操作全部下沉到详情页 —— 列表只负责选择。
-   */
-  @Builder
-  PluginList() {
-    ForEach(this.plugins, (plugin: PluginRow) => {
-      // 外层 Column 只为承载 transition：.transition() 不能直接挂在自定义组件
-      // 调用点上（会生成 __Common__ 包装节点）。按压缩放由 MotionBase 统一提供，
-      // 每行自带独立按压态，不再需要 pressedName 这种"哪一行被按"的手工记账。
-      Column() {
-        MotionBase({ pressEnabled: true }) {
-          Row() {
-            Column({ space: 3 }) {
-              Row({ space: 6 }) {
-                Text(plugin.name)
-                  .fontSize(15)
-                  .fontWeight(this.activeName === plugin.name ? FontWeight.Medium : FontWeight.Normal)
-                  .fontColor(this.activeName === plugin.name
-                    ? this.palette().accent : this.palette().textPrimary)
-                  .maxLines(1)
-                  .textOverflow({ overflow: TextOverflow.Ellipsis })
-                  .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
-                if (plugin.version !== undefined && plugin.version.length > 0) {
-                  Text('v' + plugin.version)
-                    .fontSize(10)
-                    .fontColor(this.palette().textMuted)
-                }
-              }
-              // 徽标全部去掉（用户要求）：状态用一个 3vp 圆点表达，
-              // 其余信息退化为一行灰字副标题 —— 列表只负责"选谁"，细节看详情页。
-              Row({ space: 6 }) {
-                Circle({ width: 6, height: 6 })
-                  .fill(this.statusDotColor(plugin))
-                Text(this.rowSubtitle(plugin))
-                  .fontSize(11)
-                  .fontColor(this.palette().textMuted)
-                  .maxLines(1)
-                  .textOverflow({ overflow: TextOverflow.Ellipsis })
-                  .layoutWeight(1)
-              }
-              .width('100%')
-              .alignItems(VerticalAlign.Center)
-            }
-            .layoutWeight(1)
-            .alignItems(HorizontalAlign.Start)
-
-            Image($r('app.media.ic_chevron_right'))
-              .width(15)
-              .height(15)
-              .fillColor(this.activeName === plugin.name
-                ? this.palette().accent : this.palette().textMuted)
-              .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
-              .draggable(false)
-          }
-          .width('100%')
-          .padding(14)
-          .borderRadius(RADIUS_LG)
-          .backgroundColor(this.activeName === plugin.name
-            ? this.palette().accentBg : this.palette().bgCard)
-          .border({
-            width: 1,
-            color: this.activeName === plugin.name
-              ? this.palette().accent : this.palette().glassBorder,
-          })
-          // 选中态的底色/描边渐变：MotionBase 的 .animation() 到不了这里
-          .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
-          .alignItems(VerticalAlign.Center)
-          .onClick(() => {
-            this.openDetail(plugin.name);
-          })
-        }
-      }
-      .width('100%')
-      .margin({ bottom: 10 })
-      // ForEach key 含 loaded/disabled：启停会整行重挂载，靠 transition 变成交叉淡入
-      .transition(TransitionEffect.OPACITY
-        .combine(TransitionEffect.translate({ y: 12 }))
-        .animation({ duration: ANIM_ENTER, curve: Curve.EaseOut }))
-    }, (plugin: PluginRow) => plugin.name + (plugin.loaded ? 'L' : '') + (plugin.disabled ? 'D' : ''))
-  }
-
-  /**
-   * 二级页面：插件详情。
-   * WebGUI 这里只有一个 JSON.stringify 的 <pre>，
-   * 移植时改成结构化卡片：状态 / 清单字段 / 工具 / 操作。
-   */
-  @Builder
-  DetailContent() {
-    if (this.detailLoading) {
-      Row() {
-        LoadingProgress()
-          .width(26)
-          .height(26)
-          .color(this.palette().accent)
-      }
-      .width('100%')
-      .justifyContent(FlexAlign.Center)
-      .padding({ top: 30, bottom: 30 })
-      .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
-    }
-
-    if (this.detailError.length > 0) {
-      Text(this.detailError)
-        .fontSize(12)
-        .fontColor(COLOR_ERROR)
-        .padding({ left: 4, bottom: 12 })
-        .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
-    }
-
-    // 概览卡：名称、版本、状态徽标、描述
-    PlainCard({ caption: '概览' }) {
-      Row({ space: 8 }) {
-        Text(this.detail.name.length > 0 ? this.detail.name : this.activeName)
-          .fontSize(17)
-          .fontWeight(FontWeight.Bold)
-          .fontColor(this.palette().textPrimary)
-          .layoutWeight(1)
-          .maxLines(1)
-          .textOverflow({ overflow: TextOverflow.Ellipsis })
-        if (this.detail.version.length > 0) {
-          Text('v' + this.detail.version)
-            .fontSize(12)
-            .fontColor(this.palette().textSecondary)
-        }
-      }
-      .width('100%')
-      .margin({ bottom: 10 })
-
-      this.DetailBadges()
-
-      if (this.detail.description.length > 0) {
-        Text(this.detail.description)
-          .fontSize(13)
-          .fontColor(this.palette().textSecondary)
-          .width('100%')
-          .margin({ top: 10 })
-      }
-    }
-
-    // 清单卡：只有真拿到字段才出卡，否则会留一张空壳（内置插件没有清单文件）
-    if (this.hasManifest()) {
-      PlainCard({ caption: '清单' }) {
-        this.KvRow('作者', this.detail.author)
-        this.KvRow('许可证', this.detail.license)
-        this.KvRow('主页', this.detail.homepage)
-        this.KvRow('仓库', this.detail.repository)
-        this.KvRow('入口', this.detail.entry)
-        this.KvRow('最低内核版本', this.detail.minVersion)
-      }
-    }
-
-    if (this.detail.tags.length > 0) {
-      PlainCard({ caption: '标签' }) {
-        Flex({ wrap: FlexWrap.Wrap }) {
-          ForEach(this.detail.tags, (t: string) => {
-            Text(t)
-              .fontSize(10)
-              .fontColor('#4A90D9')
-              .padding({ left: 8, right: 8, top: 3, bottom: 3 })
-              .borderRadius(RADIUS_SM)
-              .backgroundColor(this.palette().frostSoftBg)
-              .margin({ right: 5, bottom: 5 })
-          }, (t: string) => t)
-        }
-      }
-    }
-
-    this.DetailTools()
-
-    // 插件配置：plugin.<name>.* 从后端 /settings?prefix= 取，就地编辑。
-    // 这些 key 属于插件本身，之前被平铺在「设置 → 后端配置」里，
-    // 现在归位到插件详情页 —— 「插件的设计页面就是插件的详情页」。
-    if (this.activeName.length > 0) {
-      PlainCard({ caption: '插件配置' }) {
-        SettingsEditor({
-          prefix: 'plugin.' + this.activeName + '.',
-          emptyHint: '该插件没有暴露可配置项',
-        })
-      }
-    }
-
-    if (this.detail.files.length > 0) {
-      PlainCard({ caption: '文件 (' + this.detail.files.length.toString() + ')' }) {
-        ForEach(this.detail.files, (f: string) => {
-          Text(f)
-            .fontSize(12)
-            .fontColor(this.palette().textSecondary)
-            .width('100%')
-            .maxLines(1)
-            .textOverflow({ overflow: TextOverflow.Ellipsis })
-            .margin({ bottom: 4 })
-        }, (f: string) => f)
-      }
-    }
-
-    this.DetailActions()
-  }
-
-  /** 详情页状态行：同样去掉徽标，一个状态点 + 一行纯文字 */
-  @Builder
-  DetailBadges() {
-    Row({ space: 6 }) {
-      Circle({ width: 7, height: 7 })
-        .fill(this.activeStatusColor())
-      Text(this.detailStatusLine())
-        .fontSize(12)
-        .fontColor(this.palette().textSecondary)
-        .layoutWeight(1)
-        .maxLines(1)
-        .textOverflow({ overflow: TextOverflow.Ellipsis })
-    }
-    .width('100%')
-    .alignItems(VerticalAlign.Center)
-  }
-
-  private detailStatusLine(): string {
-    const parts: string[] = [];
-    parts.push(this.activeStatusText());
-    parts.push(this.activeIsBuiltin() ? '内置' : '外部');
-    if (this.detail.deprecated) {
-      parts.push('已废弃');
-    }
-    const n: number = this.activeTools().length;
-    if (n > 0) {
-      parts.push(n.toString() + ' 个工具');
-    }
-    return parts.join(' · ');
-  }
-
-  /** 工具清单来自一级列表已合并的 kernel.tools（按 plugin 归属） */
-  @Builder
-  DetailTools() {
-    if (this.activeTools().length > 0) {
-      PlainCard({ caption: '注册的工具 (' + this.activeTools().length.toString() + ')' }) {
-        Flex({ wrap: FlexWrap.Wrap }) {
-          ForEach(this.activeTools(), (tool: string) => {
-            Text(tool)
-              .fontSize(11)
-              .fontColor('#4A90D9')
-              .padding({ left: 8, right: 8, top: 3, bottom: 3 })
-              .borderRadius(RADIUS_SM)
-              .backgroundColor(this.palette().frostSoftBg)
-              .margin({ right: 5, bottom: 5 })
-          }, (tool: string) => tool)
-        }
-      }
-    }
-  }
-
-  @Builder
-  DetailActions() {
-    if (this.activeName.length > 0) {
-      PlainCard({ caption: '操作' }) {
-        Row() {
-          Button(this.activeIsDisabled() ? '启用' : '禁用')
-            .height(34)
-            .fontSize(12)
-            .backgroundColor(Color.Transparent)
-            .border({
-              width: 1,
-              color: this.activeIsDisabled()
-                ? this.palette().btnGhostBorder : 'rgba(217, 154, 43, 0.5)',
-            })
-            .fontColor(this.activeIsDisabled()
-              ? this.palette().textSecondary : '#D99A2B')
-            .animation({ duration: ANIM_FAST, curve: Curve.EaseOut })
-            .onClick(() => {
-              const r: PluginRow | null = this.activeRow();
-              if (r !== null) {
-                this.togglePlugin(r);
-              }
-            })
-          Blank()
-          if (!this.activeIsBuiltin()) {
-            Button('卸载')
-              .height(34)
-              .fontSize(12)
-              .backgroundColor(Color.Transparent)
-              .border({ width: 1, color: 'rgba(232, 64, 38, 0.45)' })
-              .fontColor(COLOR_ERROR)
-              .onClick(() => {
-                const r: PluginRow | null = this.activeRow();
-                if (r !== null) {
-                  this.removePlugin(r);
-                }
-              })
-              .transition(TransitionEffect.OPACITY.animation({ duration: ANIM_FAST, curve: Curve.EaseOut }))
-          }
-        }
-        .width('100%')
-      }
-    }
-  }
-
-  // ---- 详情页取值助手：ArkTS 禁止非空断言，统一在这里做 null 收敛 ----
-
-  private hasManifest(): boolean {
-    return this.detail.author.length > 0 || this.detail.license.length > 0 ||
-      this.detail.homepage.length > 0 || this.detail.repository.length > 0 ||
-      this.detail.entry.length > 0 || this.detail.minVersion.length > 0;
-  }
-
-  private activeIsBuiltin(): boolean {
-    const r: PluginRow | null = this.activeRow();
-    return r !== null ? !r.external : false;
-  }
-
-  private activeIsDisabled(): boolean {
-    const r: PluginRow | null = this.activeRow();
-    return r !== null ? r.disabled : false;
-  }
-
-  private activeTools(): string[] {
-    const r: PluginRow | null = this.activeRow();
-    if (r === null) {
-      return [];
-    }
-    return r.tools ?? [];
-  }
-
-  private activeStatusText(): string {
-    const r: PluginRow | null = this.activeRow();
-    return r !== null ? this.statusBadgeText(r) : '未加载';
-  }
-
-  private activeStatusColor(): string {
-    const r: PluginRow | null = this.activeRow();
-    return r !== null ? this.statusBadgeColor(r) : this.palette().textMuted;
-  }
-
-  /** 明细行：值为空时整行不渲染，避免详情页出现一排 "-" */
-  @Builder
-  KvRow(label: string, value: string) {
-    if (value.length > 0) {
-      Row() {
-        Text(label)
-          .fontSize(13)
-          .fontColor(this.palette().textSecondary)
-          .layoutWeight(1)
-        Text(value)
-          .fontSize(13)
-          .fontColor(this.palette().textPrimary)
-          .textAlign(TextAlign.End)
-          .maxLines(2)
-          .textOverflow({ overflow: TextOverflow.Ellipsis })
-          .constraintSize({ maxWidth: 220 })
-          .margin({ left: 16 })
-      }
-      .width('100%')
-      .padding({ top: 8, bottom: 8 })
-      .alignItems(VerticalAlign.Top)
-    }
-  }
-
-  @Builder
-  Toast() {
-    if (this.toastMsg.length > 0) {
-      Row() {
-        Text(this.toastMsg)
-          .fontSize(13)
-          .fontColor(this.toastIsError ? this.palette().toastErrorText : this.palette().toastText)
-          .padding({ left: 20, right: 20, top: 10, bottom: 10 })
-          .borderRadius(RADIUS_MD)
-          .backgroundColor(this.toastIsError ? this.palette().toastErrorBg : this.palette().toastBg)
-          .border({
-            width: 1,
-            color: this.toastIsError ? 'rgba(232, 64, 38, 0.3)' : 'rgba(23, 169, 100, 0.3)',
-          })
-      }
-      .width('100%')
-      .justifyContent(FlexAlign.End)
-      .padding({ right: 20 })
-      .margin({ bottom: 166 })
-      .transition(TransitionEffect.OPACITY
-        .combine(TransitionEffect.translate({ y: 12 }))
-        .animation({ duration: ANIM_NORMAL, curve: Curve.EaseOut }))
-    }
-  }
-
-  /** 状态点颜色：绿=已加载，黄=待生效，红=已禁用，灰=未加载 */
-  private statusDotColor(plugin: PluginRow): string {
-    return this.statusBadgeColor(plugin);
-  }
-
-  /** 列表行副标题：状态 + 内置/外部 + 工具数，一行灰字，不用徽标 */
-  private rowSubtitle(plugin: PluginRow): string {
-    const parts: string[] = [];
-    parts.push(this.statusBadgeText(plugin));
-    parts.push(plugin.external ? '外部' : '内置');
-    if (plugin.tools !== undefined && plugin.tools.length > 0) {
-      parts.push(plugin.tools.length.toString() + ' 工具');
-    }
-    return parts.join(' · ');
-  }
-
-  private statusBadgeText(plugin: PluginRow): string {
-    const s: string = this.statusOf(plugin);
-    if (s === 'loaded') {
-      return '已加载';
-    }
-    if (s === 'pending') {
-      return '待生效';
-    }
-    if (s === 'disabled') {
-      return '已禁用';
-    }
-    return '未加载';
-  }
-
-  private statusBadgeColor(plugin: PluginRow): string {
-    const s: string = this.statusOf(plugin);
-    if (s === 'loaded') {
-      return '#17A964';
-    }
-    if (s === 'pending') {
-      return '#D99A2B';
-    }
-    if (s === 'disabled') {
-      return '#E84026';
-    }
-    return this.palette().textMuted;
-  }
 }

cmd/ohos/HomeAgent/entry/src/main/module.json5

@@ -17,6 +17,14 @@
       },
       {
         "name": "ohos.permission.GET_NETWORK_INFO"
+      },
+      {
+        "name": "ohos.permission.READ_PASTEBOARD",
+        "reason": "$string:read_pasteboard_reason",
+        "usedScene": {
+          "abilities": ["EntryAbility"],
+          "when": "inuse"
+        }
       }
     ],
     "abilities": [

cmd/ohos/HomeAgent/entry/src/main/resources/base/element/string.json

@@ -3,6 +3,10 @@
     {
       "name": "app_name",
       "value": "HomeAgent"
+    },
+    {
+      "name": "read_pasteboard_reason",
+      "value": "用于在应用前台按你的授权响应 agent 的剪贴板读取请求"
     }
   ]
 }

cmd/ohos/README.md

@@ -9,30 +9,56 @@ HarmonyOS / OpenHarmony 原生客户端，用 ArkTS + ArkUI 实现（不是 WebV
 ```
 HomeAgent/
 ├── AppScope/                     应用级配置与图标
+├── oh_modules/                   依赖（.gitignore 忽略，但**必须存在**，见下节）
 ├── entry/src/main/
 │   ├── ets/
-│   │   ├── common/               通信与全局状态
-│   │   │   ├── ApiClient.ets     REST 客户端（X-API-Key 鉴权、超时、二进制附件）
-│   │   │   ├── SseClient.ets     SSE 长连接（Last-Event-ID 断线续传）
-│   │   │   ├── DeviceBridge.ets  设备桥：把本机能力暴露给 agent
-│   │   │   ├── BridgeRouter.ets  桥请求路由
-│   │   │   ├── BridgeCaps.ets    能力声明
-│   │   │   ├── ConnStore.ets     连接配置持久化
-│   │   │   ├── StatusStore.ets   运行状态缓存
-│   │   │   ├── NavBarController.ets / NavStackRegistry.ets  导航
-│   │   │   ├── Constants.ets     主题色板、圆角、超时、分页大小
-│   │   │   └── UserError.ets     错误转人类可读文案
+│   │   ├── common/               通信、状态与纯逻辑（无 UI）
+│   │   │   ├── ApiClient.ets           REST 客户端（X-API-Key 鉴权、超时、二进制附件）
+│   │   │   ├── SseClient.ets           SSE 长连接（Last-Event-ID 断线续传）
+│   │   │   ├── ConnStore.ets           连接配置与设备身份持久化
+│   │   │   ├── StatusStore.ets         运行状态缓存（单例 + AppStorage 广播）
+│   │   │   ├── Constants.ets           主题色板、圆角、超时、分页大小
+│   │   │   ├── UserError.ets           错误转人类可读文案
+│   │   │   ├── NavBarController.ets / NavStackRegistry.ets  导航栏显隐与导航栈登记
+│   │   │   ├── ChatStore.ets           聊天状态机（消息数组/分页/SSE/防抖刷新，单例）
+│   │   │   ├── ChatSse.ets             SSE 事件 → 状态翻译（ChatStreamSink 接口）
+│   │   │   ├── ChatSession.ets         发送/中断（POST /chat、/chat/file）
+│   │   │   ├── ChatHistory.ets         历史载荷与 tool_calls 解析
+│   │   │   ├── ChatFormat.ets          ForEach 键、工具卡状态/配色、渠道判定
+│   │   │   ├── AttachmentMeta.ets      附件解析与格式化（纯函数）
+│   │   │   ├── AttachmentImage.ets     附件字节获取与解码（沙箱/远端）
+│   │   │   ├── DeviceBridge.ets        设备桥客户端（socket 生命周期与命令分发）
+│   │   │   ├── BridgeProtocol.ets      设备桥协议消息与帧构造
+│   │   │   ├── BridgeRouter.ets        桥请求路由
+│   │   │   ├── BridgeCaps.ets          能力声明
+│   │   │   ├── DeviceBridgeSession.ets 前台桥生命周期、网关地址推导
+│   │   │   ├── DeviceModel.ets         设备页纯逻辑（device_id 兜底、在线设备解析）
+│   │   │   ├── PluginApi.ets           插件列表/详情接口
+│   │   │   ├── PluginStatus.ets        插件状态判定与配色
+│   │   │   ├── SettingsModel.ets       设置载荷解析、分类归并、分页、路由 id
+│   │   │   └── MarkdownParser.ets      Markdown 解析（块/行内/表格）
 │   │   ├── components/           可复用组件
-│   │   │   ├── MarkdownView.ets      流式 Markdown（增量渲染）
-│   │   │   ├── StaticMarkdown.ets    静态 Markdown（历史消息，一次成型）
-│   │   │   ├── Attachment.ets        附件卡片 + 详情
-│   │   │   ├── StatusCards.ets       状态卡片
-│   │   │   ├── SettingsEditor.ets    配置编辑器
-│   │   │   ├── PageTopBar.ets        顶栏 + 悬浮按钮
-│   │   │   ├── SubPage.ets           二级页容器
+│   │   │   ├── MarkdownView.ets        流式 Markdown（增量渲染）
+│   │   │   ├── StaticMarkdown.ets      静态 Markdown（历史消息，一次成型）
+│   │   │   ├── Attachment.ets          附件卡 + 附件详情内容
+│   │   │   ├── ChatStream.ets          消息列表 + 顶栏遮罩 + 底部淡出 + 触顶懒加载
+│   │   │   ├── ChatBubble.ets          单条气泡（头像/渠道名/思考卡/工具卡/附件/正文）
+│   │   │   ├── ChatToolCard.ets        思考过程卡 + 工具调用卡
+│   │   │   ├── ChatComposer.ets        悬浮输入区（选图/选文件/上传/发送）
+│   │   │   ├── ChatAttachBar.ets       加号菜单 + 待发送附件条
+│   │   │   ├── SettingsHome.ets / SettingsRootEntries.ets / SettingsEntryCard.ets  设置一级页
+│   │   │   ├── ConnectionsPane.ets / AppearancePane.ets / BackendSettingsPane.ets  设置二级页
+│   │   │   ├── PluginListView.ets / PluginDetailPane.ets / PluginsOverlays.ets     插件页
+│   │   │   ├── DeviceRootEntries.ets / DevicePanes.ets                            设备页
+│   │   │   ├── SettingsEditor.ets      配置编辑器
+│   │   │   ├── StatusCards.ets         状态卡片
+│   │   │   ├── ToastBar.ets            统一提示条（插件页与设置页共用）
+│   │   │   ├── PageTopBar.ets          顶栏 + 悬浮按钮
+│   │   │   ├── SubPage.ets             二级页容器 / NavGroup / NavRow / PlainCard
+│   │   │   ├── MotionBase.ets          统一按压反馈与入场动画
 │   │   │   └── GradientBackground.ets
 │   │   ├── model/Model.ets       共享类型定义
-│   │   ├── pages/                页面
+│   │   ├── pages/                页面（薄壳：导航 + 数据编排）
 │   │   │   ├── Index.ets         Tab 容器（入口）
 │   │   │   ├── ChatPage.ets      对话
 │   │   │   ├── DevicePage.ets    设备
@@ -45,11 +71,30 @@ HomeAgent/
 └── oh-package.json5              依赖
 ```
 
+约定：**单个 `.ets` 不超过 400 行**，页面只做页面壳（导航栈 + 数据编排），
+可复用结构进 `components/`，无 UI 的逻辑进 `common/`。
+
+这条约定有一个边界，别用反了：
+
+> **不到 400 行的文件不要为了拆分而拆分。** `@Component` 的 `build()` 只允许一个根节点，
+> 把原来多节点的 `@Builder` 改成组件时会多出一层 `Column` 包裹 —— 布局等价是**推理**出来的、
+> 不是看出来的，每拆一次都要付一次"未上机验证"的账。所以拆分只用来解决真实的可读性/维护性
+> 问题（超长文件、职责混杂），而不是凑行数。`pages/Index.ets` 目前 396 行就属于"不动"的一类：
+> 没越线，余量本身也是有用的缓冲；等它真越线了再拆，并且优先看是不是又长出了大 `@Builder`。
+
 ## 编译
 
 需要 DevEco Studio 或 [command-line-tools](https://developer.huawei.com/consumer/cn/deveco-studio/)。
 本工程用 `compatibleSdkVersion 6.1.1(24)` / `compileSdkVersion 26.0.0`。
 
+0. **前置条件：`oh_modules/` 必须存在**（`ohpm install` 的产物）。
+
+   它被 `.gitignore` 忽略，所以干净 clone 后没有；而 hvigor **不会**自动补齐它 ——
+   实测把 `oh_modules/` 移走后构建不会触发 `ohpm install`，而是直接报一堆
+   `arkts-no-untyped-obj-literals`（依赖类型声明缺失），且不会重建该目录。
+   所以：clone 后先 `ohpm install`，之后别把这个目录当垃圾清掉。
+   `entry/build/`、`.hvigor/` 是纯构建产物，可以随时删除（冷构建 ~8s）。
+
 1. **准备签名配置**（`build-profile.json5` 含密码明文，未入库）：
 
    ```bash
@@ -64,19 +109,27 @@ HomeAgent/
 2. **构建 HAP**：
 
    ```bash
-   # hvigorw 未入库（本机是符号链接），直接用 command-line-tools 里的
-   /path/to/command-line-tools/bin/hvigorw \
-     --mode module -p module=entry@default assembleHap --no-daemon
+   cd cmd/ohos/HomeAgent
+   # ⚠️ 不要用仓库里的 ./hvigorw：它是符号链接，启动脚本按 $(dirname $0) 定位，
+   #    会报 File not found: <repo>/cmd/ohos/hvigor/bin/hvigorw。
+   #    一律用 command-line-tools 里的绝对路径（本机为 /opt/huawei/command-line-tools/bin/hvigorw）：
+   /opt/huawei/command-line-tools/bin/hvigorw \
+     assembleHap --mode module -p product=default --no-daemon
    ```
 
    产物在 `entry/build/default/outputs/default/entry-default-signed.hap`。
 
-3. **安装到设备**：
+3. **安装到设备**（`entry/build/` 是纯构建产物、不入库，所以**必须先跑完第 2 步**，
+   否则下面这个路径不存在）：
 
    ```bash
    hdc install entry/build/default/outputs/default/entry-default-signed.hap
    ```
 
+   路径里的目录名随构建模式而变：默认是 `default/`，若用 `-p product=<名字>` 则是该产品名。
+   拿不准就先 `find entry/build -name '*.hap'` 找一下。同目录还有 `entry-default-unsigned.hap`，
+   `hdc install` 要用带 `-signed` 的那个。
+
 ## 连接 homed
 
 首次启动在「设置」里填：
@@ -97,3 +150,19 @@ HomeAgent/
 - **修改主题色**：改 `common/Constants.ets` 的 `DARK_PALETTE` / `LIGHT_PALETTE`，全局生效。
 - **新增页面**：同时在 `resources/base/profile/main_pages.json` 注册，且只有入口页带 `@Entry`。
 - 项目代码部分由 AI 辅助生成，改动请自行评估。
+
+## 改动后的运行时验证清单
+
+构建通过只能证明编译期没问题；ArkUI 的状态绑定、过渡动画与手势行为
+必须上设备/模拟器点一遍。UI 相关改动（尤其拆分、状态搬家）请至少走完：
+
+- [ ] 发一条消息，确认流式输出、滚动到底、"AI 思考中/工具调用"状态条正常
+- [ ] 点开思考过程卡与工具调用卡，确认能展开/收起且有过渡动画
+- [ ] 传一张图片与一个文件，确认预览条、上传进度、发送后附件卡正常
+- [ ] 进设置的四个二级页（状态/连接/外观/后端），确认进出场与保存生效
+- [ ] 进插件列表与插件详情，确认状态色、开关与卸载正常
+- [ ] 进出设备页四个二级页，确认授权开关与在线设备列表正常
+- [ ] 宽屏（>=600vp）下确认左右分栏、返回手势与返回键行为
+
+模拟器在无图形/无提权环境里可能起不来（需要写 `~/.Huawei` 等宿主目录），
+此时请在真机或有权限的机器上补这轮验证，并在提交信息里注明"未做运行时验证"。

cmd/waiter/daemon.go

@@ -39,7 +39,7 @@ type msgEntry struct {
 
 type daemonHandler struct {
 	// homed 连接
-	homeMu  sync.Mutex
+	homeMu   sync.Mutex
 	homeConn net.Conn
 	homeR    *bufio.Reader
 	homeCfg  *Config
@@ -304,14 +304,14 @@ func startDaemonDeviceBridge(cfg *Config) {
 	if dg == "" || dt == "" {
 		return
 	}
-	// 设备桥重连循环：WS 断开时自动重连
-	go runDeviceBridgeLoop(dg, dt)
+	// 设备桥重连循环：WS 断开时自动重连，并保留配置中的本地授权状态。
+	go runDeviceBridgeLoop(dg, dt, cfg.DeviceAuthorized)
 }
 
 // runDeviceBridgeLoop 无限重连循环：建立设备桥 → 等待断开 → 重连。
-func runDeviceBridgeLoop(gateway, token string) {
+func runDeviceBridgeLoop(gateway, token string, authorized bool) {
 	for {
-		bridge, err := connectDeviceBridge(gateway, token)
+		bridge, err := connectDeviceBridge(gateway, token, authorized)
 		if err != nil {
 			log.Printf("[daemon] device bridge connect failed: %v, retrying in 5s", err)
 			time.Sleep(5 * time.Second)
@@ -325,7 +325,7 @@ func runDeviceBridgeLoop(gateway, token string) {
 }
 
 // connectDeviceBridge 创建并启动一次设备桥，返回 bridge 实例供 Wait()。
-func connectDeviceBridge(gateway, token string) (*client.Bridge, error) {
+func connectDeviceBridge(gateway, token string, authorized bool) (*client.Bridge, error) {
 	hostname, _ := os.Hostname()
 	if hostname == "" {
 		hostname = "local"
@@ -355,12 +355,17 @@ func connectDeviceBridge(gateway, token string) (*client.Bridge, error) {
 	}
 
 	bridge := client.New(gw, token, deviceID, hostname, caps, info)
+	bridge.SetAuthorized(authorized)
 
-	// 注册命令处理器
+	// 注册命令处理器：cmd_type 是主信号，同时兼容旧版 homeagent-* 文本前缀。
 	cr := client.NewCmdRouter()
 	cr.Handle("homeagent-", handleHomeagentCmd)
 	cr.HandleDefault(handleShellCmd)
-	bridge.OnCmd(func(reqID, command string) {
+	bridge.OnCmd(func(reqID, command, cmdType string) {
+		if cmdType == "homeagent" {
+			handleHomeagentCmd(reqID, command)
+			return
+		}
 		cr.Dispatch(reqID, command)
 	})
 
@@ -371,8 +376,6 @@ func connectDeviceBridge(gateway, token string) (*client.Bridge, error) {
 	// 设置全局变量供 sendBridgeResult 使用
 	deviceBridge = bridge
 	deviceBridgeID = deviceID
-	auth := true // daemon 模式默认授权（配置已指定）
-	bridge.SetAuthorized(auth)
 
 	return bridge, nil
 }

cmd/waiter/device.go

@@ -61,13 +61,22 @@ func startDeviceBridge(addr, token string) error {
 	bridge := client.New(gateway, token, deviceID, "HomeAgent CLI", caps, info)
 	cmdRouter = client.NewCmdRouter()
 
-	// 注册命令处理器
+	// cmd_type 是主路由信号；保留 homeagent-* 文本前缀兼容旧服务端。
 	cmdRouter.Handle("homeagent-", handleHomeagentCmd)
 	cmdRouter.HandleDefault(handleShellCmd)
-	bridge.OnCmd(func(reqID, command string) {
+	bridge.OnCmd(func(reqID, command, cmdType string) {
+		if cmdType == "homeagent" {
+			handleHomeagentCmd(reqID, command)
+			return
+		}
 		cmdRouter.Dispatch(reqID, command)
 	})
 
+	// agent 主动投递（output_send__device/<id>）→ 终端显示。
+	// 设备侧参考实现：文本/结构化直接打出来；二进制负载走 OnData（TTS 音频等）。
+	bridge.OnPush(func(reqID, typ, payload, meta string) {
+		printlnC("cyan", fmt.Sprintf("[push:%s] %s", typ, payload))
+	})
 	if err := bridge.Start(); err != nil {
 		return fmt.Errorf("device bridge: %w", err)
 	}
@@ -767,4 +776,4 @@ func sanitizeID(s string) string {
 		}
 	}
 	return sb.String()
-}
+}

deploy/packaging/package-linux.sh

@@ -710,18 +710,25 @@ main() {
   echo "=== Done! Packages in: $DIST_DIR ==="
   echo ""
   echo "Summary:"
-  mapfile -t release_files < <(find "$DIST_DIR" -type f \( -name "*.deb" -o -name "homeagent_*.tar.gz" -o -name "*.rpm" \) 2>/dev/null | sort)
+  # 只列**本批**产物：dist/ 会跨多次构建累积，用 find 全目录会让清单／SHA256SUMS
+  # 带上历史版本的文件名——用户下载那种清单后 `sha256sum -c` 必然报缺失。
+  # （v1.2.2 构建时就出现过：清单里混进了 1.2.0/1.2.1 的包名。）按本批版本号过滤。
+  mapfile -t release_files < <(find "$DIST_DIR" -type f \( -name "*${PKG_VERSION}*.deb" -o -name "homeagent_${PKG_VERSION}_*.tar.gz" -o -name "*${PKG_VERSION}*.rpm" \) 2>/dev/null | sort)
   for f in "${release_files[@]}"; do
     echo "  $(du -h "$f" | cut -f1)  $f"
   done
   # 全部包生成之后一次计算，避免边打边算漏掉后生成的产物。
+  # 名字用**平铺名**（basename）：下载页的附件名就是平铺的，
+  # 清单里若写 ./deb/xxx.deb，用户下载后 `sha256sum -c` 会找不到文件。
   if [ ${#release_files[@]} -gt 0 ]; then
     (
       cd "$DIST_DIR"
-      find . -type f \( -name "*.deb" -o -name "homeagent_*.tar.gz" -o -name "*.rpm" \) \
-        -print0 | sort -z | xargs -0 sha256sum > SHA256SUMS
+      # 哈希取**真实路径**，标签用**平铺名**：两者不能混（直接对 basename 求哈希会找不到文件）。
+      for f in "${release_files[@]}"; do
+        printf '%s  ./%s\n' "$(sha256sum "$f" | awk '{print $1}')" "$(basename "$f")"
+      done | sort -k2 > SHA256SUMS
     )
-    echo "  SHA256SUMS: $DIST_DIR/SHA256SUMS"
+    echo "  SHA256SUMS: $DIST_DIR/SHA256SUMS  （仅本批 ${#release_files[@]} 个产物，平铺名）"
   fi
 }
 

deploy/packaging/package-windows.sh

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+# 构建 Windows 安装器（NSIS）。
+#
+# ❗安装器**不往 Windows 装 homed**：homed 依赖 fd 继承与统一共享内存区的段内偏移
+# 解引用，Windows 句柄模型无法表达（见 cmd/homed/platform_windows.go）。所以安装器的
+# 职责是**引导 WSL2，并把 Linux 包送进发行版里按 Linux 方式安装**
+# （deploy/packaging/windows/install-via-wsl.ps1）。
+#
+# 用法: VERSION=1.3.10 bash deploy/packaging/package-windows.sh <server|client|full> [arch]
+# 前置: 先产出对应的 Linux 包（VERSION=x bash deploy/packaging/package-linux.sh amd64）
+#
+# 为什么不复用 build.sh 的 stage_linux_payload：那一段把 dist/linux 下**所有** deb+tar
+# 都塞进 payload，而 server/full 的 deb 各带 ~719MB 的 Chinese-CLIP 模型 ⇒ 任何变体的
+# 安装器都会膨胀到 ~2.4GB。WSL 侧脚本只取 payload 里的**第一个** .deb
+# （install-via-wsl.ps1:141），所以这里按变体只放对应的那一个包。
+set -euo pipefail
+
+PROJECT_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+# 三个目录都可覆盖：发布件常在 tag 的干净 worktree 里构建，而这个脚本本身
+# 可能只存在于 main（例如刚补的驱动脚本还没进 tag）——那种情况下用主仓的脚本 +
+# DIST_LINUX/BUILD_DIR/DIST_RELEASE 指向 worktree，避免"脚本不存在"或产物错位。
+BUILD_DIR="${BUILD_DIR:-$PROJECT_ROOT/build}"
+DIST_LINUX="${DIST_LINUX:-$PROJECT_ROOT/dist/linux}"
+DIST_RELEASE="${DIST_RELEASE:-$PROJECT_ROOT/dist/release}"
+# ❗NSIS 的 `File` 路径是**相对 .nsi 所在目录**解析的：在 tag 的 worktree 里构建时，
+# 必须用**该 tag 里的** installer.nsi，否则它会去主仓的 build/linux-payload 找载荷
+# （实测报 `File: "..\..\build\linux-payload\*.*" -> no files found`）。
+# 用 tag 里的 .nsi 也正是"发布件与当时的脚本同源"的正确做法。
+NSI="${NSI:-$PROJECT_ROOT/deploy/packaging/installer.nsi}"
+if [ ! -f "$NSI" ]; then
+  echo "[FAIL] 找不到 NSIS 脚本: $NSI" >&2
+  exit 1
+fi
+
+VARIANT="${1:-server}"
+ARCH="${2:-amd64}"
+VERSION="${VERSION:-$(git -C "$PROJECT_ROOT" describe --tags 2>/dev/null || echo 0.0.0)}"
+VERSION="${VERSION#v}"
+
+case "$VARIANT" in
+  server) DEB_GLOB="homeagent-server_${VERSION}_${ARCH}.deb"; SUFFIX="Server"; WANT_GUI=0; WANT_WAITER=0 ;;
+  full)   DEB_GLOB="homeagent-full_${VERSION}_${ARCH}.deb";   SUFFIX="Full";   WANT_GUI=1; WANT_WAITER=1 ;;
+  client) DEB_GLOB="homeagent-client_${VERSION}_${ARCH}.deb"; SUFFIX="Client"; WANT_GUI=1; WANT_WAITER=1 ;;
+  *) echo "用法: $0 <server|client|full> [arch]" >&2; exit 2 ;;
+esac
+
+DEB="$(ls -1 "$DIST_LINUX/deb/$DEB_GLOB" "$DIST_LINUX/$DEB_GLOB" 2>/dev/null | head -1 || true)"
+if [ -z "$DEB" ]; then
+  echo "[FAIL] 找不到 $DEB_GLOB" >&2
+  echo "       先产出 Linux 包：VERSION=$VERSION bash deploy/packaging/package-linux.sh $ARCH" >&2
+  echo "       （安装器的作用是把 Linux 包送进 WSL2，所以必须先有 Linux 包）" >&2
+  exit 1
+fi
+
+# client/full 还要带 Windows GUI（HAS_GUI=1）。本机缺 electron-builder，若 build/ 下
+# 没有可用的 win32-x64 payload 就**明确失败**，不产出"装完没有界面"的半残包。
+if [ "$WANT_GUI" = 1 ]; then
+  if [ -z "$(ls -1 "$BUILD_DIR"/homeagent-gui-win32-x64/*.exe 2>/dev/null | head -1 || true)" ]; then
+    echo "[FAIL] 变体 $VARIANT 需要 Windows GUI payload（build/homeagent-gui-win32-x64/*.exe）" >&2
+    echo "       本机无 electron-builder：npm i -g electron-builder &&" >&2
+    echo "       bash deploy/packaging/build.sh windows/amd64 gui" >&2
+    echo "       （只装内核+CLI 的 WSL 场景请用 server 变体）" >&2
+    exit 1
+  fi
+fi
+
+if [ "$WANT_WAITER" = 1 ]; then
+  echo "[BUILD] waiter.exe（Windows 侧 CLI；CGO 关闭，跨平台安全）"
+  ( cd "$PROJECT_ROOT" && GOOS=windows GOARCH="$ARCH" CGO_ENABLED=0 \
+      go build -buildvcs=false -trimpath -o "$BUILD_DIR/waiter.exe" ./cmd/waiter )
+fi
+
+# ---- 变体定向 payload：只放本变体那一个 Linux 包 ----
+rm -rf "$BUILD_DIR/linux-payload"
+mkdir -p "$BUILD_DIR/linux-payload"
+cp "$DEB" "$BUILD_DIR/linux-payload/"
+echo "[STAGE] payload ← $(basename "$DEB")（$(du -h "$DEB" | cut -f1)）"
+
+if [ -z "$(ls -1 "$BUILD_DIR/linux-payload" 2>/dev/null | head -1 || true)" ]; then
+  echo "[FAIL] payload 为空：$BUILD_DIR/linux-payload" >&2
+  exit 1
+fi
+echo "[BUILD] makensis -DVARIANT=$VARIANT -DPRODUCT_VERSION=$VERSION（nsi: $NSI）"
+makensis -V2 -DVARIANT="$VARIANT" -DPRODUCT_VERSION="$VERSION" "$NSI"
+
+OUT="$BUILD_DIR/HomeAgent_v${VERSION}_${SUFFIX}_win64.exe"
+if [ ! -f "$OUT" ]; then
+  echo "[FAIL] 未找到产物 $OUT" >&2
+  exit 1
+fi
+mkdir -p "$DIST_RELEASE"
+cp "$OUT" "$DIST_RELEASE/"
+echo "[OK] $(basename "$OUT")（$(du -h "$OUT" | cut -f1)）→ $DIST_RELEASE/"
+echo "     它会在 Windows 侧引导 WSL2，并把 $(basename "$DEB") 送进去安装（homed 跑在 WSL 里）。"

docs/defect-qq-output-send-loop.md

@@ -0,0 +1,248 @@
+# QQ `output_send` 回声/无限循环（核心侧缺陷） QQ `output_send` 回声/无限循环（核心侧缺陷，非插件）
+
+> 状态：**已修复**（核心已具备轮次上限：`core.agent.max_tool_turns`，默认 10，
+> 在 `internal/agent/core/task.go` 到达上限即强制收尾；回归测试
+> `TestMaxToolTurns_CapsRunawayLoop`。本文保留为缺陷定位过程记录。）
+>
+> 原始状态（修复前）：**待修复**
+> 影响：Agent 单轮内每 ~10 秒调用一次 `output_send__qq`，持续数十分钟不结束（实测单轮 `1780624ms`，80+ 次工具调用）
+> 定位结论：**问题在核心（富回执 + 每轮重复追加同一条“继续”占位 + 无轮次上限），QQ 插件侧已是最小回执，改插件无效**
+
+---
+
+## 1. 现象
+
+生产日志（`/home/newqqagent`，homed 运行期）：
+
+```
+18:31:39 process.go:299: [agent] tool output_send__qq result: 已通过 [qq] 通道发送: map[status:sent]
+18:31:47 process.go:299: [agent] tool output_send__qq result: 已通过 [qq] 通道发送: map[status:sent]
+18:31:58 process.go:299: [agent] tool output_send__qq result: 已通过 [qq] 通道发送: map[status:sent]
+18:32:06 ...
+18:32:14 ...
+（每 8~12 秒一条，payload 长度各异：387/237/246/203/252/270/254/231/258/227/188/227/200/209/155/284/212/173/198/242/218/191…）
+18:31:19 eventloop.go:426: [agent] text from qq → response (1780624ms, tools=[... 80+ 项 ...])
+```
+
+- 每条内容**都不同**，所以“相同参数才拦”的插件保险不会触发。
+- 不是 webhook 回声（15 分钟内只有 1 条真实入站中断）。
+- 是模型每轮都收到“发送成功的富回执”，把它当成“继续下一步”的信号。
+
+---
+
+## 2. 根因链（核心侧，三层）
+
+### 2.1 QQ 插件已经返回最小回执 —— 但被核心丢弃
+
+`third_party/homeagent-sdk/example/qq/plugin.go`（`handleChannelOutput` 尾部）：
+
+```go
+if sendErr != nil {
+    return nil, sendErr
+}
+// 成功：返回极简标记。不再回传 NapCat 原始响应（含 message_id 等）给模型，
+// 避免模型把"发送成功"当成"上一步完成，继续下一步"的信号驱动循环。
+return "ok", nil
+```
+
+插件返回的是字符串 `"ok"`。
+
+### 2.2 核心 proc 桥丢弃它并伪造 `status:sent`
+
+`internal/plugin/proc/plugin.go:336`（`(*Plugin).invokeOutput`）：
+
+```go
+raw, err := p.proc.Call(MethodOutputInvoke, OutputInvokeParams{Channel: channel, Args: args})
+if err != nil { return nil, err }
+if len(raw) == 0 {
+    return map[string]interface{}{"status": "sent"}, nil
+}
+var res map[string]interface{}
+if err := json.Unmarshal(raw, &res); err != nil {
+    return map[string]interface{}{"status": "sent"}, nil   // ← "ok" 不是 JSON object，落到这里
+}
+if _, ok := res["status"]; !ok {
+    res["status"] = "sent"                                  // ← 再兜底
+}
+return res, nil
+```
+
+插件返回 `"ok"` → `json.Unmarshal` 进 `map[string]interface{}` 失败 → 核心合成 `{status: sent}`。
+**插件的返回值在这里被完全覆盖，所以只改插件永远修不掉回声。**
+
+### 2.3 核心把这个富回执喂给模型
+
+`internal/agent/core/output.go:81`（HEAD / 部署中的 homed 行为）：
+
+```go
+return fmt.Sprintf("已通过 [%s] 通道发送: %v", channel, result)
+// → "已通过 [qq] 通道发送: map[status:sent]"
+```
+
+模型看到“发送成功 + 详情”后继续调用 `output_send__qq`，形成闭环。
+
+### 2.4 核心没有工具轮次硬上限（放大器）
+
+`core.agent.max_tool_turns` 只在配置层定义，**agent 循环里没有任何读取点**：
+
+```
+internal/config/registry.go:551   set("core.agent.max_tool_turns", "10")
+internal/config/registry.go:669   reg(ConfigDef{Key: "core.agent.max_tool_turns", ...})
+$ grep -rn 'max_tool_turns\|MaxToolTurns' internal/agent/   → 无结果
+```
+
+`internal/agent/core/process.go:242` 的唯一终止条件是：
+
+```go
+if len(resp.ToolCalls) == 0 {
+    return resp.Content, toolsUsed, toolResults, nil
+}
+```
+
+即：**模型不主动停，循环就永不结束**。`core.agent.max_tool_turns`（本机 DB 现为 `1000`）形同虚设。
+
+### 2.5 每轮重复追加同一条 user 占位（“反复喂相同消息”的直接来源）
+
+`internal/agent/core/process.go:77-82`，位置在 `for turn := 0; ; turn++` 循环的**顶部**：
+
+```go
+for turn := 0; ; turn++ {
+    for _, interrupt := range a.drainInterrupts() { ... }
+
+    // 工具轮产出的 tool/assistant 消息作结尾会被 400 拒绝,故补一条 user 占位。
+    if last := msgs[len(msgs)-1]; last.Role == "assistant" || last.Role == "tool" {
+        msgs = append(msgs, agentAPI.Message{          // ← process.go:79
+            Role:    "user",
+            Content: "请根据以上工具结果继续。",
+        })
+    }
+    ...
+}
+```
+
+`msgs` 于 `process.go:32` 在循环**外**创建，循环内只增不减：
+
+- 每轮工具调用结束后，`msgs` 尾部必然是 `tool` 消息；
+- 下一轮顶部判断成立，于是**再追加一条完全相同的** `请根据以上工具结果继续。`；
+- 不做替换、不做去重、不做裁剪（`ContextPolicy: prune` 只裁剪 `a.context`，不裁剪 `msgs`）。
+
+跑 N 轮，模型收到的 prompt 里就叠了 N 条一模一样的“继续”指令。这才是“核心把前面相同消息反复喂给模型”的直接机制，也是把模型持续推向 `output_send` 的持续推力。
+
+**预期行为**：占位消息应当（a）仅在没有尾部 user 消息时补一条，或（b）补之前先移除上一条同类占位，保持至多一条；绝不能线性累积。
+
+---
+
+## 3. 现有未完成/未部署的修复
+
+| 文件 | 状态 | 内容 |
+| --- | --- | --- |
+| `internal/agent/core/output.go:81` | **已改，未提交** (`M`) | `return fmt.Sprintf("已通过 [%s] 通道发送: %v", ...)` → `return "ok"`（含解释回声的注释） |
+| `internal/plugin/proc/plugin.go:336` | **已改，未提交** (`M`) | 仍是伪造 `status:sent` 的版本，未处理非 map 返回值 |
+| `third_party/homeagent-sdk/example/qq/plugin.go` | **已改，未提交** (`M`) | `handleChannelOutput` 返回 `"ok"` |
+
+运行中的 `homed` 是 **Sep 6 11:39** 构建的二进制，不含 `output.go` 的极简回执改动 → 仍回显富回执。
+另外该二进制用旧 SDK 协议（`shmMagic` 直连，无 `unifiedMagic`），而 `third_party/homeagent-sdk` 仓库 HEAD 已升级到统一区域协议（`fc23612` 起）。**重建并部署 homed 时二者必须对齐**（见 §5）。
+
+---
+
+## 4. 建议修复
+
+### 4.1 （必须）让模型只看到最小回执
+
+**方案 A（最小改动，已在工作区）**：`internal/agent/core/output.go`
+
+```go
+// internal/agent/core/output.go:81
+// 成功回执：只返回极简标记，不回传完整插件响应。
+// 「已通过 [qq] 通道发送: map[status:sent message_id:xxx]」这类富回执
+// 会驱动模型继续调用 output_send（回声效应），是 output loop 的根源之一。
+return "ok"
+```
+
+**方案 B（同时修掉 proc 桥的伪造）**：`internal/plugin/proc/plugin.go:336`
+不要对非 map 结果伪造 `status:sent`，保留插件真实返回；例如：
+
+```go
+if len(raw) == 0 {
+    return map[string]interface{}{"status": "ok"}, nil
+}
+var res map[string]interface{}
+if err := json.Unmarshal(raw, &res); err != nil {
+    // 插件返回的是标量（如 "ok"）——原样透传，不要伪造 status
+    var scalar interface{}
+    if err2 := json.Unmarshal(raw, &scalar); err2 == nil {
+        return scalar, nil
+    }
+    return map[string]interface{}{"status": "ok"}, nil
+}
+```
+
+注意：`output.go` 仍需要 `status == "unconfirmed"/"queued"` 的判定，改成标量透传时该判定自然跳过（非 map），语义正确。
+
+### 4.2 （必须）工具循环硬上限
+
+在 `internal/agent/core/process.go` 的工具循环里读取并强制 `core.agent.max_tool_turns`：
+
+- 位置：`for turn := 0; ; turn++ {` 循环内，执行工具前/每轮结束后检查。
+- 语义：达到上限时追加一条系统消息（如 `[系统] 已达到最大工具轮次 N，请立即总结并停止调用工具`），并终止循环返回当前内容，而不是继续下一轮。
+- 至少要在 `turn > maxTurns` 时强制 `break`，避免模型不停调用。
+
+### 4.3 （建议）QQ 插件侧保持最小回执
+
+`third_party/homeagent-sdk/example/qq/plugin.go` 的 `return "ok", nil` 是正确的，保留即可。
+**不要**再依赖插件侧修这个回声——见 §2.2。
+
+### 4.4 （必须）修掉每轮重复追加的 user 占位
+
+`internal/agent/core/process.go:77-82`。改为“至多保留一条”，例如：
+
+```go
+// 只在尾部是工具轮产物时补位；先移除上一条同类占位，避免线性累积。
+if last := msgs[len(msgs)-1]; last.Role == "assistant" || last.Role == "tool" {
+    // 若尾部之上已经存在一条我们自己的占位，就不要重复追加。
+    if !isContinuationPlaceholder(msgs[len(msgs)-1]) {
+        msgs = append(msgs, agentAPI.Message{
+            Role:    "user",
+            Content: continuationPlaceholder,
+        })
+    }
+}
+```
+
+更稳妥的写法：在追加前从 `msgs` 尾部回扫，删除所有此前由本机制插入的占位，再追加一条。判定不要只靠字符串相等，建议给占位加一个可识别标记（例如 `internal:continuation`）或单独的 `NoMemory/Role` 约定，避免误删真实用户消息。
+
+同时建议给 `msgs` 加长度/ token 上限（或定期裁剪历史），防止长任务把上下文堆爆（这正是 §2.4 无轮次上限的伴生问题）。
+
+---
+
+## 5. 部署前提与步骤
+
+> ⚠️ 部署 homed 前必须先对齐 SDK 协议，否则所有子进程插件握手失败（`统一区域魔数不匹配`）。
+
+1. **确认工具链协议与要部署的 homed 一致**
+   - 现状：`/usr/local/bin/homed` = 旧协议；`/usr/local/bin/plugindev` 已替换为旧协议版本（备份 `/usr/local/bin/plugindev.bak-20260910-174547`）。
+   - 若决定升级到统一区域协议，则需同时：升级 homed 二进制 + 用新 SDK（`third_party/homeagent-sdk` HEAD）重建全部插件。
+   - 若维持旧协议：用 `/usr/local/bin/plugindev`（旧）重建插件即可，不要用仓库 HEAD 的 `tools/plugindev` 直接 `go run`。
+2. **构建 homed**：`go build ./...` 已验证通过；产出替换 `/usr/local/bin/homed`（按项目部署纪律：备份 → 原子替换）。
+3. **重启**：`systemctl restart homeagent.service`
+4. **重建受影响的子进程插件**（协议一致时）：至少 `qq`。
+
+---
+
+## 6. 验收标准
+
+修复后，发一条会触发回复的 QQ 消息，应满足：
+
+1. 日志中 `output_send__qq` 的 tool result **不再包含** `已通过 [qq] 通道发送: map[status:sent]`；
+2. 单轮只发送 1 条（或模型明确决定的多条**不同**消息），**不出现每 ~10 秒一次的持续调用**；
+3. 当模型异常地持续调用工具时，日志出现达到 `core.agent.max_tool_turns` 的终止记录，且该轮在有限步内结束；
+4. `eventloop.go:426` 的 `text from qq → response` 耗时应回落到正常量级（秒级~分钟级），不再是 30 分钟；
+5. 抓取发往上游的请求（或用调试钩子 dump `req.Messages`），确认 `请根据以上工具结果继续。` 在整轮 prompt 中**至多出现一次**；修复前应为 N 条（N=轮数），这正是 §2.5 的判据。
+
+---
+
+## 7. 相关背景（避免误修）
+
+- QQ 插件的 `beforeToolcall` 循环保险只拦“参数完全相同的重复调用”（`max_duplicate_qq_send`），**拦不住内容各异的循环**；本次循环每条内容都不同，所以保险未触发。这是设计使然，不是 bug。
+- 15 分钟内仅 1 条真实 QQ 入站中断，说明**不是** webhook 把出站消息当入站回灌，**不是**插件回声。
+- `internal/plugin/proc/plugin.go:122` 的 `invokeCleaner` 签名不匹配（此前导致 `go build` 失败）**已被修复**，当前 `go build ./...` 通过。

docs/git-branching.md

@@ -1,6 +1,6 @@
 # Git 分支管理规范
 
-> 生效：2026-08-31，2026-09-04 修订（三级发布通道 + 单条发布分支），2026-09-06 修订（SDK 仓版本语义与发版联动，见 §七）。
+> 生效：2026-08-31，2026-09-04 修订（三级发布通道 + 单条发布分支），2026-09-06 修订（SDK 仓版本语义与发版联动，见 §七），2026-09-13 修订（发布线路牌随 patch 推进 + 版本号不得固化落库）。
 > 适用：**本仓（TrueAgent/HomeAgent）与 third_party/homeagent-sdk（SDK 仓）**——两仓协作时分支策略必须一致，本规范两仓同用。
 > 核心原则一句话：**main 唯一长命、永远可部署；一切新工作在特性分支；一个中版本一条发布分支，alpha/beta/正式由 tag 区分；hotfix 只进发布分支并 cherry-pick 回 main。**
 
@@ -63,6 +63,11 @@ main ──────────────── E ────────
   同一发布线切成互不相连的碎片，追溯时无法用一条分支看完整条线的演进）。
 - **从 main 的某个可部署点切出**：`git checkout -b release/v1.0.x main`。
 - 切出后**冻结功能**——发布分支上只做：版本号 bump、发布准备、bug 修复、文档。
+- **发布线的 `meta.Version` 必须跟着该线已发的最后一个 patch 走**（`release/v1.1.x` 末态
+  `1.1.1`、`release/v1.2.x` 末态 `1.2.2`、`release/v1.3.x` 末态 `1.3.6`）。
+  ⚠️ **不要只用构建参数（`-ldflags -X ...meta.Version`）打版本号而不改源码**：
+  二进制自称 1.3.4、源码路牌还停在 1.3.0，追溯时对不上账（2026-09-13 真实踩过，
+  1.3.1–1.3.4 四个 patch 都是这么打的，`release/v1.3.x` 的路牌一直没动）。
 - **现网部署永远用发布分支上 tag 的构建产物**，不是 main 头部、更不是 feature。
 
 ### 4. 三级发布通道（alpha / beta / 正式）
@@ -162,36 +167,50 @@ git switch main && git cherry-pick <sha>   # 遵守 §三：只 pick，不 merge
 | 人格卡写死 `v0.9.0（C ABI v2）` | 内核接口/日志报 1.2.0，agent 却向用户自述旧版本（且该机制 v1.0.0 已删除） |
 | 架构文档在 1.2.0 后仍把“描述式索引 + 引用计数 GC”写成现行机制 | 读者按已删除的设计理解现行行为 |
 | README 停在 v1.1.1 并描述已被删除的机制 | 同上 |
+| 人格文本在**播种时**就把 `meta.Version` 插值写进配置库 | 装机那天即冻住版本号：内核 1.3.x 的实例仍向用户自称 `v1.0.3`（2026-09-13 用户当场发现） |
+| 发布线只用 `-ldflags -X` 打版本、源码 `meta.Version` 不动 | 二进制自称 1.3.4、源码路牌仍是 1.3.0，溯源对不上账；同类还有给 SDK 误发 patch tag（§七.1 要求 patch 位恒为 `.0`） |
 
 配套硬约束：**任何“模型或用户会当作事实”的文本，都不得写死版本号**——
-要么用 `meta.Version` 插值，要么要求读运行时快照，并用测试钉住
-（如 `TestDefaultPersonaPromptHasNoVersionLiterals`）。
+要么**在渲染时**用 `meta.Version` 插值（系统提示词占位符 `{{kernel_version}}` 即此机制），
+要么要求读运行时快照，并用测试钉住（如 `TestDefaultPersonaPromptHasNoVersionLiterals`）。
+**"插值"指的是每次组装时现算，不是把算好的结果固化进配置库/文档** ——
+固化过的版本号与写死没有区别，而且更难发现。
 
 ---
 
-## 三、当前分支对齐（2026-09-12 更新）
+## 三、当前分支对齐（2026-09-13 更新）
 
 ### 主仓（TrueAgent）
 
 | 分支 | 状态 | 处理 |
 |---|---|---|
-| `main` | 含全部回流修复；`meta.Version` = 下一个未发布中版本（现为 `1.3.0`） | ✅ 保持 |
-| `release/v1.2.x` | **本条发布线**，`meta.Version` = `1.2.0`，vendored SDK 定版 `1.2.0`；已载入两个发布前修复（GUI 输出目录、知识库同名覆盖） | 🆕 2026-09-12 从 main 切出；**尚无 tag** |
-| `release/v1.1.x` | 承载 `v1.1.0-beta.1` / `v1.1.0` / `v1.1.1` | 📦 已退役（§2.6：下个中版本发布即退役），保留供追溯 |
+| `main` | 含全部回流修复；`meta.Version` = 下一个未发布中版本（现为 **`1.4.0`** —— `1.3.0` 已归发布线所有） | ✅ 保持 |
+| `release/v1.3.x` | **本条发布线**，`meta.Version` = **`1.3.6`**（该线最后一个 patch）；承载 `v1.3.1`…`v1.3.6`；vendored SDK 定版 `1.3.0` | ✅ 保持 |
+| `release/v1.2.x` | 承载 `v1.2.0` / `v1.2.1` / `v1.2.2`，末态 `meta.Version` = `1.2.2` | 📦 已退役（§2.6），保留供追溯 |
+| `release/v1.1.x` | 承载 `v1.1.0-beta.1` / `v1.1.0` / `v1.1.1`，末态 `meta.Version` = `1.1.1` | 📦 已退役，保留供追溯 |
 | `release/v1.0.x` | 承载 1.0.x 全部 tag | 📦 保留 |
-| `feature/multimodal-embedding` | 已合入 main（`eb4762a`，43 提交，`--no-ff`） | ⏳ 待删（删远端分支需用户确认，§执行守则 3） |
 
-> `feature/memory-media`、`feature/plugin-proc-migration` 均已从远端删除（旧表里的待删项已处理）。
+> - `v1.3.0` 是**已撤回**的坏 tag：设备输出通道名 `device/<id>` 里的 `/` 拼进 LLM 函数名
+>   `output_send__device/<id>`，上游按**整条请求** 400，全量对话不可用（修复见 `v1.3.1`）。
+> - `feature/*` 分支（`input-semantics`、`multimodal-embedding`、`memory-media`、`plugin-proc-migration`）
+>   均已合入并删除。
 
 ### SDK 仓（homeagent-sdk）
 
 | 分支 | 状态 | 处理 |
 |---|---|---|
-| `main` | `meta.Version` = 下一个未发布中版本（现为 **`1.2.0`**）——SDK **不跟 beta 发版**（§七.2），1.2.0 要等核心的**正式** tag 才定版（§七.3），在那之前路牌不得越过它。此阶段与核心 main（`1.3.0`）**故意不对称**，详见 §七.4 | ✅ 保持 |
-| `release/v1.1.x` | `meta.Version` = `1.1.0`，承载 tag `v1.1.0` | ✅ 与核心对应 |
-| `release/v1.2.x` | **尚未创建** | ⏳ 随核心**正式** tag 一起建（§七.3：分支上把版本定为 `1.2.0` 再打 `v1.2.0`；beta 阶段不发 SDK） |
+| `main` | `meta.Version` = 下一个未发布中版本（现为 **`1.4.0`**）——`1.3.0` 已随核心**正式** tag 定版（§七.3），故路牌推进 | ✅ 保持 |
+| `release/v1.3.x` | `meta.Version` = `1.3.0`，承载 tag `v1.3.0`（5 平台 `hmapdev` + `SHA256SUMS` + 4 个源码归档） | ✅ 与核心对应 |
+| `release/v1.2.x` | `meta.Version` = `1.2.0`，承载 tag `v1.2.0`；同线的 `v1.2.1` 属**误发的 patch tag**（§七.1 违规），其 gitcode 条目标题已标注「（已撤回）」 | 📦 已退役 |
+| `release/v1.1.x` | `meta.Version` = `1.1.0`，承载 tag `v1.1.0` | ✅ 与核心对应（已退役） |
 | `release/v1.0.0` | 旧 patch 号命名形态，内容已被 main 完全包含 | 📦 保留（供追溯 1.0 线构建） |
 
+> ❗**SDK 仓不发 patch tag**（§七.1）：一个中版本只发一次 `vX.Y.0`。
+> 2026-09-13 曾误发 `v1.3.1`（文档用），**已撤回**（远端 tag 已删，本地 commit `05b7a20` 可恢复）；
+> `v1.2.1` 是同一类历史遗留。
+> ❗**现网 SDK store 例外**：本机 `hmapdev` store 用 `--from` 装的是 SDK 源码构建的 1.3.0，
+> 与 tag 内容一致。
+
 ### 1.0.x 发布线 tag 历史
 
 | tag | 提交 | 通道 | 说明 |
@@ -342,11 +361,79 @@ git branch -d release/v1.0.x                          # tag 已保存历史，
 1. SDK 仓也有自己的 `release/vX.Y.x`（与核心同名，一个中版本一条）；
 2. 在该分支上把 `meta.Version` 定为 `X.Y.0`；
 3. 打 tag `vX.Y.0`（首次进入该中版本时），并建 gitcode release；
-4. 上传 5 平台 plugindev 产物 + `SHA256SUMS`。
+4. 上传 5 平台 `hmapdev`（插件开发工具链）产物 + `SHA256SUMS`。
 
 同一中版本内的后续核心 patch（1.1.1 → 1.1.2 …）**不重复发 SDK**——SDK 已经是 1.1.0，
 没有新东西要发。只有接口再次变化并进入下一个中版本时，SDK 才发 1.2.0。
 
+### 5. 发版产物清单（可复现）
+
+**推 tag ≠ 完成发版**：还要打包产物、建 gitcode release 条目、上传附件。
+2026-09-13 出现过"tag 推了、release 条目和产物都没有"的情况（`v1.3.1`–`v1.3.6`），
+事后才补 —— 记录在此以免重犯。
+
+**核心仓**（在 tag 的**干净 worktree** 里构建，不要用带其它会话改动的工作区）：
+
+| 产物 | 生成方式 |
+|---|---|
+| `homeagent_<版本>_linux_amd64.tar.gz` | `VERSION=<版本> bash deploy/packaging/package-linux.sh amd64` |
+| `homeagent-client_<版本>_amd64.deb`、`-server`、`-full` | 同上；server/full 需要 Chinese-CLIP 与 ONNX Runtime 资产目录（`build/model-assets/`、`build/runtime-assets/`） |
+| `SHA256SUMS` | **全部产物生成完毕之后**统一计算（边打边算会漏掉后生成的包） |
+| 4 个源码归档（`.zip` / `.tar.gz` / `.tar.bz2` / `.tar`） | gitcode 打 tag 时自动生成，无需上传 |
+
+**SDK 仓**：`VERSION=<版本> bash package/build.sh all hmapdev` ⇒
+`hmapdev_{linux,darwin}_{amd64,arm64}` + `hmapdev_windows_amd64.exe` + `SHA256SUMS`。
+
+**Windows 安装器（WSL 安装型）**：`homed` **不再装到 Windows**（插件体系依赖 fd 继承与
+共享内存区段内偏移解引用，Windows 句柄模型表达不了），安装器的职责是**引导 WSL2 并把
+Linux 包送进发行版里安装**。产物 `HomeAgent_v<版本>_{Server,Client,Full}_win64.exe`：
+
+```bash
+# 先有 Linux 包（安装器送进 WSL 的就是它），再打安装器
+VERSION=<版本> bash deploy/packaging/package-linux.sh amd64
+VERSION=<版本> bash deploy/packaging/package-windows.sh server amd64   # 只装内核+CLI 的 WSL 场景
+VERSION=<版本> bash deploy/packaging/package-windows.sh client amd64   # 需要 Windows GUI payload
+```
+
+- `package-windows.sh` 会按**变体只放对应的那一个 deb** 进 payload。为什么：WSL 侧脚本只取
+  payload 里第一个 `.deb`（`install-via-wsl.ps1`），而 server/full 的 deb 各带 ~719MB 模型 ——
+  照 `build.sh` 的 `stage_linux_payload`（把所有 deb+tar 全塞）打出来会是 ~2.4GB 的安装器。
+- `client`/`full` 变体还带 Windows GUI，需要 electron-builder 产出
+  `build/homeagent-gui-win32-x64/`；缺它就**明确失败**，不产出"装完没有界面"的半残包。
+
+**上传**（两仓同一个脚本）：
+
+```bash
+# 核心仓
+python3 deploy/scripts/upload_assets.py <tag> <token>                # 默认上传 dist/release 下可识别的产物
+# SDK 仓（hmapdev_* 没有扩展名，不会被自动识别 ⇒ 必须显式列文件名）
+GITCODE_REPO=JianFeeeee/homeagent-sdk ASSET_DIR=<sdk>/dist/release \
+  python3 deploy/scripts/upload_assets.py <tag> <token> hmapdev_linux_amd64 ...
+```
+
+- 脚本先向 `releases/<tag>/upload_url` 取 **OBS 预签名 URL** 再 PUT ⇒ **release 条目必须先存在**；
+- alpha/beta 的产物可以上传，但必须在 release 条目上勾选**预发布**标志（§2.4）；
+- 校验和必须覆盖**全部**附件，否则等于没有校验。
+- ❗❗**gitcode 的 release 附件是"同名只写一次"**（实测：同名两次不同内容，下载始终是第一次那份；
+  且没有可用的删除接口 —— release JSON 不含 `id`，附件列表接口 404，`DELETE .../attach_files/<名>`
+  只要数字 id）。**后果**：`SHA256SUMS` 若第一次上传时只覆盖了部分平台，之后**永远改不回来** ——
+  1.3.1–1.3.10 都踩了：首次只传了 linux/amd64，后来补 arm64/darwin/win 时合并重传**全部无效**，
+  线上那份至今只有 4 项。
+  ⇒ **纪律：首次上传 `SHA256SUMS` 前必须已打包全部平台**；分批上传时**先传产物、最后传校验和**，
+  且校验和只传一次。补救只能换名（如 `SHA256SUMS.complete`）或重建 release（要重传全部产物）。
+- ❗**流水线脚本必须 `set -e`（或显式检查每步）**：否则某一步失败（例如驱动脚本在 tag 里
+  不存在）之后它仍会继续跑到上传，把**半成品校验和**推上去覆盖全量的那份。
+  （实测：v1.3.10 的校验和被 4 项覆盖掉，只能重建。）
+- ❗**在 tag 的 worktree 里构建时，驱动脚本要么已进该 tag，要么支持目录覆盖**：
+  新补的脚本只存在于 main，去 tag 的 worktree 里调就是 `No such file or directory`。
+  现 `package-windows.sh` 支持 `DIST_LINUX` / `BUILD_DIR` / `DIST_RELEASE` 覆盖，
+  可以"用主仓的脚本 + 产物目录指向 worktree"。
+- ❗**分批上传时，后一轮必须在全量产物上重算 `SHA256SUMS`**，不能只算本轮那几个文件：
+  同名附件会**覆盖**前一轮的校验和（实测：先传 amd64 的 9 个资产，后补 arm64 时
+  只算了 arm64 的 4 个，结果 amd64 的校验和从 release 上消失 ⇒ 已下载的包失去校验依据，
+  只能把产物全部下回来重算）。要么一次打包全部平台再算，要么后一轮把**已上传的**
+  也纳入计算。
+
 ### 4. 版本号在两仓 main 上的含义
 
 两仓的 `main` 都遵守 §2.1：`meta.Version` 是**下一个未发布中版本**。

docs/zh/input-scheduler-design.md

@@ -0,0 +1,631 @@
+# 输入调度器设计（四级中断优先级 · 两类别 · 可抢占 · 现场保存）
+
+> **模型更正（2026-09-13，据用户澄清重写 §2/§3/§4.1/§6.3/§9/§11/§12）**
+>
+> 本稿早期版本把「四级优先级」当成了**所有任务**的通用优先级，并按通道名
+> （qq→L2、cli→L3）由内核推断级别。那是错的。正确模型是**两类别 + 四级**：
+>
+> | | 中断输入（interrupt） | 排队输入（queued） |
+> |---|---|---|
+> | 注入 API | `InjectInterrupt*` | `InjectText*` / `InjectInputSync*` / 内核自循环 |
+> | 级别 | L1–L4 | **无级别** |
+> | 定位 | 需要及时处理 | 不需要及时处理 |
+> | 可被谁打断 | 仅**严格更高级**的中断 | **任何**中断 |
+>
+> 级别（“这项工作有多不能等”）由来源在 `InjectOptions.Priority` 里声明。
+> L1–L3 任何插件可声明；**L4 是“立即打断”能力**，只有**内核自身**（panic /
+> 内核事件 selfip，经 `raiseKernelInterrupt`）与**内核级插件**（编译期内置插件，
+> 如 WebUI 的终止按钮）能用。外部插件的 L4 会被夹到 L3。
+> 类别由**用哪个注入 API**决定，与通道名无关——QQ 走的是 `InjectInterruptTextOpts`，
+> 所以它是**低级别中断（L1）**，不是排队输入。
+
+> 分支：`feature/input-semantics`
+> 状态：**设计稿 v1**（待确认项见 §12，未确认处按 §12 的「默认取值」推进）
+> 影响面：`internal/agent/core`、`internal/agent/io`、`internal/sdk`（**仅内部**）
+> 公开 SDK：**v1 不改**（`third_party/homeagent-sdk/sdk/` diff 必须保持为 0，理由见 §13）
+
+---
+
+## 1. 背景：现状与要解决的问题
+
+现有两条输入语义（见审查结论），都建立在**串行 `eventLoop`** 之上：
+
+| 语义 | 入口 | 路径 |
+|---|---|---|
+| 排队 | `InjectText` / `InjectInput*` | `io.inputCh` → `eventLoop` → `processInput` → `process()` |
+| 中断 | `InjectInterruptText` / `InjectInterrupt*` | `io.interruptCh` → `interceptLoop` → `cancelLLM` + `a.interceptCh` |
+
+已确认的具体问题（均为源码事实）：
+
+1. **队头阻塞**：`eventLoop` 单 goroutine，`process()` 全程持 `a.mu`（`internal/agent/core/process.go:103-104`），一轮对话（含 N 轮工具）期间后续输入全部排队。
+2. **中断只在一种时刻成立**：`interceptLoop` 有三条降级回排队的路径——当前无 LLM 在跑、当前轮是 `_consolidation_`、`a.interceptCh` 满（`internal/agent/core/eventloop.go:74-116`）。它不是独立管线，而是"抢占 + 三次降级"。
+3. **回执误投风险**：`ResponseCh` 只由全局 `emitResponse` 写（`eventloop.go:475`），无任务归属。一旦引入抢占，中断的回执会写进被挂起任务的等待者。
+4. **断链点静默**：`processInput` 有多条提前 `return` 而不 `emitResponse` 的路径（`resolveInput` 失败 `:309`、10s 去重命中 `:317`、`_consolidation_` `:326`），同步调用方（`cli`、`clawhubadapter` 无超时）永久挂起。
+5. **背压策略分裂**：`inputCh` 满 → 阻塞发送方；`selfInputCh` 满 → 静默丢弃；`a.interceptCh` 满 → 降级回 `inputCh`。
+6. **假取消**：工具超时只是放弃等待，内层继续执行且副作用照做（`internal/agent/core/toolcall.go:33-45`）。
+7. **不可观测**：没有任何"当前在跑什么、谁被挂起、降级了多少次"的统一入口。
+
+**目标**：把上述隐式行为收敛成一个**显式、可 dump、可单测、可断言**的调度器。
+
+---
+
+## 2. 术语与模型
+
+```
+Task = { id, class, level, origin, frame, state, enqueueAt, preemptCount, responseCh }
+  class: queued | interrupt       // **类别由注入 API 决定，与通道名无关**
+    queued    —— 无级别；用于“不需及时处理”的场景；可被**任何**中断打断
+    interrupt —— 带级别 L1..L4；仅被**严格更高级**的中断打断（被打断则压入中断栈）
+  level: 仅 interrupt 有意义（queued 恒无级别，effectiveLevel 视作 0）
+  state:  ready | running | suspended | done
+
+TaskFrame = {
+    msgs []Message            // 本任务自己的 LLM 消息序列
+    step  Step                // 下一个要执行的 step（安全点游标）
+    turn  int                 // 已完成的工具轮数
+    toolIdx int               // 当前工具批内的下标
+    toolResults []ToolResultItem
+    toolsUsed []string
+    lastBatchReplyOnly bool
+    stageCtx *sdk.StageContext
+    budget TokenBudget
+    outputChannel string      // 该任务的输出通道
+    responseCh chan<- *OutputEvent  // 任务级回执信道（可为 nil）
+    startedAt time.Time
+    input string              // 触发本任务的输入文本（COMMIT 时写记忆）
+    noMemory bool
+    originSource string
+}
+
+Step（枚举，顺序执行，步与步之间是安全点）：
+  S_PREPARE     构建 msgs / 应用中断标记 / 合并 stage 上下文
+  S_LLM         LLM 流式调用（**可抢占**：cancel 即丢弃）
+  S_POST        StagePostAction
+  S_LLM_JUDGE   无 tool_call → 去 S_BEFORE_OUTPUT；有 → 去 S_TOOL_BEGIN
+  S_TOOL_BEGIN  replyOnly 判定 + 取当前 tc
+  S_TOOL_BEFORE StageBeforeToolcall
+  S_TOOL_EXEC   工具执行（**临界区，不可抢占**）
+  S_TOOL_AFTER  StageAfterToolcall
+  S_TOOL_NEXT   批内下一个 / 批结束 → S_LLM
+  S_BEFORE_OUTPUT / S_AFTER_OUTPUT
+  S_COMMIT      context.Append + emitMemoryCandidate（**原子，不可抢占**）
+  S_FINISH      写 responseCh、发事件
+```
+
+四个容器（**不是**“三集合并成一个比较器”）：
+
+| 容器 | 内容 | 取出规则 |
+|---|---|---|
+| `interruptQueues[1..4]` | **中断队列**，每条队列一个级别 | 从 L4 到 L1 依次扫描；同级 FIFO |
+| `immediate` | 刚抢占成功的那一条中断（**至多一个**） | 最先取出——抢占必须**立即生效** |
+| `queue` | **排队输入**形成的新任务 | 纯 FIFO（无级别可比） |
+| `suspendStack`（**中断栈**） | 被打断、保存了现场的任务 | **LIFO，只比栈顶**；栈内不做重排 |
+
+> 用词（已更正）：它**就是中断栈**。用户明确存在「中断被中断」的场景，被打断的现场必须压栈；
+> 因此恢复纪律是**严格 LIFO（只比栈顶）**，栈内不做优先级重排。
+> 早期稿把它写成“不是栈、按优先级取”是错的。
+>
+> 早期稿还让 `immediate` 与别的容器共用同一个比较器，于是出现“抢占成功后，
+> 抢占者与被挂起者同级 → 原任务被立刻选回 → 抢占空转”——为此打的
+> “同级 pending 优先”补丁已删除：抢占者根本不进队列。
+
+---
+
+## 3. 优先级（只属于中断）
+
+### 3.1 两类别 + 四级
+
+**类别（`TaskClass`）由注入 API 决定，与通道名无关**：
+
+| 类别 | 注入入口 | 级别 | 可被谁打断 |
+|---|---|---|---|
+| `queued` 排队 | `InjectText*` / `InjectInputSync*` / `InjectInputMedia*` / 内核自循环（`selfInputCh`） | **无** | **任何**中断（L1 也能） |
+| `interrupt` 中断 | `InjectInterrupt*` | L1–L4 | 仅**严格更高级**的中断 |
+
+**级别（`Level`）语义是“这项工作有多不能等”**：
+
+| Level | 名称 | 语义 | 典型来源 |
+|---|---|---|---|
+| `L4` | CRITICAL | 内核紧急 | **内核独占**：panic 中断、内核事件中断（selfip） |
+| `L3` | INTERACTIVE | 需及时处理 | 时钟/定时器到达、终端输出、交互输入 |
+| `L2` | MESSAGE | 一般提醒 | 插件希望尽快看到、但不紧急的提示 |
+| `L1` | BACKGROUND | 完全可等 | 异步消息（QQ/微信）、批量通知 |
+
+- **`queued` 没有级别**：它本就是“不需及时处理”的那一类，
+  所以“可被任何中断打断”不是漏洞而是定义（`effectiveLevel(queued) == 0`）。
+- **默认级 = `L1`**：未声明一律最低级（“显式才是特权”，新插件不会默认拿到抢占权）。
+
+### 3.2 级别从哪来
+
+| 来源 | 可达级别 | 入口 |
+|---|---|---|
+| 普通插件（外部，独立进程/动态库） | L1–L3 | `InjectOptions.Priority`（空/非法 → L1；L4 被夹到 L3） |
+| **内核级插件**（编译期内置，`init()` 自注册） | L1–**L4** | 同上；L4 用于实现**中断能力**，例如 WebUI 的终止按钮 |
+| 内核自身 | L4 | `(*Agent).raiseKernelInterrupt`（panic / selfip） |
+
+- ❌ **不是运维可调项**。不引入 `core.agent.priority.<channel>` 这类配置键，
+  也不把 `PriorityLookup` 做成可注入的策略表。
+- ✅ 插件**可以声明**自己中断的级别（这不是“把内核内部属性外化”，
+  而是调用方声明它自己那件事有多不能等）。
+- ✅ **L4 给“立即打断”能力**：内核自身（panic / selfip）与**内核级插件**
+  （编译期内置插件，如 WebUI 终止按钮）可声明。为什么必须给内置插件：
+  用户按下终止按钮时，内核需要一条能立刻打断当前任务的中断；这条能力不能给
+  外部插件，否则任何第三方插件都能随时打断用户的一切工作。
+- **判据是“这个插件是不是编译期内置”，不是它自报的名字**：
+  - 第一道闸在 **proc 桥**（外部进程的唯一入口）：走它的一律把 L4 夹到 L3。
+    在这里夹而不是只按 `source` 判，是因为 `source` 是插件自报字段、可以冒名。
+  - 第二道闸在 **core**：`isKernelLevelSource(source)` 查
+    `pluginReg.IsBuiltinPlugin`，只有内置工厂才承认 L4（纵深防御）。
+  - `source` 的约定是 `插件名` 或 `插件名/实例`（如 `webui/<deviceID>`），
+    判据取第一段——否则带设备身份的 WebUI 来源会被误判成外部插件。
+
+### 3.3 抢占判据
+
+```go
+effectiveLevel(queued) == 0
+canPreempt(incoming, running) = incoming.Class == TaskInterrupt
+                              && effectiveLevel(incoming) > effectiveLevel(running)
+```
+
+因为 `queued` 的有效级恒为 0，这一个比较同时覆盖两条规则：
+
+```
+running 是排队任务      → 任何中断（≥L1）都抢占
+running 是中断 Li       → 只有 Lj > Li 的中断抢占（严格大于）
+incoming 是排队输入     → 永不抢占
+```
+
+**严格大于才抢占**；相等一律入队——这条保证确定性，也是“较低无法打断较高”的字面实现。
+
+## 4. 调度规则
+
+### 4.1 选择函数（四容器 · 固定次序）
+
+任务结束、或运行任务到达安全点且存在待处理抢占请求时，执行：
+
+```
+1. immediate 非空           → 取它（刚抢占成功的中断，抢占必须立即生效）
+2. 中断队列非空             → 取 L4→L1 中最高级非空队列的队头（同级 FIFO）
+3. 中断栈非空（与 2 比高）  → 栈顶有效级 ≥ 队头级别 ? 弹栈顶 : 取队头
+4. queue 非空              → 取队头（纯 FIFO）
+5. 都没有                  → 空闲（阻塞等新输入 / 新中断）
+```
+
+- **中断栈只把栈顶**放进比较（严格 LIFO）——栈内更老的任务即使因饥饿防护
+  提升了有效级，也不得越过栈顶；“后被打断的先恢复”才是栈语义。
+- 第 3 步就是用户给的规则：“先判断中断队列是否为空，同时判断中断栈中任务的
+  优先级，哪个优先级高取出哪个”。栈顶是 `queued`（有效级 0）时，任何中断都赢。
+- 第 1 步的存在，使“抢占者与被抢占者同级”这个比较**根本不会发生**：
+  抢占者不经队列。这是删除早期“同级 pending 优先”补丁后的正确形态。
+- 排队任务只在中断与挂起现场都处理完后才执行——这正对应“排队输入用于
+  不需要及时处理的场景”。
+
+### 4.2 安全点（可切换点）
+
+**只有 step 与 step 之间是安全点。** 明确：
+
+- ✅ `S_LLM` 之后、`S_TOOL_BEFORE` 之后、`S_TOOL_EXEC` **之后**、`S_TOOL_AFTER` 之后……
+- ❌ `S_TOOL_EXEC` **执行中不是安全点**：工具副作用不可回滚，无法"保存现场"。
+
+### 4.3 临界区
+
+```
+CriticalSection：step 标记 nonPreemptible = true，或任务进入声明区间
+```
+
+- 实现方式：**调度器在临界区期间不求值抢占**（协作式单线程下即"不 yield"），不使用 `sync.Mutex`。
+- 资源互斥不用锁，而是**调度器持有的资源表**（若某资源被 running 占用，则不会选出同样占用它的任务）——纯数据判定，天然无优先级反转。
+- **v1 临界区清单**（显式列出，避免"隐式临界区"）：
+
+| 临界区 | 理由 |
+|---|---|
+| `S_TOOL_EXEC`（单次工具执行全程） | 副作用不可回滚；插件 RPC 不可取消 |
+| `S_COMMIT` | 上下文/记忆写入必须原子 |
+| 需 ONNX 嵌入的 `S_PREPARE` 片段 | ONNX `Run` 不可取消 |
+| 媒体 CAS 落盘 | 同上 |
+| 显式声明的 `_consolidation_` 类任务 | 记忆一致性 |
+
+- 临界区期间到达的抢占请求**不丢失**：按级别进入中断队列，在临界区结束后的第一个安全点重新求值。
+
+### 4.4 背压（v1 统一为一种）
+
+- `readyQueue` 有界（默认 256，可配）。
+- 满时：**阻塞发送方**（与现状 `inputCh` 一致，避免静默丢用户输入），但必须**计数并打日志**。
+- 中断队列合计有界（默认同 `maxQueue`）；满时**丢弃最低级别里最老的一条并计数**（中断是提示性输入，宁可丢旧保新）。
+- 中断栈帧数上界是**结构推论 = 4**（见 §6.3），不是配置项。
+
+---
+
+## 5. 中断语义
+
+### 5.1 中断产生线程的职责（钉死）
+
+`interruptLoop` 只做三件事，**绝不触碰任何 TaskFrame**：
+
+```
+① 从 io.interruptCh 收中断 → 定级（读 payload["priority"]，插件声明 L1..L3）
+② 决策（scheduler.registerInterrupt 内）：
+     canPreempt(incoming, running) 且 running 不在临界区
+        → 置让位信号 + 把 incoming 放进 immediate 槽，并返回 true（调用方据此
+          取消当前可取消的 step，即 LLM 流式）
+     否则
+        → 按级别进入对应的中断队列
+③ 唤醒调度器（scheduler.wake，cap 1）
+```
+
+共享面仅三处：让位信号（`preemptArmed`/`preemptLevel`）、中断队列、`critical` 原子标志。
+**帧的保存与恢复只能由调度器做。**
+
+### 5.2 三种情形的统一
+
+现状的三条降级路径在新模型里不再需要特殊分支：
+
+| 情形 | 旧模型 | 新模型 |
+|---|---|---|---|
+| LLM 在跑，正常 | 真抢占（同轮 continue） | 真抢占：`S_LLM` 取消，任务 A **压入中断栈**，中断任务 B 从 `S_PREPARE` 启动 |
+| LLM 没在跑 | 降级为排队 | B 按其级别入中断队列（空闲时即被 `wake` 唤醒并选出） |
+| `_consolidation_` 中 | 降级为排队 | `_consolidation_` 是后台**临界区**（且它是排队任务）→ B 入中断队列，临界区结束后求值 |
+| `a.interceptCh` 满 | 降级为排队 | 不存在该队列；中断队列有界，满则丢最低级别里最老的一条 |
+
+### 5.3 中断任务与被打断任务的关系（**已定：D1 = 方案 B**）
+
+> 用户明确：
+> *“中断打断时，上个任务到达以来的所有上下文现场被保护（含 toolcall），
+> 然后中断在**上个任务前的那个完整状态**上开始运行。中断运行结束，再把被挂起的
+> 任务与其上下文现场**加载回中断任务之上**，并继续运行。”*
+
+因此语义是：
+
+1. **被挂起任务的现场 = 它自到达以来累积的全部上下文（含 toolcall 结果）**，
+   原样保存在 `TaskFrame` 里。
+2. **中断任务从「上一个任务之前的完整状态」开始运行**——它**看不到**被打断
+   任务的任何部分进展。等价于：中断任务就是一个普通新任务，正常走 `S_PREPARE`
+   （重建 system prompt + timeline + 自己的输入）。
+3. **中断结束后，把被挂起任务与其现场加载回「中断任务之上」再继续**：
+   中断已提交的那段上下文留在**下面**（成为重建前缀的一部分），本任务自己的
+   现场接回**其上**。
+
+实现对应（`internal/agent/core/task.go`）：
+
+- `TaskFrame.PrefixLen` 记录 prepare 段构建的**基础前缀**长度
+  （system + timeline + 用户输入）；其后的 Stage 上下文与工具轮产物都是“自己的现场”。
+- `rebaseFramePrefix(f)`：恢复时重建基础前缀（因中断结束已把它的输入/输出提交进
+  `a.context`，重建出的 timeline 已含中断效果），再把 `f.Msgs[PrefixLen:]` 原样接回；
+  并补回 prepare 段的両处尾部改写（`IsInterrupt` 的 `[中断消息]` 标记、输入多模态块）。
+- 调用点：`resumeTask` 在 `runTaskSteps` **之前**调用它。
+
+> 代价（已知且接受）：中断看不到“进行到哪一步”，所以“别搜了改成 X”这类指令
+> 只能靠它自己重新理解；换来的是中断起点总是一个**一致的完整状态**。
+
+---
+
+## 6. 保存现场与恢复
+
+### 6.1 保存
+
+在安全点被抢占时：
+
+```
+suspendStack.push(Task{frame: running.frame, state: suspended,
+                      step: running.frame.step, enqueueAt: running.enqueueAt})
+running.state = done_for_now
+```
+
+- **只保存数据帧**，不保存 goroutine 栈（这正是"单调度 + 隐式状态机"优于"park goroutine"的地方）。
+- `S_LLM` 被抢占时：**不完整的 LLM 请求直接丢弃**（LLM 调用幂等、无持久副作用）；恢复时从 `S_LLM` **重发**，`msgs` 与抢占前一致（即"请求前"的状态）。
+- 已提交的副作用（已执行的工具、已 append 的 context）**不回滚**——帧里记录的 `toolResults` 会保留，恢复后继续。
+
+### 6.2 恢复
+
+从**中断栈栈顶**取出后：
+
+1. **重建基础前缀**（`rebaseFramePrefix`）—— 此时中断任务已结束并提交，
+   重建出的 timeline 包含中断的输入/输出，即“现场加载回中断任务之上”；
+2. 把本任务自己的尾部（Stage 上下文 + 工具轮产物 + 占位）原样接回；
+3. 从 `frame.Step` 继续执行。
+
+被丢弃的只有那次**不完整的 LLM 请求**（幂等），已执行的工具与已累积的
+`toolResults` 全部保留。
+
+### 6.3 嵌套
+
+- 允许中断任务自身被更高级中断抢占（嵌套）。
+- **中断栈帧数上界 = 4，是结构推论而不是配置项**：
+  链条 = `排队(L0) ← I(L1) ← I(L2) ← I(L3) ← I(L4 运行中)`，
+  被挂起 4 帧；L4 之上没有更高级别，链到此为止。
+  （插件可达级别只到 L3，所以插件链最多挂起 3 帧 + 底层排队任务；
+  第 4 帧只能由内核 L4 制造。）
+- 栈自底向上的**基础级**天然递增（能被抢占者必然级别更高），因此栈顶通常就是最高级任务。
+- 超限在正确模型下不可达：`susp` 处只做**防御性计数**（`Rejected++`），
+  **不降级、不丢弃帧**——帧丢了会丢副作用记录。早期稿写的“超限转 pendingInterrupts”已删除。
+
+## 7. 回执路由（任务级）
+
+**必须改**：`ResponseCh` 从"全局 `emitResponse` 的对象"上升为 `TaskFrame.responseCh`。
+
+```
+emitResponse(task, ...)      // 写 task.frame.responseCh，而不是"当前全局通道"
+```
+
+- 抢占场景下，中断任务 B 的 `S_FINISH` 只可能写 `B.responseCh`，绝不会写进被挂起的 `A.responseCh`。
+- **不变量**：**每个任务在 `S_FINISH` 必然产生且仅产生一个终态事件**（无论成功、失败、被跳过）。`processInput` 现有的三个提前 return（解析失败、去重、consolidation）在新模型里都必须转成"任务以 `skipped` 终态结束并回执"。
+- 这顺带修掉现有缺陷：`cli`（`internal/plugins/cli/plugin.go:242`）与 `clawhubadapter`（`internal/plugins/clawhubadapter/plugin.go:1045`）的同步注入在断链时会永久挂起。
+
+---
+
+## 8. 并发结构（两个 goroutine）
+
+```
+schedulerLoop（唯一持有任务状态与帧）
+   for {
+     if 可切换 && preemptionRequest 有效 → 执行抢占（保存现场）
+     if running == nil → pick from 三集合；无候选则等待 inbox
+     runOneStep(running)          // 可能是阻塞调用（见 §8.2）
+     处理 step 结果 → 推进或结束任务
+   }
+
+interruptLoop（不持有任何帧）
+   收 interruptCh → 定级 → 决策 → 置 preemptionRequest + cancel + wake scheduler
+```
+
+### 8.1 不变量
+
+| # | 不变量 |
+|---|---|
+| I1 | 任意时刻至多一个 `running` 任务（"一个 running"约束的是**副作用**，不只是 CPU） |
+| I2 | 任务帧只由 `schedulerLoop` 读写；`interruptLoop` 只写 `preemptionRequest` / 读 `stepCancel` |
+| I3 | 任何跨挂起点的状态都是纯数据，不持有锁 |
+| I4 | 安全点只在 step 边界；工具执行中与 COMMIT 不是安全点 |
+| I5 | 每个任务恰好一次终态事件（含 `responseCh` 写入） |
+| I6 | 调度器本身永不退出（panic 只使当前任务失败） |
+
+### 8.2 关于"调度器不被阻塞"（**待确认 D2**）
+
+> **M3 拆分的理由**：真正的挂起要求帧跨越 `prepare → step… → finish` 全生命周期。
+> 若只把 `process()` 改成可挂起，`processInput` 会在挂起返回后继续执行
+> `context.Append` 与 `emitResponse`——造成重复提交。故 M3 分为 M3a（所有权重构，
+> 行为等价）与 M3b（抢占语义）两步。
+
+v1 采纳：**`S_TOOL_EXEC` / ONNX / CAS 属于临界区，调度器在这些 step 上会阻塞进插件 RPC / 原生调用。** 这是有意的取舍：
+
+- 好处：与"两个 goroutine 就够"一致，实现简单，无临时 goroutine。
+- 代价：这些临界区期间**中断只能排队，不能抢占**。换言之，**中断的有效窗口 = `S_LLM`**（与今天的实际行为相同，但现在是显式声明而非隐式结果）。
+- 演进（v2）：把 `S_TOOL_EXEC` 改成异步 step（临时 goroutine + 完成事件），并给插件协议加 `tool.cancel`。此路径在文档保留，不在 v1 实现。
+
+### 8.3 panic 隔离与 panic 中断
+
+- `runOneStep` 外包 `recover`：panic → 当前任务标记 `failed`，**调度器继续**。
+- panic 同时**产生一条内核 L4 中断**（`reportTaskPanic` → `raiseKernelInterrupt`）：
+  内核把自己发生了 panic 这件事作为最高级中断通知给调度器，让 agent 能知情/善后。
+- 递归保护是**结构性**的：若 panic 的任务本身就是 L4 内核中断，不再产生新的 L4——
+  否则同一个 panic 会自我放大成中断风暴。
+- 取代现有 `eventLoop`/`interceptLoop` 的 `recover → sleep 1s → go loop()` 无退避重启（`eventloop.go:19-22,38-42`）。
+
+---
+
+## 9. 失效模式与防御
+
+| 失效 | 防御 |
+|---|---|
+| 饥饿（高优先级流反复抢占） | `preemptCount` 提升有效级：`effectiveLevel = min(4, baseLevel + min(preemptCount, 2))`；被抢占 +1。**只对中断生效**——排队任务无级别，按定义可被任何中断打断 |
+| 无界下潜 | 中断栈帧数上界 4（结构推论 = 中断级数）；超限只做防御性计数，**不降级不丢帧** |
+| 中断请求堆积 | 中断队列合计有界，满则丢最低级别里最老的一条并计数 |
+| 就绪队列满 | 阻塞发送方 + 计数（不静默丢） |
+| 同一任务反复被打断 | `preemptCount` 达阈值后有效级提升；另设**抢占冷却**：刚被抢占的任务在 `cooldown` 内不再被同级/更低级抢占 |
+| 任务永不结束 | 每任务 `maxTurns`（主循环目前缺失，见审查 P0）+ 每步超时 |
+| 不可观测 | `Scheduler.Dump()` 原子快照 + 事件（切换原因、降级次数、丢弃次数） |
+
+---
+
+## 10. 非目标（v1 明确不做）
+
+1. 工具级取消 / 可抢占工具（`tool.cancel`）。
+2. 多 agent 并行（仍是单 agent 单调度器）。
+3. 公开 SDK 接口变更。
+4. 微抢占（任意指令级）。
+5. 跨进程恢复（帧不落盘）。
+
+---
+
+## 11. 测试点、测试方式与预期结果
+
+测试基础设施（先于 M1 落地）：
+
+- **假时钟** `Clock` 接口（`Now()` / `AfterFunc`），生产用真实实现，测试注入可控时钟。
+- **假 Provider**：实现 `agentAPI.Provider`，返回脚本化的 `tool_calls` 序列（支持"第 N 次调用时挂起直到放行"）。
+- **假工具**：测试内 `StageHost.RegisterTool` 注册，可控制每次执行耗时、是否返回错误、是否触发中断注入。
+- **同步栅栏**：测试通过 `scheduler.Inbox` 注入中断并用 `runtime.Gosched` + 显式 `waitFor(state)` 断言，不用 sleep 猜时序。
+- **快照断言**：`scheduler.Dump()` 返回 `{running, queue, interruptQueues[1..4], immediate, suspendStack, counters}`，测试对纯数据断言。
+
+### 11.1 优先级与抢占
+
+| 编号 | 测试点 | 方式 | 预期结果 |
+|---|---|---|---|
+| P1 | 更高中断抢占中断 | running=L2 在 `S_LLM`；注入 L3 中断 | L2 压入中断栈（step=S_LLM）；L3 进 `immediate` 并变 running |
+| P2 | 相等级别不抢占 | running=L2 中断在 `S_LLM`；注入 L2 | 不抢占；请求入 L2 中断队列；running 不变 |
+| P3 | 更低级别不抢占 | running=L3 中断；注入 L2 | 同上，不抢占 |
+| P4 | 逐级抢占嵌套 | 排队任务 → L1 → L2 → L3 → L4，均在 `S_LLM` | 中断栈深度依次 1/2/3/4；每层 step 均为 S_LLM |
+| P5 | 抢占后在安全点才生效 | running=排队任务在 `S_TOOL_EXEC`；注入 L4 | 抢占**不立即生效**；工具返回后才保存/切换；`deferredPreemptions==1` |
+| P6 | 临界区不可抢占 | running 声明临界区；注入 L4 | 同上；L4 请求留在中断队列，临界区结束立即被选中 |
+| **P7** | **排队任务被任何中断打断** | running=排队任务；注入 **L1** 中断 | L1 也抢占成功（排队任务有效级 0） |
+| **P8** | **排队输入永不抢占** | running=任意任务；注入排队输入 | 不抢占，入排队队列 |
+| **P9** | **外部插件不能声明 L4** | 外部来源声明 `Priority="L4"` | 被夹到 L3（proc 桥 + core 双重） |
+| **P11** | **内核级插件可用 L4** | 内置插件（如 webui）声明 `L4` | 得到 L4 并立即打断当前任务（终止按钮） |
+| **P10** | **panic 产生 L4 中断** | 任务 panic | 产生一条带 `kernel=true` 的 L4 中断；L4 自身 panic 不再递归 |
+
+### 11.2 保存现场与恢复
+
+| 编号 | 测试点 | 方式 | 预期结果 |
+|---|---|---|---|
+| R1 | 在 `S_LLM` 抢占后恢复 | 构造 A 在 `S_LLM` 被 B 抢占；B 结束 | A 恢复后**重新发起** LLM 请求；`msgs` 与 A 被抢占前**逐字节相同**；不重复执行已完成的工具 |
+| R2 | 在 `S_TOOL_BEGIN` 抢占后恢复 | A 完成 1 个工具批后于 `S_TOOL_BEGIN` 被抢占 | A 恢复后继续**下一批**工具；`toolResults` 长度不变 |
+| R3 | 恢复结果与不中断一致 | 同一脚本跑两次：一次中途注入中断，一次不注入 | 两次最终 `context` 事件序列**除"中断任务自身的事件"外一致**；A 的 `toolsUsed` 顺序相同 |
+| R4 | 嵌套恢复顺序 | L4→L3→L2 依次抢占后依次结束 | 按有效级/到达序恢复；每个任务的 `frame.step` 与其被挂起时一致 |
+| R5 | 不完整的 LLM 请求被丢弃 | 假 Provider 在流式途中触发中断 | 该次请求被 cancel；**不产生任何 `msgs` 追加、不产生 tool_call**；恢复后重发次数 = 1 |
+
+### 11.3 回执路由
+
+| 编号 | 测试点 | 方式 | 预期结果 |
+|---|---|---|---|
+| X1 | 任务级回执不误投 | A 为同步任务并已挂起；B 为同步中断 | B 的回执只到 `B.responseCh`；`A.responseCh` 在 A 恢复并结束后才收到自己的回执 |
+| X2 | 断链路径必有终态 | 分别构造：解析失败、10s 去重命中、`_consolidation_` | 三种都产生 `skipped` 终态事件并回执；同步调用方**不挂起** |
+| X3 | 每任务恰一次终态 | 统计 `S_FINISH` 次数 vs 任务数 | 相等（I5），无重复写入 |
+| X4 | 无超时同步注入不再永久挂起 | `cli` 路径（无超时）注入一条会被去重的输入 | 返回 `skipped` 回执而非永久阻塞 |
+
+### 11.4 队列与选择
+
+| 编号 | 测试点 | 方式 | 预期结果 |
+|---|---|---|---|
+| Q1 | 中断队列按级别扫 | 四条中断队列各放一个，入队顺序与级别相反 | 取出顺序 L4→L3→L2→L1；中断耗尽后才是排队任务（FIFO） |
+| Q2 | 挂起现场优先于新排队工作 | A 被抢占挂起 + B 为新排队输入 | A（栈顶）先被选中 |
+| Q3 | 栈顶 vs 中断队头 | 栈顶 L3 + 队头 L2 / 栈顶 L3 + 队头 L4 / 栈顶为排队任务 + 队头 L1 | 分别取 栈顶 / 队头 / 队头 |
+| Q4 | 就绪队列背压 | readyQueue 满后注入排队输入 | 发送方阻塞 + 计数 +1；不静默丢弃 |
+| Q5 | 中断队列溢出 | 中断队列合计满后注入更多 | 丢**最低级别里最老**的一条 + 计数；其余保持 |
+| **Q6** | **immediate 最优先** | `immediate` 非空且中断队列里有更高级别 | 取 `immediate`（抢占必须立即生效） |
+
+### 11.5 深度、饥饿与并发
+
+| 编号 | 测试点 | 方式 | 预期结果 |
+|---|---|---|---|
+| D1T | 下潜深度上界（结构推论） | 挂起 3 帧后继续注入；再挂起到 4 帧 | 3 帧时 `canSuspend()==true`；4 帧（全链：排队+L1+L2+L3，L4 运行中）时为 `false` |
+| G1 | 饥饿防护（抢占提升） | 对同一 **L1 中断**连续抢占 5 次（同级/高级交替） | `effectiveLevel` 提升至 `min(4, 1+2)=3`；第 3 次后不再被 L1/L2 抢占 |
+| G2 | 冷却生效 | 同一中断刚被抢占后立刻再注入同级中断 | 冷却期内不抢占，请求入中断队列 |
+| **G3** | **提升也必须只在中断间生效** | 排队任务被连续抢占 | 排队任务有效级恒 0（不被提升；它按定义可被任何中断打断） |
+| K1 | panic 隔离 | 假工具 panic | 只有该任务变 `failed`；调度器存活；后续任务正常执行 |
+| K2 | 竞态检查 | 全部调度用例加 `-race` | 无数据竞争报告 |
+| O1 | 快照一致性 | 在任意 step 边界调 `Dump()` | 返回的 `running/ready/pending/suspend` 三集合互不重叠且总数守恒 |
+| O2 | 切换可观测 | 每次抢占/恢复 | 产生一条事件（任务 id、原因、from→to、level） |
+
+### 11.6 端到端
+
+| 编号 | 测试点 | 方式 | 预期结果 |
+|---|---|---|---|
+| E1 | 真实 provider + 假长工具 | 启动内核，用一个会阻塞 5s 的假工具跑 L1 任务，途中经 `interceptCh` 注入 L4 中断 | 中断**在工具执行期间不被处理**；工具返回后立即抢占；中断任务先完成；原任务恢复并完成 |
+| E2 | LLM 流式中断 | 假 Provider 慢速流式返回 | 中断后当前流被 cancel，任务挂起，中断任务完成，原任务恢复并重新请求 |
+| E3 | 现有 e2e 回归 | 跑 `internal/plugins/integration_test.go`、`real_plugin_smoke_test.go` | 行为不变（除文档化的语义变化） |
+| **E4** | **优先级压力（用户指定形状）** | 固定内容假 provider（**记延迟，且被取消时立刻返回**），100 条排队输入 + 100 条中断（L1/L2/L3/L4 各 25）混合打入；每条中断都等到“该被它打断的受害者正在跑”时才注入 | 200 个任务全部到达终态；`Rejected=0`；各级登记数 = 25；**各级抢占数都 > 0**；排空后 `Suspended == Resumed`；每次“取消流式段”都换来一次挂起 |
+| **E5** | **嵌套到结构上限并 LIFO 展开** | 排队任务运行中依次注入 L1→L2→L3→L4（每级都等上一级在跑） | 栈深峰值恰好 **4**（= 结构上限，`canSuspend()==false`）；恢复顺序严格 LIFO `[L3, L2, L1, 排队]`；`Suspended==Resumed==4` |
+
+> E4/E5 的 provider 必须**感知 ctx 取消**：否则抢占只能等任务自然结束，
+> 测到的全是"步骤之间让位"，流式段的取消路径（真正的现场保存/恢复）压不到。
+> 实测：不感知取消时 `LLM完成 == 任务数`、挂起接近 0；感知后取消次数与挂起次数一一对应。
+
+---
+
+## 12. 待确认决策（含默认取值）
+
+> 未获异议时按"默认取值"实现；每项单独一个 commit，便于回退。
+
+| 编号 | 问题 | 默认取值 |
+|---|---|---|
+| **D1** | 中断任务的上下文 | **方案 B（已定）**：中断从上一个任务之前的完整状态开始；恢复时把被挂起任务的现场加载回中断之上 |
+| **D2** | 阻塞 step 处置：v1 全部声明为临界区（调度器可被阻塞）还是引入异步 step | **v1 = 临界区**；异步 step 留到 v2 |
+| **D3** | 中断队列与排队队列是否合一 | **完全分离**：中断按级别分四条队列（L4→L1 扫描），排队队列纯 FIFO，两者不共用比较器 |
+| **D7** | 任务类别怎么定 | **由注入 API 决定**（`InjectInterrupt*` = 中断；`InjectText*`/`InjectInputSync*`/自循环 = 排队），**不按通道名推断** |
+| **D8** | L4 归谁 | **内核独占**。唯一入口 `(*Agent).raiseKernelInterrupt`（panic / selfip）；`clampPluginLevel` 把插件声明夹到 L3 |
+| **D9** | L1–L3 归谁 | **插件在 `InjectOptions.Priority` 里声明**（纯追加字段）；空/非法降级到 L1 |
+| **D10** | 抢占者进入队列还是立即运行 | **立即运行**（`immediate` 槽）。这消除“抢占者与被挂起者同级”的比较，删除了早期的“同级 pending 优先”补丁 |
+| **D11** | 中断栈帧数上界 | **结构推论 = 4**（排队 L0 + I1 + I2 + I3 挂起，I4 运行中），不是配置项；超限只计防御性计数 |
+| **D4** | readyQueue 满时：阻塞发送方 or 返回错误 | **阻塞发送方 + 计数**（与现状一致，避免丢用户输入） |
+| **D5** | 饥饿防护：抢占计数提升 or 时间老化 | **抢占计数提升**（确定性、易测）；时间老化留待需要时 |
+| **D6** | 主循环 `max_tool_turns` 是否在本特性一并落地 | **是**（审查 P0，且调度器需要"任务可终止"这一前提） |
+
+---
+
+## 13. 与发布纪律的关系
+
+- 本特性在 `feature/input-semantics` 上开发，完成后合回 `main`，**不碰 `release/v1.2.x`**。
+- **公开 SDK 在本特性上有意新增**（feature 分支不受 rel 分支的接口冻结约束）：
+  `sdk.InjectOptions.Priority` 与 `sdk.PriorityL1/L2/L3`。这是为了让插件能声明
+  自己中断的级别（§3.2）。
+- **追加是唯一的形态**：不改既有字段、不改签名、不改语义；`Priority` 的零值
+  等价于旧行为（L1）。
+- 合回 `main` 前需完成的发布动作：
+  1. 同步更新 `docs/zh/plugin-interface-matrix.md`；
+  2. 与 SDK 仓协同升 SDK 中版本；
+  3. 遵守“只增不减、签名不改”边界。
+- 内核侧接口（`internal/agent/io`、proc 桥的 `injectParams`/`injectMediaParams`）
+  同步追加 `priority`，与公开 SDK 字段一一对应。
+
+## 14. 实现里程碑（逐个实现，每个 = 一个可独立验收的提交）
+
+| 里程碑 | 内容 | 验收 |
+|---|---|---|
+| **M0** | 测试基础设施：`Clock` 接口、假 Provider、假工具、`waitFor`、`Dump()` 骨架 | 新测试可运行；`go vet` 干净 |
+| **M1** | **纯重构**：把 `process()` 拆成显式 step 状态机 + `TaskFrame`；仍由现有 `eventLoop` 驱动，无优先级/无抢占 | R3、X3 通过；既有全部 agent 测试通过（行为等价） |
+| **M2** | 调度器骨架：单 `schedulerLoop` + `readyQueue`，取代 `eventLoop` 的输入处理；无优先级（全部 L1，纯 FIFO） | Q1/Q4 通过；integration 测试通过 |
+| **M3a** | **前置重构（本次拆分引入）**：把一轮对话的所有权从 `processInput` 移到调度器——帧覆盖 `prepare → step… → finish`；同时移除 `process()` 整轮持有的 `a.mu`（挂起不能持锁） | 既有全部 agent 测试 + 既有 e2e 通过（行为等价）；`-race` 干净 |
+| **M3b** | `interruptLoop` 重写 + 四级优先级 + 严格大于抢占 + 中断栈 LIFO；只支持 `S_LLM` 抢占 | P1–P4、R1、R5、K1–K2 通过；嵌套 LIFO 判据通过 |
+| **M4** | 临界区 + `S_TOOL_EXEC` 声明 + 中断队列 + 深度上界（**后经模型更正重做，见下**） | P5–P6、D1T、Q3、Q5 通过 |
+| **M5** | 饥饿防护（抢占计数提升 + 冷却） | G1–G2 通过 |
+| **M6** | 任务级 `responseCh` + 断链点统一为终态事件 | X1–X4 通过；`cli`/`clawhub` 不再挂起 |
+| **M7** | 可观测性（`Dump()`/事件/状态页）+ 既有回归 | O1–O2、E1–E3 通过；`go test -race ./internal/agent/... ./internal/plugin/...` 全绿 |
+
+每步收尾命令：
+
+```bash
+export GOCACHE=/tmp/gocache GOPATH=/tmp/gopath
+gofmt -l internal/agent internal/plugin internal/sdk   # 本步新增文件必须为空
+go build ./... && go vet ./...
+go test -race -count=1 ./internal/agent/... ./internal/plugin/... ./internal/sdk/...
+```
+
+### 实现状态（2026-09-13 完成）
+
+| 里程碑 | 提交 | 验收结果 |
+|---|---|---|
+| M1 | `9a58878` | ✅ agent 全量 + `-race`；新增 `task_test.go` 4 项 |
+| M2 | `7082a50` | ✅ 新增 `scheduler_test.go` 6 组（含 O1/K1） |
+| M3a+M3b | `c69a1f1` | ✅ 新增 `task_lifecycle_test.go` 5 项、`scheduler_preempt_test.go` 5 项 |
+| M4 | `7565248` | ✅ 新增 `scheduler_critical_test.go` 3 项 |
+| M5 | `a971fc8` | ✅ 新增 `scheduler_starvation_test.go` 4 项 |
+| M6 | `4e4e0ad` | ✅ 新增 `task_terminal_test.go` 3 项 |
+| M7 | `f11de37` | ✅ 新增 `scheduler_e2e_test.go` 3 项（压力/可观测/端到端） |
+
+#### 模型更正后的重构（2026-09-13，同一特性分支）
+
+用户逐条澄清后重做调度核心（**行为有意的语义变化**，非等价重构）：
+
+| 项 | 内容 | 验收 |
+|---|---|---|
+| 类别化 | `TaskClass{queued,interrupt}`；类别由注入 API 决定；`newInputTask`/`newSelfTask` 为 queued，`newInterruptTask` 为 interrupt | `scheduler_kernel_test.go` P7/P8 |
+| 级别归位 | `Level` 语义改为“中断级别”；`taskLevel()`（按通道名推断）删除，改为 `interruptLevel(evt, privileged)` 读 `payload["priority"]` | P9、P11、Q1 |
+| L4 内核独占 | `raiseKernelInterrupt`（panic/selfip）；`requestKernelPreempt` 不夹取；panic 报告为 L4 且带递归保护 | P10、`TestKernel_PanicRaisesL4Interrupt` |
+| 选择结构 | `immediate` + 四条中断队列 + 排队 FIFO + 中断栈；删除统一比较器 `pickTaskIndex`/`taskBefore` 与“同级 pending 优先”补丁 | Q1–Q3、Q6 |
+| 栈上界 | `maxSuspendDepth`（配置语义）→ `maxInterruptFrames = int(LevelCritical)`（结构推论）；删除“超限转 pending”降级 | D1T |
+| 公开 SDK | `InjectOptions.Priority` + `PriorityL1..L4`；io/proc 桥/插件模板同步透传；`example/qq` 声明 L1、`timer` 声明 L3、`webui` 终止按钮声明 L4 | `go test ./...` 全绿 |
+| 分级可观测 | `SchedulerStats.InterruptsByLevel[1..4]` / `PreemptsByLevel[1..4]`（按级别分桶，见 §11.6 E4） | 压力测试按级别断言 |
+| 计数修正 | `Resumed` 原本在 `nextRef` 与 `resumeTask` **各计一次**（双计），使"排空后 Suspended==Resumed"失真；现只在 `resumeTask` 计 | E4 断言 |
+| 压力测试 | `scheduler_stress_test.go`：100 排队 + 100 中断（各级 25）混合；另加嵌套到 4 帧上限并验证 LIFO | E4/E5 |
+
+实现期与设计的差异（均已回写本文档）：
+
+1. **M3 拆为 M3a/M3b**：真正挂起要求帧跨 `prepare→run→finish`，否则 `processInput`
+   会在挂起返回后继续提交。
+2. **`a.mu` 整体移除**：它原本只包住整轮 `process()`（同一 goroutine），
+   移除后所有任务状态由 schedulerLoop 独占（不变量 I2/I3 可落地）。
+3. **`interceptCh` 被删除**：M3b 起中断一律走中断队列（当时叫 `pendingInterrupts`），旧的
+   “同行注入 + 三处 drain + 批次放弃” 已无写入者，属死代码（M4 清理）。
+4. **v1 未做 M0 的伪时钟**：所有抢占测试用“单次调用阻塞到 ctx 取消”的
+   provider 达到确定性，无需注入时钟。时序型判据（老化式提升）留待需要时。
+5. **工具执行中不可抢占是被结构保证的**：让位检查只在 step 之间；
+   不需要在 step 内部再判一次。
+
+---
+
+## 15. 开放问题（后续版本）
+
+1. 异步 step + `tool.cancel`（真正让工具可抢占）。
+2. 帧落盘（跨进程/崩溃恢复）。
+3. 多 agent 并行调度。
+4. 与 `plan.md` §13.7 的 `RuntimeManager + 分组 worker` 合并（本设计是其前置）。
+
+> **已更正**：早期稿写“`InjectOptions.Priority` 进入公开 SDK 已被删除”，
+> 前提是“优先级是内核内部属性、不应由插件声明”。用户澄清后该前提被推翻：
+> **L1–L3 就是给插件声明使用的**。L4 的归属后来也明确了——不是“只有
+> panic/selfip”，而是**内核 + 内核级插件**（编译期内置）都能用，用于实现
+> “立即打断”（panic、内核事件、WebUI 终止按钮）。因此公开 SDK 同时导出了
+> `PriorityL4`（附“仅内核级插件”的说明）。
+>
+> 仍**不做**的是“运维可调的策略表”（`core.agent.priority.<channel>`）——
+> 那是把调度内部属性外化成配置，与“由调用方声明自己那件事有多不能等”不同。

docs/zh/resident-subagent-design.md

@@ -0,0 +1,626 @@
+# 驻留式子 Agent 设计（轻量内核 · 两级记忆 · 父子中断）
+
+> **前置**：本文建立在《输入调度器设计》（`docs/zh/input-scheduler-design.md`）之上。
+> 那里已经落地了：两类别输入（中断 / 排队）、四级中断优先级、可抢占、
+> 现场保存/恢复、中断栈（LIFO，结构上界 4 帧）、任务级回执、panic→L4。
+> 本文只描述**驻留式子 agent** 这一新能力，以及它对既有实现的改动。
+>
+> 标记：**［已定］**= 用户明确拍板；**［默认］**= 本文给出的可逆默认取值，实现时在提交信息里标注。
+
+---
+
+## 1. 背景与目标
+
+现状的子 agent 是**工作式轻量子**：`spawn_child` 起一个一次性 goroutine（临时 `msgs`），
+跑完把结果经 `selfInputCh` 回投父，然后销毁。它**没有**自己的中断机制、没有通道分配、
+没有可查询的状态面，父也无法在它运行途中干预它。
+
+要让父 agent 能**长期派驻**一个下属去持续处理某类工作（一个 inputch 上的来源、一段长期目标），
+就需要一种新的子 agent：**驻留子**。它必须满足：
+
+- 有自己的**轻量内核**（自己的调度器、中断机制、上下文），所以父能"打断它"、"查它"、"回收它"；
+- 有自己的**记忆空间**（可写），但**改不了父的主记忆** —— 记忆入库的决策权留在父手里；
+- 与父之间有**双向、可寻址**的通道（子→父、父→指定子），且父对子的消息是**最高级中断**；
+- 有一张**可被父查询的状态面**（inputch 处理表），使父不打断它也能知道它做到哪；
+- 生命周期由父掌握：父可随时**销毁**它，父退出时**必须**销毁全部。
+
+**两类子 agent 并存**［已定］：工作式轻量子**原样保留**（它是"内核自循环"的一部分，
+不是对等 agent）；驻留子是新增的第二类。
+
+---
+
+## 2. 术语
+
+| 术语 | 含义 |
+|---|---|
+| **根 agent** | 进程级主 agent，拥有**完整内核**（含记忆读写、全部通道） |
+| **驻留子** | 父创建、长期驻留的子 agent，拥有**轻量内核**与**临时记忆空间** |
+| **工作式轻量子** | 现状 `spawn_child` 的一次性子任务（**不是内核实例**） |
+| **inputch** | **最基本的输入路由单位**：对"中断输入 / 排队输入"两者的高层抽象，是**路由与分配**的单位；**由插件注册，一个插件可注册多个** |
+| **outputch** | 输出通道；输出是 agent 的**主动调用**，并**可寻址到具体 agent** |
+| **main 空间** | 主记忆空间：父读写、所有子只读、全部子共享 |
+| **temp 空间** | 子临时记忆空间：该子读写、子之间互不可见 |
+| **状态面** | 子对外（对父）可查询的状态：含 **inputch 处理表**与产出 |
+| **处理表** | 按 inputch 记录每轮处理信息的状态表（子持有，父 pull） |
+| **登记表** | 父持有的全部子 agent 名录（id / 状态 / 通道 / 状态面句柄） |
+| **contextfull** | 子的上下文窗口满，产生 L4 中断通知父 |
+| **压缩 / 回收 / 销毁** | 父对 contextfull 的三种处置（见 §9） |
+
+---
+
+## 3. 角色与内核形态
+
+| | **根 agent** | **驻留子** | **工作式轻量子**（保留不动） |
+|---|---|---|---|
+| 内核 | 完整 | **轻量** | 无（不是内核实例） |
+| 调度器 / 四级中断 / 中断栈 | ✅ | ✅（**L4 只来自父**） | ❌ |
+| 上下文 | 完整（记忆介导） | 传统上下文（消息序列） | 临时 `msgs` |
+| 记忆 | main 读写 | **读 temp ∪ main，写 temp** | 无 |
+| 通道 | 全部 | 父**划入**的输入通道 + **授权**的输出通道 | 无（结果回投父） |
+| 插件与工具 | 全部 | **父授权，默认完整授权**［已定］ | 现有剔除规则不变 |
+| 状态面 / 处理表 | — | ✅（父 pull） | ❌ |
+| 子→父 | — | 主动消息 = **L3 中断** | `injectSelfChannel` → `selfInputCh`（排队） |
+| 主→子 | — | **L4 中断**（取消当前状态 + 插入新消息） | 无 |
+| 生命周期 | 进程级 | 父持登记表；父可随时销毁；**父退出必须全部销毁** | 跑完即销毁 |
+
+---
+
+## 4. 通道模型
+
+### 4.1 `inputch` 的定义 ［已定］
+
+`inputch` **不是**通道名标签，也**不是**与 outputch 配对的东西。它是：
+
+1. **最基本的输入路由单位** —— 路由粒度到此为止：比"插件"细、比"通道名字符串"实；
+2. **由插件注册，且一个插件可注册多个** —— 同一个插件的多个 inputch 是**彼此独立**的
+   路由单位（可以绑给不同 agent、可以分别授权）。登记接口即现有的
+   `RegisterInputChannel(name, def)`，调 N 次就是 N 个 inputch；
+3. **对"中断输入"与"排队输入"两者的高层抽象** —— 两类输入都从 inputch 进出；
+4. **路由与分配的单位**：
+   - **路由**：一条输入投给哪个 inputch，就是"该由谁处理"的**既定事实**
+     ⇒ **路由发生在进内核之前**；
+   - **分配**：inputch 是**可分配资源**（父把输入通道划给子）。
+
+「中断 vs 排队」是**每条输入自己的类别**（由注入 API 决定），级别（L1–L4）也是
+**每条输入的属性**，都不是 inputch 的属性。
+
+### 4.2 三个入场（沿用现有实现）
+
+| 入口 | 承载 |
+|---|---|
+| `inputCh` | 外部客户端 / 插件的**排队与中断**输入（已预寻址） |
+| `interruptCh` | 中断入站（外部 / 插件 / 内核自身） |
+| `selfInputCh` | **内核自循环**：consolidation、工作式轻量子回投 |
+
+### 4.3 输出是**主动调用** ［已定］
+
+- 异步通道（qq / 微信 / 群聊…）：必须显式调用 `output_send__{通道名}` 才真正送达；
+- 同步通道（webui / cli / 终端）：返回纯文本，内核把文本交给等待方 ——
+  走输入事件自带的 `ResponseCh`，这是**事前定好的回程**。
+
+⇒ **内核不持有"当前通道"可变状态**，**提示词也不预设 outputch**。
+（要删 `Agent.currentOutputChannel`；要删 `tooldefs.go` 里"当前输入来源通道是 X，
+对应输出门工具是 output_send__X"那两行。）
+
+> 之前把这件事说成"内核路由"是错的：内核只负责**投递到既定的回程**与**执行显式的输出调用**。
+
+### 4.4 通道分配：不对称 ［已定］
+
+- **不按对划分**。父为子：**划入若干 inputch**（单位是 inputch，可以来自同一个插件的不同 inputch）
+  + 授权**一组可用输出通道**（授权集合，不是一对一）。
+- **输出通道可寻址到具体 agent**：
+  - **子 → 主**：子直接打到主（经输出通道投进主的 inputch）；
+  - **主 → 指定某个子**：父经输出通道投进**指定子**的 inputch。
+
+### 4.5 已经落地/待落地的两件事
+
+**已落地（N1a）**：inputch 登记表（归属插件 / 归属 agent / 容量 / 默认回程 / 策略）+ 共享登记表
++ 单工具多视图总览（`input_channels`，见 §4.6）。
+
+**已落地（N1b）**：
+- **输出通道授权集合**［已定：默认完整授权，父可收窄］：
+  `AgentConfig.AllowedOutputs`（nil/空 = 全部）。三处过滤点必须一致，
+  否则会出现"列表里看不到、按名字还能调"的裂缝：
+  1. **工具表**：不为未授权的通道生成 `output_send__X`（模型看不到就不会调）；
+  2. **列表工具**：`output_list_channels` 只列授权的（已登记目标的会标出"目标: agent / inputch"）；
+  3. **调用点**：凭名字直调未授权的输出门**必须被拒**（纵深防御）。
+- **输出通道 → 目标 agent 的 inputch 解析**：`ChannelRegistry.BindOutputTarget` /
+  `ResolveOutputTarget`（未登记的通道由传输层 device 自行处理，如 qq/webui）。
+  这是"输出可寻址到具体 agent"的数据面；真正的跨 agent 投递在 N4。
+
+**已落地（N3）：子的 io 通道视图 = 对父的**实时回退**
+
+输出通道在 io 层就是 `Device`，而它们由插件登记在**父**的 `IOManager` 上。驻留子确实该有
+自己的输入入口与 `outputCh`（所以子是 `NewIOManager()`），但**必须继承父的设备视图** ——
+否则上面 §4.4 的授权集合形同虚设：`output_list_channels` 为空、`output_send__X`
+连工具都不生成、按名字直调也会被判「通道不存在或不可用」。
+
+落地方式：`IOManager.SetParentIO(父)`（子创建时挂上）。
+
+| 方法 | 行为 |
+|---|---|
+| `GetDevice` / `GetChannelCapabilities` | 自己设备表没有时回退到父 |
+| `ListChannels` | 自己的登记优先（可覆盖/屏蔽同名通道），其次并入父的可见通道，按**名字**去重 |
+| `ExecuteTool` | 自己的设备工具没有时回退到父 |
+
+- **为什么是实时回退、不是创建时复制快照**：设备随资源生灭（远程设备上线/掉线以分钟计，
+  现场日志 60 秒一个来回），快照转瞬即过期；回退永远与父一致（父注销后子立刻看不见）。
+- **回退只解决"看得见"，不解决"能不能用"**：§4.4 的三处过滤点仍然在白名单之后，
+  授权收窄不受影响（判据：白名单外的通道既不出现在工具表里，直调也被拒且不送达）。
+- 现场缺陷（2026-09-13 用户线上联调实录）：**父侧通道装载完整、子侧 `childIO` 空壳**，
+  子调 `output_send__cli` 被判「通道 [cli] 不存在或不可用」。修复后线上实测：子调
+  `output_send__cli` → `result: ok`，并经 `notify_parent` 回报。
+
+### 4.5.1 通道的一等化（后续要求）
+
+现在 `Source` / `OutputChannel` 只是字符串标签，`IOManager.inputCh` 是**一条全局 channel**，
+`inputChannels` 只是策略表（`ChannelDef`：NoMemory / Cleaner / ContextPolicy），
+**没有归属、没有绑定、没有容量**。要实现 §4.4 需要新增：
+
+- **通道注册层**：`inputch` 成为一等对象。它已经是**最基本的输入路由单位**，
+  所以注册表以 **inputch 为键**（一个插件 → N 个 inputch），并给每个 inputch 带上：
+  **归属/被划给的 agent · 容量 · 可接收类别 · 输出目标解析**；
+  ⇒ 同一个插件的两个 inputch 可以**分别划给不同 agent**、**分别限额**；
+- **输出通道 → 目标 agent 的 inputch** 的解析；
+- **授权过滤**：`output_list_channels` 只列该 agent 被授权的通道。
+
+### 4.6 inputch 总览：**单工具多视图** ［已定］
+
+父 agent 必须能看清两件事：**有哪些 inputch 已注册（谁注册的）**、**它们是怎么划分的**。
+按用户要求构筑为**单工具多视图**（一个工具 + 一个 `view` 参数），而不是一堆小工具 ——
+视图切换比工具增殖更好用，也更省提示词预算。
+
+工具：**`input_channels`**
+
+| view | 内容 |
+|---|---|
+| `all`（默认） | 全部已注册 inputch：名字 / **归属插件** / 归属 agent / 容量 / 记忆策略标记 |
+| `mine` | 划给**本 agent** 的 |
+| `unassigned` | **尚未划出**的（可按需分配） |
+| `by_agent` | **划分情况总览**：按归属 agent 分组列出各自拥有哪些 inputch |
+| `detail`（需 `name`） | 单个 inputch 的全字段（注册插件 / 归属 / 容量 / 默认回程 / 记忆策略） |
+
+- 未知 `view` **必须报错并列出可用值**（拼错不得被静默当成默认视图）。
+- 登记表是**可共享对象**（`*ChannelRegistry`）：根 agent 与它的驻留子共用同一份，
+  这样"划入/授权"才有意义（默认每个 agent 自带一份，向后兼容）。
+- **插件重载不得抹掉划分**：重复登记只更新「归属插件 + 策略」，
+  保留已有的 Owner / Capacity / Output。
+
+---
+
+## 5. 记忆模型：两级空间 ［已定］
+
+> **适用范围**：这套"两级空间"是针对**图记忆**的。子 agent 的记忆面是
+> **传统上下文 + 图记忆**；**doc 记忆**与 **context 动态上下文**是内核独立设计的
+> 记忆能力，**只有根 agent 有**（子不可见、不可用，见 §5.5）。
+
+```
+主记忆空间（main）      ← 子【只读，可看到全部】；父【读写】；所有子共享
+子临时记忆空间（temp）  ← 该子【读写】；每个子独立、互不可见
+
+子的记忆查询 = temp ∪ main        子的记忆写入 → 只落 temp
+```
+
+| | 根 agent | 驻留子 |
+|---|---|---|
+| main | **读写** | **只读**（可见全部） |
+| temp | —（它自己就是 main 的所有者） | **读写**（自己的空间） |
+| 查询范围 | main | **temp ∪ main** |
+
+### 5.1 "轻量内核"的真正理由
+
+不是砍功能，而是**记忆层被作用域化**：
+
+- **写目标**被限定到 `temp`（子自己的命名空间）；
+- **读视图**被扩成 `temp ∪ main`（两个空间的并集）。
+
+完整内核的记忆层**硬绑定在单一 main 空间**上。要让每个 agent 都有自己的空间 +
+并集读视图，记忆层就必须接受**每个 agent 一份的作用域参数** —— 这就是轻量内核存在的理由。
+
+### 5.2 推论：记忆写工具不禁用，而是**重定向**
+
+子是**能写**的（写自己的 temp）。因此：
+
+- 记忆写工具（图记忆写、文本记忆写、**文档记忆写**、**向量索引写**、**媒体落盘**）
+  **不禁用，而是重定向到 temp 命名空间**；
+- 检索注入算"读"，范围 `temp ∪ main`；
+- 子**不能**写 main ⇒ "哪些内容进入主记忆"的决策**结构上**只在父手里（§9.2）。
+
+### 5.3 三种处置对记忆的作用
+
+| 动作 | temp | main | 子 |
+|---|---|---|---|
+| **压缩** | 保留 | 不写 | 继续 |
+| **回收** | 父读 → **选中的 promote 进 main** → 丢弃 temp | 父写 | 取消 |
+| **销毁** | 直接丢弃 | 不写 | 立刻移除 |
+
+### 5.5 子的记忆面：**传统上下文 + 图记忆** ［已定］
+
+| 记忆能力 | 根 agent | 驻留子 |
+|---|---|---|
+| **图记忆**（实体/关系/句子，含其向量检索） | ✅ main 读写 | ✅ **作用域化**（读 temp∪main，写 temp） |
+| **doc 记忆**（文档记忆） | ✅ | ❌ **不可用**（内核独立设计的记忆能力，父专属） |
+| **context 动态上下文**（动态上下文装配/裁剪） | ✅ | ❌ **不可用**；子用**传统上下文**（纯消息序列） |
+| 蒸馏 / 归档 / consolidation | ✅ | ❌（属上述父专属能力） |
+| 文本记忆 / 知识库 / 媒体 / 社交 | ✅ | ❌（同上） |
+
+⇒ 所以"轻量内核"的准确表述是：**传统上下文 + 图记忆（作用域化）** ——
+不是"记忆变轻了"，而是**记忆面被裁到只剩图记忆，且图记忆被作用域化**。
+
+### 5.6 实现形态：**独立存储实例**（不做 space 列）［已定］
+
+轻量内核的记忆**不是**把共享记忆层加一个 `space` 维度，而是**换一套装配**：
+
+```
+子的轻量内核
+├─ temp 图记忆实例（独立存储，**读写**）   ← 子的一切图记忆写入落这里，与子同生共死
+└─ 主图记忆的**受限句柄**（只读）          ← 子只能读
+     · OpenGraphDBReadOnly：连接可读/可恢复 WAL，但 SQLite 层 `PRAGMA query_only=1`
+       把一切写入直接拒掉 —— "子改不了 main" 是**结构性**保证，不靠自觉
+子的图记忆查询 = temp 实例 与 主实例 各查一次，应用层合并（并集）
+```
+
+- **不碰共享记忆层**：不加 `space` 列、不做 schema 迁移、55 处 SQL 原样。
+- **隔离靠"不同存储实例"**，不靠 where 条件 —— 漏写条件也不会串台。
+- **回收时由父合入**：父读子的 temp 实例，选出要保留的记录，写进主图记忆（父有写权）。
+- **可选简化**［用户给的备选］：把"允许子写图记忆"做成 profile 开关
+  （`AllowTempGraphWrite`，默认开）。设为 `false` 时子对图记忆**完全只读**，
+  没有 temp 实例、没有合入 —— 代价是回收时只剩状态面/处理表可收割。
+
+### 5.4 待钉的边界 ［默认］
+
+- temp 与 main 是**同一套记忆子系统里的命名空间**（同一批表/索引 + 一个 space 维度），
+  不是独立存储 ⇒ "并集读"就是一次查询里的两个 space 条件；
+- 父**可读**子的 temp（要决定 promote 什么），属"查看状态面"的一部分；
+- temp **与子同生共死**；子之间 temp **互不可见**。
+
+---
+
+## 6. 中断模型：两条独立阶梯 ［已定］
+
+```
+在【父的】中断阶梯上：
+    子的主动消息        = L3 中断   （子主动汇报，带子标识）
+    子的 contextfull    = L4 中断   （资源耗尽，需父立即决策，带子标识）
+
+在【子的】中断阶梯上：
+    父的消息（发送消息） = L4 中断   ← 子的 L4 归父独占
+```
+
+### 6.1 L4 归属通则
+
+> **某个 agent 的 L4 只属于它的"内核"。**
+
+- 根 agent 的内核 = 内核自身（panic / 内核事件 selfip）+ 内核级插件（WebUI 终止按钮）；
+- 驻留子的内核 = **父 agent**。
+
+⇒ 现有 `isKernelLevelSource`（只认编译期内置插件）**泛化为"该 agent 的上级"**，不为子开特例。
+
+### 6.1.1 **父消息 = 子的 L4**（落地机制，钉死）
+
+父 → 子的"发送消息"是一条 **L4 中断**，它是**子的阶梯上唯一的 L4 来源**。具体落地：
+
+```
+父【发送消息】到指定子
+   └─ 经输出通道寻址到该子的某个 inputch
+        └─ 在该子的调度器里按 L4 登记（子的内核级来源 = 父）
+             └─ 子的 L4 > 子内部一切 ⇒ 立即打断子的当前任务
+```
+
+- **子内部任何来源都够不到 L4**：子自己的输入注入、工具、定时器、插件……
+  一律被夹到 **≤ L3**（与根 agent 里"外部插件被夹到 L3"完全同一条规则，
+  只是"内核级来源"从"编译期内置插件"变成了"父 agent"）。
+- 后果一：**子内部任何东西都压不过父**（父的话是子的最高级输入）。
+- 后果二：父的"取消当前状态 + 插入新消息"因此是**确定能生效**的
+  —— 不会因子内部正在跑什么而被挡住（除非子处于不可抢占临界区，
+  此时按调度器既有规则在安全点生效）。
+
+**子侧内核级事件如何上报**（推论，待确认）：子的 panic / contextfull 属于**子侧的内核级事件**，
+但在**子的**阶梯上 L4 归父独占，所以它们不能作为"子自己的 L4"；应当**上报给父**，
+在**父的阶梯上以 L4（带子标识）**出现 —— 与 §9 的 contextfull 同一条通路。
+（即：父侧 L4 = 子侧内核级事件的接收位；子侧 L4 = 父控制语的发射位。）
+
+### 6.2 为什么 contextfull 是 L4 而不是 L3
+
+它是**必须由父立刻决策**的场合（三个处置都与子的存续有关），且决策要读**一整个状态面** ⇒
+只能"**推信号 + 拉状态**"，不能把状态塞进中断消息里。
+
+---
+
+## 7. 父对子的控制面（6 个动作）［已定：原语在内核，决策在父的模型］
+
+| 动作 | 语义 | 子是否继续存在 | 走哪条路 |
+|---|---|---|---|
+| **创建** | 划入输入通道 + 授权输出通道 + 授权插件/工具（默认完整）+ 在固定提示词之上注入任务提示词 | — | 内核原语 |
+| **发送消息** | 经输出通道寻址到子的 inputch：**取消当前状态 + 插入新消息** | 是 | 对子 = **L4 中断** |
+| **查看** | **pull** 子的状态面（处理表 + temp 产出），**不打断**子 | 是 | 纯查询，**不走中断** |
+| **压缩** | **保留语义**：压上下文 + **清理处理表** | **是**（同一驻留子） | 见 §9 |
+| **回收** | **取消语义**：父看状态面 → 选择哪些 **promote 进 main** → **取消**该驻留子 | 否 | 见 §9 |
+| **销毁** | **立刻销毁并从登记表移除**（不收割） | 否 | 立即 |
+
+- **创建/销毁/回收/查看/发送**是**父可调用的原语（工具）**；**决策**（压还是收、收哪些）
+  在父的模型手里 —— 内核不替父决定。
+- **默认完整授权**［已定］：子默认拿到全部插件与工具（含输出门）；
+  父可在创建时**收窄**（收窄工具子集、收窄可用输出通道集合）。
+  ⚠️ 默认含输出门意味着**子可以直接对用户通道发消息**；若要默认收窄，改一处默认即可。
+
+---
+
+## 8. inputch 处理表
+
+### 8.1 归属与方向
+
+- **子是持有者**；父**主动查看（pull）**，**不是**推给父。
+- **内容**：按 inputch 记录**每一轮**子对该 inputch 的处理信息。
+- **存在意义**：长期驻留子的**进度可见性** —— 父不必打断它就能知道它做到哪。
+
+### 8.2 写入规则
+
+- 子**主动写入**时，系统**不**自动写；
+- 子**未主动写入**时，系统**自动**把该轮 inputch 对应的信息写进去；
+- ⇒ **每一轮必有记录**，父不会看到空洞。
+
+［默认］"主动写入"的动作形态 = 子调用一个 `inputch_note` 类**工具**；
+自动写入在轮次结束时由内核兜底。
+
+### 8.3 生命周期 = 上下文窗口
+
+处理表记的是"**当前这段上下文窗口**里每轮 inputch 做了什么"。
+因此：
+
+- **压缩必须清表**（窗口被压成摘要后，逐轮记录被摘要取代；留着会让父看到与当前窗口
+  不对应的陈旧状态）；
+- **回收不必清表**（表就是父刚读过的收割材料，子都没了，表自然作废）；
+- ⇒ 处理表天然有**大小上界**（窗口多大、表最长多长），不需要额外容量策略。
+
+---
+
+## 9. contextfull 的处置
+
+```
+子的上下文窗口满
+   └─ 产生 contextfull → **L4 中断**通知父（中断信息里标明是哪个子）—— 只推信号
+        └─ 父【查看】子的状态面（处理表 + temp 产出）
+             ├─ 【压缩】压成摘要 → 清处理表 → 子续用            （保留语义）
+             ├─ 【回收】选择 temp 中哪些 promote 进 main          （取消语义）
+             │            → 丢弃 temp → 取消该驻留子
+             └─ 【销毁】立刻销毁并移除                            （不收割）
+```
+
+| 动作 | 语义 | 子上下文/成果 | 子 agent | 处理表 |
+|---|---|---|---|---|
+| **压缩** | **保留** | 压成摘要 | **继续存在** | **必须清理** |
+| **回收** | **取消** | 选中的 promote 进 main | **取消** | 不必清 |
+| **销毁** | 立刻销毁并移除 | 不收割 | 立刻销毁 + 出登记表 | 无关 |
+
+［默认］压缩由**子的轻量内核自己执行**（它拥有自己的上下文与 LLM）。
+
+---
+
+## 10. 登记表与生命周期硬约束
+
+- 父持 **agent 登记表**，记录全部子：`id / 状态 / 划入的输入通道 / 授权的输出通道 /
+  授权的插件与工具 / 状态面句柄`。
+- 它是**查看 · 发送 · 压缩 · 回收 · 销毁**的寻址依据。
+- **硬约束（必须写成测试）**：
+  1. 父 `Stop()` ⇒ 销毁全部子（取消运行中的任务、停轻量内核、释放其通道），
+     **登记表清空、不留孤儿**；
+  2. **子不得比父活得久**（无孤儿 goroutine / 无悬空通道 / 无残留 temp）。
+
+---
+
+## 11. 并发与不变量
+
+沿用输入调度器的并发模型，并按多 agent 扩展：
+
+- **每个 agent 一个调度器 goroutine**（根 agent 与每个驻留子各一个），
+  它**独占**自己的队列 / running / 中断栈 / 帧。
+- 跨 agent 投递只经**通道**（值传递），**不共享帧**；父**永远不能**直接改子的帧。
+- **子不得比父活得久**（§10）。
+- 父的"查看"是**只读快照**，不阻塞子、不参与子的调度决策。
+- **L4 独占**：子的调度器只接受来自父的 L4（§6.1）。
+
+---
+
+## 12. 与现有实现的接合点（差距清单）
+
+| 设计项 | 现状 | 要做 |
+|---|---|---|
+| 两类别 + 四级中断 + 抢占/挂起/恢复/中断栈 | ✅ 已落地（见 input-scheduler-design.md） | 复用 |
+| inputch 一等化（归属/容量/授权） | ❌ `inputCh` 是全局单 channel；`ChannelDef` 只是策略表 | **新增通道注册与分配层** |
+| 输出通道可寻址到 agent | ❌ 只有字符串标签；`output_list_channels` 列全部 | 通道解析表 + 授权过滤 |
+| 子的 L4 = 父 | ⚠️ `isKernelLevelSource` 只认内置插件 | 泛化为"该 agent 的上级"（分层） |
+| 轻量内核（记忆作用域化） | ❌ 记忆层绑定单一 main 空间 | 记忆子系统加 **space 维度**；`AgentConfig` 加**作用域参数** |
+| 记忆写路径重定向到 temp | ❌ 写路径无空间概念 | 所有写入口带 space；子的一切写 → temp |
+| 驻留子生命周期 + 登记表 | ❌ 只有一次性 `runChildTask` | 驻留子 + 父的登记表 + 退出清理 |
+| 跨 agent 投递（子→父 L3 / 父→子 L4） | ❌ 无 | 投递原语（复用注入层 + 通道寻址） |
+| inputch 处理表 | ❌ 无 | 新数据结构 + 主动写入工具 + 自动写兜底 |
+| contextfull 检测 | ❌ **完全没有** | 检测 + L4 通知（带子标识）+ 三处置 |
+| 内核不持有"当前通道" | ❌ `currentOutputChannel` + 提示词预设 | 删字段、删预设 |
+| 工作式轻量子 | ✅ | **不动** |
+
+### 16.0 N2c 施工方案（轻量内核接线）［已定方案：**窄接口 + nil 即禁用**］
+
+**先按"谁在调"把 `a.memory` 的 42 处使用分类**（`grep` 实测，非估计）：
+
+| 分组 | 位置 | 方法 | 谁用 |
+|---|---|---|---|
+| **A 记忆整理流水线** | `distill.go`（10）：`archiveLoop` / `reviewLoop` / `mergeLoop` / `detectEntityMerge` / `reviewRelations` / `archiveColdDocs` | `Recall`, `ClearSentenceID`, `CleanupOrphanedSentences` | **root-only**（后台定时器） |
+| **B 记忆块 + 媒体桥** | `graphmedia.go`（18）、`medialoop.go`（4） | `PutMemoryBlocks`, `AddMemoryBlockEdge`, `BlocksForNode`, `PutDocumentNode`, `MemoryBlocks`, `MigrateLegacyMediaEntities`, `mediaContextFor*` | **root-only** |
+| **C 记忆整理工具** | `toolcall.go::executeMemoryTool`（8） | `Introspect`, `MergeEntities`, `DeleteEntity`, `Purge`, `Commit` | **root-only**（`memory_merge`/`memory_delete_entity`/`memory_block_merge`/`memory_purge`/`memory_edit`/`memory_stats`） |
+| **D 共同面** | `graphmedia.go:114`（自动写入）、`toolcall.go:130`（`memory_recall`） | **只有 `Recall` + `Commit`** | 根与子都要 |
+| **E 判空/状态** | 22 处 `if a.memory != nil` + `GetKernelStatus` + `buildToolDefs` | — | 既有关卡 |
+
+⇒ **子 agent 需要的记忆面只有 `Recall` + `Commit`**；其余全是"整理记忆 / 记忆整理流水线"
+（用户指出的关键点），**子根本不该有那些代码路径**。
+
+#### 设计：窄接口 + nil 即禁用（不写"18 个方法返回错误"的受限包装）
+
+```go
+// core 内部：共同面（根与子都要）
+type GraphMemory interface {
+    Recall(keywords, seedEntities []string, depth int, sessionFilter string) (*memory.RecallResult, error)
+    Commit(triples []memory.Triple, sessionID string, turnID int) (int, int, error)
+}
+```
+
+| | `a.graph`（共同面） | `a.memory`（整理面：块/媒体/流水线/整理工具） |
+|---|---|---|
+| **根 agent** | 同一个 `*GraphDB` | `*GraphDB` |
+| **驻留子** | `*LightMemory` | **`nil`** |
+
+- 子把 `a.memory` 设为 `nil` ⇒ **既有的 22 处 nil 关卡自动禁掉全部 root-only 路径**
+  （`executeMemoryTool` 开头已经是 `if a.memory == nil { return "图记忆系统不可用" }`）。
+- 唯一要拆的是**自动写入路径** `commitTriplesWithMedia`：
+  图部分 → `a.graph.Commit`；块/媒体部分 → 由 `a.memory != nil` 守卫。
+- 工具表：`memory_recall`（读）对子开放；整理类
+  （`memory_merge`/`memory_delete_entity`/`memory_block_merge`/`memory_purge`/`memory_edit`/`memory_stats`）
+  **不进子的工具表**（而不是让它们进去再报"不可用"）。
+- 轻量 profile 另外不接线的装配：doc 记忆 / context 动态上下文（`pruneOnInput` 等）/
+  蒸馏 / 归档 / 关系复审 / 实体合并定时器 / consolidation / 人格门禁。
+
+### 16.0.0 传统上下文的实现口径（子 vs 父）
+
+"传统上下文"不是一句口号，它对应三处**代码闸门**（都按 `isLightKernel()` 判）：
+
+| 能力 | 父（完整内核） | 子（轻量内核） | 闸门位置 |
+|---|---|---|---|
+| 时间线拼装预算 | `budget.ContextTokens`（动态上下文算出的份额，≈窗口 32%~53%） | **整个窗口** `budget.MaxContext` | `contextTokenBudget()`（`stepPrepare` 与 `rebaseFramePrefix` 两处） |
+| 按相关度裁剪 + 向 doc 记忆归档 | 通道/注入点声明 `context_policy=prune` 时执行 | **不执行** | `pruneOnInput()` 前置返回 |
+| doc 记忆 / 记忆整理流水线 | 有 | 无（`a.memory == nil` ⇒ 既有 22 处关卡自动关闭） | `memoryface.go` / `tooldefs.go` |
+
+**"不裁"的准确含义**：不做**策略性**裁剪（不按相关度挑、不归档），只受"模型能收多少"这个
+**硬上限**约束；而且在撞到硬上限之前，contextfull（90% 窗口）已按 L4 上报父 agent —— 
+**丢事件的决定权在父，不在内核**（父可压缩/回收/销毁）。
+
+**顺带修掉的既有 bug**：`formatMergedTimeline` 逐事件估算原用 `len()`（**字节**）再 ×2，
+而 `EstimateTokens` 是 rune×2 ⇒ 中文事件被高估 3 倍，窗口还有余量也提前 break、
+把更早事件整段丢掉（实测 2384 字中文事件被估成 14398 token > 8192）。已改为统一的
+`EstimateTokens`。这条 bug 对父同样有效（中文长会话会被过早裁剪）。
+
+### 16.0.1 工具面（已实现）
+
+| 工具 | 谁用 | 作用 |
+|---|---|---|
+| `resident_agents` | 父 | **单工具多动作**：`list` / `create`（划入 inputch + 授权输出通道 + 注入任务提示词）/ `send`（对子 = L4）/ `inspect`（pull 处理表，不打断）/ `compress`（保留）/ `reclaim`（取消 + 合入）/ `destroy` |
+| `notify_parent` | 子 | 主动汇报（父侧 = **L3 中断**） |
+| `inputch_note` | 子 | 主动写本轮 inputch 处理信息（写了就不自动写） |
+
+> 声明是条件式的：父（`parentID == ""`）才有 `resident_agents`；子才有 `notify_parent` / `inputch_note`。
+
+### 16.1 N2 的记忆面清单（现状）
+
+`internal/memory/` 下需要加 space 维度的面：
+
+| 面 | 载体 | 表 | 子 agent 可用？ |
+|---|---|---|---|
+| **图记忆** | `memory.GraphDB` | `entities` / `sentences` / `relations` | ✅ **作用域化**（读 temp∪main，写 temp） |
+| **图记忆的向量检索** | `memory.Indexer` | （索引侧，与图记忆同步） | ✅ 同图记忆（需按 space 过滤） |
+| 文档记忆（doc 记忆） | `document.Store` | `documents` | ❌ 父专属 |
+| context 动态上下文 | 内核上下文装配/裁剪（`pruneOnInput` 等） | — | ❌ 父专属；子用传统上下文 |
+| 知识库 | `knowledge.Store` | 各自表 | ❌ |
+| 文本记忆 | `text.Memory` | 各自表 | ❌ |
+| 媒体 | `media.Store` | 落盘 + 索引 | ❌ |
+| 社交 | `social` | 各自表 | ❌ |
+
+⇒ N2a 做**图记忆 + 其向量检索**这一条纵切（子唯一可用的记忆面，
+也是"子写 temp / 父 promote 进 main"的主战场）；其余面在 v1 **不加 space 维度**
+（子根本够不到，加了是白工）——若将来子扩展记忆面再逐面补。
+
+---
+
+## 13. 非目标（本文明确不做）
+
+1. 跨进程 / 跨主机的驻留子（v1 只在同进程内）。
+2. 子的**子**（驻留子再创建驻留子）——先不做，保留扩展位。
+3. main 空间的**多写者**（父是唯一写者，不做并发合并）。
+4. temp 空间的持久化（跟子同生共死，不落盘）。
+5. 工作式轻量子的任何行为变更。
+
+---
+
+## 14. 测试点、方式与预期
+
+| 编号 | 测试点 | 方式 | 预期 |
+|---|---|---|---|
+| S1 | 创建：划入输入通道 + 授权输出通道 | 创建子，向划入的 inputch 投输入 | 子处理它；未划入的 inputch 投不进（或报错） |
+| S2 | 授权收窄 | 创建时只授权部分工具/插件 | 子的工具表恰为该子集；`output_list_channels` 只列授权的 |
+| S3 | 默认完整授权 | 不传授权参数创建 | 子拿到全部插件/工具 |
+| S4 | 子→父 L3 | 子在工作中主动发消息 | 父侧收到 **L3 中断**且带子标识；父可被打断（非临界区时） |
+| S5 | contextfull → L4 | 灌满子的上下文 | 父侧收到 **L4 中断**、带子标识，且**只推信号** |
+| S6 | 父→子 L4 | 父"发送消息"到指定子 | 子在收到时被打断（L4 > 子内部一切），按 §15 的默认挂起/恢复 |
+| S7 | 查看（pull 不打断） | 子在跑长任务时父"查看" | 返回状态面快照；**子的 step/帧不变**、未被抢占 |
+| S8 | 处理表：自动写兜底 | 子一轮不主动写 | 该轮仍有记录（系统自动写） |
+| S9 | 处理表：主动写优先 | 子主动写 `inputch_note` | 该轮只有主动写的内容，无自动写 |
+| S10 | 压缩（保留语义） | 父选压缩 | 上下文变短；**处理表被清空**；**子继续存在**且能继续干活 |
+| S11 | 回收（取消语义） | 父选回收并挑若干条 promote | 选中内容进 **main**、其余丢弃；**temp 被丢弃**；**子被取消** |
+| S12 | 销毁（立刻） | 父销毁（含子正在跑工具/LLM 时） | 子立刻消失、出登记表、其 temp 丢弃、通道释放 |
+| S13 | 子不得写 main | 子调记忆写工具 | 落在 **temp**；main 无新增 |
+| S14 | 子查询范围 = temp ∪ main | 子查只在 main 里的内容 / 只在 temp 里的内容 | 两者都能查到 |
+| S15 | 子之间 temp 隔离 | 两个子各写 temp，互相查 | 查不到对方的 temp |
+| S16 | 父退出清理 | 父 `Stop()`（多个子、有子在工作中） | 全部子被销毁；登记表空；**无孤儿 goroutine / 无悬空通道 / 无残留 temp** |
+| S17 | L4 独占 | 子内部（子自己的输入/工具/定时器）试图产生 L4 | 被夹到 **≤L3**；只有父的消息是 L4 |
+| S21 | 一个插件多个 inputch 可分别路由 | 同一插件注册 2 个 inputch，分别划给父与子后各投一条输入 | 各自只到被划给的 agent，互不串台 |
+| S22 | inputch 总览（单工具多视图） | 一个插件注册 2 个 inputch、另一插件 1 个；把其中若干划给本 agent | `view=all` 列出全部（带归属插件）；`mine`/`unassigned` 各自正确；`by_agent` 给出划分总览；`detail` 给出单条全字段；未知 view 报错并列出可用值 |
+| S23 | 插件重载不抹划分 | 先划分 inputch，再重复登记（模拟插件重载） | Owner/Capacity 保留，仅策略被更新 |
+| S19 | 父消息必能打断子 | 子在长任务中（LLM 流式段）时父发送消息 | 子按 L4 被打断；若子在不可抢占临界区，则在安全点生效 |
+| S20 | 子的内核级事件上报 | 子 panic / 子 contextfull | 在**父的阶梯上以 L4（带子标识）**出现；子侧不自己产生 L4 |
+| S18 | 内核不持有"当前通道" | 抢占/中断后被打断任务恢复并发响应 | 提示词与事件标签都**只来自输入事件**（不再有被覆盖的字段） |
+
+---
+
+## 15. 待确认决策（含默认取值）
+
+| 编号 | 问题 | 取值 |
+|---|---|---|
+| **R1** | 驻留子的内核形态 | **［已定］独立轻量内核**（自己的调度器/中断栈/上下文/记忆作用域） |
+| **R2** | 插件与工具 | **［已定］父授权，默认完整授权**（可收窄） |
+| **R3** | 记忆模型 | **［已定］两级空间**：读 temp∪main，写 temp（**范围 = 图记忆**） |
+| **R3b** | 子的记忆面 | **［已定］传统上下文 + 图记忆**；doc 记忆与 context 动态上下文是**父专属**（内核独立设计的记忆能力） |
+| **R13** | inputch 总览的形态 | **［已定］单工具多视图**（`input_channels` + `view`） |
+| **R11** | 父消息的级别 | **［已定］对子 = L4**（子的阶梯上唯一 L4 来源；子内部一律 ≤L3） |
+| **R12** | 子的内核级事件（panic / contextfull）上报级别 | **［默认/推论］在父的阶梯上以 L4（带子标识）上报** |
+| **R4** | 父→子消息落地 | **［默认］挂起/恢复**（现场不丢）；一处开关可改"直接丢弃" |
+| **R5** | "主动写入处理表"的形态 | **［默认］子调用 `inputch_note` 类工具**；未调用则轮末自动写 |
+| **R6** | 输入通道"划入"的语义与容量 | **［默认］读写授权（不转移所有权）+ 创建时给定容量**；**划入单位 = inputch**（不是插件、不是通道组） |
+| **R7** | 压缩由谁执行 | **［默认］子的轻量内核自己压**（它有自己的上下文与 LLM），压缩后清表 |
+| **R8** | 压缩前父是否"查看后决定" | **［默认］纯机械压缩**（父只在选"压缩 vs 回收"时决策） |
+| **R9** | 回收时处理表 | **［默认］不必清**（子都没了）；若日后要留作审计需单独策略 |
+| **R10** | 默认授权是否含输出门 | **［默认］含**（"默认完整授权"的字面含义）；若嫌宽，改默认即可 |
+
+---
+
+## 16. 实现里程碑（每步 = 一个可独立验收的提交）
+
+| 里程碑 | 内容 | 验收 |
+|---|---|---|
+| **N0** | **无状态化**：删 `Agent.currentOutputChannel`、删提示词里的通道预设 | S18；既有全部测试通过（这是纯收敛，不含新能力） |
+| **N1a** | **通道登记层**：inputch 一等化（归属插件 / 归属 agent / 容量 / 共享登记表）+ **单工具多视图总览** | S21–S23 |
+| **N1b** | 输出通道授权过滤 + 目标解析（outputch → 目标 agent 的 inputch） | S1–S3 |
+| **N2a** | ~~作用域对象 + 图记忆 space 维度~~ **已完成（改为独立存储实例）**：`OpenGraphDBReadOnly`（query_only 受限句柄）+ `LightMemory`（temp 可写 / 主库只读 / 并集查询 + 应用层合并） | S13–S15 ✅ |
+| **N2b** | 图记忆的向量检索在并集下的排序/去重（当前按实体名/三元组合并，检索排序沿用单库语义） | 待做（非阻塞） |
+| — | 其余记忆面（doc 记忆 / 动态上下文 / 知识库 / 文本 / 媒体 / 社交）：**v1 不加 space**（子不可达） | 由 S13/S14 隐含 |
+| **N2c** | ~~Agent 级 profile~~ **已完成**：`GraphMemory` 窄接口（Recall/Commit）+ `a.graph` 共同面；子 `a.memory = nil` ⇒ 22 处既有关卡自动禁用整理面 | S13–S15 ✅ |
+| **N2d** | ~~晋升与丢弃~~ **数据面已完成**：`GraphDB.ExportTriples` + 复用 `Commit` 合入（父选哪几条）；`LightMemory.Close()` 丢弃 temp | S11 数据面 ✅ |
+| **N3** | ~~驻留子生命周期~~ **已完成**：`SpawnResident` / `DestroyResident` / `Residents()`（登记表）/ `Stop()` 内 `StopResidents()`（父退出不留孤儿）/ 归还划入的 inputch / 丢弃 temp 目录 | S12、S16 ✅ |
+| **N4** | ~~跨 agent 投递~~ **已完成**：子→父 `notify_parent`（L3，投父的 `child/<id>` inputch）；父→子 `SendToResident`（L4，`KernelSource` 分层使父在子的阶梯上是唯一 L4 来源）；子的 contextfull 经 `raiseKernelInterrupt` 以 L4 上报父 | S4、S6、S17、S19、S20 ✅ |
+| **N5** | ~~inputch 处理表~~ **已完成**：`inputch_note`（主动写优先）+ `autoRecordInputch`（轮末兜底）+ `CompressResident` 清表 + 父 `ResidentTable(id)` pull 查看 | S8、S9 ✅ |
+| **N6** | ~~contextfull~~ **已完成**：判据 = **未裁剪的积累上下文**超过窗口 90%（不能用拼好的 `f.Msgs`——它被 token 预算封在 ~80% 窗口内，是永不成立的判据）；通知 = 父侧 L4（`child/<id>`）；三处置 = `CompressResident`（保留：`TrimKeepRecent` + 清表）/ `ReclaimResident`（取消：`ExportTriples` 选出后 `Commit` 进 main）/ `DestroyResident` | S5、S10、S11 ✅ |
+| **N7** | ~~e2e + 压力~~ **已完成**：`resident_test.go` 五项（生命周期/双向投递/处理表/contextfull 三处置/8 子×12 轮压力 + 双向汇报），`-race -count=3` 干净 | S1–S20 覆盖 ✅ |
+
+每步收尾命令：
+
+```bash
+export GOCACHE=/tmp/gocache GOPATH=/tmp/gopath TMPDIR=/var/tmp/gotmp
+gofmt -l internal/agent internal/plugin internal/sdk   # 本步新增文件必须为空
+go build ./... && go vet ./...
+go test -count=1 ./... && go test -race -count=1 ./internal/agent/... ./internal/plugin/...
+```
+
+---
+
+## 17. 与发布纪律的关系
+
+- 本设计在 `feature/input-semantics` 之后的特性分支上开发，完成后合回 `main`。
+- 若需要动公开 SDK（例如新增 `agent_*` 控制面原语、通道授权字段），按"**只增不减、签名不改**"
+  追加，并同步 `docs/zh/plugin-interface-matrix.md` 与 SDK 仓版本。

internal/agent/core/agent.go

@@ -26,19 +26,47 @@ import (
 // ContextEvent 和 RelevanceContext 定义在 context.go
 
 // Agent — 单 agent，不区分会话/实例
+//
+// 并发现状（M3a 起）：所有任务状态只由 **schedulerLoop goroutine** 独占读写，
+// 因此不再有保护整轮执行的互斥量——挂起不能持锁（见 docs/zh/input-scheduler-design.md §8.1 I3）。
+// 仍需跨 goroutine 保护的是：childMu/llmMu/lastInputMu/noMergeMu 与各子系统自己的锁；
+// interceptLoop 只允许触碰 preemptionRequest 与 cancelLLM（经 llmMu）。
 type Agent struct {
-	mu              sync.Mutex
 	id              types.AgentID
 	provider        agentAPI.Provider
 	providerManager *agentAPI.ProviderManager
 	io              *agentIO.IOManager
 	memory          *memory.GraphDB
-	indexer         *memory.Indexer
-	tracker         *tracker.Tracker
-	context         *RelevanceContext
-	systemPrompt    string
-	ctx             context.Context
-	cancel          context.CancelFunc
+	// graph 是本 agent 的**图记忆共同面**（根 = 同一个 GraphDB；驻留子 = LightMemory）。
+	// 整理面仍走 memory 字段（子为 nil ⇒ 既有的 nil 关卡自动禁用整理面）。
+	graph GraphMemory
+
+	// kernelSource/parentID/taskPrompt/dataDir：驻留子相关的层级信息（见 AgentConfig）。
+	kernelSource string
+	parentID     string
+	taskPrompt   string
+	dataDir      string
+
+	// 驻留子（父侧）：登记表 + 子侧钩子。
+	residentMu sync.Mutex
+	residents  map[string]*residentChild
+
+	// 子侧：向父发消息（L3）与 contextfull 上报（父侧内核级事件）的钩子。
+	notifyParent    func(text string)
+	onContextFull   func()
+	ctxFullSignaled bool
+
+	// 子侧：inputch 处理表（子持有，父 pull）。
+	tableMu        sync.Mutex
+	inputchTable   []InputchRecord
+	inputchPending *InputchRecord
+	currentInputch string
+	indexer        *memory.Indexer
+	tracker        *tracker.Tracker
+	context        *RelevanceContext
+	systemPrompt   string
+	ctx            context.Context
+	cancel         context.CancelFunc
 
 	// 文档记忆（第二层）
 	docStore *document.Store
@@ -64,6 +92,9 @@ type Agent struct {
 	// 为 nil 时门禁与工具都静默关闭（例如单测里不接配置的场景）。
 	personaStore PersonaStore
 
+	// 被授权的输出通道集合（空 = 完整授权，见 AgentConfig.AllowedOutputs）。
+	allowedOutputs []string
+
 	// 插件注册表（用于 plgreload）
 	pluginReg *plugin.Registry
 	pluginDir string
@@ -80,7 +111,6 @@ type Agent struct {
 	maxContextSize int
 
 	// 当前请求的输出通道（mutex 保护，process() 内独占）
-	currentOutputChannel string
 
 	// 阶段管道：插件消息流编辑
 	stageHost    *StageHost
@@ -106,8 +136,12 @@ type Agent struct {
 	// childSeq 给完成的任务排个序，用于有界淘汰。
 	childSeq int64
 
-	// 高优先级打断通道：interceptLoop 注入，process() 在工具循环轮次间非阻塞读取
-	interceptCh chan *agentIO.InputEvent
+	// 输入调度器：就绪队列、任务抽象与快照（见 scheduler.go）。
+	// M2 起取代 eventLoop 的隐式 channel 排队。
+	sched *scheduler
+
+	// 工具轮次硬上限（0 = 不限）；见 AgentConfig.MaxToolTurns。
+	maxToolTurns int
 
 	// 进行中的 LLM 请求取消函数，interceptLoop 可调用以在请求中打断
 	cancelLLM context.CancelFunc
@@ -128,7 +162,7 @@ type Agent struct {
 	//
 	// 需要缓存而不是当场挂到事件上：媒体在 process() 执行期间被捕获，
 	// 而承载它的 ContextEvent 要等 process() 返回后才 Append——此刻还没有 owner_id。
-	// 与 pendingMedia 同受 a.mu 保护。
+	// 由 schedulerLoop goroutine 独占读写。
 	pendingMediaDigests []string
 
 	// 当前输入是否为工具提醒/中断（以 system 角色注入，避免被当成用户消息）
@@ -182,8 +216,13 @@ type AgentConfig struct {
 	ProviderManager *agentAPI.ProviderManager
 	IO              *agentIO.IOManager
 	Memory          *memory.GraphDB
-	Indexer         *memory.Indexer
-	Tracker         *tracker.Tracker
+	// LightMemory 是**轻量内核**的图记忆装配（驻留子用；读 temp∪main，只写 temp）。
+	//
+	// 给了它就意味着这是轻量内核：`Memory` 必须为 nil，
+	// 于是记忆整理面（块/媒体/流水线/整理工具）全部不可达（见 memoryface.go）。
+	LightMemory *memory.LightMemory
+	Indexer     *memory.Indexer
+	Tracker     *tracker.Tracker
 
 	DocStore        *document.Store
 	Knowledge       *knowledge.Store
@@ -193,12 +232,29 @@ type AgentConfig struct {
 	MultimodalSpace vector.MultimodalEmbedder
 	// EmbeddingProvider / EmbeddingError 是向量空间的配置身份与打开失败原因，
 	// 供 healthcheck_kernel 状态报告区分「未配置 / 打开失败 / 已启用」。
-	EmbeddingProvider  string
-	EmbeddingError     string
-	FusionCfg          CrossModalFusionConfig // 跨模态融合权重；零值用默认
-	Personality        *agentPkg.Personality
-	PersonaStore       PersonaStore // 人格设定的读写面（首启门禁 + persona_set 工具）
-	PluginReg          *plugin.Registry
+	EmbeddingProvider string
+	EmbeddingError    string
+	FusionCfg         CrossModalFusionConfig // 跨模态融合权重；零值用默认
+	Personality       *agentPkg.Personality
+	PersonaStore      PersonaStore // 人格设定的读写面（首启门禁 + persona_set 工具）
+	PluginReg         *plugin.Registry
+	// KernelSource 是本 agent 的"上级"（驻留子的父）。
+	//
+	// 设计 §6.1：某个 agent 的 L4 只属于它的**内核** —— 根 agent 的内核是内核自身与
+	// 内核级插件；驻留子的内核是**父 agent**。因此子的 KernelSource = 父 ⇒ 只有父
+	// 能在子的阶梯上产生 L4（父的"发送消息"）。
+	KernelSource string
+	// ParentID 是父 agent 的 id（空 = 根 agent）。子用它判断自己是不是驻留子。
+	ParentID string
+	// DataDir 是本 agent 的数据目录；创建驻留子时用它派生 temp 图记忆路径。
+	DataDir string
+	// TaskPrompt 是在固定提示词之上注入的**任务提示词**（驻留子创建时给定）。
+	TaskPrompt string
+	// AllowedOutputs 是本 agent **被授权的输出通道集合**（设计 §4.4 / R2）。
+	//
+	// nil 或空 = **完整授权**（默认）；非空 = 白名单，只允许列出的输出通道。
+	// 父 agent 创建驻留子时用它收窄子的输出能力。
+	AllowedOutputs     []string
 	PluginDir          string
 	DistillInterval    time.Duration
 	ArchiveInterval    time.Duration          // 冷文档归档间隔（L2→L3），0 则使用 DistillInterval
@@ -215,6 +271,10 @@ type AgentConfig struct {
 	SkillIndexProvider SkillIndexProvider
 
 	InputProcessing types.InputProcessingConfig // 非文本输入处理配置
+
+	// MaxToolTurns 是单个任务允许的工具轮次上限（0 = 不限）。
+	// 设计文档 D6：主循环必须有硬上限，否则模型不停调用就永不完结。
+	MaxToolTurns int
 }
 
 func New(cfg AgentConfig) *Agent {
@@ -265,13 +325,18 @@ func New(cfg AgentConfig) *Agent {
 		}
 	}
 
-	return &Agent{
+	a := &Agent{
 		id:                cfg.ID,
 		startTime:         time.Now(),
 		provider:          cfg.Provider,
 		providerManager:   cfg.ProviderManager,
 		io:                cfg.IO,
 		memory:            cfg.Memory,
+		graph:             graphMemoryOf(cfg),
+		kernelSource:      cfg.KernelSource,
+		parentID:          cfg.ParentID,
+		taskPrompt:        cfg.TaskPrompt,
+		dataDir:           cfg.DataDir,
 		indexer:           cfg.Indexer,
 		tracker:           cfg.Tracker,
 		context:           rc,
@@ -285,6 +350,7 @@ func New(cfg AgentConfig) *Agent {
 		mediaStore:        cfg.MediaStore,
 		personality:       cfg.Personality,
 		personaStore:      cfg.PersonaStore,
+		allowedOutputs:    cfg.AllowedOutputs,
 		pluginReg:         cfg.PluginReg,
 		pluginDir:         cfg.PluginDir,
 		distillInterval:   cfg.DistillInterval,
@@ -297,7 +363,8 @@ func New(cfg AgentConfig) *Agent {
 		eventBus:          cfg.EventBus,
 		selfInputCh:       make(chan selfInputMsg, 64),
 		childTasks:        make(map[string]*childTaskState),
-		interceptCh:       make(chan *agentIO.InputEvent, 64),
+		sched:             newScheduler(256),
+		maxToolTurns:      cfg.MaxToolTurns,
 		pluginHealth:      newPluginHealthTracker(),
 		thinkingEnabled:   cfg.ThinkingEnabled,
 		inputCfg:          cfg.InputProcessing,
@@ -309,13 +376,21 @@ func New(cfg AgentConfig) *Agent {
 		noMergeMarkers:    make(map[string]int),
 		lastInput:         make(map[string]time.Time),
 	}
+
+	// 输入路由：inputch 是可分配资源，划给某个 agent 后输入**只**流向那个 agent
+	// （设计 §4.1「路由发生在进内核之前」）。io 层不认识 agent，所以在这里把路由器
+	// 注入进去：插件注入输入时先问它，被别的 agent 接管就不再进本内核队列。
+	if a.io != nil {
+		a.io.SetInputRouter(a.routeInputByOwner)
+	}
+	return a
 }
 
 // SetSkillIndexProvider 注入技能索引提供者（skillmgr 插件加载后由 main 接线）。
 func (a *Agent) SetSkillIndexProvider(p SkillIndexProvider) { a.skillIndex = p }
 
 func (a *Agent) Start() {
-	go a.eventLoop()
+	go a.schedulerLoop()
 	go a.interceptLoop()
 	go a.distillLoop()
 	go a.archiveLoop()
@@ -327,11 +402,89 @@ func (a *Agent) Start() {
 }
 
 func (a *Agent) Stop() {
+	// 父退出**必须**销毁全部驻留子（设计 §10 硬约束：子不得比父活得久、不留孤儿）。
+	a.StopResidents()
+	// 停机前给待办任务补终态。运行中的任务会经 cancel → LLM 失败 → emitResponse
+	// 自然拿到终态，但**从未运行**（排队/待处理）与**已挂起**的任务不会有任何人
+	// 回它们；带 ResponseCh 的同步注入方（cli / clawhubadapter 均无超时）会永久挂起
+	// （设计 §7 I5、§11.3 X2/X4）。必须在 cancel 之前做：cancel 会让调度器直接 return。
+	a.drainPendingInterrupts("agent_stopped")
 	a.cancel()
 }
 
+// drainPendingInterrupts 给排队/待处理/已挂起任务中带同步回执通道的调用方补一条
+// skipped 终态（复用 emitSkippedReply：非阻塞写，不对外发 agent_output 事件）。
+func (a *Agent) drainPendingInterrupts(reason string) {
+	if a.sched == nil {
+		return
+	}
+	pending := a.sched.pendingEvents()
+	if len(pending) == 0 {
+		return
+	}
+	for _, evt := range pending {
+		a.emitSkippedReply(evt, reason)
+	}
+	log.Printf("[agent] %s: 停机，%d 条待办任务已补 skipped 终态", a.id, len(pending))
+}
+
+// graphMemoryOf 决定本 agent 的图记忆共同面实现。
+//
+//   - 轻量内核（给了 LightMemory）：用 LightMemory，**整理面保持 nil**；
+//   - 完整内核：直接用主图库（*memory.GraphDB 天然满足 GraphMemory）。
+func graphMemoryOf(cfg AgentConfig) GraphMemory {
+	if cfg.LightMemory != nil {
+		return cfg.LightMemory
+	}
+	if cfg.Memory == nil {
+		return nil
+	}
+	return cfg.Memory
+}
+
+// graphMem 返回本 agent 的图记忆**共同面**。
+//
+// `graph` 显式为 nil 时回落到 `memory` —— 这样"只设 memory 的构造"
+// （大量既有测试直接用 Agent 字面量）照常工作，不需要同时维护两个字段。
+// 轻量内核则显式设 graph=LightMemory 且 memory=nil：共同面走 LightMemory，
+// 整理面因 memory==nil 而全部不可达。
+func (a *Agent) graphMem() GraphMemory {
+	if a.graph != nil {
+		return a.graph
+	}
+	if a.memory == nil {
+		return nil
+	}
+	return a.memory
+}
+
 func (a *Agent) ID() types.AgentID { return a.id }
 
+// IsOutputAllowed 报告某个输出通道是否被授权给本 agent。
+//
+// 默认（未配置白名单）= **完整授权**；这是"默认完整授权、父可收窄"的落点。
+func (a *Agent) IsOutputAllowed(channel string) bool {
+	if len(a.allowedOutputs) == 0 {
+		return true
+	}
+	for _, c := range a.allowedOutputs {
+		if c == channel {
+			return true
+		}
+	}
+	return false
+}
+
+// ResolveOutputTarget 解析输出通道的投递目标（agent + inputch）。
+//
+// ok=false 表示该输出通道由传输层（device 通道，如 qq/webui）自行处理。
+func (a *Agent) ResolveOutputTarget(channel string) (agentIO.OutputTarget, bool) {
+	if a.io == nil || a.io.ChannelRegistry() == nil {
+		return agentIO.OutputTarget{}, false
+	}
+	return a.io.ChannelRegistry().ResolveOutputTarget(channel)
+}
+
 // isDuplicateInput 判断是否为短窗口内的重复输入（防 webui/GUI 断线重连消息重放）。
 // key=source+"|"+content；窗口内重复返回 true 并刷新时间戳（持续轰炸时保持拦截）。
 const duplicateInputWindow = 10 * time.Second

internal/agent/core/context.go

@@ -451,6 +451,29 @@ func (c *RelevanceContext) Blocks() []memory.MemoryBlock {
 	return out
 }
 
+// TrimKeepRecent 只保留最近 n 条事件，丢弃更旧的（返回丢弃条数）。
+//
+// 这是**压缩上下文**（保留语义）的机械原语：不归档、不写任何记忆，直接丢弃旧事件。
+// 用于轻量内核（驻留子）：它没有 doc 记忆与记忆整理流水线，压缩只能是"保留最近的"。
+func (c *RelevanceContext) TrimKeepRecent(n int) int {
+	c.mu.Lock()
+	if n < 1 {
+		n = 1
+	}
+	if len(c.events) <= n {
+		c.mu.Unlock()
+		return 0
+	}
+	dropped := len(c.events) - n
+	kept := make([]*ContextEvent, n)
+	copy(kept, c.events[dropped:])
+	c.events = kept
+	c.dirty = true
+	c.mu.Unlock()
+	c.save()
+	return dropped
+}
+
 func (c *RelevanceContext) Len() int {
 	c.mu.Lock()
 	defer c.mu.Unlock()

internal/agent/core/device_tool_auth_test.go

@@ -0,0 +1,92 @@
+package core
+
+// 设备类工具的**授权闸**：设备指令类工具走的是工具面，而 AllowedOutputs 只作用于
+// output_send__<通道> —— 不补闸的话"授权"对指令类完全无效（驻留子拿到
+// device_ctl_cmdrun 就能指挥任意设备）。这里按目标设备的通道名 device/<id> 查同一道闸。
+
+import (
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+)
+
+// registerFakeDevice 注册一台假设备，带一个"需要 device_id 的指令类工具"和一个无参枚举工具。
+func registerFakeDevice(t *testing.T, a *Agent, name string, called *[]string) {
+	t.Helper()
+	dev := &mockOutputDevice{
+		name: name,
+		caps: agentIO.CapStructured,
+		tools: []agentIO.ToolDef{
+			{Name: "device_ctl_cmdrun", Description: "在设备上执行命令"},
+			{Name: "devicedetect", Description: "枚举设备"},
+		},
+		toolFn: func(tool string, args map[string]interface{}) (interface{}, error) {
+			if called != nil {
+				*called = append(*called, tool)
+			}
+			return "ok:" + tool, nil
+		},
+	}
+	if err := a.io.RegisterDevice(dev); err != nil {
+		t.Fatalf("注册测试设备 %s 失败: %v", name, err)
+	}
+}
+
+func deviceToolCall(name string, args map[string]interface{}) agentAPI.ToolCall {
+	return agentAPI.ToolCall{ID: "call_1", Name: name, Arguments: args}
+}
+
+// 完整授权（根 agent 默认）：设备指令工具照常可用。
+func TestDeviceToolAuth_RootHasFullGrant(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+	var called []string
+	registerFakeDevice(t, a, "devicectl", &called)
+
+	got := a.executeToolCall(deviceToolCall("device_ctl_cmdrun", map[string]interface{}{
+		"device_id": "pc-1", "command": "ls",
+	}), "cli")
+	if !strings.Contains(got, "ok:device_ctl_cmdrun") {
+		t.Fatalf("根 agent 应可指挥任意设备，实际: %s", got)
+	}
+}
+
+// 收窄授权（驻留子）：只授权了 device/ok-1，指挥别的设备必须被拒，且**不落到设备**。
+func TestDeviceToolAuth_NarrowedGrantRefusesOtherDevice(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+	a.allowedOutputs = []string{"device/ok-1"}
+	var called []string
+	registerFakeDevice(t, a, "devicectl", &called)
+
+	got := a.executeToolCall(deviceToolCall("device_ctl_cmdrun", map[string]interface{}{
+		"device_id": "other-2", "command": "rm -rf /",
+	}), "cli")
+	if !strings.Contains(got, "未授权") {
+		t.Fatalf("未授权设备应被拒，实际: %s", got)
+	}
+	if len(called) != 0 {
+		t.Fatalf("被拒的调用不得落到设备，实际执行了 %v", called)
+	}
+
+	// 已授权的设备照常可用
+	got = a.executeToolCall(deviceToolCall("device_ctl_cmdrun", map[string]interface{}{
+		"device_id": "ok-1", "command": "ls",
+	}), "cli")
+	if !strings.Contains(got, "ok:device_ctl_cmdrun") {
+		t.Fatalf("已授权设备应可用，实际: %s", got)
+	}
+}
+
+// 无参枚举类（devicedetect）不受闸门影响：它不指向具体设备。
+func TestDeviceToolAuth_EnumerationNotGated(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+	a.allowedOutputs = []string{"device/ok-1"}
+	var called []string
+	registerFakeDevice(t, a, "devicectl", &called)
+
+	got := a.executeToolCall(deviceToolCall("devicedetect", map[string]interface{}{}), "cli")
+	if !strings.Contains(got, "ok:devicedetect") {
+		t.Fatalf("枚举类工具不应被设备授权闸拦，实际: %s", got)
+	}
+}

internal/agent/core/distill.go

@@ -495,7 +495,6 @@ func (a *Agent) emitMemoryCandidate(source, input, response string, toolResults
 
 func (a *Agent) processConsolidation(evt *agentIO.InputEvent, input string) {
 	start := time.Now()
-	a.currentOutputChannel = "_consolidation_"
 
 	stageCtx := a.stageCtxFromInput(input, evt.Source, "")
 	stageCtx.Extra["output_channel"] = evt.OutputChannel

internal/agent/core/eventloop.go

@@ -13,25 +13,11 @@ import (
 	pubsdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk"
 )
 
-func (a *Agent) eventLoop() {
-	defer func() {
-		if r := recover(); r != nil {
-			log.Printf("[agent] eventLoop panic recovered: %v\n%s", r, debug.Stack())
-			time.Sleep(time.Second)
-			go a.eventLoop()
-		}
-	}()
-	for {
-		select {
-		case evt := <-a.io.InputChan():
-			a.handleInput(evt)
-		case msg := <-a.selfInputCh:
-			a.handleSelfInput(msg)
-		case <-a.ctx.Done():
-			return
-		}
-	}
-}
+// eventLoop 已由 scheduler.go 的 schedulerLoop 取代（M2）。
+//
+// 原实现直接在 select 里处理 inputCh/selfInputCh，没有任何可枚举的队列、
+// 无法承载优先级与抢占；现在任务先入就绪队列，由选择函数 pickTaskIndex 决定下一个。
+// 兼容性说明：M2 全部任务为 LevelBackground，因此行为等价于原先的 FIFO。
 
 func (a *Agent) interceptLoop() {
 	defer func() {
@@ -64,43 +50,16 @@ func (a *Agent) interceptLoop() {
 			clone.Payload["interrupt_source"] = evt.Source
 			clone.Payload["interrupt_channel"] = evt.OutputChannel
 
-			a.llmMu.Lock()
-			hasActiveLLM := a.cancelLLM != nil
-			if hasActiveLLM {
-				a.cancelLLM()
-				log.Printf("[agent] LLM request cancelled by interrupt")
-			}
-			a.llmMu.Unlock()
-
-			if hasActiveLLM {
-				if a.currentOutputChannel == "_consolidation_" {
-					log.Printf("[agent] consolidation interrupted, re-injecting input for %s/%s", evt.Source, evt.OutputChannel)
-					a.io.InjectInputTo(evt.Source, evt.OutputChannel, "text", map[string]interface{}{
-						"content":           text,
-						"interrupt":         true,
-						"interrupt_source":  evt.Source,
-						"interrupt_channel": evt.OutputChannel,
-					})
-				} else {
-					select {
-					case a.interceptCh <- clone:
-					default:
-						log.Printf("[agent] intercept channel full, queuing input for %s", evt.Source)
-						a.io.InjectInputTo(evt.Source, evt.OutputChannel, "text", map[string]interface{}{
-							"content":           text,
-							"interrupt":         true,
-							"interrupt_source":  evt.Source,
-							"interrupt_channel": evt.OutputChannel,
-						})
-					}
-				}
-			} else {
-				a.io.InjectInputTo(evt.Source, evt.OutputChannel, "text", map[string]interface{}{
-					"content":           text,
-					"interrupt":         true,
-					"interrupt_source":  evt.Source,
-					"interrupt_channel": evt.OutputChannel,
-				})
+			// 决策交给调度器：requestPreempt 总会登记中断（进中断队列或 immediate，
+			// 因而不会丢），仅当它会真抢占时才告诉我“该取消可取消的步骤”。
+			// 本 goroutine 不碰任何帧——只写中断队列与让位信号。
+			//
+			// 级别由来源声明（InjectOptions.Priority → payload["priority"]）；
+			// 未声明一律 L1。L4（“立即打断”）只有内核级插件能声明，
+			// 外部插件即便报了 L4 也会被夹到 L3；内核自身另有 raiseKernelInterrupt。
+			level := interruptLevel(evt, a.isKernelLevelSource(evt.Source))
+			if a.sched.requestPreempt(clone, level) {
+				a.cancelCurrentLLM()
 			}
 
 		case <-a.ctx.Done():
@@ -109,6 +68,20 @@ func (a *Agent) interceptLoop() {
 	}
 }
 
+// cancelCurrentLLM 取消正在进行的 LLM 请求（若有）。
+//
+// 只有 LLM 流式步骤是可取消的；工具 RPC / ONNX / CAS 在 v1 是临界区，
+// 取消对它们无效——让位信号会等它们自然结束后的安全点（设计文档 D2）。
+func (a *Agent) cancelCurrentLLM() {
+	a.llmMu.Lock()
+	cancel := a.cancelLLM
+	a.llmMu.Unlock()
+	if cancel != nil {
+		cancel()
+		log.Printf("[agent] LLM request cancelled by preemption")
+	}
+}
+
 // channelConsolidation 标记记忆整理类自输入：无记忆路径处理，
 // 不写入对话上下文、不向任何输出通道 emit 响应。
 const channelConsolidation = "_consolidation_"
@@ -122,22 +95,27 @@ type selfInputMsg struct {
 	channel string
 }
 
-func (a *Agent) handleSelfInput(msg selfInputMsg) {
+// selfEvent 把内核自循环消息归一成输入事件。
+func selfEvent(msg selfInputMsg) *agentIO.InputEvent {
 	if msg.channel == "" {
 		msg.channel = channelConsolidation // 兼容空值：默认走整理路径
 	}
-	a.processInput(&agentIO.InputEvent{
+	return &agentIO.InputEvent{
 		Source:        "system",
 		Type:          "text",
 		Payload:       map[string]interface{}{"content": msg.text},
 		OutputChannel: msg.channel,
-	})
+	}
+}
+
+func (a *Agent) handleSelfInput(msg selfInputMsg) {
+	_, _ = a.runInputTask(selfEvent(msg))
 }
 
 func (a *Agent) handleInput(evt *agentIO.InputEvent) {
 	switch evt.Type {
 	case "text", "image", "audio":
-		a.processInput(evt)
+		_, _ = a.runInputTask(evt)
 
 	case "event":
 		log.Printf("[agent] event from %s: %v", evt.Source, evt.Payload)
@@ -297,171 +275,51 @@ func (a *Agent) mediaToBlocks(payload map[string]interface{}, mediaType string,
 	return blocks, alt
 }
 
-// processInput 是全部模态输入的唯一主干。
+// emitSkippedReply 给被跳过任务的**同步**调用方一个终态。
 //
-// 文本、用户上传的图/音频、插件注入的多模态块走同一条路径，因此去重、
-// no_memory、通道 Cleaner、中断语义、EventRawInput、媒体入 CAS、媒体记忆绑定
-// 对所有模态一致——不会再出现「文本路径加了功能、媒体路径没跟上」。
-func (a *Agent) processInput(evt *agentIO.InputEvent) {
-	start := time.Now()
-
-	in, ok := a.resolveInput(evt)
-	if !ok {
+// 为什么要单独一条路径而不是复用 emitResponse：跳过意味着“我们没有处理这条输入”，
+// 不应对外发 agent_output 事件（否则 WebUI 聊天记录会凭空多出一条空消息），
+// 但必须写 ResponseCh——否则 cli/clawhub 这类无超时的同步注入会永久挂起。
+//
+// 非阻塞写：ResponseCh 由同步调用方以 cap=1 创建，调用方超时离开后仍可写入。
+func (a *Agent) emitSkippedReply(evt *agentIO.InputEvent, reason string) {
+	if evt == nil || evt.ResponseCh == nil {
 		return
 	}
-
-	// 去重按文本做：webui/GUI 断线重连会重放未确认消息。
-	// 带媒体时跳过——媒体输入的 alt 文案（"[从 qq 收到了 image]"）对不同图片
-	// 是同一句，拿它去重会把连发的两张图误判成重复。
-	if len(in.blocks) == 0 && a.isDuplicateInput(evt.Source, in.text) {
-		log.Printf("[agent] dropped duplicate input from %s: %s", evt.Source, truncateStr(in.text, 60))
-		return
+	ch := evt.OutputChannel
+	if ch == "" {
+		ch = evt.Source
 	}
-
-	a.currentOutputChannel = evt.OutputChannel
-	if a.currentOutputChannel == "" {
-		a.currentOutputChannel = evt.Source
+	payload := map[string]interface{}{
+		"content":    "",
+		"request_id": evt.RequestID,
+		"skipped":    true,
+		"reason":     reason,
 	}
-
-	if evt.OutputChannel == "_consolidation_" {
-		a.processConsolidation(evt, in.text)
-		return
-	}
-
-	// pendingMedia 让 describe_image / transcribe_audio / ocr_image 拿到本轮媒体的
-	// 原始 data/url，也是这三个工具是否出现在工具表里的开关。仅对用户直接上传成立
-	//（payload 里才有 data/url）；插件注入的是成品 block，取不到原始数据。
-	if evt.Type == "image" || evt.Type == "audio" {
-		a.pendingMedia = evt.Payload
-		defer func() { a.pendingMedia = nil }()
-	}
-
-	// 媒体先落进 CAS。不存的后果是 ContextEvent.Input 只剩一句 alt 文本，
-	// base64 随 message 数组发给模型后就丢了。
-	if len(in.blocks) > 0 {
-		a.stageMediaDigests(a.captureBlockMedia(in.blocks, in.captureTool)...)
-	}
-
-	noMemory := false
-	if v, ok := evt.Payload["no_memory"].(bool); ok {
-		noMemory = v
-	}
-	if !noMemory && a.io != nil {
-		if chDef, ok := a.io.GetInputChannelDef(evt.Source); ok && chDef.NoMemory {
-			noMemory = true
-		}
-	}
-
-	// 工具提醒/中断（terminal_watch、timer 等）不是用户发言：
-	// 以 system 角色注入 LLM，且不写入用户对话履历。
-	isInterrupt, _ := evt.Payload["interrupt"].(bool)
-	a.mu.Lock()
-	a.interruptInput = isInterrupt
-	a.mu.Unlock()
-	if isInterrupt {
-		noMemory = true
-	}
-
-	stageCtx := a.stageCtxFromInput(in.text, evt.Source, "")
-	stageCtx.Extra["input_source"] = evt.Source
-	stageCtx.Extra["output_channel"] = evt.OutputChannel
-	if len(in.blocks) > 0 {
-		stageCtx.Extra["media_blocks"] = in.blocks
-		stageCtx.Extra["media_type"] = in.mediaType
-	}
-	if noMemory {
-		stageCtx.NoMemory = true
-	}
-	a.injectSourceContext(stageCtx, evt)
-
-	if a.runStage(sdk.StageOnInput, stageCtx) {
-		a.emitResponse(evt, *stageCtx.Response)
-		return
-	}
-
-	input := stageCtx.RawMessage
-
-	// 计算层用的清洗文本（不改原文）：通道 Cleaner 提取语义内容后用于向量化/提关键词
-	cleanInput := input
-	if a.io != nil {
-		if chDef, ok := a.io.GetInputChannelDef(evt.Source); ok && chDef.Cleaner != nil {
-			cleanInput = chDef.Cleaner(input)
-		}
-	}
-
-	// upload_* 字段一并转发：webui 的 EventRawInput 订阅方靠它们还原附件卡片。
-	// 媒体路径此前把整个 payload 塞进 content（一个 map），订阅方按 string 断言
-	// 直接失败 → 用户发的图从不出现在聊天记录里。
-	rawPayload := map[string]interface{}{"content": input, "source": evt.Source}
-	for _, k := range []string{"upload_url", "upload_type", "upload_size", "upload_name"} {
-		if v, ok := evt.Payload[k]; ok {
-			rawPayload[k] = v
-		}
-	}
-	a.publishEvent(events.EventRawInput, rawPayload)
-
-	archived := a.pruneOnInput(evt, cleanInput)
-	if archived > 0 {
-		log.Printf("[agent] pruned %d low-relevance events to document memory", archived)
-	}
-
-	if !isInterrupt {
-		a.context.Append(ContextEvent{
-			Timestamp: start,
-			Source:    evt.Source,
-			Input:     input,
-		})
-	}
-
-	response, toolsUsed, toolResults, err := a.process(input, stageCtx)
-	if err != nil {
-		log.Printf("[agent] process %s error: %v", evt.Type, err)
-		resp := fmt.Sprintf("处理错误: %v", err)
-		a.emitResponse(evt, resp)
-		a.context.Append(ContextEvent{Timestamp: time.Now(), Source: "agent", Input: input, Response: resp})
-		return
-	}
-
-	elapsed := time.Since(start)
-	log.Printf("[agent] %s from %s → response (%dms, tools=%v)", evt.Type, evt.Source, elapsed.Milliseconds(), toolsUsed)
-
-	// 本轮捕获的媒体一起挂到这条事件上：用户上传的、插件注入的，以及模型调
-	// multimodal_see_picture / see_video 时经 SetToolBlocks 注入的（后者在
-	// process() 里被捕获，纯文本输入也会有）。
-	turnEvt := ContextEvent{
-		Timestamp:   time.Now(),
-		Source:      "agent",
-		Input:       cleanInput,
-		Response:    response,
-		ToolsUsed:   toolsUsed,
-		ToolResults: toolResults,
-	}
-	a.bindEventMedia(&turnEvt, a.drainMediaDigests())
-	a.context.Append(turnEvt)
-
-	a.emitResponse(evt, response)
-
-	if !stageCtx.NoMemory {
-		a.emitMemoryCandidate(evt.Source, cleanInput, response, toolResults, toolsUsed)
+	select {
+	case evt.ResponseCh <- &agentIO.OutputEvent{
+		RequestID:     evt.RequestID,
+		Target:        evt.Source,
+		Type:          "text",
+		Payload:       payload,
+		Done:          true,
+		OutputChannel: ch,
+	}:
+	default:
 	}
 }
 
 func (a *Agent) emitResponse(evt *agentIO.InputEvent, response string) {
+	// 通道一律从**输入事件**推导（内核不持有"当前通道"）。
+	ch := outputChannelOf(evt)
 	stageCtx := &sdk.StageContext{
 		FinalText: response,
 		Phase:     sdk.StageBeforeOutput,
+		Extra:     map[string]interface{}{"output_channel": ch},
 	}
 	a.runStage(sdk.StageBeforeOutput, stageCtx)
 	response = stageCtx.FinalText
 
-	ch := a.currentOutputChannel
-	if ch == "" {
-		ch = evt.OutputChannel
-	}
-	if ch == "" {
-		ch = evt.Source
-	}
-
 	payload := map[string]interface{}{
 		"content":    response,
 		"request_id": evt.RequestID,
@@ -473,13 +331,20 @@ func (a *Agent) emitResponse(evt *agentIO.InputEvent, response string) {
 		payload["usage"] = stageCtx.TokenUsage
 	}
 	if evt.ResponseCh != nil {
-		evt.ResponseCh <- &agentIO.OutputEvent{
+		// 非阻塞写：ResponseCh 由同步调用方以 cap=1 创建。按不变量 I5（每任务恰一次
+		// 终态）这里永远写得进去；但一旦哪天写出第二次，阻塞会卡死**调度器 goroutine**
+		// （整个 agent 停摆），而丢弃只是丢一条回执——与 emitSkippedReply 对称。
+		select {
+		case evt.ResponseCh <- &agentIO.OutputEvent{
 			RequestID:     evt.RequestID,
 			Target:        evt.Source,
 			Type:          "text",
 			Payload:       payload,
 			Done:          true,
 			OutputChannel: ch,
+		}:
+		default:
+			log.Printf("[agent] ResponseCh 已满，终态回执被丢弃（request=%s，可能违反不变量 I5）", evt.RequestID)
 		}
 	}
 
@@ -496,33 +361,6 @@ func (a *Agent) emitResponse(evt *agentIO.InputEvent, response string) {
 	a.runStage(sdk.StageAfterOutput, stageCtx)
 }
 
-func (a *Agent) drainInterrupts() []string {
-	var out []string
-	for {
-		select {
-		case evt := <-a.interceptCh:
-			if evt == nil {
-				continue
-			}
-			text, _ := evt.Payload["content"].(string)
-			if text == "" {
-				continue
-			}
-			source := evt.Source
-			if source == "" {
-				source = "unknown"
-			}
-			channel := evt.OutputChannel
-			if channel == "" {
-				channel = source
-			}
-			out = append(out, fmt.Sprintf("[打断消息][来源:%s][输出通道:%s] %s", source, channel, text))
-		default:
-			return out
-		}
-	}
-}
-
 // pruneOnInput 按声明的上下文策略裁剪上下文，返回归档的事件数。
 //
 // 默认**不裁剪**：ContextPolicy 必须在注入点（payload 的 context_policy）
@@ -535,15 +373,13 @@ func (a *Agent) drainInterrupts() []string {
 //
 // 查询向量取**清洗后**的输入（通道 Cleaner 的输出），与工具侧同一套语义：
 // 原始输入里的 ANSI/base64/JSON 包装会把相关性打分带偏，裁掉本该保留的事件。
+//
+// 实际执行交由 memoryPass（与召回共用入口、query、预算与审计）。
 func (a *Agent) pruneOnInput(evt *agentIO.InputEvent, cleanInput string) int {
-	if a.context == nil || !a.pruneDeclared(evt) {
+	if !a.pruneDeclared(evt) {
 		return 0
 	}
-	topK := a.maxContextSize - 1
-	if topK < 1 {
-		topK = 1
-	}
-	return a.context.Prune(cleanInput, topK, a.docStore)
+	return a.memoryPass(cleanInput, "input:"+evt.Source, true, false).Archived
 }
 
 // pruneDeclared 判定这次输入是否显式声明了裁剪。
@@ -562,6 +398,29 @@ func (a *Agent) pruneDeclared(evt *agentIO.InputEvent) bool {
 	return false
 }
 
+// recallDeclared 判定这次输入是否要触发记忆召回（注入）。
+//
+// 与 pruneDeclared **正交**：prune 管“踢出去”（归档低相关 L0 事件），
+// recall 管“取进来”（把 L2/L3 相关记忆注入本轮）。
+//
+// 默认值与 prune 刻意相反：召回是只读增量、日常对话本就需要，所以**默认 auto**；
+// 只有显式声明 recall_policy=none（如中断通知的 meta 文本）才关闭。
+// 优先级同 prune：注入点（payload）> 通道（ChannelDef）> 默认 auto。
+func (a *Agent) recallDeclared(evt *agentIO.InputEvent) bool {
+	if evt == nil {
+		return true
+	}
+	if p, ok := evt.Payload["recall_policy"].(string); ok && p != "" {
+		return p != pubsdk.RecallPolicyNone
+	}
+	if a.io != nil {
+		if chDef, ok := a.io.GetInputChannelDef(evt.Source); ok && chDef.RecallPolicy != "" {
+			return chDef.RecallPolicy != pubsdk.RecallPolicyNone
+		}
+	}
+	return true
+}
+
 // cleanInputFor 解析这条输入在计算层应当使用的清洗文本。
 //
 // 优先级：注入点声明的 cleaner（payload.cleaner_name，引用某个已注册的通道

internal/agent/core/graphmedia.go

@@ -107,11 +107,14 @@ func (a *Agent) linkBlocksToDocument(docID string, blocks []memory.MemoryBlock)
 // seed 是调用方已持有的一等块（如 L2 文档的 Blocks），用于保持块身份；
 // 普通对话路径传 nil。blocks 是本次写入 L3 的块数。
 func (a *Agent) commitTriplesWithMedia(triples []memory.Triple, sessionID string, turnID int, seed []memory.MemoryBlock) (entities, relations, blocks int, err error) {
-	if a.memory == nil {
+	g := a.graphMem()
+	if g == nil {
 		return 0, 0, 0, fmt.Errorf("graph memory 未启用")
 	}
-	if a.mediaStore == nil {
-		ec, rc, cErr := a.memory.Commit(triples, sessionID, turnID)
+	// 轻量内核（memory == nil，子只有图记忆）或没有媒体库时：只写图记忆。
+	// 写目标由 a.graph 决定 —— 根落 main，子落自己的 temp。
+	if a.memory == nil || a.mediaStore == nil {
+		ec, rc, cErr := g.Commit(triples, sessionID, turnID)
 		return ec, rc, 0, cErr
 	}
 	sentenceIDs, ec, rc, err := a.memory.CommitWithMedia(triples, sessionID, turnID)

internal/agent/core/inputch.go

@@ -0,0 +1,170 @@
+package core
+
+// inputch 总览：**单工具多视图**。
+//
+// inputch 是**最基本的输入路由单位**（由插件注册，一个插件可注册多个）。
+// 父 agent 需要能看清两件事：
+//  1. 有哪些 inputch 已注册（谁注册的）；
+//  2. 它们是怎么划分的（各自划给了哪个 agent、容量多少）。
+//
+// 按用户要求做成**单工具多视图**（一个 `input_channels` 工具 + `view` 参数），
+// 而不是一堆小工具 —— 视图切换比工具增殖更好用，也更省提示词预算。
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+)
+
+func (a *Agent) executeInputChannels(tc agentAPI.ToolCall) string {
+	view, _ := tc.Arguments["view"].(string)
+	view = strings.TrimSpace(view)
+	if view == "" {
+		view = "all"
+	}
+	name, _ := tc.Arguments["name"].(string)
+
+	all := a.io.InputChannels()
+	if len(all) == 0 {
+		return "没有任何已注册的 inputch。"
+	}
+
+	switch view {
+	case "all":
+		return a.renderInputChannels(all, "全部已注册 inputch")
+	case "mine":
+		return a.renderInputChannels(a.channelRegistry().ListByOwner(string(a.id)),
+			"划给本 agent（"+string(a.id)+"）的 inputch")
+	case "unassigned":
+		return a.renderInputChannels(a.channelRegistry().ListByOwner(""),
+			"尚未划出的 inputch（可按需分配）")
+	case "by_agent":
+		return a.renderInputChannelsByAgent(all)
+	case "detail":
+		if name == "" {
+			return "view=detail 需要 name 参数（inputch 名）"
+		}
+		ch, ok := a.io.LookupInputChannel(name)
+		if !ok {
+			return fmt.Sprintf("inputch %q 未注册", name)
+		}
+		return renderInputChannelDetail(ch)
+	default:
+		return fmt.Sprintf("未知 view=%q；可用：all | mine | unassigned | by_agent | detail", view)
+	}
+}
+
+func (a *Agent) channelRegistry() *agentIO.ChannelRegistry { return a.io.ChannelRegistry() }
+
+// renderInputChannels 渲染一组 inputch 的一行式概览。
+func (a *Agent) renderInputChannels(list []agentIO.InputChannel, title string) string {
+	if len(list) == 0 {
+		return title + "：无"
+	}
+	var b strings.Builder
+	fmt.Fprintf(&b, "%s（%d 个）:", title, len(list))
+	for _, ch := range list {
+		fmt.Fprintf(&b, "\n  - %s%s%s", ch.Name, pluginSuffix(ch), policySuffix(ch))
+		fmt.Fprintf(&b, "\n      归属: %s", ownerLabel(ch.Owner))
+		if ch.Capacity > 0 {
+			fmt.Fprintf(&b, " | 容量: %d", ch.Capacity)
+		}
+		if ch.Output != "" {
+			fmt.Fprintf(&b, " | 默认回程: %s", ch.Output)
+		}
+	}
+	return b.String()
+}
+
+// renderInputChannelsByAgent 按归属分组（"划分情况"总览）。
+func (a *Agent) renderInputChannelsByAgent(all []agentIO.InputChannel) string {
+	byOwner := map[string][]agentIO.InputChannel{}
+	for _, ch := range all {
+		byOwner[ch.Owner] = append(byOwner[ch.Owner], ch)
+	}
+	owners := make([]string, 0, len(byOwner))
+	for o := range byOwner {
+		owners = append(owners, o)
+	}
+	sort.Strings(owners)
+
+	var b strings.Builder
+	fmt.Fprintf(&b, "inputch 划分情况（共 %d 个）:", len(all))
+	for _, o := range owners {
+		names := make([]string, 0, len(byOwner[o]))
+		for _, ch := range byOwner[o] {
+			names = append(names, ch.Name)
+		}
+		sort.Strings(names)
+		fmt.Fprintf(&b, "\n  - %s: %s", ownerLabel(o), strings.Join(names, ", "))
+	}
+	return b.String()
+}
+
+// renderInputChannelDetail 渲染单个 inputch 的全部字段。
+func renderInputChannelDetail(ch agentIO.InputChannel) string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "inputch: %s\n", ch.Name)
+	fmt.Fprintf(&b, "  注册插件: %s\n", orDash(ch.Plugin))
+	fmt.Fprintf(&b, "  归属 agent: %s\n", ownerLabel(ch.Owner))
+	if ch.Capacity > 0 {
+		fmt.Fprintf(&b, "  容量: %d\n", ch.Capacity)
+	} else {
+		fmt.Fprintf(&b, "  容量: 内核默认\n")
+	}
+	fmt.Fprintf(&b, "  默认回程输出通道: %s\n", orDash(ch.Output))
+	fmt.Fprintf(&b, "  记忆策略: %s\n", policyLabel(ch))
+	return b.String()
+}
+
+func pluginSuffix(ch agentIO.InputChannel) string {
+	if ch.Plugin == "" {
+		return ""
+	}
+	return "（插件 " + ch.Plugin + "）"
+}
+
+// policySuffix 用短标记提示策略（详见 view=detail）。
+func policySuffix(ch agentIO.InputChannel) string {
+	var m []string
+	if ch.Def.NoMemory {
+		m = append(m, "无记忆")
+	}
+	if ch.Def.Cleaner != nil {
+		m = append(m, "清洗")
+	}
+	if ch.Def.ContextPolicy != "" && ch.Def.ContextPolicy != "none" {
+		m = append(m, "裁剪:"+ch.Def.ContextPolicy)
+	}
+	if ch.Def.RecallPolicy != "" && ch.Def.RecallPolicy != "auto" {
+		m = append(m, "召回:"+ch.Def.RecallPolicy)
+	}
+	if len(m) == 0 {
+		return ""
+	}
+	return " [" + strings.Join(m, "/") + "]"
+}
+
+func policyLabel(ch agentIO.InputChannel) string {
+	if s := policySuffix(ch); s != "" {
+		return strings.Trim(s, " []")
+	}
+	return "默认（记入记忆、不裁剪）"
+}
+
+func ownerLabel(owner string) string {
+	if owner == "" {
+		return "未分配（根 agent/内核默认）"
+	}
+	return owner
+}
+
+func orDash(s string) string {
+	if s == "" {
+		return "-"
+	}
+	return s
+}

internal/agent/core/inputch_test.go

@@ -0,0 +1,104 @@
+package core
+
+// inputch 总览工具（单工具多视图）的验收。
+//
+// 需求：父 agent 能看到**所有已注册的 inputch**以及**它们的划分情况**。
+// 构筑方式：单工具（input_channels）+ 多视图（view=all|mine|unassigned|by_agent|detail）。
+
+import (
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+)
+
+func inputChToolCall(args map[string]interface{}) agentAPI.ToolCall {
+	return agentAPI.ToolCall{ID: "ic1", Name: "input_channels", Arguments: args}
+}
+
+func TestInputChannelsTool_SingleToolMultipleViews(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+	me := string(a.id)
+
+	// 同一个插件注册多个 inputch（最基本的输入路由单位）；另一个插件再注册一个。
+	if err := a.io.RegisterInputChannelFrom("qq", "qq", agentIO.ChannelDef{NoMemory: true}); err != nil {
+		t.Fatal(err)
+	}
+	if err := a.io.RegisterInputChannelFrom("qq", "qq/device-2", agentIO.ChannelDef{}); err != nil {
+		t.Fatal(err)
+	}
+	if err := a.io.RegisterInputChannelFrom("sub", "sub/in", agentIO.ChannelDef{}); err != nil {
+		t.Fatal(err)
+	}
+	// 划分：qq 与 sub/in 归本 agent，qq/device-2 留未分配。
+	if err := a.io.AssignInputChannel("qq", me, 64); err != nil {
+		t.Fatal(err)
+	}
+	if err := a.io.AssignInputChannel("sub/in", me, 0); err != nil {
+		t.Fatal(err)
+	}
+
+	// view=all（默认）：全部已注册，且带归属插件。
+	all := a.executeInputChannels(inputChToolCall(nil))
+	for _, want := range []string{"qq", "qq/device-2", "sub/in", "插件 qq", "插件 sub", "无记忆"} {
+		if !strings.Contains(all, want) {
+			t.Fatalf("view=all 缺少 %q：\n%s", want, all)
+		}
+	}
+
+	// view=mine：只有划给本 agent 的。
+	mine := a.executeInputChannels(inputChToolCall(map[string]interface{}{"view": "mine"}))
+	if !strings.Contains(mine, "qq") || !strings.Contains(mine, "sub/in") {
+		t.Fatalf("view=mine 应含 qq 与 sub/in：\n%s", mine)
+	}
+	if strings.Contains(mine, "qq/device-2") {
+		t.Fatalf("view=mine 不应含未分配的 qq/device-2：\n%s", mine)
+	}
+
+	// view=unassigned：只有尚未划出的。
+	un := a.executeInputChannels(inputChToolCall(map[string]interface{}{"view": "unassigned"}))
+	if !strings.Contains(un, "qq/device-2") {
+		t.Fatalf("view=unassigned 应含 qq/device-2：\n%s", un)
+	}
+	if strings.Contains(un, "sub/in") {
+		t.Fatalf("view=unassigned 不应含已划分的 sub/in：\n%s", un)
+	}
+
+	// view=by_agent：划分情况总览（按归属分组）。
+	byAgent := a.executeInputChannels(inputChToolCall(map[string]interface{}{"view": "by_agent"}))
+	if !strings.Contains(byAgent, me+":") {
+		t.Fatalf("view=by_agent 应列出归属 %q：\n%s", me, byAgent)
+	}
+	if !strings.Contains(byAgent, "未分配") {
+		t.Fatalf("view=by_agent 应列出未分配一组：\n%s", byAgent)
+	}
+
+	// view=detail：单个 inputch 的全字段（容量 / 策略 / 回程 / 归属）。
+	detail := a.executeInputChannels(inputChToolCall(map[string]interface{}{"view": "detail", "name": "qq"}))
+	for _, want := range []string{"inputch: qq", "注册插件: qq", "容量: 64", "无记忆", me} {
+		if !strings.Contains(detail, want) {
+			t.Fatalf("view=detail 缺少 %q：\n%s", want, detail)
+		}
+	}
+	if miss := a.executeInputChannels(inputChToolCall(map[string]interface{}{"view": "detail", "name": "nope"})); !strings.Contains(miss, "未注册") {
+		t.Fatalf("detail 查未注册的 inputch 应明确报错：%s", miss)
+	}
+	if noName := a.executeInputChannels(inputChToolCall(map[string]interface{}{"view": "detail"})); !strings.Contains(noName, "需要 name") {
+		t.Fatalf("detail 缺 name 应提示：%s", noName)
+	}
+
+	// 未知视图必须报错并列出可用值（不要把拼错静默当成默认视图）。
+	bad := a.executeInputChannels(inputChToolCall(map[string]interface{}{"view": "whatever"}))
+	if !strings.Contains(bad, "未知 view") || !strings.Contains(bad, "by_agent") {
+		t.Fatalf("未知 view 应报错并列出可用值：%s", bad)
+	}
+}
+
+// 一个 inputch 都没有时应给出明确说明，而不是空串。
+func TestInputChannelsTool_NoChannels(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+	if out := a.executeInputChannels(inputChToolCall(nil)); !strings.Contains(out, "没有任何已注册") {
+		t.Fatalf("空登记表应明确说明：%q", out)
+	}
+}

internal/agent/core/inputroute.go

@@ -0,0 +1,44 @@
+package core
+
+import (
+	"log"
+
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+)
+
+// routeInputByOwner 实现**输入路由**：inputch 是最基本的输入路由单位，
+// 划给某个 agent 之后，该通道的输入**只流向那个 agent**，本内核看不到它
+// （docs/zh/resident-subagent-design.md §4.1：「路由发生在进内核之前」）。
+//
+// 为什么必须在进内核之前做：插件注入输入的收口是**父**的 IOManager
+// （`cmd/homed` 里 pluginReg 拿到的就是它），而父的内核是该 io 唯一的消费者。
+// 如果不按归属路由，登记表里的 Owner 就只是个标签 —— 现场表现正是如此：
+// 子挂着 `inputch=[timer]`，timer 的输入却打在父身上，子的轮次永远是 0。
+//
+// 返回 true = 本次注入已被"持有该 inputch 的 agent"接管，本内核不再处理。
+//
+// 已知边界：路由只在本 agent 的**直接**驻留子里找。若孙辈的 inputch 由子划拨，
+// 而插件注入打在根 io 上，根解析不到那个 owner ⇒ 兜底给根处理（有日志）。
+// 这一层要等"孙辈 + 根可见的 agent 表"再收口，此处不静默丢输入。
+func (a *Agent) routeInputByOwner(evt *agentIO.InputEvent, isInterrupt bool) bool {
+	if evt == nil || evt.OutputChannel == "" || a.io == nil {
+		return false
+	}
+	entry, ok := a.io.LookupInputChannel(evt.OutputChannel)
+	if !ok || entry.Owner == "" || entry.Owner == string(a.id) {
+		return false // 未分配 / 归自己 ⇒ 本内核处理
+	}
+
+	a.residentMu.Lock()
+	rc := a.residents[entry.Owner]
+	a.residentMu.Unlock()
+	if rc == nil || rc.agent == nil || rc.agent.io == nil {
+		// 归属到一个不存在（或已销毁、登记表尚未归还）的 agent：
+		// **不吞输入** —— 由本内核兜底处理并留痕。吞掉一条输入比多处理一条更糟：
+		// 用户会看到"消息发出去了却没人理"，而日志里什么都没有。
+		log.Printf("[route] inputch %s 归属 %s 无对应 agent，输入由 %s 兜底", evt.OutputChannel, entry.Owner, a.id)
+		return false
+	}
+	rc.agent.io.DeliverRouted(evt, isInterrupt)
+	return true
+}

internal/agent/core/inputroute_test.go

@@ -0,0 +1,85 @@
+package core
+
+import (
+	"path/filepath"
+	"testing"
+
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+)
+
+// 输入路由是**独占**的：inputch 划给子之后，该通道的输入只流向子，父不再收到。
+//
+// 现场缺陷（用户线上联调实录）：子挂着 inputch=[timer]，timer 的输入却打在父身上
+// （日志 `[agent] interrupt from timer/timer`），子的轮次永远是 0 —— 因为
+// `Assign` 只把 Owner 写进登记表，注入路径根本没有按归属路由。
+func TestResident_InputchRoutingIsExclusive(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+	reg := parent.io.ChannelRegistry()
+	if err := reg.Register(agentIO.InputChannel{Name: "sub/in", Plugin: "sub"}); err != nil {
+		t.Fatal(err)
+	}
+	spawnTestResident(t, parent, dir, "r-route", "sub/in")
+	child := parent.residents["r-route"].agent
+
+	before := parent.DumpScheduler().Stats.Enqueued
+	// 插件往"已划给子"的 inputch 投输入
+	parent.io.InjectTextTo("plugin-sub", "sub/in", "去查一下这个")
+
+	waitFor(t, "子处理了划给它的输入", func() bool {
+		if child.DumpScheduler().Stats.Executed > 0 {
+			return true
+		}
+		return parent.residents["r-route"].info().TableSize > 0
+	})
+	if got := parent.DumpScheduler().Stats.Enqueued; got != before {
+		t.Fatalf("划给子的 inputch，父不应再入队（before=%d after=%d）", before, got)
+	}
+	// 轮次必须真的涨：此前 info() 根本没填 Rounds ⇒ 父永远读到 0
+	// （现场：子处理表已有 2 条，轮次却显示 0，被误判成"子没干活"）。
+	if got := parent.residents["r-route"].info().Rounds; got <= 0 {
+		t.Fatalf("子处理的轮次应 > 0，实际 %d", got)
+	}
+}
+
+// 归属到一个不存在（或已销毁）的 agent 时**不吞输入**：父兜底处理。
+// 吞掉一条输入比多处理一条更糟 —— 用户会看到"消息发出去了却没人理"，日志里什么都没有。
+func TestResident_InputchRoutingFallsBackWhenOwnerMissing(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+	reg := parent.io.ChannelRegistry()
+	if err := reg.Register(agentIO.InputChannel{Name: "ghost/in", Plugin: "ghost"}); err != nil {
+		t.Fatal(err)
+	}
+	// 故意划给一个不存在的 agent id
+	if err := reg.Assign("ghost/in", "no-such-agent", 0); err != nil {
+		t.Fatal(err)
+	}
+	_ = dir
+
+	before := parent.DumpScheduler().Stats.Enqueued
+	parent.io.InjectTextTo("plugin-ghost", "ghost/in", "兜底测试")
+	waitFor(t, "父兜底处理了无人认领的输入", func() bool {
+		return parent.DumpScheduler().Stats.Enqueued > before
+	})
+}
+
+// 未划拨的 inputch（Owner 为空）仍然由父处理 —— 路由不能把默认路径也改掉。
+func TestResident_UnassignedInputchStaysWithParent(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+	reg := parent.io.ChannelRegistry()
+	if err := reg.Register(agentIO.InputChannel{Name: "own/in", Plugin: "own"}); err != nil {
+		t.Fatal(err)
+	}
+	// 造一个子在跑，确保路由逻辑是"有子存在"的情形
+	spawnTestResident(t, parent, dir, "r-other", "own/in")
+	_ = filepath.Join(dir, "residents")
+
+	// 把通道退还给父（未分配）
+	if err := reg.Assign("own/in", "", 0); err != nil {
+		t.Fatal(err)
+	}
+	before := parent.DumpScheduler().Stats.Enqueued
+	parent.io.InjectTextTo("plugin-own", "own/in", "还是我的")
+	waitFor(t, "未分配的 inputch 仍由父处理", func() bool {
+		return parent.DumpScheduler().Stats.Enqueued > before
+	})
+}

internal/agent/core/lightprofile_test.go

@@ -0,0 +1,169 @@
+package core
+
+// N2c 验收：**轻量内核 profile**。
+//
+// 设计 docs/zh/resident-subagent-design.md §16.0（窄接口 + nil 即禁用）与 §5.5。
+//
+// 轻量内核（驻留子）的记忆装配：
+//   - graph = *memory.LightMemory（读 temp∪main，只写 temp）
+//   - memory = nil ⇒ 既有的 `if a.memory != nil` 关卡自动禁掉**全部**整理面：
+//     记忆整理流水线（distill.go 的 archive/review/merge 循环）、记忆块与媒体桥
+//     （graphmedia.go / medialoop.go）、记忆整理工具（merge/delete/purge/edit/block_merge）
+//
+// 因此这里要钉住四件事：
+//   ① 子的写入只落 temp，主库不受影响；
+//   ② 子的读是并集（看得到主库 + 自己的 temp）；
+//   ③ 整理类工具**不进子的工具表**；
+//   ④ 即便被直调，整理类操作也明确报"轻量内核不支持"（纵深防御，不静默降级）。
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+)
+
+// newLightAgent 构造一个轻量内核 agent（驻留子形态）：有 LightMemory，没有整理面。
+func newLightAgent(t *testing.T, main *memory.GraphDB, tempPath string) *Agent {
+	t.Helper()
+	light, err := memory.NewLightMemory(main, tempPath, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	a := New(AgentConfig{
+		ID:              "sub-1",
+		Provider:        &scriptProvider{},
+		ProviderManager: agentAPI.NewProviderManager(),
+		IO:              agentIO.NewIOManager(),
+		StageHost:       NewStageHost(),
+		LightMemory:     light, // 轻量内核：只给图记忆共同面
+	})
+	t.Cleanup(func() { light.Close() })
+	return a
+}
+
+func TestLightProfile_MemoryFaceWiring(t *testing.T) {
+	dir := t.TempDir()
+	main, err := memory.NewGraphDB(filepath.Join(dir, "main.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer main.Close()
+	if _, _, err := main.Commit([]memory.Triple{
+		{Subject: "主记忆实体", Relation: "属于", Object: "主库"},
+	}, "sess", 1); err != nil {
+		t.Fatal(err)
+	}
+
+	a := newLightAgent(t, main, filepath.Join(dir, "sub.db"))
+
+	// ① 整理面必须为 nil —— 这正是"nil 即禁用"的开关。
+	if a.memory != nil {
+		t.Fatal("轻量内核不该有整理面（a.memory 必须为 nil）")
+	}
+	if a.graphMem() == nil {
+		t.Fatal("轻量内核必须有图记忆共同面")
+	}
+
+	// ② 写入只落 temp：主库不得出现子才知道的实体。
+	if _, _, _, err := a.commitTriplesWithMedia([]memory.Triple{
+		{Subject: "子独有实体", Relation: "来自", Object: "子的temp"},
+	}, "sess", 1, nil); err != nil {
+		t.Fatalf("子的写入应成功（落 temp）: %v", err)
+	}
+	mainRes, err := main.Recall([]string{"子独有实体"}, nil, 1, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, e := range mainRes.Entities {
+		if e.Name == "子独有实体" {
+			t.Fatalf("子的写入不该进主库：%v", e.Name)
+		}
+	}
+
+	// ③ 读是并集：主库的实体与 temp 的实体都要看得到。
+	got := a.executeMemoryTool(agentAPI.ToolCall{
+		ID: "c1", Name: "memory_recall",
+		Arguments: map[string]interface{}{"query_intent": "主记忆实体,子独有实体"},
+	})
+	if !strings.Contains(got, "主记忆实体") {
+		t.Fatalf("子应看得到主记忆：%s", got)
+	}
+	if !strings.Contains(got, "子独有实体") {
+		t.Fatalf("子应看得到自己的 temp：%s", got)
+	}
+}
+
+func TestLightProfile_OrganizeToolsAbsentAndRefused(t *testing.T) {
+	dir := t.TempDir()
+	main, err := memory.NewGraphDB(filepath.Join(dir, "main.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer main.Close()
+
+	a := newLightAgent(t, main, filepath.Join(dir, "sub.db"))
+
+	// ① 整理类工具不进子的工具表（不是进去再报不可用）。
+	names := toolNames(a)
+	for _, banned := range []string{
+		"memory_merge", "memory_delete_entity", "memory_block_merge",
+		"memory_purge", "memory_edit",
+	} {
+		if hasTool(names, banned) {
+			t.Fatalf("轻量内核不该声明整理类工具 %s：%v", banned, names)
+		}
+	}
+	// 对照：共同面/无关能力照常在。
+	if !hasTool(names, "input_channels") {
+		t.Fatalf("轻量内核仍应有共同面工具：%v", names)
+	}
+
+	// ② 纵深防御：即便被直调，整理类操作也必须明确报"轻量内核不支持"。
+	for _, tool := range []string{
+		"memory_merge", "memory_delete_entity", "memory_block_merge",
+		"memory_purge", "memory_edit", "memory_introspect",
+	} {
+		got := a.executeMemoryTool(agentAPI.ToolCall{
+			ID: "x", Name: tool,
+			Arguments: map[string]interface{}{
+				"name": "任意", "source": "a", "target": "b", "criteria": map[string]interface{}{},
+			},
+		})
+		if !strings.Contains(got, "轻量内核") {
+			t.Fatalf("%s 在轻量内核里必须明确报不支持，实际 %q", tool, got)
+		}
+	}
+}
+
+// 对照：完整内核（根 agent）仍有整理面与整理工具。
+func TestFullProfile_KeepsOrganizeFace(t *testing.T) {
+	dir := t.TempDir()
+	main, err := memory.NewGraphDB(filepath.Join(dir, "main.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer main.Close()
+
+	a := New(AgentConfig{
+		ID:              "root",
+		Provider:        &scriptProvider{},
+		ProviderManager: agentAPI.NewProviderManager(),
+		IO:              agentIO.NewIOManager(),
+		StageHost:       NewStageHost(),
+		Memory:          main,
+	})
+	if a.memory == nil {
+		t.Fatal("根 agent 必须有整理面")
+	}
+	if a.graphMem() == nil {
+		t.Fatal("根 agent 必须有图记忆共同面")
+	}
+	names := toolNames(a)
+	if !hasTool(names, "memory_merge") {
+		t.Fatalf("根 agent 应保留整理类工具：%v", names)
+	}
+}

internal/agent/core/mediaref.go

@@ -138,7 +138,7 @@ func (a *Agent) embedMediaOnIngest(digest, mime string, data []byte) {
 //
 // 为何要缓存而不是当场建块：媒体在 process() 执行期间被捕获，而承载它的
 // ContextEvent 要等 process() 返回后才 Append——此刻还没有 owner_id。
-// 与既有的 a.pendingMedia 同一手法（都在 a.mu 保护下）。
+// 与既有的 a.pendingMedia 同一手法（均由 schedulerLoop goroutine 独占读写）。
 func (a *Agent) stageMediaDigests(digests ...string) {
 	if len(digests) == 0 {
 		return
@@ -197,7 +197,7 @@ func mediaLabel(it *media.Item) string {
 //
 // 沿用 document.Store 的 doc_<unixnano> 手法（同一份代码库里保持一致，
 // 也避免为此引入 uuid 依赖）。纳秒精度足够：同一 Agent 的事件由
-// a.mu 串行化 Append，不存在同纳秒两条。
+// schedulerLoop 单 goroutine 串行 Append，不存在同纳秒两条。
 func newEventID() string {
 	return fmt.Sprintf("evt_%d", time.Now().UnixNano())
 }

internal/agent/core/memoryface.go

@@ -0,0 +1,56 @@
+package core
+
+// 图记忆的**共同面**（设计 docs/zh/resident-subagent-design.md §16.0）。
+//
+// 只有两个方法 —— 因为按调用方实测分类后，`Agent.memory` 的 42 处使用里，
+// 真正"根与子都要"的只有：
+//
+//	Recall  读（上下文检索 / memory_recall）
+//	Commit  写（自动写入路径的图部分 / memory_commit）
+//
+// 其余 40 处全是**主 agent 整理记忆**与**记忆整理流水线**：
+//   - 记忆整理流水线：distill.go 的 archive/review/merge 循环
+//   - 记忆块 + 媒体桥：graphmedia.go / medialoop.go
+//   - 记忆整理工具：memory_merge / memory_delete_entity / memory_block_merge /
+//     memory_purge / memory_edit / memory_introspect
+//
+// 所以驻留子的轻量内核**不该有那些代码路径**：它用 `*memory.LightMemory` 接上 `graph`，
+// 而 `a.memory`（整理面）保持 nil —— 既有的 22 处 `if a.memory != nil` 关卡
+// 会自动把整理面全部禁掉，不需要写"每个方法都返回错误"的受限包装。
+
+import "gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+
+// isLightKernel 报告本 agent 是不是**轻量内核**（驻留子）。
+//
+// 轻量内核 = 传统上下文 + 图记忆（作用域化）：它**没有**动态上下文能力
+// （预算裁剪 / 按相关度裁剪并向 doc 记忆归档），那些是父 agent 专属的。
+func (a *Agent) isLightKernel() bool { return a != nil && a.parentID != "" }
+
+// contextTokenBudget 返回拼装时间线时可用的 token 预算。
+//
+//	完整内核：用动态上下文算出来的 ContextTokens（按相关度/预算**策略性**裁时间线）
+//	轻量内核：**用整个窗口** —— 传统上下文只受"模型能收多少"这个**硬上限**约束，
+//	          不做任何策略性裁剪（不按相关度挑、不向 doc 记忆归档）；
+//	          而且在撞到硬上限之前，contextfull（90% 窗口）已按 L4 上报父 agent
+//	          决策（压缩/回收/销毁）—— 丢事件的决定权在父，不在内核。
+func (a *Agent) contextTokenBudget(b TokenBudget) int {
+	if a.isLightKernel() {
+		if b.MaxContext > 0 {
+			return b.MaxContext
+		}
+		return defaultMaxContextTokens
+	}
+	return b.ContextTokens
+}
+
+// GraphMemory 是任意 agent 都能用的图记忆面。
+//
+// 实现者：
+//   - 根 agent：直接就是 *memory.GraphDB
+//   - 驻留子：*memory.LightMemory（读 temp∪main，只写 temp）
+type GraphMemory interface {
+	// Recall 按关键词/种子实体召回（子的实现是两空间并集）。
+	Recall(keywords []string, seedEntities []string, depth int, sessionFilter string) (*memory.RecallResult, error)
+	// Commit 写入三元组（子的实现只落自己的 temp 空间）。
+	Commit(triples []memory.Triple, sessionID string, turnID int) (int, int, error)
+}

internal/agent/core/memorypass.go

@@ -0,0 +1,65 @@
+package core
+
+import "log"
+
+// memoryPassOut 是一次记忆操作（取进来 / 踢出去）的结果。
+type memoryPassOut struct {
+	// Archived 是被归档进文档记忆的低相关 L0 事件数（prune 的输出）。
+	Archived int
+	// RecallText 是可注入 prompt 的记忆索引文本（recall 的输出，空串表示无）。
+	RecallText string
+}
+
+// memoryPass 是「取进来（召回）」与「踢出去（裁剪）」的**唯一入口**。
+//
+// prune 与 recall 是两根正交的声明轴（默认值刻意相反：裁剪是破坏性的、
+// 默认关；召回是只读增量、默认开），但两者都建立在**同一份清洗后的 query**
+// 之上。调用点只负责解析声明，这里统一做三件各写一遍就会写歪的事：
+//
+//  1. 同一 query：prune 与 recall 用同一个查询向量来源，避免「裁错事件、
+//     召回错记忆」——原始内容里的 ANSI/base64/JSON 噪声会把相关性打分带偏。
+//  2. 同一次预算：召回文本按 token 预算截断只做一次（见 recallText）。
+//  3. 同一条审计：谁（trigger）据什么触发了哪种操作都落一条日志，
+//     否则又是一个「幕后发生、查不出是谁」的机制（对齐 prune 的设计初衷）。
+//
+// 边界：prune 与 recall 目前仍走**各自的相关性空间**（prune 用 L0 事件的
+// 稠密/词向量给已有事件打分，recall 用图 + TF-IDF 实体索引）。真正的
+// 「一次打分」要先统一打分空间（后续步骤）；这里统一的是**入口、query、
+// 预算与审计**——这已是「一个过程」的可审计外壳，剩下的差在打分空间。
+func (a *Agent) memoryPass(query, trigger string, prune, recall bool) memoryPassOut {
+	var out memoryPassOut
+	if a == nil || (!prune && !recall) {
+		return out
+	}
+	if prune {
+		out.Archived = a.pruneByQuery(query)
+	}
+	if recall && query != "" {
+		out.RecallText = a.recallTextFor(query, trigger)
+	}
+	if out.Archived > 0 || out.RecallText != "" {
+		log.Printf("[agent] memory pass (%s): archived=%d recalled=%d chars",
+			trigger, out.Archived, len(out.RecallText))
+	}
+	return out
+}
+
+// pruneByQuery 按相关性把低相关 L0 事件归档进文档记忆，返回归档数。
+//
+// **不做声明判定**——声明已由调用方（pruneOnInput / stepToolAfter）解析，
+// 这里只负责执行。放在 memoryPass 内部是为了让裁剪与召回共享入口。
+func (a *Agent) pruneByQuery(query string) int {
+	if a == nil || a.context == nil {
+		return 0
+	}
+	// **动态上下文**是父 agent 专属能力：轻量内核（驻留子）用传统上下文，
+	// 不做按相关度的裁剪与向 doc 记忆的归档（子也没有 doc 记忆）。
+	if a.isLightKernel() {
+		return 0
+	}
+	topK := a.maxContextSize - 1
+	if topK < 1 {
+		topK = 1
+	}
+	return a.context.Prune(query, topK, a.docStore)
+}

internal/agent/core/memorypass_test.go

@@ -0,0 +1,107 @@
+package core
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory/document"
+)
+
+// memoryPass 是「裁剪」与「召回」的唯一入口：两根正交轴，但共用同一份 query。
+//
+// 这一组测试锁死三件事：
+//  1. 两个策略都不声明时是 no-op（不裁剪、不召回）；
+//  2. 同时声明时一次调用同时产出「归档数」与「召回文本」；
+//  3. 单一策略只产出对应的那一个输出（正交，不互相触发）。
+func TestMemoryPass_NoPolicyIsNoOp(t *testing.T) {
+	a := &Agent{
+		context:        newPruneableContext(15),
+		maxContextSize: 4,
+		indexer:        newTestIndexer(t, "咖啡", "张三"),
+	}
+	out := a.memoryPass("咖啡", "test", false, false)
+	if out.Archived != 0 || out.RecallText != "" {
+		t.Fatalf("未声明任何策略时不应有任何输出，实际 %+v", out)
+	}
+}
+
+func TestMemoryPass_PruneAndRecallTogether(t *testing.T) {
+	a := newMemoryPassAgent(t)
+	before := a.context.Len()
+	out := a.memoryPass("咖啡", "tool:test", true, true)
+	if out.Archived == 0 {
+		t.Fatal("声明 prune 应归档低相关事件")
+	}
+	if a.context.Len() >= before {
+		t.Fatalf("裁剪后上下文应变短：%d → %d", before, a.context.Len())
+	}
+	if !strings.Contains(out.RecallText, "【记忆索引】") {
+		t.Fatalf("声明 recall 应产出记忆索引文本，实际 %q", out.RecallText)
+	}
+}
+
+func TestMemoryPass_PoliciesAreOrthogonal(t *testing.T) {
+	// 只裁不召回：输出只有归档数。
+	onlyPrune := &Agent{
+		context:        newPruneableContext(15),
+		maxContextSize: 4,
+		indexer:        newTestIndexer(t, "咖啡", "张三"),
+	}
+	if out := onlyPrune.memoryPass("咖啡", "test", true, false); out.RecallText != "" {
+		t.Fatalf("只声明 prune 不应召回，实际 %q", out.RecallText)
+	}
+	// 只召回不裁剪：输出只有召回文本，上下文条数不变。
+	onlyRecall := &Agent{
+		context:        newPruneableContext(15),
+		maxContextSize: 4,
+		indexer:        newTestIndexer(t, "咖啡", "张三"),
+	}
+	before := onlyRecall.context.Len()
+	out := onlyRecall.memoryPass("咖啡", "test", false, true)
+	if out.Archived != 0 {
+		t.Fatalf("只声明 recall 不应裁剪，实际归档 %d", out.Archived)
+	}
+	if onlyRecall.context.Len() != before {
+		t.Fatalf("只声明 recall 不应改变上下文条数：%d → %d", before, onlyRecall.context.Len())
+	}
+}
+
+// 输入侧召回必须用**清洗后**的 query（通道 Cleaner 的输出），与裁剪侧一致。
+// 用无关原文 + 命中清洗文本做区分，锁死「用的是 CleanInput 而不是 Input」。
+func TestBuildTaskMemoryContext_UsesCleanInput(t *testing.T) {
+	a := &Agent{indexer: newTestIndexer(t, "咖啡", "张三")}
+
+	// CleanInput 命中实体、原文完全不相关 → 应召回（证明用了清洗文本）。
+	f := &TaskFrame{Evt: nil, CleanInput: "咖啡"}
+	if got := a.buildTaskMemoryContext(f, "zzz", 0); !strings.Contains(got, "【记忆索引】") {
+		t.Fatalf("应据清洗后的 query 召回，实际 %q", got)
+	}
+	// 清洗为空 → 回退原文；原文无关则不召回。
+	f2 := &TaskFrame{CleanInput: ""}
+	if got := a.buildTaskMemoryContext(f2, "zzz", 0); got != "" {
+		t.Fatalf("清洗为空且原文无关时不应召回，实际 %q", got)
+	}
+}
+
+// newMemoryPassAgent 造一个同时能做裁剪与召回的 agent（含 doc 记忆落点）。
+func newMemoryPassAgent(t *testing.T) *Agent {
+	t.Helper()
+	return &Agent{
+		context:        newPruneableContext(15),
+		maxContextSize: 4,
+		indexer:        newTestIndexer(t, "咖啡", "张三"),
+		docStore:       document.NewStore(filepath.Join(t.TempDir(), "docs"), memory.TokenizeWords),
+	}
+}
+
+// newPruneableContext 造 n 条可被裁剪的上下文（最近 10 条受保护）。
+func newPruneableContext(n int) *RelevanceContext {
+	ctx := NewRelevanceContext("", memory.NewStaticEmbedder(""))
+	for i := 0; i < n; i++ {
+		ctx.Append(ContextEvent{Timestamp: time.Now(), Source: "user", Input: "事件内容"})
+	}
+	return ctx
+}

internal/agent/core/output.go

@@ -13,9 +13,19 @@ func (a *Agent) executeOutputSendTool(tc agentAPI.ToolCall) string {
 	channel := strings.TrimPrefix(tc.Name, "output_send__")
 	payload, _ := tc.Arguments["payload"].(string)
 	rawType, _ := tc.Arguments["type"].(string)
-	if channel == "" || payload == "" || rawType == "" {
-		return "工具名称格式: output_send__{channel}，payload 和 type 不能为空"
+	if channel == "" || payload == "" {
+		return "工具名称格式: output_send__{channel}，payload 不能为空"
 	}
+	// type 缺省按 text 处理：绝大多数输出就是文本，让模型为"省略一个默认值"付一次
+	// 失败重试没有意义（判据该拦的是"不知道发什么"，不是"没写众所周知的默认值"）。
+	if rawType == "" {
+		rawType = "text"
+	}
+	// 授权闸（纵深防御）：模型可能凭名字直接调未授权的输出门。
+	if !a.IsOutputAllowed(channel) {
+		return fmt.Sprintf("通道 [%s] 未授权给本 agent。可用通道见 output_list_channels", channel)
+	}
+
 	meta, _ := tc.Arguments["meta"].(string)
 
 	caps := a.io.GetChannelCapabilities(channel)
@@ -146,7 +156,14 @@ func (a *Agent) executeOutputListChannels() string {
 		if ch.OutputCaps == 0 {
 			continue
 		}
-		parts = append(parts, fmt.Sprintf("  - %s: [%s] %s", ch.Name, ch.OutputCaps.String(), ch.Description))
+		if !a.IsOutputAllowed(ch.Name) {
+			continue
+		}
+		line := fmt.Sprintf("  - %s: [%s] %s", ch.Name, ch.OutputCaps.String(), ch.Description)
+		if t, ok := a.ResolveOutputTarget(ch.Name); ok {
+			line += fmt.Sprintf("（目标: %s / inputch %s）", orDash(t.AgentID), orDash(t.InputCh))
+		}
+		parts = append(parts, line)
 		for _, t := range ch.Tools {
 			parts = append(parts, fmt.Sprintf("     工具: %s - %s", t.Name, t.Description))
 		}

internal/agent/core/output_grant_test.go

@@ -0,0 +1,138 @@
+package core
+
+// N1b：输出通道授权集合 + 输出通道 → 目标 agent 的 inputch 解析。
+//
+// 设计依据 docs/zh/resident-subagent-design.md §4.4（通道分配：不对称）与 R2
+// （插件与工具由父授权，**默认完整授权**）。
+//
+// 三个过滤点必须一致，否则会出现"列表里看不到、但按名字还能调"的裂缝：
+//   ① 工具表（不为未授权的通道生成 output_send__X）
+//   ② 列表工具（output_list_channels 只列授权的）
+//   ③ 调用点（凭名字直调也必须被拒 —— 纵深防御）
+
+import (
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+)
+
+// registerFakeOutput 注册一个假的输出通道（device 通道）。
+func registerFakeOutput(t *testing.T, a *Agent, name string) {
+	t.Helper()
+	if err := a.io.RegisterDevice(&mockOutputDevice{name: name, caps: agentIO.CapText}); err != nil {
+		t.Fatalf("注册测试通道 %s 失败: %v", name, err)
+	}
+}
+
+func toolNames(a *Agent) []string {
+	var names []string
+	for _, t := range a.buildToolDefs() {
+		m, ok := t.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		fn, _ := m["function"].(map[string]interface{})
+		if n, _ := fn["name"].(string); n != "" {
+			names = append(names, n)
+		}
+	}
+	return names
+}
+
+func hasTool(names []string, want string) bool {
+	for _, n := range names {
+		if n == want {
+			return true
+		}
+	}
+	return false
+}
+
+// 默认（未配置白名单）= 完整授权：所有输出通道都能用。
+func TestOutputGrant_DefaultIsFull(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+	registerFakeOutput(t, a, "qq")
+	registerFakeOutput(t, a, "webui")
+
+	if !a.IsOutputAllowed("qq") || !a.IsOutputAllowed("webui") {
+		t.Fatal("默认应为完整授权")
+	}
+	names := toolNames(a)
+	if !hasTool(names, "output_send__qq") || !hasTool(names, "output_send__webui") {
+		t.Fatalf("默认完整授权下应生成全部输出门，实际 %v", names)
+	}
+	if out := a.executeOutputListChannels(); !strings.Contains(out, "qq") || !strings.Contains(out, "webui") {
+		t.Fatalf("默认完整授权下列表应含全部通道：\n%s", out)
+	}
+}
+
+// 白名单收窄：三个过滤点必须一致。
+func TestOutputGrant_NarrowedWhitelist(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+	a.allowedOutputs = []string{"webui"} // 模拟父创建子时收窄
+	registerFakeOutput(t, a, "qq")
+	registerFakeOutput(t, a, "webui")
+
+	if a.IsOutputAllowed("qq") {
+		t.Fatal("白名单外的通道不应被授权")
+	}
+	if !a.IsOutputAllowed("webui") {
+		t.Fatal("白名单内的通道应被授权")
+	}
+
+	// ① 工具表
+	names := toolNames(a)
+	if hasTool(names, "output_send__qq") {
+		t.Fatalf("未授权的通道不该生成输出门工具：%v", names)
+	}
+	if !hasTool(names, "output_send__webui") {
+		t.Fatalf("已授权的通道应生成输出门工具：%v", names)
+	}
+
+	// ② 列表工具
+	out := a.executeOutputListChannels()
+	if strings.Contains(out, "qq") {
+		t.Fatalf("列表不应含未授权通道：\n%s", out)
+	}
+	if !strings.Contains(out, "webui") {
+		t.Fatalf("列表应含已授权通道：\n%s", out)
+	}
+
+	// ③ 调用点（凭名字直调）
+	got := a.executeOutputSendTool(agentAPI.ToolCall{
+		ID: "c1", Name: "output_send__qq",
+		Arguments: map[string]interface{}{"payload": "hi", "type": "text"},
+	})
+	if !strings.Contains(got, "未授权") {
+		t.Fatalf("未授权的输出门必须被拒，实际 %q", got)
+	}
+}
+
+// 输出通道 → 目标 agent 的 inputch 的解析（"输出可寻址到具体 agent"）。
+func TestOutputTarget_Resolution(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+	reg := a.io.ChannelRegistry()
+
+	if err := reg.BindOutputTarget("to-child-1", "child-1", "sub/in"); err != nil {
+		t.Fatal(err)
+	}
+	tgt, ok := a.ResolveOutputTarget("to-child-1")
+	if !ok || tgt.AgentID != "child-1" || tgt.InputCh != "sub/in" {
+		t.Fatalf("解析结果=%+v ok=%v", tgt, ok)
+	}
+	// 未登记的输出通道由传输层处理（如 qq/webui 这类 device 通道）。
+	if _, ok := a.ResolveOutputTarget("qq"); ok {
+		t.Fatal("未登记目标解析的输出通道不应解析出 agent")
+	}
+	if err := reg.BindOutputTarget("", "x", "y"); err == nil {
+		t.Fatal("空输出通道名应报错")
+	}
+
+	// 列表工具在已登记时带出目标，便于模型知道"这条通道发给谁"。
+	registerFakeOutput(t, a, "to-child-1")
+	if out := a.executeOutputListChannels(); !strings.Contains(out, "child-1") {
+		t.Fatalf("已登记目标的输出通道应在列表里标出目标：\n%s", out)
+	}
+}

internal/agent/core/output_rules_test.go

@@ -0,0 +1,100 @@
+package core
+
+import (
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+)
+
+// 设计口径：输出是 agent 的**主动调用** —— 收到一次输入后，可以往任意（已授权的）
+// 通道发**任意多次**（分段播报、先回执后结论、同时通知多个通道都合法）。
+//
+// 这条判据钉住的是"提示词里不得出现输出次数限制"。此前 `tooldefs.go` 里写着
+// 「每轮对话通常只需调用一次 output_send__{通道名} 即可完成回复」—— 一条凭空的限制，
+// 会让模型自己收起合理的多次输出（用户现场指出）。
+func TestSystemPromptDoesNotRestrictOutputCount(t *testing.T) {
+	parent, _, _ := newRootForResidents(t)
+	defer parent.Stop()
+
+	prompt := parent.buildSystemPrompt("", "你好")
+	banned := []string{
+		"只需调用一次",
+		"只能调用一次",
+		"通常只需调用",
+		"不要重复发送",
+	}
+	for _, b := range banned {
+		if strings.Contains(prompt, b) {
+			t.Fatalf("系统提示词里仍有输出次数限制 %q —— 设计上次数不限", b)
+		}
+	}
+	if !strings.Contains(prompt, "输出次数与目标通道由你自己决定") {
+		t.Fatal("系统提示词应明确「输出次数与目标通道由你自己决定」")
+	}
+	if !strings.Contains(prompt, "没有任何「一轮只能发一次」的限制") {
+		t.Fatal("系统提示词应显式否认「一轮只能发一次」")
+	}
+}
+
+// 输出工具的 type 可省略，缺省按 text 处理（判据该拦的是"不知道发什么"，
+// 不是"没写众所周知的默认值"）。
+func TestOutputSendTypeDefaultsToText(t *testing.T) {
+	parent, _, _ := newRootForResidents(t)
+	defer parent.Stop()
+
+	dev := &outputTestDevice{name: "fakeout"}
+	if err := parent.io.RegisterDevice(dev); err != nil {
+		t.Fatal(err)
+	}
+
+	out := parent.executeOutputSendTool(agentAPI.ToolCall{
+		Name:      "output_send__fakeout",
+		Arguments: map[string]interface{}{"payload": "只给 payload，不给 type"},
+	})
+	if out != "ok" {
+		t.Fatalf("省略 type 时应默认 text 并发送成功，得到 %q", out)
+	}
+	if len(dev.sent) != 1 {
+		t.Fatalf("通道应收到 1 次输出，得到 %d", len(dev.sent))
+	}
+	if args, _ := dev.sent[0]["args"].(map[string]interface{}); args["type"] != "text" {
+		t.Fatalf("缺省类型应为 text，实际 %v", args["type"])
+	}
+
+	// 工具 schema：required 只应含 payload
+	var found bool
+	for _, td := range parent.buildToolDefs() {
+		entry, _ := td.(map[string]interface{})
+		fn, _ := entry["function"].(map[string]interface{})
+		if n, _ := fn["name"].(string); n != "output_send__fakeout" {
+			continue
+		}
+		found = true
+		params, _ := fn["parameters"].(map[string]interface{})
+		req, _ := params["required"].([]string)
+		if len(req) != 1 || req[0] != "payload" {
+			t.Fatalf("output_send 的 required 应只有 payload，实际 %v", req)
+		}
+	}
+	if !found {
+		t.Fatal("未生成 output_send__fakeout 工具")
+	}
+}
+
+// 空 payload 仍应被拦（这条判据是对的：不知道发什么不能放过）。
+func TestOutputSendStillRequiresPayload(t *testing.T) {
+	parent, _, _ := newRootForResidents(t)
+	defer parent.Stop()
+
+	if err := parent.io.RegisterDevice(&outputTestDevice{name: "fakeout"}); err != nil {
+		t.Fatal(err)
+	}
+	out := parent.executeOutputSendTool(agentAPI.ToolCall{
+		Name:      "output_send__fakeout",
+		Arguments: map[string]interface{}{"type": "text"},
+	})
+	if !strings.Contains(out, "payload 不能为空") {
+		t.Fatalf("空 payload 应被拦，得到 %q", out)
+	}
+}

internal/agent/core/process.go

@@ -7,12 +7,10 @@ import (
 	"fmt"
 	"log"
 	"strings"
-	"time"
 
 	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
 	"gitcode.com/JianFeeeee/HomeAgent/internal/events"
 	sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk"
-	pubsdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk"
 )
 
 // continuationPlaceholder 是工具轮之后补的 user 占位内容。
@@ -83,6 +81,29 @@ func (a *Agent) toolOutputForQuery(toolName, raw string) string {
 	return raw
 }
 
+// recallMsgMarker 是工具触发召回时注入的 system 消息前缀。
+// 用它做去重与替换的识别标（与用户/中断的 system 消息区分开）。
+const recallMsgMarker = "【记忆召回】"
+
+// appendOrReplaceRecall 把一段召回文本作为 system 消息挂到消息末尾。
+//
+// 同一任务内多次触发（如模型多次调用 qq_get_message）时**替换**上一条召回，
+// 而不是累加：否则召回会线性叠进 prompt，把上下文与 token 预算越挤越紧。
+// 替换位置固定在末尾，不影响 tool/assistant 消息的配对。
+func appendOrReplaceRecall(msgs []agentAPI.Message, recallText string) []agentAPI.Message {
+	if recallText == "" {
+		return msgs
+	}
+	full := recallMsgMarker + "\n" + recallText
+	for i := len(msgs) - 1; i >= 0; i-- {
+		if msgs[i].Role == "system" && strings.HasPrefix(msgs[i].Content, recallMsgMarker) {
+			msgs[i].Content = full
+			return msgs
+		}
+	}
+	return append(msgs, agentAPI.Message{Role: "system", Content: full})
+}
+
 // dropContinuationPlaceholders 移除此前由本机制插入的 user 占位。
 //
 // 为什么必须移除而不仅仅是“不再追加”：`msgs` 在循环外创建、循环内只增不减，
@@ -99,420 +120,6 @@ func dropContinuationPlaceholders(msgs []agentAPI.Message) []agentAPI.Message {
 	return out
 }
 
-func (a *Agent) process(input string, stageCtx *sdk.StageContext) (response string, toolsUsed []string, toolResults []ToolResultItem, err error) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	if a.provider == nil {
-		return "", nil, nil, fmt.Errorf("agent: no LLM provider configured")
-	}
-
-	budget := ComputeTokenBudget(a.provider, a.systemPrompt)
-
-	memContext := a.buildMemoryContext(input, budget.MemoryTokens)
-	sysPrompt := a.buildSystemPrompt(memContext, input)
-	tools := a.buildToolDefs()
-
-	msgs := a.buildMessages(sysPrompt, input, budget.ContextTokens)
-	// 工具提醒（interrupt）：以 system 角色注入，不让模型误认为用户发言
-	if a.interruptInput {
-		last := msgs[len(msgs)-1]
-		last.Role = "system"
-		last.Content = "[中断消息] " + last.Content
-		msgs[len(msgs)-1] = last
-		a.interruptInput = false
-	}
-	if blocks, ok := stageCtx.Extra["media_blocks"].([]agentAPI.ContentBlock); ok && len(blocks) > 0 {
-		if len(msgs) > 0 {
-			msgs[len(msgs)-1].Blocks = blocks
-		}
-	}
-
-	log.Printf("[agent] tool call loop start, max_ctx=%d target=%d fixed=%d mem=%d ctx=%d %d tools, %d events, personality=%t, docs=%d",
-		budget.MaxContext, budget.TargetUsage, budget.FixedTokens, budget.MemoryTokens, budget.ContextTokens,
-		len(tools), a.context.Len(),
-		a.personality != nil && a.personality.Content != "",
-		a.docStoreSize())
-
-	if a.runStage(sdk.StagePreAction, stageCtx) {
-		return *stageCtx.Response, toolsUsed, toolResults, nil
-	}
-	if len(stageCtx.ContextMsgs) > 0 {
-		for _, m := range stageCtx.ContextMsgs {
-			role, _ := m["role"].(string)
-			content, _ := m["content"].(string)
-			if role != "" {
-				msgs = append(msgs, agentAPI.Message{Role: role, Content: content})
-			}
-		}
-	}
-
-	// lastBatchReplyOnly 记录上一批工具调用是否全部是输出通道发送。
-	lastBatchReplyOnly := false
-
-	for turn := 0; ; turn++ {
-		for _, interrupt := range a.drainInterrupts() {
-			msgs = append(msgs, agentAPI.Message{
-				Role:    "system",
-				Content: "[中断消息] " + interrupt,
-			})
-		}
-
-		// zen 兼容网关要求请求的最后一条消息必须是 user(thinking 续写模式校验),
-		// 工具轮产出的 tool/assistant 消息作结尾会被 400 拒绝,故补一条 user 占位。
-		// 注意:仅当尾部确为工具轮产物(assistant/tool)时才补位;首轮 system 上下文结尾不补,
-		// 否则会错误覆盖实际用户输入(如 injectSourceContext 追加的 system 说明)。
-		//
-		// 补位前先移除前面轮次插入的同类占位，保证占位**不随轮次线性累积**——
-		// 占位是核心插的传输层附加物，不是用户发言，不该在 prompt 里叠成 N 条。
-		//
-		// 文案分情况：上一批全是 output_send__* 时不能说“继续”，详见
-		// replyDeliveredPlaceholder 的说明。
-		msgs = dropContinuationPlaceholders(msgs)
-		if last := msgs[len(msgs)-1]; last.Role == "assistant" || last.Role == "tool" {
-			msgs = append(msgs, agentAPI.Message{
-				Role:    "user",
-				Content: continuationFor(lastBatchReplyOnly),
-			})
-		}
-
-		req := &agentAPI.CompletionRequest{
-			Messages:        msgs,
-			MaxTokens:       4096,
-			Tools:           tools,
-			ToolChoice:      "auto",
-			DisableThinking: !a.thinkingEnabled,
-		}
-
-		var providers []agentAPI.Provider
-		if a.providerManager != nil {
-			// 精确模型名走 byModel 路由；AUTO/空走优先级链
-			var allProviders []agentAPI.Provider
-			if req.Model != "" && !strings.EqualFold(req.Model, "AUTO") {
-				allProviders = a.providerManager.ResolveForModel(req.Model)
-			} else {
-				allProviders = a.providerManager.OrderedProviders()
-			}
-			providers = make([]agentAPI.Provider, 0, len(allProviders))
-			for _, p := range allProviders {
-				if a.providerManager.IsAvailable(p.Name()) {
-					providers = append(providers, p)
-				}
-			}
-		}
-		if len(providers) == 0 {
-			providers = []agentAPI.Provider{a.provider}
-		}
-		var resp *agentAPI.CompletionResponse
-		var llmErr error
-
-		for pi, fbProvider := range providers {
-			if pi > 0 {
-				log.Printf("[agent] LLM fallback: trying provider %q (fallback #%d/%d)",
-					fbProvider.Name(), pi, len(providers)-1)
-			}
-
-			// 同源瞬时错误重试：网关瞬断（502/503/504/429/网络抖动）通常秒级恢复，
-			// 直接跳下一个 provider（或直接报错）会丢掉本可成功的请求。
-			// 凭证错误（401/403）与用户中断不重试。
-			const maxAttempts = 2
-			for attempt := 1; attempt <= maxAttempts; attempt++ {
-				if attempt > 1 {
-					log.Printf("[agent] provider %q transient failure, retry %d/%d in 2s: %v",
-						fbProvider.Name(), attempt, maxAttempts, llmErr)
-					select {
-					case <-time.After(2 * time.Second):
-					case <-a.ctx.Done():
-						llmErr = a.ctx.Err()
-					}
-					if llmErr == nil || errors.Is(llmErr, context.Canceled) || errors.Is(llmErr, context.DeadlineExceeded) {
-						break
-					}
-				}
-
-				fCtx, fCancel := context.WithCancel(a.ctx)
-				a.llmMu.Lock()
-				a.cancelLLM = fCancel
-				a.llmMu.Unlock()
-
-				resp, llmErr = chatStreamWithFallback(fCtx, fbProvider, req, a)
-
-				a.llmMu.Lock()
-				a.cancelLLM = nil
-				a.llmMu.Unlock()
-				fCancel()
-
-				if llmErr == nil {
-					a.providerManager.ResetAvailability(fbProvider.Name())
-					if fbProvider != a.provider {
-						a.provider = fbProvider
-						log.Printf("[agent] switched active provider to %q after fallback",
-							fbProvider.Name())
-					}
-					break
-				}
-
-				// 用户中断：立即终止，不重试也不换 provider
-				if errors.Is(llmErr, context.Canceled) {
-					break
-				}
-				// 凭证错误：重试无意义，跳出重试循环进入 provider 标记/切换
-				var pe *agentAPI.ProviderError
-				if errors.As(llmErr, &pe) && (pe.StatusCode == 401 || pe.StatusCode == 403) {
-					break
-				}
-				// 其余错误（含 5xx/429/网络）：还有重试机会则继续，否则跳出
-			}
-
-			if llmErr == nil {
-				break
-			}
-			if errors.Is(llmErr, context.Canceled) {
-				break
-			}
-			var pe *agentAPI.ProviderError
-			if errors.As(llmErr, &pe) && (pe.StatusCode == 401 || pe.StatusCode == 403) {
-				a.providerManager.ReportStatus(fbProvider.Name(), pe.StatusCode)
-				log.Printf("[agent] provider %q marked unavailable (HTTP %d)", fbProvider.Name(), pe.StatusCode)
-			} else {
-				a.providerManager.MarkUnavailable(fbProvider.Name())
-			}
-			log.Printf("[agent] provider %q failed: %v", fbProvider.Name(), llmErr)
-		}
-
-		if llmErr != nil {
-			if errors.Is(llmErr, context.Canceled) && a.ctx.Err() == nil {
-				if a.currentOutputChannel == "_consolidation_" {
-					return "", toolsUsed, toolResults, fmt.Errorf("interrupted by user input")
-				}
-				continue
-			}
-			return "", toolsUsed, toolResults, fmt.Errorf("all %d providers failed, last error: %w",
-				len(providers), llmErr)
-		}
-
-		stageCtx.LLMText = resp.Content
-		stageCtx.ReasoningContent = resp.ReasoningContent
-		stageCtx.TokenUsage = map[string]int{
-			"prompt_tokens":     resp.TokenUsage.Prompt,
-			"completion_tokens": resp.TokenUsage.Completion,
-			"total_tokens":      resp.TokenUsage.Total,
-		}
-		stageCtx.ToolCalls = convertToolCalls(resp.ToolCalls)
-		for i := range stageCtx.ToolCalls {
-			if stageCtx.ToolCalls[i].Plugin == "" {
-				stageCtx.ToolCalls[i].Plugin = a.resolveToolPlugin(stageCtx.ToolCalls[i].Name)
-			}
-		}
-		if a.runStage(sdk.StagePostAction, stageCtx) {
-			return *stageCtx.Response, toolsUsed, toolResults, nil
-		}
-		resp.Content = stageCtx.LLMText
-		resp.ToolCalls = convertBackToolCalls(stageCtx.ToolCalls)
-
-		chainPayload := map[string]interface{}{
-			"content":    resp.Content,
-			"reasoning":  resp.ReasoningContent,
-			"tool_calls": resp.ToolCalls,
-			"phase":      "intermediate",
-			"turn":       turn,
-		}
-		if resp.TokenUsage.Total > 0 {
-			chainPayload["usage"] = map[string]int{
-				"prompt":     resp.TokenUsage.Prompt,
-				"completion": resp.TokenUsage.Completion,
-				"total":      resp.TokenUsage.Total,
-			}
-		}
-		a.publishEvent(events.EventAgentLLMChain, chainPayload)
-
-		if resp.ReasoningContent != "" {
-			a.publishEvent(events.EventReasoning, map[string]interface{}{
-				"content": resp.ReasoningContent,
-				"channel": a.currentOutputChannel,
-			})
-		}
-
-		if len(resp.ToolCalls) == 0 {
-			return resp.Content, toolsUsed, toolResults, nil
-		}
-
-		// 本批是否全部是输出通道发送（=模型刚交付了给用户的回复）。
-		// 必须在执行前判定：执行过程中的中断/拒绝分支会 continue/break，
-		// 放在循环里统计会漏。
-		replyOnly := true
-		for _, tc := range resp.ToolCalls {
-			if !isOutputDeliveryTool(tc.Name) {
-				replyOnly = false
-				break
-			}
-		}
-
-		contentOnce := true
-		for _, tc := range resp.ToolCalls {
-			if len(a.interceptCh) > 0 {
-				for _, interrupt := range a.drainInterrupts() {
-					msgs = append(msgs, agentAPI.Message{Role: "system", Content: "[中断消息] " + interrupt})
-				}
-				a.publishEvent(events.EventToolCall, map[string]interface{}{
-					"tool":    tc.Name,
-					"plugin":  a.resolveToolPlugin(tc.Name),
-					"args":    tc.Arguments,
-					"status":  "interrupted",
-					"reason":  "user interrupt before execution",
-					"channel": a.currentOutputChannel,
-				})
-				break
-			}
-
-			toolsUsed = append(toolsUsed, tc.Name)
-			pluginName := a.resolveToolPlugin(tc.Name)
-			log.Printf("[agent] executing tool: %s (plugin=%s, id=%s)", tc.Name, pluginName, tc.ID)
-			if tc.RawArguments != "" {
-				log.Printf("[agent] tool %s raw_arguments: %s", tc.Name, truncateStr(tc.RawArguments, 300))
-			}
-
-			sdkTC := sdk.ToolCall{ID: tc.ID, Name: tc.Name, Plugin: pluginName, Arguments: tc.Arguments}
-			stageCtx.ToolCalls = []sdk.ToolCall{sdkTC}
-			stageCtx.ToolResults = nil
-			if a.runStage(sdk.StageBeforeToolcall, stageCtx) {
-				result := fmt.Sprintf("工具 %s 已被插件拒绝", tc.Name)
-				msgs = append(msgs, agentAPI.Message{Role: "assistant", ToolCalls: []agentAPI.ToolCall{tc}})
-				msgs = append(msgs, agentAPI.Message{Role: "tool", ToolCallID: tc.ID, Content: result})
-				a.publishEvent(events.EventToolCall, map[string]interface{}{
-					"tool":    tc.Name,
-					"plugin":  pluginName,
-					"args":    tc.Arguments,
-					"result":  result,
-					"status":  "denied",
-					"channel": a.currentOutputChannel,
-				})
-				continue
-			}
-			tc.Arguments = stageCtx.ToolCalls[0].Arguments
-
-			if pluginName != "" && !a.pluginHealth.isHealthy(pluginName) {
-				result := fmt.Sprintf("插件 %s 处于崩溃状态，已跳过执行，等待自动恢复重载", pluginName)
-				log.Printf("[agent] skip tool %s: plugin %s unhealthy", tc.Name, pluginName)
-				msgs = append(msgs, agentAPI.Message{Role: "assistant", ToolCalls: []agentAPI.ToolCall{tc}})
-				msgs = append(msgs, agentAPI.Message{Role: "tool", ToolCallID: tc.ID, Content: result})
-				continue
-			}
-
-			result := a.executeToolCall(tc)
-			toolResults = append(toolResults, ToolResultItem{Name: tc.Name, Output: result})
-			log.Printf("[agent] tool %s result: %s", tc.Name, truncateStr(result, 100))
-
-			stageCtx.ToolResults = []sdk.ToolResult{{CallID: tc.ID, Name: tc.Name, Plugin: pluginName, Success: true, Result: result}}
-			a.runStage(sdk.StageAfterToolcall, stageCtx)
-			if len(stageCtx.ToolResults) > 0 {
-				if r, ok := stageCtx.ToolResults[0].Result.(string); ok {
-					result = r
-				}
-			}
-			// ContextPolicy: prune 工具调用后执行上下文裁剪（§13.8）
-			if def := a.stageHost.ToolDef(tc.Name); def != nil && def.ContextPolicy == "prune" {
-				if a.context != nil {
-					topK := a.maxContextSize - 1
-					if topK < 1 {
-						topK = 1
-					}
-					// 查询向量取**清洗后**的有效内容，否则噪声（ANSI/base64/JSON
-					// 包装）会把相关性打分带偏，裁掉本该保留的事件。
-					a.context.Prune(a.toolOutputForQuery(tc.Name, result), topK, a.docStore)
-				}
-			}
-
-			msgContent := ""
-			if contentOnce {
-				msgContent = resp.Content
-				contentOnce = false
-			}
-			msgs = append(msgs, agentAPI.Message{Role: "assistant", Content: msgContent, ReasoningContent: resp.ReasoningContent, ToolCalls: []agentAPI.ToolCall{tc}})
-
-			// 多模态工具结果：插件通过 SDK.SetToolBlocks 注入 image_url/audio_url block。
-			//
-			// 媒体不挂在 tool message 上，而是另起一条紧随其后的 user message——
-			// 这也是插件文案一直在说的「注入后续对话」。
-			// 为何不能挂 tool message：同一张图、同一模型、三轮实测——
-			//   图在 user message      → 3/3 读到
-			//   图在 tool message      → 0/3（模型答「没能读到这张图」）
-			//   tool 纯文本 + 后接 user → 3/3 读到
-			// tool message 那轮 prompt_tokens 反而更高（7967 vs 7089），base64 确实
-			// 进了上游，但 role=tool 上的多模态 content 数组不被当作可视内容。
-			//
-			// 主模型不支持该模态时更不能直接塞：网关会把 image_url 静默剥离后仍
-			// 返回 200，模型回答「我没有看到图片」而内核以为注入成功。改走回退链。
-			toolMsg := agentAPI.Message{Role: "tool", ToolCallID: tc.ID, Content: result}
-			var mediaMsg *agentAPI.Message
-			if rawBlocks := a.io.ConsumeToolBlocks(); len(rawBlocks) > 0 {
-				var blocks []agentAPI.ContentBlock
-				for _, b := range rawBlocks {
-					if cb, ok := b.(pubsdk.ContentBlock); ok {
-						// 跨包类型拷贝（pubsdk.ContentBlock → agentAPI.ContentBlock）
-						block := agentAPI.ContentBlock{Type: cb.Type, Text: cb.Text}
-						if cb.ImageURL != nil {
-							block.ImageURL = &agentAPI.ImageURL{URL: cb.ImageURL.URL, Detail: cb.ImageURL.Detail}
-						}
-						if cb.AudioURL != nil {
-							block.AudioURL = &agentAPI.AudioURL{URL: cb.AudioURL.URL}
-						}
-						blocks = append(blocks, block)
-					}
-				}
-				if len(blocks) > 0 {
-					// 先落进 CAS：无论下面走直视还是回退转写，媒体本体都该进记忆。
-					// 不存的后果是 ToolResultItem.Output 只剩那句
-					// "[已将图片注入后续对话] /tmp/x.png"，文件一删线索就断了。
-					a.stageMediaDigests(a.captureBlockMedia(blocks, tc.Name)...)
-
-					if native, fallbackText := a.prepareToolBlocks(blocks); len(native) > 0 {
-						// 能直视：另起一条 user message 承载媒体，并补一句来源说明，
-						// 否则模型会把它当成用户新发的图而不是工具拉回来的。
-						mediaBlocks := append([]agentAPI.ContentBlock{{
-							Type: "text",
-							Text: fmt.Sprintf("[以下是 %s 注入的媒体内容]", tc.Name),
-						}}, native...)
-						mediaMsg = &agentAPI.Message{Role: "user", Blocks: mediaBlocks}
-					} else if fallbackText != "" {
-						// 回退链已把媒体转写成文字：并进 tool message 的纯文本 content，
-						// 不再另起消息（文字在 tool message 里本来就能被读到）。
-						toolMsg.Content = result + "\n\n" + fallbackText
-						result = toolMsg.Content
-						if len(toolResults) > 0 {
-							toolResults[len(toolResults)-1].Output = result
-						}
-					}
-				}
-			}
-			msgs = append(msgs, toolMsg)
-			if mediaMsg != nil {
-				// 必须紧跟在 toolMsg 之后：中间插入其他消息会让 tool_call_id 配对断开。
-				msgs = append(msgs, *mediaMsg)
-			}
-
-			a.publishEvent(events.EventToolCall, map[string]interface{}{
-				"tool":    tc.Name,
-				"plugin":  pluginName,
-				"args":    tc.Arguments,
-				"result":  result,
-				"status":  "ok",
-				"channel": a.currentOutputChannel,
-			})
-
-			if len(a.interceptCh) > 0 {
-				for _, interrupt := range a.drainInterrupts() {
-					msgs = append(msgs, agentAPI.Message{Role: "system", Content: "[中断消息] " + interrupt})
-				}
-				break
-			}
-		}
-
-		// 供下一轮顶部选择补位文案。
-		lastBatchReplyOnly = replyOnly
-	}
-}
-
 // chatStreamWithFallback 优先流式调用 provider，失败时回退非流式 Chat()。
 //
 // 流式路径：ChatStream 拿到 chunk channel，逐块累积 content/reasoning_content，
@@ -525,14 +132,14 @@ func (a *Agent) process(input string, stageCtx *sdk.StageContext) (response stri
 //
 // 超时收益：首包 ~1-3s 到达即建立活性，后续只要 token 在流动就不会触发
 // 空闲超时；总生成时长不再受限於 180s 整体超时。
-func chatStreamWithFallback(ctx context.Context, p agentAPI.Provider, req *agentAPI.CompletionRequest, a *Agent) (*agentAPI.CompletionResponse, error) {
+func chatStreamWithFallback(ctx context.Context, p agentAPI.Provider, req *agentAPI.CompletionRequest, a *Agent, channel string) (*agentAPI.CompletionResponse, error) {
 	ch, err := p.ChatStream(ctx, req)
 	if err != nil {
 		log.Printf("[agent] stream connect failed (%v), falling back to non-stream chat", err)
 		return p.Chat(ctx, req)
 	}
 
-	resp, accErr := accumulateStream(ctx, ch, a)
+	resp, accErr := accumulateStream(ctx, ch, a, channel)
 
 	// 中断/超时取消必须保持取消语义传给调用方（与原 Chat() 行为一致：
 	// 被 cancel 时丢弃已收内容返回 err），让 process() 的 continue 分支
@@ -543,7 +150,7 @@ func chatStreamWithFallback(ctx context.Context, p agentAPI.Provider, req *agent
 		if a != nil {
 			a.publishEvent(events.EventContentDelta, map[string]interface{}{
 				"content": "",
-				"channel": a.currentOutputChannel,
+				"channel": channel,
 				"reset":   true,
 			})
 		}
@@ -573,7 +180,7 @@ type toolCallAcc struct {
 
 // accumulateStream 消费 chunk channel，累积为完整 CompletionResponse，
 // 同时发布增量事件。返回的 response 与非流式 Chat() 的返回等价。
-func accumulateStream(ctx context.Context, ch <-chan agentAPI.StreamChunk, a *Agent) (*agentAPI.CompletionResponse, error) {
+func accumulateStream(ctx context.Context, ch <-chan agentAPI.StreamChunk, a *Agent, channel string) (*agentAPI.CompletionResponse, error) {
 	resp := &agentAPI.CompletionResponse{
 		ToolCalls: make([]agentAPI.ToolCall, 0),
 	}
@@ -625,7 +232,7 @@ func accumulateStream(ctx context.Context, ch <-chan agentAPI.StreamChunk, a *Ag
 				if a != nil {
 					a.publishEvent(events.EventReasoningDelta, map[string]interface{}{
 						"content": ck.ReasoningContent,
-						"channel": a.currentOutputChannel,
+						"channel": channel,
 					})
 				}
 			}
@@ -634,7 +241,7 @@ func accumulateStream(ctx context.Context, ch <-chan agentAPI.StreamChunk, a *Ag
 				if a != nil {
 					a.publishEvent(events.EventContentDelta, map[string]interface{}{
 						"content": ck.Content,
-						"channel": a.currentOutputChannel,
+						"channel": channel,
 					})
 				}
 			}
@@ -747,11 +354,13 @@ func (a *Agent) formatMergedTimeline(maxTokens int) string {
 	include := 0
 	for i := len(events) - 1; i >= 0; i-- {
 		e := events[i]
-		est := len(e.Source) + len(e.Input) + 40
+		// ❗单位必须与 EstimateTokens 一致（rune×2）。这里曾用 `len()`（**字节**）再 ×2：
+		// CJK 一字 3 字节 ⇒ 中文事件被高估 3 倍，窗口还有余量也会提前 break，
+		// 把更早的事件整段丢掉（实测：2384 字的中文事件被估成 14398 token > 8192）。
+		estTokens := EstimateTokens(e.Source) + EstimateTokens(e.Input) + 40
 		if e.Response != "" {
-			est += 120
+			estTokens += 120
 		}
-		estTokens := est * 2
 		if remaining-estTokens < 0 && include > 0 {
 			break
 		}

internal/agent/core/promptvars_test.go

@@ -0,0 +1,32 @@
+package core
+
+import (
+	"strings"
+	"testing"
+
+	"gitcode.com/JianFeeeee/HomeAgent/internal/meta"
+	sdkmeta "gitcode.com/JianFeeeee/homeagent-sdk/meta"
+)
+
+func TestExpandPromptVars(t *testing.T) {
+	got := expandPromptVars("型号 {{kernel_version}}（{{kernel_commit}}），SDK {{sdk_version}}")
+	if !strings.Contains(got, meta.Version) || !strings.Contains(got, sdkmeta.Version) {
+		t.Fatalf("占位符未展开: %q", got)
+	}
+	if strings.Contains(got, "{{") {
+		t.Fatalf("仍有未展开的内置占位符: %q", got)
+	}
+	// 人格卡实测原文：写死了 v1.0.3，应能被占位符取代
+	live := expandPromptVars("你是 HomeAgent 的看板娘「小宅」(Xiao Zhai)，HΔ-Kernel v{{kernel_version}} 型号的家政型 AI 管家助手。")
+	if strings.Contains(live, "1.0.3") || !strings.Contains(live, "v"+meta.Version) {
+		t.Fatalf("人格卡版本未跟随内核: %q", live)
+	}
+	// 未知占位符必须原样保留（写错要看得见，不能被静默吞掉）
+	if unk := expandPromptVars("版本 {{kernel_verison}}"); !strings.Contains(unk, "{{kernel_verison}}") {
+		t.Fatalf("未知占位符被吞: %q", unk)
+	}
+	// 无占位符时原样返回（人格卡热路径，不做无谓拷贝）
+	if plain := "无占位符"; expandPromptVars(plain) != plain {
+		t.Fatal("无占位符时不应改写")
+	}
+}

internal/agent/core/recallpolicy_test.go

@@ -0,0 +1,141 @@
+package core
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+	pubsdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk"
+)
+
+// 这一组测试锁死「默认召回、可显式关闭」这条语义。
+//
+// 与 prune 刻意相反：裁剪是破坏性的、默认关；召回是只读增量、默认开。
+// 两者正交，一根 ContextPolicy 表达不了 2×2 的组合（只召回不裁剪 / 只裁不召回）。
+func TestRecallDeclared_DefaultsToRecall(t *testing.T) {
+	m := agentIO.NewIOManager()
+	a := &Agent{io: m}
+
+	// 没有任何声明 → 默认召回（保持既有"每条输入都召回"的行为）。
+	if !a.recallDeclared(&agentIO.InputEvent{Source: "unknown", Payload: map[string]interface{}{}}) {
+		t.Fatal("未声明的输入默认必须召回")
+	}
+	// 通道注册了但没设 RecallPolicy → 仍默认召回。
+	m.RegisterInputChannel("plain", pubsdk.ChannelDef{})
+	if !a.recallDeclared(&agentIO.InputEvent{Source: "plain", Payload: map[string]interface{}{}}) {
+		t.Fatal("ChannelDef 未设 RecallPolicy 应默认召回")
+	}
+	// nil 事件不能 panic，且按默认召回。
+	if !a.recallDeclared(nil) {
+		t.Fatal("nil 事件应默认召回")
+	}
+}
+
+func TestRecallDeclared_ChannelOptOut(t *testing.T) {
+	m := agentIO.NewIOManager()
+	m.RegisterInputChannel("meta", pubsdk.ChannelDef{RecallPolicy: pubsdk.RecallPolicyNone})
+	m.RegisterInputChannel("talk", pubsdk.ChannelDef{RecallPolicy: pubsdk.RecallPolicyAuto})
+	a := &Agent{io: m}
+
+	if a.recallDeclared(&agentIO.InputEvent{Source: "meta", Payload: map[string]interface{}{}}) {
+		t.Fatal("通道声明 none 不应召回")
+	}
+	if !a.recallDeclared(&agentIO.InputEvent{Source: "talk", Payload: map[string]interface{}{}}) {
+		t.Fatal("通道声明 auto 应召回")
+	}
+}
+
+// 注入点声明优先于通道定义：同一通道下的不同注入可以有不同意图。
+func TestRecallDeclared_InjectionOverridesChannel(t *testing.T) {
+	m := agentIO.NewIOManager()
+	a := &Agent{io: m}
+	m.RegisterInputChannel("qq", pubsdk.ChannelDef{RecallPolicy: pubsdk.RecallPolicyNone})
+
+	evt := &agentIO.InputEvent{Source: "qq", Payload: map[string]interface{}{
+		"recall_policy": pubsdk.RecallPolicyAuto,
+	}}
+	if !a.recallDeclared(evt) {
+		t.Fatal("注入点声明 auto 应覆盖通道的 none")
+	}
+
+	m.RegisterInputChannel("plain", pubsdk.ChannelDef{RecallPolicy: pubsdk.RecallPolicyAuto})
+	evt = &agentIO.InputEvent{Source: "plain", Payload: map[string]interface{}{
+		"recall_policy": pubsdk.RecallPolicyNone,
+	}}
+	if a.recallDeclared(evt) {
+		t.Fatal("注入点声明 none 应覆盖通道的 auto")
+	}
+}
+
+// buildTaskMemoryContext 在声明 none 时必须返回空串（不注入记忆索引）。
+func TestBuildTaskMemoryContext_RespectsPolicy(t *testing.T) {
+	m := agentIO.NewIOManager()
+	m.RegisterInputChannel("meta", pubsdk.ChannelDef{RecallPolicy: pubsdk.RecallPolicyNone})
+	a := &Agent{io: m, indexer: newTestIndexer(t, "咖啡", "张三")}
+
+	f := &TaskFrame{Evt: &agentIO.InputEvent{Source: "meta", Payload: map[string]interface{}{}}}
+	if got := a.buildTaskMemoryContext(f, "咖啡", 0); got != "" {
+		t.Fatalf("声明 none 时不应注入记忆，实际 %q", got)
+	}
+
+	f2 := &TaskFrame{Evt: &agentIO.InputEvent{Source: "plain", Payload: map[string]interface{}{}}}
+	if got := a.buildTaskMemoryContext(f2, "咖啡", 0); !strings.Contains(got, "【记忆索引】") {
+		t.Fatalf("默认应注入记忆索引，实际 %q", got)
+	}
+}
+
+// 工具触发的召回：以（清洗后的）工具输出为 query，产出可注入的记忆文本。
+func TestRecallTextFor_UsesQuery(t *testing.T) {
+	a := &Agent{indexer: newTestIndexer(t, "咖啡", "张三")}
+	got := a.recallTextFor("咖啡", "tool:test")
+	if !strings.Contains(got, "【记忆索引】") {
+		t.Fatalf("应产出记忆索引文本，实际 %q", got)
+	}
+	// 空 query 或无 indexer 时不产出、不 panic。
+	if got := a.recallTextFor("", "tool:test"); got != "" {
+		t.Fatalf("空 query 应返回空串，实际 %q", got)
+	}
+	if got := (&Agent{}).recallTextFor("咖啡", "tool:test"); got != "" {
+		t.Fatalf("无 indexer 应返回空串，实际 %q", got)
+	}
+}
+
+// 召回文本以 system 消息挂在末尾；同一任务内多次触发是**替换**而非累加。
+func TestAppendOrReplaceRecall(t *testing.T) {
+	msgs := []agentAPI.Message{{Role: "user", Content: "hi"}}
+	msgs = appendOrReplaceRecall(msgs, "第一段")
+	if len(msgs) != 2 || msgs[1].Role != "system" || !strings.Contains(msgs[1].Content, "第一段") {
+		t.Fatalf("首次应追加一条 system 召回消息，实际 %+v", msgs)
+	}
+	msgs = appendOrReplaceRecall(msgs, "第二段")
+	if len(msgs) != 2 {
+		t.Fatalf("再次触发应替换而非累加，实际 %d 条", len(msgs))
+	}
+	if !strings.Contains(msgs[1].Content, "第二段") || strings.Contains(msgs[1].Content, "第一段") {
+		t.Fatalf("替换后应只含最新召回，实际 %q", msgs[1].Content)
+	}
+	if msgs = appendOrReplaceRecall(msgs, ""); len(msgs) != 2 {
+		t.Fatalf("空召回不应改变消息，实际 %d 条", len(msgs))
+	}
+}
+
+// newTestIndexer 造一个只含给定实体的图记忆 + 已同步的索引器。
+func newTestIndexer(t *testing.T, subject, object string) *memory.Indexer {
+	t.Helper()
+	db, err := memory.NewGraphDB(filepath.Join(t.TempDir(), "graph.db"))
+	if err != nil {
+		t.Fatalf("NewGraphDB: %v", err)
+	}
+	t.Cleanup(func() { db.Close() })
+	if _, _, err := db.Commit([]memory.Triple{{Subject: subject, Relation: "喜欢", Object: object}}, "s", 0); err != nil {
+		t.Fatalf("Commit: %v", err)
+	}
+	idx := memory.NewIndexer(db)
+	if err := idx.Sync(); err != nil {
+		t.Fatalf("Sync: %v", err)
+	}
+	return idx
+}

internal/agent/core/resident.go

@@ -0,0 +1,573 @@
+package core
+
+// 驻留式子 agent 的**生命周期与控制面**（设计 docs/zh/resident-subagent-design.md §7/§9/§10）。
+//
+//	父 ──创建/发送消息/查看/压缩/回收/销毁──► 驻留子
+//	子 ──主动消息(L3) / contextfull(L4)──► 父
+//
+// 层级关系：
+//   - 父持**登记表**（residents），它是查看·发送·压缩·回收·销毁的寻址依据；
+//   - 父 `Stop()` ⇒ 销毁全部子（**不留孤儿**）；
+//   - 子的 `KernelSource` = 父；父则把子的 contextfull 当**内核级事件**（raiseKernelInterrupt）上报给自己；
+//   - 子持有自己的 **inputch 处理表**（父 pull，不打断子）。
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+	"gitcode.com/JianFeeeee/HomeAgent/pkg/types"
+)
+
+// InputchRecord 是 inputch 处理表的一条记录（子持有，父 pull）。
+type InputchRecord struct {
+	InputCh   string    `json:"inputch"`
+	At        time.Time `json:"at"`
+	Proactive bool      `json:"proactive"` // true = 子主动写入；false = 系统自动写
+	Text      string    `json:"text"`
+}
+
+// ResidentOptions 是创建一个驻留子的参数（父的"创建"动作）。
+type ResidentOptions struct {
+	// ID 是子 agent 的 id（同时是登记表的键、跨 agent 寻址的依据）。
+	ID string
+	// TaskPrompt 是在固定提示词之上注入的**任务提示词**。
+	TaskPrompt string
+	// InputChs 是**划入**给这个子的 inputch（单位 = inputch；可来自同一插件的多个）。
+	InputChs []string
+	// AllowedOutputs 是授权给它的输出通道集合（nil/空 = 完整授权）。
+	AllowedOutputs []string
+	// Capacity 是划入 inputch 的队列容量（0 = 内核默认）。
+	Capacity int
+	// TempPath 是它 temp 图记忆的存储路径（必填；与子同生共死）。
+	TempPath string
+}
+
+// ResidentInfo 是父对某个驻留子的可查询状态（登记表条目 + 状态面摘要）。
+type ResidentInfo struct {
+	ID             string          `json:"id"`
+	State          string          `json:"state"`
+	InputChs       []string        `json:"inputchs"`
+	AllowedOutputs []string        `json:"allowed_outputs"`
+	Rounds         int             `json:"rounds"`
+	ContextFull    bool            `json:"context_full"`
+	CreatedAt      time.Time       `json:"created_at"`
+	TableSize      int             `json:"table_size"`
+	Table          []InputchRecord `json:"table,omitempty"`
+
+	// Sched* 是这个驻留子**自己的**输入调度器积压摘要（排队 / 待处理中断 /
+	// 中断栈 / 四级中断队列）。
+	//
+	// 为什么必须单列：每个驻留子是独立 agent，跑自己的事件循环与调度器
+	// （见 agent.go 的 newScheduler）。KernelStatus.Scheduler 只是**根**那份，
+	// 拿它代表全部子会让界面把「某个子堵死」显示成「一切正常」。
+	SchedReady   int    `json:"sched_ready"`
+	SchedPending int    `json:"sched_pending"`
+	SchedStack   int    `json:"sched_stack"`
+	SchedQueues  [5]int `json:"sched_queues"`
+}
+
+type residentChild struct {
+	id        string
+	agent     *Agent
+	light     *memory.LightMemory
+	mainRO    *memory.GraphDB
+	tempPath  string
+	dir       string
+	inputChs  []string
+	allowed   []string
+	createdAt time.Time
+
+	mu    sync.Mutex
+	state string // running | contextfull | stopped
+}
+
+// mainGraph 返回父自己的完整图记忆库（驻留子的受限句柄由它派生）。
+func (a *Agent) mainGraph() *memory.GraphDB { return a.memory }
+
+// SpawnResident 创建一个驻留子（父的"创建"动作）。
+func (a *Agent) SpawnResident(opts ResidentOptions) (ResidentInfo, error) {
+	if strings.TrimSpace(opts.ID) == "" {
+		return ResidentInfo{}, fmt.Errorf("驻留子必须有 id")
+	}
+	if strings.TrimSpace(opts.TempPath) == "" {
+		return ResidentInfo{}, fmt.Errorf("驻留子必须给出 temp 图记忆路径")
+	}
+	main := a.mainGraph()
+	if main == nil {
+		return ResidentInfo{}, fmt.Errorf("父没有图记忆，无法为驻留子提供主库只读视图")
+	}
+
+	a.residentMu.Lock()
+	if a.residents == nil {
+		a.residents = map[string]*residentChild{}
+	}
+	if _, dup := a.residents[opts.ID]; dup {
+		a.residentMu.Unlock()
+		return ResidentInfo{}, fmt.Errorf("驻留子 %s 已存在", opts.ID)
+	}
+	a.residentMu.Unlock()
+
+	// ① 轻量内核的记忆装配：主库**受限句柄**（结构上写不进）+ 自己的 temp 实例。
+	// temp 目录由内核创建（调用方只给路径）——与子同生共死，销毁时整目录丢弃。
+	if dir := filepath.Dir(opts.TempPath); dir != "" && dir != "." {
+		if err := os.MkdirAll(dir, 0o700); err != nil {
+			return ResidentInfo{}, fmt.Errorf("创建 temp 目录: %w", err)
+		}
+	}
+	mainRO, err := memory.OpenGraphDBReadOnly(main.Path())
+	if err != nil {
+		return ResidentInfo{}, fmt.Errorf("打开主库受限句柄: %w", err)
+	}
+	light, err := memory.NewLightMemory(mainRO, opts.TempPath, true)
+	if err != nil {
+		_ = mainRO.Close()
+		return ResidentInfo{}, err
+	}
+
+	// ② 划入 inputch（登记表里记归属；一个插件的多个 inputch 可分别划给不同子）。
+	if reg := a.io.ChannelRegistry(); reg != nil {
+		for _, ch := range opts.InputChs {
+			if err := reg.Assign(ch, opts.ID, opts.Capacity); err != nil {
+				_ = light.Close()
+				_ = mainRO.Close()
+				return ResidentInfo{}, fmt.Errorf("划入 inputch %s: %w", ch, err)
+			}
+		}
+	}
+
+	// ③ 子的 io：**独立**的 IOManager（自己的输入通道入口），但共享通道登记表，
+	// 并把父的 io 挂成"上级"——**输出通道（io 里的 Device）由插件登记在父的 io 上**，
+	// 子若不继承这张视图，`output_send__<通道>` 一律被判"通道不存在或不可用"、
+	// `output_list_channels` 为空、连 `output_send__*` 工具都不会生成
+	// （现场联调：父侧通道装载完整、子侧 childIO 空壳）。
+	// 回退是实时的（设备随资源生灭），授权仍由 opts.AllowedOutputs 白名单把关。
+	childIO := agentIO.NewIOManager()
+	if reg := a.io.ChannelRegistry(); reg != nil {
+		childIO.SetChannelRegistry(reg)
+	}
+	childIO.SetParentIO(a.io)
+
+	parentID := string(a.id)
+	child := New(AgentConfig{
+		ID:              types.AgentID(opts.ID),
+		Provider:        a.provider,
+		ProviderManager: a.providerManager,
+		IO:              childIO,
+		StageHost:       a.stageHost,
+		LightMemory:     light, // 轻量内核：只有图记忆共同面
+		AllowedOutputs:  opts.AllowedOutputs,
+		KernelSource:    parentID, // 子的 L4 只属于父
+		ParentID:        parentID,
+		TaskPrompt:      opts.TaskPrompt,
+	})
+
+	rc := &residentChild{
+		id: opts.ID, agent: child, light: light, mainRO: mainRO,
+		tempPath: opts.TempPath, dir: filepath.Dir(opts.TempPath),
+		inputChs:  append([]string(nil), opts.InputChs...),
+		allowed:   append([]string(nil), opts.AllowedOutputs...),
+		createdAt: time.Now(), state: "running",
+	}
+
+	// ④ 子 → 父的主动消息（**L3 中断**，带子标识）：投进父的 inputch。
+	parentInCh := a.residentInboundChannel(opts.ID)
+	// 登记了入站 inputch 就必须有回滚路径：注册点与 residents 登记之间
+	// 当前无可失败步骤，但一旦将来插入（或 child.Start 变更），早退会把这条
+	// 登记留在共享表里——就是 child/<id> 残留那只 bug 的另一条入口。
+	// defer 保证“只要没走到成功返回，就注销这条登记”。
+	registered := false
+	defer func() {
+		if registered {
+			return
+		}
+		if reg := a.io.ChannelRegistry(); reg != nil {
+			reg.Unregister(inboundChannelName(opts.ID))
+		}
+	}()
+	child.notifyParent = func(text string) {
+		a.io.InjectInterruptTextOpts(opts.ID, parentInCh, text,
+			agentIO.InjectOptions{Priority: "L3"})
+	}
+	// ⑤ 子的 contextfull → 父侧的**内核级事件**（L4，带子标识）。
+	child.onContextFull = func() { a.handleChildContextFull(rc) }
+
+	a.residentMu.Lock()
+	a.residents[opts.ID] = rc
+	a.residentMu.Unlock()
+
+	child.Start()
+
+	// ⑥ create 即开工：把任务提示词作为**第一条排队输入**投给子。
+	//
+	// 为什么必须在这里投：TaskPrompt 只进子的系统提示词（"你是谁、要做什么"），
+	// 而**不会**让子跑起来 —— 实测现象是子启动后 rounds=0、永远待机
+	// （日志 `[agent] r1 started, waiting for IO interrupts` 之后无事发生）。
+	// 走排队输入（非中断）：创建是"安排工作"，不是"打断它正在做的事"。
+	if strings.TrimSpace(opts.TaskPrompt) != "" {
+		child.io.InjectInputTo(a.residentParentSource(), parentInCh, "text",
+			map[string]interface{}{"content": opts.TaskPrompt})
+	}
+	registered = true
+	return rc.info(), nil
+}
+
+// residentParentSource 是"父给子投递"的输入来源名（子的视角里能看出是谁发的）。
+func (a *Agent) residentParentSource() string { return "parent/" + string(a.id) }
+
+// residentInboundChannel 是"父接收某个子的消息"的 inputch 名（登记进登记表可见）。
+//
+// inboundChannelName 只拼名字，不产生副作用（注销路径要用它算出同一个名字，
+// 不能再去调 residentInboundChannel——那会顺手把刚摘掉的登记又写回去）。
+func inboundChannelName(childID string) string { return "child/" + childID }
+
+func (a *Agent) residentInboundChannel(childID string) string {
+	ch := inboundChannelName(childID)
+	if reg := a.io.ChannelRegistry(); reg != nil {
+		// 归属父自己：它是父的入站 inputch。
+		_ = reg.Register(agentIO.InputChannel{Name: ch, Plugin: "resident", Owner: string(a.id)})
+	}
+	return ch
+}
+
+// DestroyResident 立刻销毁一个驻留子并从登记表移除（父的"销毁"动作；不收割）。
+//
+// 销毁是父**随时**可做的；父退出时由 StopResidents 对全部子执行。
+func (a *Agent) DestroyResident(id string) error {
+	a.residentMu.Lock()
+	rc, ok := a.residents[id]
+	if ok {
+		delete(a.residents, id)
+	}
+	a.residentMu.Unlock()
+	if !ok {
+		return fmt.Errorf("驻留子 %s 不存在", id)
+	}
+	a.teardownResident(rc)
+	return nil
+}
+
+// teardownResident 停内核、放通道、丢 temp（销毁与回收共用）。
+func (a *Agent) teardownResident(rc *residentChild) {
+	rc.mu.Lock()
+	rc.state = "stopped"
+	rc.mu.Unlock()
+
+	rc.agent.Stop() // 停子的调度器（取消其运行中的任务）
+	if rc.light != nil {
+		_ = rc.light.Close() // 关掉 temp 实例
+	}
+	if rc.mainRO != nil {
+		_ = rc.mainRO.Close()
+	}
+	// temp 与子同生共死：连同目录一起丢弃（回收/销毁都不保留）。
+	if rc.dir != "" && strings.Contains(rc.tempPath, rc.id) {
+		_ = os.RemoveAll(rc.dir)
+	}
+	// 归还划入的 inputch（归属清空 ⇒ 回到"未分配"，可再分配）。
+	if reg := a.io.ChannelRegistry(); reg != nil {
+		for _, ch := range rc.inputChs {
+			_ = reg.Assign(ch, "", 0)
+		}
+		// 注销"父接收该子消息"的入站 inputch（child/<id>）。
+		//
+		// 它由 residentInboundChannel 在 create 时登记（Owner=父），销毁时必须
+		// 一并摘掉：登记表是共享的、按 name 全局唯一，残留会随 create/destroy
+		// 次数单调累积脏数据。实测：destroy 后 child/<id> 仍挂在根 agent 名下，
+		// 而外部没有任何工具能单独注销 inputch，只能重启 homed 清。
+		// 注意用纯函数算名字，不要再走 residentInboundChannel（会重新登记）。
+		reg.Unregister(inboundChannelName(rc.id))
+	}
+}
+
+// StopResidents 销毁全部驻留子（父退出时必须；不留孤儿）。
+func (a *Agent) StopResidents() int {
+	a.residentMu.Lock()
+	all := make([]*residentChild, 0, len(a.residents))
+	for _, rc := range a.residents {
+		all = append(all, rc)
+	}
+	a.residents = map[string]*residentChild{}
+	a.residentMu.Unlock()
+	for _, rc := range all {
+		a.teardownResident(rc)
+	}
+	return len(all)
+}
+
+// Residents 返回登记表的快照（按 id 排序，便于断言与展示稳定）。
+func (a *Agent) Residents() []ResidentInfo {
+	a.residentMu.Lock()
+	all := make([]*residentChild, 0, len(a.residents))
+	for _, rc := range a.residents {
+		all = append(all, rc)
+	}
+	a.residentMu.Unlock()
+	out := make([]ResidentInfo, 0, len(all))
+	for _, rc := range all {
+		out = append(out, rc.info())
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
+	return out
+}
+
+// ResidentTable 是父**查看**子的 inputch 处理表（pull，不打断子）。
+func (a *Agent) ResidentTable(id string) ([]InputchRecord, error) {
+	a.residentMu.Lock()
+	rc, ok := a.residents[id]
+	a.residentMu.Unlock()
+	if !ok {
+		return nil, fmt.Errorf("驻留子 %s 不存在", id)
+	}
+	return rc.agent.inputchTableSnapshot(), nil
+}
+
+// SendToResident 是父的"发送消息"：经输出通道寻址到该子的 inputch，
+// 对子而言是 **L4 中断**（取消当前状态 + 插入新消息）。
+func (a *Agent) SendToResident(id, text string) error {
+	a.residentMu.Lock()
+	rc, ok := a.residents[id]
+	a.residentMu.Unlock()
+	if !ok {
+		return fmt.Errorf("驻留子 %s 不存在", id)
+	}
+	ch := "sub/" + id
+	if len(rc.inputChs) > 0 {
+		ch = rc.inputChs[0]
+	}
+	// 来源 = 父；子的 KernelSource 是父 ⇒ 在子的阶梯上这是合法的 L4。
+	rc.agent.io.InjectInterruptTextOpts(string(a.id), ch, text,
+		agentIO.InjectOptions{Priority: "L4"})
+	return nil
+}
+
+// CompressResident 是父的"压缩"（**保留语义**）：压上下文 + **清理处理表**，子继续存在。
+func (a *Agent) CompressResident(id string) (int, error) {
+	a.residentMu.Lock()
+	rc, ok := a.residents[id]
+	a.residentMu.Unlock()
+	if !ok {
+		return 0, fmt.Errorf("驻留子 %s 不存在", id)
+	}
+	dropped := rc.agent.context.TrimKeepRecent(residentKeepRecent)
+	rc.agent.clearInputchTable() // 处理表记的是被压掉那段窗口的逐轮处理 ⇒ 必须清
+	rc.agent.resetContextFull()
+	rc.mu.Lock()
+	rc.state = "running"
+	rc.mu.Unlock()
+	return dropped, nil
+}
+
+// ReclaimResident 是父的"回收"（**取消语义**）：父读子的 temp → 选记录 → 合入 main
+// → 丢弃 temp → **取消**该驻留子。
+//
+// keep 由父决定"哪些纳入记忆"；为 nil 时表示全部合入。
+func (a *Agent) ReclaimResident(id string, keep func([]InputchRecord, []memory.Triple) []memory.Triple) (ResidentInfo, error) {
+	a.residentMu.Lock()
+	rc, ok := a.residents[id]
+	a.residentMu.Unlock()
+	if !ok {
+		return ResidentInfo{}, fmt.Errorf("驻留子 %s 不存在", id)
+	}
+	info := rc.info()
+
+	var promoted int
+	// 收割：读 temp 的全部活跃三元组（比通过图记录选择更直接）。
+	if rc.light != nil && rc.light.Temp() != nil && a.mainGraph() != nil {
+		exported, err := rc.light.Temp().ExportTriples(0)
+		if err != nil {
+			return info, fmt.Errorf("读取子 temp 失败: %w", err)
+		}
+		selected := exported
+		if keep != nil {
+			selected = keep(info.Table, exported)
+		}
+		if len(selected) > 0 {
+			if _, _, err := a.mainGraph().Commit(selected, "reclaim/"+id, 0); err != nil {
+				return info, fmt.Errorf("合入主记忆失败: %w", err)
+			}
+			promoted = len(selected)
+		}
+	}
+
+	// 收割完成 ⇒ 取消该驻留子（回收是取消语义，≠ 压缩）。
+	if err := a.DestroyResident(id); err != nil {
+		return info, err
+	}
+	info.State = fmt.Sprintf("reclaimed(promoted=%d)", promoted)
+	return info, nil
+}
+
+// handleChildContextFull 把子的 contextfull 当**内核级事件**上报给父自己：
+// 父侧 L4 中断（带子标识）—— 只推信号，细节靠"查看"拉状态面。
+func (a *Agent) handleChildContextFull(rc *residentChild) {
+	rc.mu.Lock()
+	rc.state = "contextfull"
+	rc.mu.Unlock()
+	a.raiseKernelInterrupt("child/"+rc.id, "kernel",
+		fmt.Sprintf("内核事件：驻留子 %s 上下文已满（contextfull）。请【查看】其状态面后决定【压缩】/【回收】/【销毁】。", rc.id))
+}
+
+// checkContextFull 判断本 agent 的**积累上下文是否已经装不下窗口**，是则触发一次 contextfull。
+//
+// ❗判据为什么不能写成"估算拼好的 f.Msgs"：`buildMessages` 拿到的 `budget.ContextTokens`
+// 本身就是按 `targetUsage = 0.8 × 窗口` 算出来的，时间线**在拼进消息之前就被预算裁过**了。
+// 于是 `f.Msgs` 的规模结构上封顶在 ~80% 窗口 —— 对 90% 阈值而言是**永远不成立**的判据
+// （写测试时我用一个比系统提示词还小的窗口才勉强越过线，那等于什么都没测）。
+//
+// 正确的事是"**要被裁了**"：拿**未裁剪**的积累上下文（`a.context` 的全部事件）估算，
+// 它超过窗口阈值就说明下一轮必须丢事件 ⇒ 这就是 contextfull。
+//
+// 只对**驻留子**生效（只有它们设了 onContextFull）。
+func (a *Agent) checkContextFull(f *TaskFrame) {
+	if a.onContextFull == nil || a.ctxFullSignaled {
+		return
+	}
+	max := 0
+	if a.provider != nil {
+		max = a.provider.MaxContextTokens()
+	}
+	if max <= 0 {
+		max = defaultMaxContextTokens
+	}
+	if a.context == nil {
+		return
+	}
+	// 未裁剪的积累上下文规模。
+	acc := 0
+	for _, e := range a.context.Recent(0) {
+		acc += EstimateTokens(e.Input) + EstimateTokens(e.Response)
+	}
+	if float64(acc) < float64(max)*contextFullRatio {
+		return
+	}
+	a.ctxFullSignaled = true
+	a.onContextFull()
+}
+
+func (a *Agent) resetContextFull() { a.ctxFullSignaled = false }
+
+// ---- 子侧：inputch 处理表（子持有，父 pull） ----
+
+// recordInputchNote 是子**主动写入**本轮 inputch 的处理信息（工具 inputch_note）。
+func (a *Agent) recordInputchNote(text string) {
+	a.tableMu.Lock()
+	defer a.tableMu.Unlock()
+	a.inputchPending = &InputchRecord{
+		InputCh: a.currentInputch, At: time.Now(), Proactive: true, Text: text,
+	}
+}
+
+// autoRecordInputch 是**系统自动写**兜底：本轮未主动写时，把该轮 inputch 的处理信息写入。
+// 保证每一轮必有记录，父不会看到空洞。
+func (a *Agent) autoRecordInputch(f *TaskFrame) {
+	if f == nil {
+		return
+	}
+	a.tableMu.Lock()
+	defer a.tableMu.Unlock()
+	if a.inputchPending != nil {
+		rec := *a.inputchPending
+		a.inputchPending = nil
+		rec.InputCh = firstNonEmpty(rec.InputCh, a.currentInputch)
+		a.inputchTable = append(a.inputchTable, rec)
+		return
+	}
+	text := fmt.Sprintf("轮次完成：输入=%s", truncateStr(f.Input, 80))
+	if f.Response != "" {
+		text += "；产出=" + truncateStr(f.Response, 120)
+	}
+	a.inputchTable = append(a.inputchTable, InputchRecord{
+		InputCh: a.currentInputch, At: time.Now(), Proactive: false, Text: text,
+	})
+}
+
+func (a *Agent) inputchTableSnapshot() []InputchRecord {
+	a.tableMu.Lock()
+	defer a.tableMu.Unlock()
+	return append([]InputchRecord(nil), a.inputchTable...)
+}
+
+func (a *Agent) clearInputchTable() {
+	a.tableMu.Lock()
+	defer a.tableMu.Unlock()
+	a.inputchTable = nil
+	a.inputchPending = nil
+}
+
+// ---- 子侧：主动向父发消息（L3） ----
+
+func (a *Agent) notifyParentFrom(text string) string {
+	if a.notifyParent == nil {
+		return "本 agent 没有上级，无法发送消息"
+	}
+	if strings.TrimSpace(text) == "" {
+		return "消息内容不能为空"
+	}
+	a.notifyParent(text)
+	return "已发送给主 agent"
+}
+
+func firstNonEmpty(a, b string) string {
+	if a != "" {
+		return a
+	}
+	return b
+}
+
+// residentKeepRecent 是压缩时保留的最近事件条数。
+const residentKeepRecent = 20
+
+// contextFullRatio 是触发 contextfull 的占比：积累上下文超过窗口的这个比例就报。
+// 取 0.9 而不是 1.0：留一点余量，让父 agent 在"下一次必须丢事件"之前就能决策
+// （压缩 / 回收 / 销毁），而不是等已经丢了再报。
+const contextFullRatio = 0.9
+
+// defaultMaxContextTokens 是 provider 未报告窗口时的兜底（与 ComputeTokenBudget 一致）。
+const defaultMaxContextTokens = 32768
+
+func (rc *residentChild) info() ResidentInfo {
+	rc.mu.Lock()
+	state, full := rc.state, rc.state == "contextfull"
+	rc.mu.Unlock()
+	table := rc.agent.inputchTableSnapshot()
+	// 子自己的调度器积压（per-agent 负载展示用）。schedulerStatus 只读快照，
+	// 每次状态轮询为每个子算一次，成本可忽略（驻留子数量是个位数）。
+	sc := rc.agent.schedulerStatus()
+	info := ResidentInfo{
+		ID: rc.id, State: state, InputChs: append([]string(nil), rc.inputChs...),
+		AllowedOutputs: append([]string(nil), rc.allowed...),
+		ContextFull:    full, CreatedAt: rc.createdAt, TableSize: len(table),
+		SchedReady:   sc.ReadyQueueDepth,
+		SchedPending: sc.PendingInterrupts,
+		SchedStack:   sc.SuspendStack,
+		SchedQueues:  sc.InterruptQueues,
+		// Rounds = 子**已执行的轮次数**（调度器的执行计数，单调不减）。
+		//
+		// 此前这里根本没填这个字段 ⇒ 父看到的永远是 `轮次=0`，与"处理表已有 N 条"
+		// 自相矛盾（现场：子明明处理了两轮，父读到 rounds=0，误判成"子没干活"）。
+		// 注意它**不等于** len(table)：处理表记的是"当前上下文窗口内"的轮次，
+		// 压缩会清空（§8.3），所以窗口内的条数会被重置，而轮次总数不会。
+		Rounds: rc.agent.roundsExecuted(),
+	}
+	if len(table) > 0 {
+		info.Table = table
+	}
+	return info
+}
+
+// MarshalResidentInfo 便于工具输出（单工具多视图用 JSON 视图）。
+func MarshalResidentInfo(info ResidentInfo) string {
+	b, err := json.Marshal(info)
+	if err != nil {
+		return fmt.Sprintf("%+v", info)
+	}
+	return string(b)
+}

internal/agent/core/resident_output_test.go

@@ -0,0 +1,145 @@
+package core
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+)
+
+// outputTestDevice 是最小的输出通道替身（io 里输出通道就是 Device）。
+type outputTestDevice struct {
+	name string
+	sent []map[string]interface{}
+}
+
+func (d *outputTestDevice) Name() string                                 { return d.name }
+func (d *outputTestDevice) Type() agentIO.DeviceType                     { return agentIO.DeviceOutput }
+func (d *outputTestDevice) Description() string                          { return "测试输出通道" }
+func (d *outputTestDevice) Tools() []agentIO.ToolDef                     { return nil }
+func (d *outputTestDevice) Start() error                                 { return nil }
+func (d *outputTestDevice) Stop() error                                  { return nil }
+func (d *outputTestDevice) OutputCapabilities() agentIO.OutputCapability { return agentIO.CapText }
+func (d *outputTestDevice) ChannelDef() agentIO.ChannelDef               { return agentIO.ChannelDef{} }
+func (d *outputTestDevice) Execute(tool string, args map[string]interface{}) (interface{}, error) {
+	d.sent = append(d.sent, map[string]interface{}{"tool": tool, "args": args})
+	return map[string]interface{}{"status": "sent"}, nil
+}
+
+func outputSendTool(name, payload string) agentAPI.ToolCall {
+	return agentAPI.ToolCall{
+		Name:      "output_send__" + name,
+		Arguments: map[string]interface{}{"payload": payload, "type": "text"},
+	}
+}
+
+// 驻留子必须能看见并使用**父**登记的输出通道。
+//
+// 现场缺陷（联调实录）：父侧通道装载完整、子侧 childIO 空壳 ——
+// 子调 output_send__X 被 `GetChannelCapabilities` 判 0 ⇒
+// 「通道 [X] 不存在或不可用。可用输出工具列表见 output_list_channels」，
+// 而 output_list_channels 也是空的。根因是子的 io 是新建的、设备表为空，
+// 而输出通道（io 的 Device）由插件登记在父的 io 上。
+func TestResident_InheritsParentOutputChannels(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+	defer parent.Stop()
+
+	fake := &outputTestDevice{name: "fakeout"}
+	other := &outputTestDevice{name: "other"}
+	if err := parent.io.RegisterDevice(fake); err != nil {
+		t.Fatal(err)
+	}
+	if err := parent.io.RegisterDevice(other); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := parent.SpawnResident(ResidentOptions{
+		ID:         "r-out",
+		TaskPrompt: "有情况就发到 fakeout",
+		// 白名单只放行一个：验证"继承可见"不等于"绕过授权"
+		AllowedOutputs: []string{"fakeout"},
+		TempPath:       filepath.Join(dir, "residents", "r-out", "graph.db"),
+	}); err != nil {
+		t.Fatalf("创建驻留子失败: %v", err)
+	}
+	child := parent.residents["r-out"].agent
+
+	// ① 看得见：修复前这里是 0（childIO 空壳）
+	if caps := child.io.GetChannelCapabilities("fakeout"); caps == 0 {
+		t.Fatal("驻留子看不见父的输出通道（childIO 空壳）")
+	}
+	// ② 发得出去：真走 dev.Execute("output", ...)
+	if out := child.executeOutputSendTool(outputSendTool("fakeout", "子发来的消息")); out != "ok" {
+		t.Fatalf("子发送应成功，得到 %q", out)
+	}
+	if len(fake.sent) != 1 {
+		t.Fatalf("父通道应收到 1 次输出，得到 %d", len(fake.sent))
+	}
+
+	// ③ 授权闸不被回退绕过：白名单外的通道照样拒绝
+	if out := child.executeOutputSendTool(outputSendTool("other", "越权")); !strings.Contains(out, "未授权") {
+		t.Fatalf("白名单外的通道应被拒，得到 %q", out)
+	}
+	if len(other.sent) != 0 {
+		t.Fatal("越权输出不应真的送达")
+	}
+
+	// ④ 工具面一致：子应生成 output_send__fakeout（含配套 _help），
+	//    而**不生成**白名单外通道的工具 —— 模型看不到就不会去调。
+	var names []string
+	for _, td := range child.buildToolDefs() {
+		entry, _ := td.(map[string]interface{})
+		fn, _ := entry["function"].(map[string]interface{})
+		if n, _ := fn["name"].(string); strings.HasPrefix(n, "output_send__") {
+			names = append(names, n)
+		}
+	}
+	has := func(want string) bool {
+		for _, n := range names {
+			if n == want {
+				return true
+			}
+		}
+		return false
+	}
+	if !has("output_send__fakeout") || !has("output_send__fakeout_help") {
+		t.Fatalf("子缺少授权通道的输出工具，得到 %v", names)
+	}
+	for _, n := range names {
+		if strings.HasPrefix(n, "output_send__other") {
+			t.Fatalf("白名单外的通道不该生成工具，得到 %v", names)
+		}
+	}
+
+	// ⑤ 实时性：父之后新登记的通道，子立刻可见（设备随资源生灭）
+	late := &outputTestDevice{name: "late"}
+	if err := parent.io.RegisterDevice(late); err != nil {
+		t.Fatal(err)
+	}
+	if caps := child.io.GetChannelCapabilities("late"); caps == 0 {
+		t.Fatal("父新登记的通道未实时反映到子（说明是快照而非回退）")
+	}
+}
+
+// 默认授权（AllowedOutputs 空）= 完整授权：子用父的全部输出通道。
+func TestResident_DefaultOutputsAreFull(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+	defer parent.Stop()
+
+	dev := &outputTestDevice{name: "anywhere"}
+	if err := parent.io.RegisterDevice(dev); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := parent.SpawnResident(ResidentOptions{
+		ID: "r-full", TaskPrompt: "待命",
+		TempPath: filepath.Join(dir, "residents", "r-full", "graph.db"),
+	}); err != nil {
+		t.Fatalf("创建驻留子失败: %v", err)
+	}
+	child := parent.residents["r-full"].agent
+	if out := child.executeOutputSendTool(outputSendTool("anywhere", "默认授权")); out != "ok" {
+		t.Fatalf("默认应完整授权，得到 %q", out)
+	}
+}

internal/agent/core/resident_test.go

@@ -0,0 +1,501 @@
+package core
+
+// 驻留子：生命周期（N3）、跨 agent 投递（N4）、inputch 处理表（N5）、contextfull（N6）。
+//
+// 设计 docs/zh/resident-subagent-design.md §6/§7/§8/§9/§10。
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+)
+
+// newRootWith 造一个带完整图记忆的父 agent，并指定它（以及它的驻留子）用的 provider。
+func newRootWith(t *testing.T, provider agentAPI.Provider) (*Agent, *memory.GraphDB, string) {
+	t.Helper()
+	dir := t.TempDir()
+	main, err := memory.NewGraphDB(filepath.Join(dir, "main.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	a := New(AgentConfig{
+		ID:              "parent",
+		Provider:        provider,
+		ProviderManager: agentAPI.NewProviderManager(),
+		IO:              agentIO.NewIOManager(),
+		StageHost:       NewStageHost(),
+		Memory:          main,
+		DataDir:         dir,
+	})
+	a.Start() // 父也有自己的调度器：子的消息要真的进它的中断队列并被处理
+	t.Cleanup(func() { a.Stop(); main.Close() })
+	return a, main, dir
+}
+
+// newRootForResidents 是默认构造（正常窗口）。
+func newRootForResidents(t *testing.T) (*Agent, *memory.GraphDB, string) {
+	t.Helper()
+	return newRootWith(t, &countingProvider{})
+}
+
+func spawnTestResident(t *testing.T, parent *Agent, dir, id string, inputChs ...string) ResidentInfo {
+	t.Helper()
+	info, err := parent.SpawnResident(ResidentOptions{
+		ID:         id,
+		TaskPrompt: "盯住这个通道，有情况就汇报",
+		InputChs:   inputChs,
+		TempPath:   filepath.Join(dir, "residents", id, "graph.db"),
+	})
+	if err != nil {
+		t.Fatalf("创建驻留子失败: %v", err)
+	}
+	return info
+}
+
+// waitFor 轮询直到条件成立（测试里不使用 sleep 猜时序）。
+func waitFor(t *testing.T, what string, fn func() bool) {
+	t.Helper()
+	waitForWithin(t, what, 5*time.Second, fn)
+}
+
+func waitForWithin(t *testing.T, what string, within time.Duration, fn func() bool) {
+	t.Helper()
+	deadline := time.Now().Add(within)
+	for time.Now().Before(deadline) {
+		if fn() {
+			return
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	t.Fatalf("等待超时：%s", what)
+}
+
+// ---- N3：生命周期 ----
+
+func TestResident_LifecycleAndNoOrphans(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+
+	// 父先注册两个 inputch（模拟插件注册），再把其中一个划给子。
+	reg := parent.io.ChannelRegistry()
+	if err := reg.Register(agentIO.InputChannel{Name: "qq", Plugin: "qq"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := reg.Register(agentIO.InputChannel{Name: "sub/in", Plugin: "sub"}); err != nil {
+		t.Fatal(err)
+	}
+
+	info := spawnTestResident(t, parent, dir, "child-1", "sub/in")
+	if info.State != "running" {
+		t.Fatalf("新建的驻留子状态=%q", info.State)
+	}
+	if list := parent.Residents(); len(list) != 1 || list[0].ID != "child-1" {
+		t.Fatalf("登记表=%+v", list)
+	}
+
+	// 划入生效：inputch 的归属变成子。
+	ch, ok := reg.Lookup("sub/in")
+	if !ok || ch.Owner != "child-1" {
+		t.Fatalf("划入未生效：%+v", ch)
+	}
+	// 未划入的仍是未分配。
+	if qq, _ := reg.Lookup("qq"); qq.Owner != "" {
+		t.Fatalf("未划入的 inputch 不该有归属：%+v", qq)
+	}
+	// 父的入站 inputch（接收该子的消息）登记在父名下。
+	if inbound, ok := reg.Lookup("child/child-1"); !ok || inbound.Owner != "parent" {
+		t.Fatalf("父的入站 inputch 未登记：%+v ok=%v", inbound, ok)
+	}
+
+	// 子的轻量内核：有共同面、没有整理面。
+	c1 := parent.residents["child-1"]
+	if c1.agent.memory != nil {
+		t.Fatal("驻留子不该有记忆整理面")
+	}
+	if c1.agent.graphMem() == nil {
+		t.Fatal("驻留子必须有图记忆共同面")
+	}
+	// 子的 L4 只属于父。
+	if !c1.agent.isKernelLevelSource("parent") {
+		t.Fatal("父必须是子的内核级来源（子的 L4 归父独占）")
+	}
+	if c1.agent.isKernelLevelSource("别人") {
+		t.Fatal("非父来源不得成为子的内核级来源")
+	}
+
+	// 销毁：出登记表、归还 inputch、temp 目录丢弃。
+	if err := parent.DestroyResident("child-1"); err != nil {
+		t.Fatal(err)
+	}
+	if len(parent.Residents()) != 0 {
+		t.Fatal("销毁后登记表应为空")
+	}
+	if ch, _ := reg.Lookup("sub/in"); ch.Owner != "" {
+		t.Fatalf("销毁后 inputch 应回到未分配：%+v", ch)
+	}
+	// 父的入站 inputch（child/<id>）必须在销毁时一并注销，否则登记表残留脏数据——
+	// HomeAgent 实测：destroy 后 child/<id> 仍挂在根 agent 名下，且无工具可单独注销。
+	if inbound, ok := reg.Lookup("child/child-1"); ok {
+		t.Fatalf("销毁后父的入站 inputch 应被注销，实际残留：%+v", inbound)
+	}
+	if err := parent.DestroyResident("child-1"); err == nil {
+		t.Fatal("重复销毁应报错")
+	}
+
+	// **父退出 ⇒ 全部子销毁、不留孤儿**。
+	spawnTestResident(t, parent, dir, "c-a", "sub/in")
+	spawnTestResident(t, parent, dir, "c-b")
+	if n := parent.StopResidents(); n != 2 {
+		t.Fatalf("StopResidents 销毁 %d 个，期望 2", n)
+	}
+	if len(parent.Residents()) != 0 {
+		t.Fatal("父退出后登记表必须为空")
+	}
+	for _, id := range []string{"c-a", "c-b"} {
+		if _, err := osStat(filepath.Join(dir, "residents", id)); err == nil {
+			t.Fatalf("子 %s 的 temp 目录应被丢弃", id)
+		}
+		if _, ok := reg.Lookup(inboundChannelName(id)); ok {
+			t.Fatalf("父退出后子 %s 的入站 inputch 应被注销", id)
+		}
+	}
+}
+
+// osStat 只是为了让"目录是否还存在"的断言可读（存在返回 nil 错误）。
+func osStat(path string) (interface{}, error) {
+	_, err := os.Stat(path)
+	return nil, err
+}
+
+// ---- N4：跨 agent 投递 ----
+
+func TestResident_DeliveryBothDirections(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+	spawnTestResident(t, parent, dir, "child-1")
+	child := parent.residents["child-1"].agent
+
+	// 父 → 子：发送消息 ⇒ 子在 **L4** 上收到（父是子的内核级来源）。
+	if err := parent.SendToResident("child-1", "先停一下，改做 X"); err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, "子收到 L4 中断", func() bool {
+		return child.DumpScheduler().Stats.InterruptsByLevel[LevelCritical] >= 1
+	})
+
+	// 子 → 父：主动消息 ⇒ 父在 **L3** 上收到（不是 L4）。
+	// 注意 L3 的枚举值是 LevelInteractive（LevelMessage 是 L2）。
+	child.notifyParent("我这边发现了点东西")
+	waitFor(t, "父收到子的 L3 消息", func() bool {
+		return parent.DumpScheduler().Stats.InterruptsByLevel[LevelInteractive] >= 1
+	})
+	if got := parent.DumpScheduler().Stats.InterruptsByLevel[LevelCritical]; got != 0 {
+		t.Fatalf("子的主动消息不得以 L4 出现在父的阶梯上（实际 %d 次）", got)
+	}
+}
+
+// ---- N5：inputch 处理表 ----
+
+func TestResident_InputchTableAutoAndProactive(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+	spawnTestResident(t, parent, dir, "child-1")
+	child := parent.residents["child-1"].agent
+
+	// 说明：create 会把任务提示词作为**第一条输入**投给子（"create 即开工"），
+	// 所以这里先等那一轮写完 —— 表里每多一轮就多一条，正是"每轮必有记录"。
+	waitFor(t, "任务提示词那一轮写入", func() bool {
+		table, err := parent.ResidentTable("child-1")
+		return err == nil && len(table) >= 1
+	})
+	base, err := parent.ResidentTable("child-1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	n := len(base)
+
+	// ① 子不主动写 ⇒ 系统自动写（每一轮必有记录）。
+	child.io.InjectInput("sub/in", "text", map[string]interface{}{"content": "干活"})
+	waitFor(t, "自动写处理表", func() bool {
+		table, err := parent.ResidentTable("child-1")
+		return err == nil && len(table) == n+1 && !table[n].Proactive
+	})
+	table, err := parent.ResidentTable("child-1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if table[n].InputCh != "sub/in" {
+		t.Fatalf("处理表应记本轮 inputch，实际 %q", table[n].InputCh)
+	}
+
+	// ② 子主动写 ⇒ 本轮不再自动写。
+	child.recordInputchNote("本轮我自己记：已完成第一阶段")
+	child.autoRecordInputch(&TaskFrame{Input: "第二轮"})
+	table, err = parent.ResidentTable("child-1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(table) != n+2 || !table[n+1].Proactive || !strings.Contains(table[n+1].Text, "第一阶段") {
+		t.Fatalf("主动写优先的语义不成立：%+v", table)
+	}
+}
+
+// ---- N6：contextfull + 三种处置 ----
+
+func TestResident_ContextFullAndDispositions(t *testing.T) {
+	parent, main, dir := newRootForResidents(t)
+
+	// ① contextfull：把子的**积累上下文**（a.context，不是拼好的消息）灌到超过窗口 90%。
+	//    注意不能靠"拼好的消息很大"来触发：拼装前时间线已被 token 预算裁到 ~80% 窗口。
+	spawnTestResident(t, parent, dir, "child-1")
+	rc := parent.residents["child-1"]
+	child := rc.agent
+	child.context.Append(ContextEvent{
+		Timestamp: time.Now(), Source: "sub/in",
+		Input: strings.Repeat("上下文填充", 8000), // 40000 字 ≈ 80000 token ≫ 8192×0.9
+	})
+	child.io.InjectInput("sub/in", "text", map[string]interface{}{"content": "继续"})
+
+	// 父在 **L4** 上收到 contextfull（带子标识）—— 只推信号。
+	waitFor(t, "父收到 contextfull 的 L4 中断", func() bool {
+		return parent.DumpScheduler().Stats.InterruptsByLevel[LevelCritical] >= 1
+	})
+	waitFor(t, "父的登记表显示子 contextfull", func() bool {
+		for _, r := range parent.Residents() {
+			if r.ID == "child-1" && r.ContextFull {
+				return true
+			}
+		}
+		return false
+	})
+
+	// ② 压缩（保留语义）：上下文变短 + 处理表清空 + 子继续存在。
+	child.recordInputchNote("压缩前的记录")
+	if _, err := parent.CompressResident("child-1"); err != nil {
+		t.Fatal(err)
+	}
+	if len(parent.Residents()) != 1 {
+		t.Fatal("压缩后子必须继续存在（压缩是保留语义）")
+	}
+	if table, _ := parent.ResidentTable("child-1"); len(table) != 0 {
+		t.Fatalf("压缩必须清理 inputch 处理表，实际 %d 条", len(table))
+	}
+
+	// ③ 回收（取消语义）：父选中的 temp 记录合入 main，然后取消该子。
+	if _, _, err := child.graphMem().Commit([]memory.Triple{
+		{Subject: "子的发现", Relation: "指向", Object: "结论"},
+	}, "sess", 1); err != nil {
+		t.Fatalf("子写自己的 temp 应成功: %v", err)
+	}
+	if _, err := parent.ReclaimResident("child-1", reclaimKeepAll); err != nil {
+		t.Fatal(err)
+	}
+	if len(parent.Residents()) != 0 {
+		t.Fatal("回收是取消语义：子不该继续存在")
+	}
+	res, err := main.Recall([]string{"子的发现"}, nil, 1, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	found := false
+	for _, e := range res.Entities {
+		if e.Name == "子的发现" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("回收应把选中的 temp 记录合入主记忆")
+	}
+
+	// ④ 销毁：随时可做、立刻移除。
+	spawnTestResident(t, parent, dir, "child-2")
+	if err := parent.DestroyResident("child-2"); err != nil {
+		t.Fatal(err)
+	}
+	if len(parent.Residents()) != 0 {
+		t.Fatal("销毁后不该还在登记表里")
+	}
+}
+
+func envInt(key string, def int) int {
+	if v := os.Getenv(key); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n > 0 {
+			return n
+		}
+	}
+	return def
+}
+
+// ---- N7：端到端 + 压力 ----
+
+func TestResident_E2EAndStress(t *testing.T) {
+	parent, _, dir := newRootForResidents(t)
+	reg := parent.io.ChannelRegistry()
+
+	// 压力规模可用环境变量放大（默认 8 子 × 12 轮）：
+	//   RESIDENT_STRESS_N / RESIDENT_STRESS_ROUNDS
+	nResidents := envInt("RESIDENT_STRESS_N", 8)
+	roundsEach := envInt("RESIDENT_STRESS_ROUNDS", 12)
+	ids := make([]string, 0, nResidents)
+	for i := 0; i < nResidents; i++ {
+		id := "sub-" + string(rune('a'+i))
+		ch := "sub/" + id + "/in"
+		if err := reg.Register(agentIO.InputChannel{Name: ch, Plugin: "sub"}); err != nil {
+			t.Fatal(err)
+		}
+		spawnTestResident(t, parent, dir, id, ch)
+		ids = append(ids, id)
+	}
+
+	// 压力：每个子灌 roundsEach 轮输入；其中一半走父→子的 L4 消息，一半走普通输入。
+	for _, id := range ids {
+		for r := 0; r < roundsEach; r++ {
+			// 内容必须唯一：内核会去重相同输入（去重路径不产生处理表记录）。
+			msg := fmt.Sprintf("%s 第 %d 轮", id, r)
+			if r%2 == 0 {
+				if err := parent.SendToResident(id, msg); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				parent.residents[id].agent.io.InjectInput("sub/"+id+"/in", "text",
+					map[string]interface{}{"content": msg})
+			}
+		}
+	}
+
+	// 全部子都必须活着，且每一轮都留下处理表记录（自动或主动）。
+	waitForWithin(t, "全部子完成各自轮次", 30*time.Second, func() bool {
+		for _, id := range ids {
+			table, err := parent.ResidentTable(id)
+			if err != nil || len(table) < roundsEach/2 {
+				return false
+			}
+		}
+		return true
+	})
+
+	// 双向通信在压力下也成立：让每个子都汇报一次（父侧 L3）。
+	for _, id := range ids {
+		parent.residents[id].agent.notifyParent("压力汇报 " + id)
+	}
+	waitForWithin(t, "父收到全部子的汇报", 10*time.Second, func() bool {
+		return parent.DumpScheduler().Stats.InterruptsByLevel[LevelInteractive] >= uint64(nResidents)
+	})
+
+	// 父退出 ⇒ 全部子销毁、登记表清空（不留孤儿）。
+	if n := parent.StopResidents(); n != nResidents {
+		t.Fatalf("父退出应销毁 %d 个子，实际 %d", nResidents, n)
+	}
+	if len(parent.Residents()) != 0 {
+		t.Fatal("父退出后登记表必须为空")
+	}
+	t.Logf("压力通过：%d 个驻留子 × %d 轮（父→子 L4 与普通输入各半）+ 双向汇报",
+		nResidents, roundsEach)
+}
+
+// ---- 传统上下文：轻量内核不做动态上下文的裁剪 ----
+
+// captureProvider 记录模型**实际收到**的消息。
+//
+// 为什么不直接看 TaskFrame：`prepareInputTask` 只做前半段（去重/通道/阶段/落上下文），
+// 消息是在 `runTaskSteps` 的 stepPrepare 里才拼出来的；而且断言"模型看到了什么"
+// 本来就比断言内核内部字段更接近事实。
+type captureProvider struct {
+	countingProvider
+	mu       sync.Mutex
+	calls    int
+	messages []agentAPI.Message
+}
+
+func (p *captureProvider) Chat(ctx context.Context, req *agentAPI.CompletionRequest) (*agentAPI.CompletionResponse, error) {
+	p.mu.Lock()
+	p.calls++
+	if req != nil {
+		p.messages = append([]agentAPI.Message(nil), req.Messages...)
+	}
+	p.mu.Unlock()
+	return &agentAPI.CompletionResponse{Content: "ok"}, nil
+}
+
+func (p *captureProvider) chatText() (int, string) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	var b strings.Builder
+	for _, m := range p.messages {
+		b.WriteString(m.Content)
+		b.WriteString("\n")
+	}
+	return p.calls, b.String()
+}
+
+// 子 agent 的上下文是**传统上下文**：累积的事件全部交给模型，
+// 内核**不得**按动态上下文的预算静默丢弃（那是父 agent 的能力）。
+// 装不下时由 contextfull 上报父决策，而不是自己丢。
+func TestLightKernel_TraditionalContextNoTrimming(t *testing.T) {
+	provider := &captureProvider{}
+	parent, _, dir := newRootWith(t, provider)
+	spawnTestResident(t, parent, dir, "child-1")
+	child := parent.residents["child-1"].agent
+
+	if !child.isLightKernel() {
+		t.Fatal("驻留子必须被识别为轻量内核")
+	}
+
+	// 先等"create 即开工"那一轮（任务提示词）跑完，否则下面抓到的是它的请求，
+	// 而不是我们注入了大段上下文之后的那一轮。
+	waitFor(t, "任务提示词那一轮结束", func() bool {
+		table, err := parent.ResidentTable("child-1")
+		return err == nil && len(table) >= 1
+	})
+	// 前提：动态上下文的份额 < 窗口（否则测不出区别）。
+	b := ComputeTokenBudget(child.provider, child.systemPrompt)
+	if b.MaxContext <= b.ContextTokens {
+		t.Fatalf("前提不成立：窗口(%d) 应大于动态上下文份额(%d)", b.MaxContext, b.ContextTokens)
+	}
+	// 填充量：**超过动态份额、但仍在窗口内**。
+	// ⇒ 完整内核会因预算把最早那条裁掉；轻量内核不该裁（只受窗口硬上限约束）。
+	filler := strings.Repeat("填", b.ContextTokens/2+200)
+	if EstimateTokens(filler) <= b.ContextTokens {
+		t.Fatalf("测试前提不成立：填充(%d token) 应超过动态份额(%d)", EstimateTokens(filler), b.ContextTokens)
+	}
+	child.context.Append(ContextEvent{Timestamp: time.Now(), Source: "sub/in", Input: "最早的事件标记EARLY"})
+	child.context.Append(ContextEvent{Timestamp: time.Now(), Source: "sub/in", Input: filler})
+	child.context.Append(ContextEvent{Timestamp: time.Now(), Source: "sub/in", Input: "最新的事件标记LATE"})
+
+	child.io.InjectInput("sub/in", "text", map[string]interface{}{"content": "本轮输入"})
+
+	// 等**新的一轮**请求（首轮可能已经发过，必须严格等到注入之后那次）。
+	waitFor(t, "子发出新一轮 LLM 请求", func() bool {
+		n, _ := provider.chatText()
+		return n >= 2
+	})
+	_, got := provider.chatText()
+	if !strings.Contains(got, "最早的事件标记EARLY") {
+		t.Fatalf("传统上下文：更早的事件不得被预算裁掉（属于父 agent 的动态上下文能力）；实收消息长度=%d", len(got))
+	}
+	if !strings.Contains(got, "最新的事件标记LATE") {
+		t.Fatal("最新事件必须在内")
+	}
+}
+
+// 对照：完整内核（根 agent）仍走动态上下文（按预算裁时间线）。
+func TestFullKernel_StillUsesDynamicContext(t *testing.T) {
+	parent, _, _ := newRootForResidents(t)
+	if parent.isLightKernel() {
+		t.Fatal("根 agent 不是轻量内核")
+	}
+	b := ComputeTokenBudget(parent.provider, "sys")
+	if got := parent.contextTokenBudget(b); got != b.ContextTokens {
+		t.Fatalf("完整内核应使用动态上下文的 ContextTokens(%d)，实际 %d", b.ContextTokens, got)
+	}
+	if b.MaxContext <= b.ContextTokens {
+		t.Fatalf("前提不成立：窗口(%d) 应大于动态上下文份额(%d)", b.MaxContext, b.ContextTokens)
+	}
+}

internal/agent/core/resident_tools.go

@@ -0,0 +1,179 @@
+package core
+
+// 驻留子的**工具面**（对照设计 §7 控制面与 §8 处理表）。
+//
+// 单工具多动作：父侧一个 `resident_agents`（list/create/send/inspect/compress/reclaim/destroy），
+// 子侧两个小工具：`notify_parent`（L3 主动汇报）与 `inputch_note`（主动写处理表）。
+
+import (
+	"fmt"
+	"log"
+	"path/filepath"
+	"strings"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+)
+
+func strArg(tc agentAPI.ToolCall, key string) string {
+	s, _ := tc.Arguments[key].(string)
+	return strings.TrimSpace(s)
+}
+
+func splitArg(s string) []string {
+	if strings.TrimSpace(s) == "" {
+		return nil
+	}
+	parts := strings.Split(s, ",")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// executeResidentAgents 是父的驻留子控制面（单工具多动作）。
+func (a *Agent) executeResidentAgents(tc agentAPI.ToolCall) string {
+	switch action := strArg(tc, "action"); action {
+	case "", "list":
+		list := a.Residents()
+		if len(list) == 0 {
+			return "当前没有驻留子 agent。"
+		}
+		var b strings.Builder
+		fmt.Fprintf(&b, "驻留子 agent（%d 个）:", len(list))
+		for _, r := range list {
+			fmt.Fprintf(&b, "\n  - %s [%s] inputch=%v 轮次=%d 处理表=%d",
+				r.ID, r.State, r.InputChs, r.Rounds, r.TableSize)
+			if r.ContextFull {
+				b.WriteString("  ⚠️ contextfull")
+			}
+		}
+		return b.String()
+
+	case "create":
+		id := strArg(tc, "id")
+		tempPath := strArg(tc, "temp_path")
+		if tempPath == "" {
+			anchor := a.dataDir
+			if anchor == "" {
+				// 兜底：从**主图库路径**推导（<data>/memory/graph.db ⇒ <data>）。
+				// 为什么不静默失败：这条路径只在"配置漏接线"时走到，
+				// 静默报错会让线上表现为"工具能调但永远建不出来"（实测就是这样）。
+				if a.memory != nil && a.memory.Path() != "" {
+					anchor = filepath.Dir(filepath.Dir(a.memory.Path()))
+					log.Printf("[resident] data_dir 未接线，回退到主图库目录: %s", anchor)
+				}
+			}
+			if anchor == "" {
+				return "创建驻留子需要 data_dir 或显式 temp_path（内核未接线 DataDir）"
+			}
+			tempPath = filepath.Join(anchor, "residents", id, "graph.db")
+		}
+		info, err := a.SpawnResident(ResidentOptions{
+			ID:             id,
+			TaskPrompt:     strArg(tc, "task_prompt"),
+			InputChs:       splitArg(strArg(tc, "input_chs")),
+			AllowedOutputs: splitArg(strArg(tc, "allowed_outputs")),
+			Capacity:       intArg(tc, "capacity"),
+			TempPath:       tempPath,
+		})
+		if err != nil {
+			return fmt.Sprintf("创建驻留子失败: %v", err)
+		}
+		return "已创建驻留子: " + MarshalResidentInfo(info)
+
+	case "send":
+		if err := a.SendToResident(strArg(tc, "id"), strArg(tc, "text")); err != nil {
+			return fmt.Sprintf("发送失败: %v", err)
+		}
+		return "已发送（对子而言是 L4 中断）"
+
+	case "inspect":
+		id := strArg(tc, "id")
+		if id == "" {
+			return "inspect 需要 id（或先用 action=list）"
+		}
+		table, err := a.ResidentTable(id)
+		if err != nil {
+			return fmt.Sprintf("查看失败: %v", err)
+		}
+		var b strings.Builder
+		fmt.Fprintf(&b, "驻留子 %s 的 inputch 处理表（%d 条）:", id, len(table))
+		for _, r := range table {
+			kind := "系统写"
+			if r.Proactive {
+				kind = "主动写"
+			}
+			fmt.Fprintf(&b, "\n  - [%s][%s] %s", r.InputCh, kind, r.Text)
+		}
+		if len(table) == 0 {
+			b.WriteString("\n  （尚无记录）")
+		}
+		return b.String()
+
+	case "compress":
+		n, err := a.CompressResident(strArg(tc, "id"))
+		if err != nil {
+			return fmt.Sprintf("压缩失败: %v", err)
+		}
+		return fmt.Sprintf("已压缩子 agent 上下文（丢弃 %d 条旧事件，并发清理其 inputch 处理表）；子继续存在", n)
+
+	case "reclaim":
+		info, err := a.ReclaimResident(strArg(tc, "id"), reclaimKeepAll)
+		if err != nil {
+			return fmt.Sprintf("回收失败: %v", err)
+		}
+		return "已回收（temp 中选中的记录已合入主记忆，该驻留子已取消）: " + MarshalResidentInfo(info)
+
+	case "destroy":
+		if err := a.DestroyResident(strArg(tc, "id")); err != nil {
+			return fmt.Sprintf("销毁失败: %v", err)
+		}
+		return "已销毁并移除该驻留子"
+
+	default:
+		return fmt.Sprintf("未知 action=%q；可用：list | create | send | inspect | compress | reclaim | destroy", action)
+	}
+}
+
+// reclaimKeepAll 是回收时的默认策略：把子 temp 的活跃记录全部纳入主记忆
+// （"哪些纳入"由父的模型决定——这里给的是"全要"这一档）。
+func reclaimKeepAll(_ []InputchRecord, triples []memory.Triple) []memory.Triple { return triples }
+
+func intArg(tc agentAPI.ToolCall, key string) int {
+	switch v := tc.Arguments[key].(type) {
+	case float64:
+		return int(v)
+	case int:
+		return v
+	}
+	return 0
+}
+
+// executeNotifyParent 是子的"主动向父发消息"（父侧阶梯 = **L3 中断**）。
+func (a *Agent) executeNotifyParent(tc agentAPI.ToolCall) string {
+	return a.notifyParentFrom(strArg(tc, "text"))
+}
+
+// executeInputchNote 是子"主动写入本轮 inputch 的处理信息"。
+// 主动写过 ⇒ 本轮系统不再自动写（见 autoRecordInputch）。
+func (a *Agent) executeInputchNote(tc agentAPI.ToolCall) string {
+	text := strArg(tc, "text")
+	if text == "" {
+		return "text 不能为空"
+	}
+	a.recordInputchNote(text)
+	return "已记录本轮 inputch 处理信息（本轮系统不会再自动写）"
+}
+
+// childInboundChannelHint 是给子看的"父会怎么把消息投给你"的提示（不参与调度）。
+func childInboundChannelHint(a *Agent) string { return "sub/" + string(a.id) }
+
+// residentTempDir 返回某个驻留子 temp 存储所在目录（销毁时连同目录丢弃）。
+func residentTempDir(tempPath string) string { return filepath.Dir(tempPath) }
+
+var _ = agentIO.InputChannel{} // 保持 agentIO 依赖（工具面未来会用通道登记）

internal/agent/core/scheduler_channel_routing_test.go

@@ -0,0 +1,91 @@
+package core
+
+// 抢占场景下的**输出通道路由**：被打断任务恢复后，回复必须回到它自己的输出通道。
+//
+// 回归判据（做驻留式子 agent 前必须成立）：**内核不持有"当前通道"可变状态**。
+// 曾经有 agent 级字段 a.currentOutputChannel：只在 prepare 段写入，而被打断任务
+// 恢复时不重新 prepare（resumeTask 只 rebase 前缀），于是中断任务 prepare 时把它
+// 覆盖成自己的通道，被恢复的任务再把回复发到**中断任务的通道**上——两任务串台。
+// N0 已删除该字段：通道一律从输入事件/帧推导（outputChannelOf / f.OutputChannel）。
+//
+// 每任务回执（evt.ResponseCh，Target=evt.Source）不受影响，所以既有测试全绿；
+// 但按通道投递（OutputEvent.OutputChannel / events.EventAgentOutput 的 channel）
+// 是插件渲染给用户的路径，它会串。
+
+import (
+	"testing"
+	"time"
+)
+
+func TestPreempt_ResumeKeepsOwnOutputChannel(t *testing.T) {
+	sp := newPreemptProvider("intr-done", "low-done")
+	a := newPreemptAgent(t, sp)
+
+	// 排队任务，来源与输出通道都是 qq。
+	lowEvt, lowCh := textEvent("qq", "低优先级任务")
+	lowTask := newInputTask(lowEvt)
+	if !a.sched.enqueue(lowTask) {
+		t.Fatal("入队失败")
+	}
+	if lowEvt.OutputChannel != "qq" {
+		t.Fatalf("前置条件不成立：OutputChannel=%q", lowEvt.OutputChannel)
+	}
+
+	lt, _, kind := a.sched.nextRef()
+	if kind != nextReady {
+		t.Fatalf("应取到排队任务，kind=%v", kind)
+	}
+	done := make(chan struct{})
+	go func() { a.executeNewTask(lt); close(done) }()
+
+	select {
+	case <-sp.entered:
+	case <-time.After(3 * time.Second):
+		t.Fatal("provider 未被调用")
+	}
+
+	// cli 中断抢占（L3）：任务被挂起。
+	intrEvt, intrCh := textEvent("cli", "紧急打断")
+	intrEvt.Payload["interrupt"] = true
+	if !a.sched.requestPreempt(intrEvt, LevelInteractive) {
+		t.Fatal("L3 中断应能抢占排队任务")
+	}
+	a.cancelCurrentLLM()
+	select {
+	case <-done:
+	case <-time.After(3 * time.Second):
+		t.Fatal("被打断任务未挂起")
+	}
+
+	// 中断任务先运行（它会 prepare，通道是 cli）。
+	it, _, k := a.sched.nextRef()
+	if k != nextImmediate {
+		t.Fatalf("应取到立即运行的中断，kind=%v", k)
+	}
+	a.executeNewTask(it)
+	if len(intrCh) != 1 {
+		t.Fatalf("中断任务应回执一次，实际 %d", len(intrCh))
+	}
+	// 注意：这里**刻意**不再有任何"内核当前通道"可断言 —— 该字段已删除，
+	// 通道只跟着输入事件与帧走。下面断言的就是这个性质本身。
+
+	// 恢复被抢占任务：它不重新 prepare，只能靠帧里记着自己的通道。
+	rt, rf, k2 := a.sched.nextRef()
+	if k2 != nextSuspended {
+		t.Fatalf("应恢复被抢占任务，kind=%v", k2)
+	}
+	a.resumeTask(rt, rf)
+
+	select {
+	case out := <-lowCh:
+		if out.OutputChannel != "qq" {
+			t.Fatalf("被打断任务恢复后的输出通道=%q，期望 qq —— 被中断任务的通道覆盖了 agent 级字段（两任务串台）",
+				out.OutputChannel)
+		}
+		if out.Target != "qq" {
+			t.Fatalf("回执 Target=%q，期望 qq", out.Target)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("被恢复任务未回执")
+	}
+}

internal/agent/core/scheduler_critical_test.go

@@ -0,0 +1,260 @@
+package core
+
+// M4 验收测试：临界区语义显式化 + 抢占延迟到安全点 + 批次不再被中断放弃。
+//
+// 设计依据 docs/zh/input-scheduler-design.md §4.3（临界区）、§11.1（P5/P6）。
+//
+// 关键结构事实：让位检查**只在 step 之间**进行，因此任何正在执行的 step
+// （工具 RPC、ONNX、CAS 落盘）天然不可抢占——中断只能等它返回。
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk"
+)
+
+// P5/P6：工具执行期间到达的高优先级中断不得立即抢占；必须等工具返回后的安全点。
+func TestPreempt_DeferredDuringToolExec(t *testing.T) {
+	sh := NewStageHost()
+	entered := make(chan struct{})
+	release := make(chan struct{})
+	var once sync.Once
+	sh.RegisterTool("t_slow", sdk.ToolDef{Name: "t_slow", Plugin: "t"}, func(args map[string]interface{}) (interface{}, error) {
+		once.Do(func() { close(entered) })
+		<-release
+		return "slow-done", nil
+	})
+
+	sp := &scriptProvider{script: []*agentAPI.CompletionResponse{
+		{Content: "", ToolCalls: []agentAPI.ToolCall{tc("c1", "t_slow")}}, // 低优先级任务调用慢工具
+		{Content: "low-done"},  // 恢复后收尾
+		{Content: "intr-done"}, // 中断任务
+	}}
+	a := New(AgentConfig{
+		ID:              "crit",
+		Provider:        sp,
+		ProviderManager: agentAPI.NewProviderManager(),
+		IO:              agentIO.NewIOManager(),
+		StageHost:       sh,
+	})
+
+	if _, _ = enqueueQueued(t, a, "qq", "低优先级任务"); true {
+	}
+	lt, _, _ := a.sched.nextRef()
+	done := make(chan struct{})
+	go func() { a.executeNewTask(lt); close(done) }()
+
+	select {
+	case <-entered:
+	case <-time.After(3 * time.Second):
+		t.Fatal("慢工具未被调用")
+	}
+
+	// 工具执行中注入 L4 中断。
+	intrEvt, _ := textEvent("cli", "紧急打断")
+	intrEvt.Payload["interrupt"] = true
+	if !a.sched.requestKernelPreempt(intrEvt) {
+		t.Fatal("L4 应 arm 让位信号")
+	}
+	// 关键断言：信号已 arm，但任务仍在工具里 —— 绝不能挂起。
+	if !a.sched.preemptGrantedFor() {
+		t.Fatal("让位信号应已 arm")
+	}
+	if a.DumpScheduler().Running == nil {
+		t.Fatal("工具执行中不得挂起（StepToolExec 是临界区）")
+	}
+	if len(a.DumpScheduler().SuspendStack) != 0 {
+		t.Fatal("工具执行中 suspendStack 应为空")
+	}
+
+	// 放行工具 → 工具返回后的安全点才挂起。
+	close(release)
+	select {
+	case <-done:
+	case <-time.After(3 * time.Second):
+		t.Fatal("工具返回后未挂起")
+	}
+
+	snap := a.DumpScheduler()
+	if len(snap.SuspendStack) != 1 {
+		t.Fatalf("工具返回后 suspendStack=%d，期望 1", len(snap.SuspendStack))
+	}
+	if snap.SuspendStack[0].Frame.Step != StepToolAfter {
+		t.Fatalf("应在工具执行后的安全点挂起（StepToolAfter），实际 %v", snap.SuspendStack[0].Frame.Step)
+	}
+	if len(snap.PendingInterrupts) != 1 {
+		t.Fatalf("中断请求不得丢失，pendingInterrupts=%d", len(snap.PendingInterrupts))
+	}
+}
+
+// _consolidation_ 整任务视为不可抢占（它直接改图库）。
+func TestCriticalSection_ConsolidationMarked(t *testing.T) {
+	a := newPreemptAgent(t, newPreemptProvider())
+
+	// 判定：只有记忆整理通道是整任务临界区。
+	if isCriticalChannel("cli") {
+		t.Fatal("普通通道不应被判为临界区")
+	}
+	if !isCriticalChannel(channelConsolidation) {
+		t.Fatal("记忆整理必须是不可抢占临界区")
+	}
+
+	// 集成：标志的推导链「输入事件 → 通道 → isCriticalChannel → scheduler.critical」
+	// 必须成立（N0 之后通道只从事件推导，不再有内核可变字段）。
+	for _, c := range []struct {
+		channel string
+		want    bool
+	}{
+		{"cli", false},
+		{channelConsolidation, true},
+	} {
+		evt, _ := textEvent("tc", "x")
+		evt.OutputChannel = c.channel
+		a.sched.setCritical(isCriticalChannel(outputChannelOf(evt)))
+		if got := a.sched.inCritical(); got != c.want {
+			t.Fatalf("通道 %q → critical=%v，期望 %v", c.channel, got, c.want)
+		}
+	}
+}
+
+// 新语义：没有抢占时，同批的多个工具必须全部执行——不再有「中断放弃剩余批」。
+func TestBatch_NotAbandonedWithoutPreemption(t *testing.T) {
+	sh := NewStageHost()
+	var mu sync.Mutex
+	var ran []string
+	reg := func(name string) {
+		sh.RegisterTool(name, sdk.ToolDef{Name: name, Plugin: "t"}, func(args map[string]interface{}) (interface{}, error) {
+			mu.Lock()
+			ran = append(ran, name)
+			mu.Unlock()
+			return name + "-out", nil
+		})
+	}
+	reg("t_a")
+	reg("t_b")
+
+	sp := &scriptProvider{script: []*agentAPI.CompletionResponse{
+		{Content: "", ToolCalls: []agentAPI.ToolCall{tc("c1", "t_a"), tc("c2", "t_b")}},
+		{Content: "全部完成"},
+	}}
+	a := New(AgentConfig{
+		ID:              "batch",
+		Provider:        sp,
+		ProviderManager: agentAPI.NewProviderManager(),
+		IO:              agentIO.NewIOManager(),
+		StageHost:       sh,
+	})
+
+	if _, _ = enqueueQueued(t, a, "cli", "跑两个工具"); true {
+	}
+	tt, _, _ := a.sched.nextRef()
+	a.executeNewTask(tt)
+
+	if len(ran) != 2 || ran[0] != "t_a" || ran[1] != "t_b" {
+		t.Fatalf("同批工具应全部按序执行，实际 %v", ran)
+	}
+	snap := a.DumpScheduler()
+	if len(snap.SuspendStack) != 0 || len(snap.PendingInterrupts) != 0 {
+		t.Fatalf("无抢占时不应有挂起或待处理中断：%+v", snap)
+	}
+	if snap.Stats.Executed != 1 {
+		t.Fatalf("Executed=%d，期望 1", snap.Stats.Executed)
+	}
+}
+
+// TestSchedulerStatusExposesLevelsAndStack 钉住调度器状态面**按级别可读**：
+// 四级队列深度、各级累计计数、立即抢占项、中断栈帧。
+//
+// 起因：此前 SchedulerStatus 只给 total（pending_interrupts / suspend_stack），
+// 看不出"堵在 L1 还是 L4"、"栈里压的是谁"。WebUI 想画运行态就无数据可用。
+//
+// 这个用例直接摆好调度器内部状态、只验**映射**（同包白盒）：调度行为本身
+// 由 scheduler_e2e_test / scheduler_critical_test 覆盖，这里不该重复它们的时序。
+func TestSchedulerStatusExposesLevelsAndStack(t *testing.T) {
+	a := New(AgentConfig{ID: "rt", ProviderManager: agentAPI.NewProviderManager(), IO: agentIO.NewIOManager()})
+	if a.sched == nil {
+		t.Fatal("agent 应带调度器")
+	}
+	a.sched.mu.Lock()
+	a.sched.queue = append(a.sched.queue, &Task{ID: 1, Class: TaskQueued, Kind: TaskKindInput})
+	a.sched.interruptQueues[LevelCritical] = append(a.sched.interruptQueues[LevelCritical],
+		&Task{ID: 2, Class: TaskInterrupt, Level: LevelCritical, Kind: TaskKindInput},
+		&Task{ID: 3, Class: TaskInterrupt, Level: LevelCritical, Kind: TaskKindInput})
+	a.sched.interruptQueues[LevelBackground] = append(a.sched.interruptQueues[LevelBackground],
+		&Task{ID: 4, Class: TaskInterrupt, Level: LevelBackground, Kind: TaskKindSelf})
+	a.sched.immediate = &Task{ID: 5, Class: TaskInterrupt, Level: LevelCritical, Kind: TaskKindInput}
+	a.sched.suspendStack = append(a.sched.suspendStack, &suspendedTask{
+		Task:  &Task{ID: 6, Class: TaskInterrupt, Level: LevelInteractive, Kind: TaskKindInput},
+		Frame: &TaskFrame{},
+	})
+	a.sched.stats.InterruptsByLevel[LevelCritical] = 7
+	a.sched.stats.PreemptsByLevel[LevelCritical] = 3
+	a.sched.mu.Unlock()
+
+	got := a.schedulerStatus()
+	if got.ReadyQueueDepth != 1 {
+		t.Fatalf("ready_queue_depth 应为 1，实际 %d", got.ReadyQueueDepth)
+	}
+	// 按级别的队列深度：下标即级别，下标 0 恒为 0
+	if got.InterruptQueues[LevelCritical] != 2 || got.InterruptQueues[LevelBackground] != 1 {
+		t.Fatalf("按级别队列深度不对：%v", got.InterruptQueues)
+	}
+	if got.InterruptQueues[0] != 0 {
+		t.Fatalf("下标 0（无级别）必须恒为 0，实际 %v", got.InterruptQueues)
+	}
+	// pending = 两条队列 + immediate
+	if got.PendingInterrupts != 4 {
+		t.Fatalf("pending_interrupts 应为 4，实际 %d", got.PendingInterrupts)
+	}
+	// 立即抢占项要能单独看到
+	if got.Immediate == nil || got.Immediate.ID != 5 || got.Immediate.Level != int(LevelCritical) {
+		t.Fatalf("immediate 未正确映射：%+v", got.Immediate)
+	}
+	// 中断栈帧（栈底→栈顶）要带任务标识
+	if len(got.SuspendFrames) != 1 || got.SuspendFrames[0].Task.ID != 6 ||
+		got.SuspendFrames[0].Task.Level != int(LevelInteractive) {
+		t.Fatalf("中断栈帧未正确映射：%+v", got.SuspendFrames)
+	}
+	// 累计计数按级别透传
+	if got.InterruptsByLevel[LevelCritical] != 7 || got.PreemptsByLevel[LevelCritical] != 3 {
+		t.Fatalf("各级计数未透传：interrupts=%v preempts=%v", got.InterruptsByLevel, got.PreemptsByLevel)
+	}
+	// 未使用的级别必须是 0（不能把别的级别串进来）
+	if got.InterruptQueues[LevelMessage] != 0 || got.InterruptQueues[LevelInteractive] != 0 {
+		t.Fatalf("未使用的级别应为 0：%v", got.InterruptQueues)
+	}
+}
+
+// TestChannelInfoCarriesTopology 钉住通道状态面不再丢信息：
+// 方向、描述、工具名、输出能力都要能被前端画出来。
+func TestChannelInfoCarriesTopology(t *testing.T) {
+	ch := channelInfoFromIO(agentIO.ChannelInfo{
+		Name:        "webui",
+		Type:        agentIO.DeviceOutput,
+		Description: "Web 控制台",
+		Tools:       []agentIO.ToolDef{{Name: "output_send"}},
+		OutputCaps:  agentIO.CapText | agentIO.CapImage,
+	})
+	if ch.Direction != "out" {
+		t.Fatalf("方向应为 out，实际 %q", ch.Direction)
+	}
+	if ch.Description != "Web 控制台" {
+		t.Fatalf("描述丢失：%q", ch.Description)
+	}
+	if len(ch.Tools) != 1 || ch.Tools[0] != "output_send" {
+		t.Fatalf("工具名丢失：%v", ch.Tools)
+	}
+	if ch.OutputCaps != int(agentIO.CapText|agentIO.CapImage) || ch.CapsText == "" {
+		t.Fatalf("输出能力丢失：caps=%d text=%q", ch.OutputCaps, ch.CapsText)
+	}
+	if d := channelInfoFromIO(agentIO.ChannelInfo{Name: "mic", Type: agentIO.DeviceInput}).Direction; d != "in" {
+		t.Fatalf("输入通道方向应为 in，实际 %q", d)
+	}
+	if d := channelInfoFromIO(agentIO.ChannelInfo{Name: "both", Type: agentIO.DeviceIO}).Direction; d != "io" {
+		t.Fatalf("双向通道方向应为 io，实际 %q", d)
+	}
+}

internal/agent/core/scheduler_e2e_test.go

@@ -0,0 +1,222 @@
+package core
+
+// M7 验收测试：可观测性 + 压力 + 端到端。
+//
+// 设计依据 docs/zh/input-scheduler-design.md §11.5（O1/O2）、§11.6（E1/E2）。
+//
+// 这一组与前几组的区别：前几组直接驱动调度器（确定性、可断言内部状态），
+// 这一组**完整启动** schedulerLoop + interceptLoop，经真实 channel 投递，
+// 验证组装后的行为与不变量。
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/events"
+)
+
+// countingProvider 只统计调用次数，永远成功。
+type countingProvider struct{ n atomic.Int64 }
+
+func (p *countingProvider) Name() string { return "counting" }
+func (p *countingProvider) Chat(ctx context.Context, req *agentAPI.CompletionRequest) (*agentAPI.CompletionResponse, error) {
+	p.n.Add(1)
+	return &agentAPI.CompletionResponse{Content: "ok"}, nil
+}
+func (p *countingProvider) ChatStream(ctx context.Context, req *agentAPI.CompletionRequest) (<-chan agentAPI.StreamChunk, error) {
+	return nil, errors.New("counting provider: no stream")
+}
+func (p *countingProvider) MaxContextTokens() int { return 8192 }
+
+func waitQuiescent(t *testing.T, a *Agent, wantExecuted uint64, timeout time.Duration) SchedulerSnapshot {
+	t.Helper()
+	deadline := time.Now().Add(timeout)
+	for {
+		snap := a.DumpScheduler()
+		if snap.Running == nil && len(snap.Queue) == 0 &&
+			len(snap.PendingInterrupts) == 0 && len(snap.SuspendStack) == 0 &&
+			snap.Stats.Executed >= wantExecuted {
+			return snap
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("未在 %v 内排空：running=%v queue=%d pending=%d suspend=%d executed=%d",
+				timeout, snap.Running != nil, len(snap.Queue), len(snap.PendingInterrupts),
+				len(snap.SuspendStack), snap.Stats.Executed)
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+}
+
+// 压力：N 个排队输入 + M 个中断，全部经真实 loop 执行，结束时三集合必须排空。
+func TestScheduler_StressMixedLoad(t *testing.T) {
+	sp := &countingProvider{}
+	a := New(AgentConfig{
+		ID:              "stress",
+		Provider:        sp,
+		ProviderManager: agentAPI.NewProviderManager(),
+		IO:              agentIO.NewIOManager(),
+		StageHost:       NewStageHost(),
+	})
+	a.Start()
+	defer a.Stop()
+
+	const nInputs = 200
+	const nInterrupts = 50
+
+	for i := 0; i < nInputs; i++ {
+		a.io.InjectInput("cli", "text", map[string]interface{}{"content": fmt.Sprintf("msg-%d", i)})
+	}
+	// 中断按 L1/L2/L3 轮转：把“四条中断队列按级别高→低扫描”真正压上，
+	// 而不只是排空一条队列。
+	levels := []string{"L1", "L2", "L3"}
+	for i := 0; i < nInterrupts; i++ {
+		a.io.InjectInterruptTextOpts("qq", "cli", fmt.Sprintf("intr-%d", i),
+			agentIO.InjectOptions{Priority: levels[i%len(levels)]})
+	}
+
+	snap := waitQuiescent(t, a, nInputs+nInterrupts, 30*time.Second)
+
+	if got := sp.n.Load(); got != int64(nInputs+nInterrupts) {
+		t.Fatalf("LLM 调用=%d，期望 %d（每条输入/中断恰好一次）", got, nInputs+nInterrupts)
+	}
+	if snap.Stats.Rejected != 0 {
+		t.Fatalf("容量充足却出现 Rejected=%d，说明背压/深度判定有误", snap.Stats.Rejected)
+	}
+	// 上次快照的计数在排空后应当稳定（不丢不重）：等于入队后的执行数。
+	if snap.Stats.Executed != uint64(nInputs+nInterrupts) {
+		t.Fatalf("Executed=%d，期望 %d", snap.Stats.Executed, nInputs+nInterrupts)
+	}
+}
+
+// O2：每次挂起/恢复都产生一条 scheduler 事件。
+func TestObservability_SchedulerEventsAndStatus(t *testing.T) {
+	bus := events.NewBus()
+	var mu sync.Mutex
+	var actions []string
+	bus.Subscribe(events.EventScheduler, func(e *events.Event) {
+		mu.Lock()
+		actions = append(actions, fmt.Sprint(e.Payload["action"]))
+		mu.Unlock()
+	})
+
+	sp := newPreemptProvider("intr-done", "low-done")
+	a := New(AgentConfig{
+		ID:              "obs",
+		Provider:        sp,
+		ProviderManager: agentAPI.NewProviderManager(),
+		IO:              agentIO.NewIOManager(),
+		StageHost:       NewStageHost(),
+		EventBus:        bus,
+	})
+
+	// 直接驱动一次抢占-挂起-恢复（与 M3b 相同的手法）。
+	lowEvt, _ := textEvent("qq", "低优先级")
+	lowTask := &Task{Kind: TaskKindInput, Level: LevelBackground, Event: lowEvt, EnqueuedAt: time.Now()}
+	a.sched.enqueue(lowTask)
+	lt, _, _ := a.sched.nextRef()
+
+	done := make(chan struct{})
+	go func() { a.executeNewTask(lt); close(done) }()
+	select {
+	case <-sp.entered:
+	case <-time.After(3 * time.Second):
+		t.Fatal("provider 未进入")
+	}
+
+	intrEvt, _ := textEvent("cli", "紧急")
+	intrEvt.Payload["interrupt"] = true
+	a.sched.requestKernelPreempt(intrEvt)
+	a.cancelCurrentLLM()
+	<-done
+
+	it, _, _ := a.sched.nextRef()
+	a.executeNewTask(it)
+	rt, rf, _ := a.sched.nextRef()
+	a.resumeTask(rt, rf)
+
+	mu.Lock()
+	got := strings.Join(actions, ",")
+	mu.Unlock()
+	if !strings.Contains(got, "suspend") || !strings.Contains(got, "resume") {
+		t.Fatalf("调度事件缺失：%q", got)
+	}
+
+	// 状态快照（供状态页/诊断）：计数一致、三集合为空。
+	st := a.GetKernelStatus().Scheduler
+	if st.SuspendStack != 0 || st.PendingInterrupts != 0 || st.ReadyQueueDepth != 0 {
+		t.Fatalf("排空后状态非空：%+v", st)
+	}
+	if st.Suspended == 0 || st.Resumed == 0 {
+		t.Fatalf("挂起/恢复计数缺失：%+v", st)
+	}
+	if st.Executed < 2 {
+		t.Fatalf("Executed=%d，期望 >=2", st.Executed)
+	}
+	if st.MaxSuspendDepth != 4 {
+		t.Fatalf("MaxSuspendDepth=%d，期望 4", st.MaxSuspendDepth)
+	}
+}
+
+// E1/E2：完整启动 loop，经真实 channel 投递 L1 任务与 L4 中断，
+// 断言「LLM 流式中断 → 挂起 → 中断先完成 → 原任务恢复」的整条链路。
+func TestE2E_RealLoopPreemption(t *testing.T) {
+	bus := events.NewBus()
+	var mu sync.Mutex
+	var actions []string
+	bus.Subscribe(events.EventScheduler, func(e *events.Event) {
+		mu.Lock()
+		actions = append(actions, fmt.Sprint(e.Payload["action"]))
+		mu.Unlock()
+	})
+
+	sp := newPreemptProvider("intr-done", "low-done")
+	a := New(AgentConfig{
+		ID:              "e2e",
+		Provider:        sp,
+		ProviderManager: agentAPI.NewProviderManager(),
+		IO:              agentIO.NewIOManager(),
+		StageHost:       NewStageHost(),
+		EventBus:        bus,
+	})
+	a.Start()
+	defer a.Stop()
+
+	// 排队输入：qq 入站消息 → 阻塞在第一次 LLM 调用（排队任务无级别）
+	a.io.InjectInput("qq", "text", map[string]interface{}{"content": "长任务"})
+	select {
+	case <-sp.entered:
+	case <-time.After(5 * time.Second):
+		t.Fatal("低优先级任务未进入 LLM")
+	}
+
+	// 插件声明的 L3 中断：interceptLoop 应取消 LLM 并登记抢占。
+	// 注意它能打断**排队任务**不是因为级别高，而是因为排队任务无级别——
+	// 任何中断都大于它。
+	a.io.InjectInterruptTextOpts("cli", "cli", "紧急打断", agentIO.InjectOptions{Priority: "L3"})
+	a.io.InjectInput("cli", "text", map[string]interface{}{"content": "后续常规输入"})
+
+	// 排空：中断任务 + 被恢复的原任务 + 后续常规输入
+	snap := waitQuiescent(t, a, 3, 15*time.Second)
+
+	mu.Lock()
+	got := strings.Join(actions, ",")
+	mu.Unlock()
+	if !strings.Contains(got, "suspend") || !strings.Contains(got, "resume") {
+		t.Fatalf("E2E 未发生抢占-挂起-恢复：%q", got)
+	}
+	if snap.Stats.Executed < 3 {
+		t.Fatalf("Executed=%d，期望 >=3", snap.Stats.Executed)
+	}
+	// 第一次 LLM 调用被丢弃 + 中断 1 + 恢复 1 + 常规输入 1 = 4
+	if sp.callCount() != 4 {
+		t.Fatalf("LLM 调用=%d，期望 4（丢弃 1 + 中断 1 + 恢复 1 + 常规 1）", sp.callCount())
+	}
+}

internal/agent/core/scheduler_kernel_test.go

@@ -0,0 +1,294 @@
+package core
+
+// L4 的内核独占性 + 两类别抢占规则。
+//
+// 模型（用户明确）：
+//   - 类别由**用哪个注入 API** 决定，与通道名无关；
+//   - L1..L3 由插件在 InjectOptions.Priority 声明；
+//   - L4 只有内核持有（panic / 内核事件 selfip）；
+//   - 排队输入无级别，可被**任何**中断打断。
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/plugin"
+	sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk"
+)
+
+// 非内核级来源声明 L4 必须被夹到 L3；内核级来源（内置插件）可用到 L4。
+func TestKernel_L4RequiresKernelLevelSource(t *testing.T) {
+	if got := clampPluginLevel(LevelCritical); got != LevelInteractive {
+		t.Fatalf("非特权声明 L4 应被夹到 L3，实际 %v", got)
+	}
+	cases := []struct {
+		declared string
+		want     Level
+	}{
+		{"L1", LevelBackground},
+		{"L2", LevelMessage},
+		{"L3", LevelInteractive},
+		{"l2", LevelMessage},
+		{"L4", LevelInteractive}, // 非特权 → 夹到 L3
+		{"L7", DefaultLevel},     // 未知 → 默认级
+		{"", DefaultLevel},       // 未声明 → 默认级
+		{"紧急", DefaultLevel},     // 拼写错误 → 默认级（不得被静默当成别的级别）
+	}
+	for _, c := range cases {
+		evt := &agentIO.InputEvent{Payload: map[string]interface{}{}}
+		if c.declared != "" {
+			evt.Payload["priority"] = c.declared
+		}
+		if got := interruptLevel(evt, false); got != c.want {
+			t.Fatalf("非特权声明 %q → 级别 %v，期望 %v", c.declared, got, c.want)
+		}
+	}
+	if got := interruptLevel(nil, false); got != DefaultLevel {
+		t.Fatalf("无事件应为默认级，实际 %v", got)
+	}
+
+	// 特权（内核级插件）：L4 被承认，其余待遇不变。
+	for _, c := range []struct {
+		declared string
+		want     Level
+	}{
+		{"L4", LevelCritical},
+		{"L3", LevelInteractive},
+		{"L1", LevelBackground},
+		{"", DefaultLevel},
+		{"L9", DefaultLevel},
+	} {
+		evt := &agentIO.InputEvent{Payload: map[string]interface{}{}}
+		if c.declared != "" {
+			evt.Payload["priority"] = c.declared
+		}
+		if got := interruptLevel(evt, true); got != c.want {
+			t.Fatalf("特权声明 %q → 级别 %v，期望 %v", c.declared, got, c.want)
+		}
+	}
+}
+
+// 内核级 = 插件注册表里的**内置工厂**（编译期自注册），与插件自报名无关；
+// source 约定 `插件名` 或 `插件名/实例`（如 webui/<deviceID>）。
+func TestKernel_KernelLevelSource(t *testing.T) {
+	plugin.RegisterFactory("core_test_builtin", func(string, map[string]interface{}) (sdk.Plugin, error) {
+		return nil, nil
+	})
+	a := &Agent{pluginReg: plugin.NewRegistry()}
+
+	cases := []struct {
+		source string
+		want   bool
+	}{
+		{"core_test_builtin", true},
+		{"core_test_builtin/dev-1", true}, // 插件名/实例
+		{"core_test_external", false},
+		{"webui", false}, // 本测试注册表里没有 webui 工厂
+		{"", false},
+		{"core_test_builtinX", false}, // 不做前缀匹配
+	}
+	for _, c := range cases {
+		if got := a.isKernelLevelSource(c.source); got != c.want {
+			t.Fatalf("source=%q → %v，期望 %v", c.source, got, c.want)
+		}
+	}
+	if (&Agent{}).isKernelLevelSource("core_test_builtin") {
+		t.Fatal("没有插件注册表时不得授予内核级")
+	}
+}
+
+// 排队任务可被**任何**中断打断——包括最低的 L1。
+func TestKernel_QueuedTaskIsPreemptedByAnyInterrupt(t *testing.T) {
+	s := newScheduler(8)
+	q := newInputTask(&agentIO.InputEvent{Source: "plugin", OutputChannel: "plugin"})
+	s.enqueue(q)
+	if task, _, kind := s.nextRef(); task != q || kind != nextReady {
+		t.Fatalf("应取到排队任务，kind=%v", kind)
+	}
+
+	evt, _ := textEvent("qq", "最低级中断")
+	if !s.registerInterrupt(newInterruptTask(evt, LevelBackground)) {
+		t.Fatal("L1 中断也必须能打断排队任务（排队任务无级别）")
+	}
+	if s.immediate == nil || s.immediate.Level != LevelBackground {
+		t.Fatalf("抢占者应进 immediate 槽，实际 %+v", s.immediate)
+	}
+}
+
+// 排队输入从不抢占——它没有级别，也就没有“比谁高”。
+func TestKernel_QueuedInputNeverPreempts(t *testing.T) {
+	s := newScheduler(8)
+	if !s.enqueue(newInputTask(&agentIO.InputEvent{Source: "a", OutputChannel: "a"})) {
+		t.Fatal("入队失败")
+	}
+	s.nextRef() // running = 第一个排队任务
+	if s.registerInterrupt(newInputTask(&agentIO.InputEvent{Source: "b", OutputChannel: "b"})) {
+		t.Fatal("排队输入不得抢占任何任务")
+	}
+}
+
+// 内核 L4 入口不受夹取影响，且能抢占中断（L3）。
+func TestKernel_RequestKernelPreemptUsesL4(t *testing.T) {
+	s := newScheduler(8)
+	evt, _ := textEvent("cli", "L3 运行中")
+	s.registerInterrupt(newInterruptTask(evt, LevelInteractive))
+	s.nextRef() // running = L3 中断
+
+	kevt, _ := textEvent("kernel", "panic 中断")
+	if !s.requestKernelPreempt(kevt) {
+		t.Fatal("内核 L4 应能抢占 L3 中断")
+	}
+	if s.immediate == nil || s.immediate.Level != LevelCritical {
+		t.Fatalf("内核中断必须是 L4，实际 %+v", s.immediate)
+	}
+}
+
+// 任务 panic → 内核 L4 中断（panic 是 L4 的来源之一）。
+func TestKernel_PanicRaisesL4Interrupt(t *testing.T) {
+	sp := &scriptProvider{script: []*agentAPI.CompletionResponse{{Content: "已收到内核事件"}}}
+	a := newPreemptAgent(t, sp)
+
+	// Event 为 nil：handleInput 解引用即 panic。
+	bad := newInputTask(nil)
+	if !a.sched.enqueue(bad) {
+		t.Fatal("入队失败")
+	}
+	task, _, _ := a.sched.nextRef()
+	a.executeTask(task) // panic 被隔离
+
+	snap := a.DumpScheduler()
+	if snap.Immediate == nil {
+		t.Fatal("panic 必须产生一条内核 L4 中断")
+	}
+	if snap.Immediate.Level != LevelCritical {
+		t.Fatalf("panic 中断级别=%v，期望 L4", snap.Immediate.Level)
+	}
+	text, _ := snap.Immediate.Event.Payload["content"].(string)
+	if !strings.Contains(text, "panic") {
+		t.Fatalf("panic 中断应说明发生了什么，实际 %q", text)
+	}
+	if snap.Immediate.Event.Payload["kernel"] != true {
+		t.Fatal("内核中断必须带 kernel 标记，便于与插件中断区分")
+	}
+}
+
+// 递归保护是结构性的：L4 内核中断自己 panic 时，不再产生新的 L4。
+func TestKernel_PanicInsideL4DoesNotRecurse(t *testing.T) {
+	sp := &scriptProvider{}
+	a := newPreemptAgent(t, sp)
+
+	evt, _ := textEvent("kernel", "内核事件")
+	l4 := newKernelInterruptTask(evt)
+	a.sched.immediate = l4
+	task, _, _ := a.sched.nextRef()
+	if task != l4 {
+		t.Fatal("应取到 L4 内核中断")
+	}
+	a.executeTask(&Task{ID: task.ID, Class: TaskInterrupt, Level: LevelCritical, Kind: TaskKindInput, Event: nil})
+
+	snap := a.DumpScheduler()
+	if snap.Immediate != nil || len(snap.PendingInterrupts) != 0 {
+		t.Fatalf("L4 自身 panic 不得再产生中断（否则自我放大），实际 immediate=%+v pending=%d",
+			snap.Immediate, len(snap.PendingInterrupts))
+	}
+}
+
+// 中断栈的 4 帧上界是**结构推论**：排队(L0) ← I(L1) ← I(L2) ← I(L3) ← I(L4 运行中)。
+func TestKernel_StackBoundIsFullChain(t *testing.T) {
+	s := newScheduler(16)
+	frame := func() *TaskFrame { return &TaskFrame{} }
+	chain := []struct {
+		class TaskClass
+		lv    Level
+	}{
+		{TaskQueued, 0},
+		{TaskInterrupt, LevelBackground},
+		{TaskInterrupt, LevelMessage},
+		{TaskInterrupt, LevelInteractive},
+	}
+	for i := 0; i < len(chain)-1; i++ {
+		s.suspend(&Task{ID: uint64(i + 1), Class: chain[i].class, Level: chain[i].lv}, frame())
+	}
+	if !s.canSuspend() {
+		t.Fatal("3 帧挂起时仍应容得下 L3（第 4 级）继续下潜")
+	}
+	s.suspend(&Task{ID: 4, Class: TaskInterrupt, Level: LevelInteractive}, frame())
+	if s.canSuspend() {
+		t.Fatal("4 帧挂起 = 全链挂起（L4 运行中），不应再有下潜余量")
+	}
+}
+
+// 端到端：插件声明 Priority → io.applyInjectOpts → payload → interruptLevel → 任务级别。
+// 这条链路断在任何一环，插件声明的级别都会静默失效（降级到 L1）。
+func TestKernel_PriorityFlowsThroughIOLayer(t *testing.T) {
+	ioM := agentIO.NewIOManager()
+	ioM.InjectInterruptTextOpts("qq", "cli", "通知", agentIO.InjectOptions{Priority: "L3"})
+
+	select {
+	case evt := <-ioM.InputInterruptChan():
+		if got := interruptLevel(evt, false); got != LevelInteractive {
+			t.Fatalf("经 io 层后的级别=%v，期望 L3（payload=%v）", got, evt.Payload)
+		}
+		task := newInterruptTask(evt, interruptLevel(evt, false))
+		if task.Class != TaskInterrupt || task.Level != LevelInteractive {
+			t.Fatalf("中断任务类别/级别=%v/%v，期望 interrupt/L3", task.Class, task.Level)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("中断未到达 interruptCh")
+	}
+
+	// 排队路径带 priority 也必须无效：排队输入没有级别。
+	ioM.InjectTextOpts("qq", "cli", "普通输入", agentIO.InjectOptions{Priority: "L3"})
+	select {
+	case evt := <-ioM.InputChan():
+		task := newInputTask(evt)
+		if task.Class != TaskQueued || task.Level != 0 {
+			t.Fatalf("排队任务类别/级别=%v/%v，期望 queued/无级别", task.Class, task.Level)
+		}
+		if effectiveLevel(task) != 0 {
+			t.Fatalf("排队任务有效级=%v，期望 0", effectiveLevel(task))
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("排队输入未到达 inputCh")
+	}
+}
+
+// 内核级插件声明的 L4 必须一路到达调度器（“立即打断”能力，如 WebUI 终止按钮）。
+func TestKernel_KernelLevelPluginCanRaiseL4(t *testing.T) {
+	plugin.RegisterFactory("core_test_l4", func(string, map[string]interface{}) (sdk.Plugin, error) {
+		return nil, nil
+	})
+	a := newPreemptAgent(t, &scriptProvider{})
+	a.pluginReg = plugin.NewRegistry()
+
+	// 先让一个排队任务跑起来（无级别），才能看到“抢占”。
+	evt, _ := textEvent("qq", "长任务")
+	if !a.sched.enqueue(newInputTask(evt)) {
+		t.Fatal("入队失败")
+	}
+	a.sched.nextRef()
+
+	// 内核级插件（内置）声明 L4 的终止通知。
+	kevt, _ := textEvent("core_test_l4", "用户按了终止按钮")
+	kevt.Payload["priority"] = "L4"
+	level := interruptLevel(kevt, a.isKernelLevelSource(kevt.Source))
+	if level != LevelCritical {
+		t.Fatalf("内核级插件声明 L4 应得 L4，实际 %v", level)
+	}
+	if !a.sched.requestPreempt(kevt, level) {
+		t.Fatal("L4 应能打断排队任务")
+	}
+	if a.sched.immediate == nil || a.sched.immediate.Level != LevelCritical {
+		t.Fatalf("应有一条 L4 中断在 immediate，实际 %+v", a.sched.immediate)
+	}
+
+	// 反例：同样的声明来自外部插件 → 夹到 L3。
+	eevt, _ := textEvent("core_test_external", "外部插件也想立即打断")
+	eevt.Payload["priority"] = "L4"
+	if got := interruptLevel(eevt, a.isKernelLevelSource(eevt.Source)); got != LevelInteractive {
+		t.Fatalf("外部插件声明 L4 应被夹到 L3，实际 %v", got)
+	}
+}