refactor(terminal): 内核开终端/命令历史权威视图，WebUI 与 CLI 都改接内核

按「内核开，两个插件接」重构终端与命令历史的数据归属。

背景：此前 WebUI 与 CLI 各订 EventToolCall/EventTerminalOutput 攅一份状态，
同一件事两份推导，还各自踩过同一个坑——工具 result 是 Go 的 map 文本
（map[cols:80 ... id:term_2 ...]），断言成 map[string]interface{} 永远失败，
terminal_create 的 id 回填不生效，/terminals 因此恒空（WebUI 也一样）。
实测确认：WebUI 自己的 /api/v1/terminals 与 /api/v1/cmd/history 同样是空的。

内核开（权威唯一真相）：
- internal/agent/core/terminal_registry.go：TerminalRegistry 归并两类事件——
  EventToolCall（terminal_create/close、cmd_run，id/command 从 args 或 Go map
  文本回填）与 EventTerminalOutput（agentcli 生命周期 + 输出，含 64KB 缓冲上限、
  100 条命令历史、50 个终端上限）。
- internal/sdk/terminal.go：新增 TerminalAPI（ListTerminals/CmdHistory）与
  TerminalStatus/CmdExecStatus DTO。**不塞进 KernelStatus**：那是全量快照，
  前端每 3 秒轮询 /kernel，背上每终端最多 64KB 输出会让轮询成本爆炸；
  终端输出是按需拉取的明细，另开接口。
- Agent 订阅自己的事件总线（subscribeTerminalRegistry），且**只根 agent 建**
  （驻留子共用同一总线，每个子都建会 N+1 份重复记账）。
- SDKConfig/Registry/bootstrap 接线：pluginReg.SetTerminalAPI(agent)。

生产者补全（agentcli）：终端无输出时 ticker 不发事件，内核就无从知道终端
存在。新增 emitTermState，在 handleCreate/handleClose/readLoop 退出（超时/
进程结束/读取错误/stopCh）显式上报 running 状态，并给输出事件补 command 字段。
handleClose 改为接收 *sdk.PluginSDK 以便上报。

两个插件接（消费方）：
- WebUI：删掉本地 termStates/cmdHistory/subscribeTerminalStream/handleToolEvent
  及不再使用的 getStr；/terminals 与 /cmd/history 直接读 s.Terminal()。
- CLI：删掉上一轮刚加的 subscribeToolEvents 与 cliTermState/cliCmdExec；
  /terminals 与 /cmd/history 直接读 s.Terminal()。两条路（local/remote）都通。

测试：新增 terminal_registry_test.go，锁死 Go map 文本解析（旧缺陷根因）、
生命周期、CLI 直调路径（无 EventToolCall 仅凭 output 事件建条目）、历史与
终端数量上限。全量 go test ./internal/... ./cmd/... 通过。

internal/plugins/webui/handler.go

@@ -96,6 +96,7 @@ type Handler struct {
 	settings   sdk.SettingsAPI
 	pluginMgr  sdk.PluginManager
 	status     sdk.StatusAPI
+	term       sdk.TerminalAPI
 	llm        sdk.LLMAPI
 
 	sessionMu sync.Mutex
@@ -125,26 +126,23 @@ type Handler struct {
 	chatMsgMu    sync.Mutex
 	chatMsgCache map[string]*chatMsgEntry // client_msg_id -> 首次处理结果
 	chatMsgOrder []string                 // FIFO 淘汰序
-	cmdMu        sync.Mutex
-	cmdHistory   []CmdExec
-	termMu       sync.Mutex
-	termStates   map[string]*termState
 }
 
 func NewHandler(s *sdk.PluginSDK) *Handler {
 	var (
-		sup sdk.SupervisorAPI
-		mem sdk.MemoryAPI
-		idx sdk.IndexerAPI
-		ad  sdk.AdapterAPI
-		cfg sdk.ConfigAPI
-		tm  sdk.TextMemoryAPI
-		ks  sdk.KnowledgeAPI
-		tr  sdk.TrackerAPI
-		se  sdk.SettingsAPI
-		pm  sdk.PluginManager
-		st  sdk.StatusAPI
-		llm sdk.LLMAPI
+		sup  sdk.SupervisorAPI
+		mem  sdk.MemoryAPI
+		idx  sdk.IndexerAPI
+		ad   sdk.AdapterAPI
+		cfg  sdk.ConfigAPI
+		tm   sdk.TextMemoryAPI
+		ks   sdk.KnowledgeAPI
+		tr   sdk.TrackerAPI
+		se   sdk.SettingsAPI
+		pm   sdk.PluginManager
+		st   sdk.StatusAPI
+		term sdk.TerminalAPI
+		llm  sdk.LLMAPI
 	)
 	if s != nil {
 		sup, mem, idx = s.Supervisor(), s.Memory(), s.Indexer()
@@ -152,6 +150,7 @@ func NewHandler(s *sdk.PluginSDK) *Handler {
 		tm, ks, tr = s.TextMemory(), s.Knowledge(), s.Tracker()
 		se, pm = s.Settings(), s.PluginMgr()
 		st, llm = s.Status(), s.LLM()
+		term = s.Terminal()
 	}
 	h := &Handler{
 		sdk:          s,
@@ -167,9 +166,9 @@ func NewHandler(s *sdk.PluginSDK) *Handler {
 		settings:     se,
 		pluginMgr:    pm,
 		status:       st,
+		term:         term,
 		llm:          llm,
 		sessions:     make(map[string]time.Time),
-		termStates:   make(map[string]*termState),
 		pendingIdx:   -1,
 		chatMsgCache: make(map[string]*chatMsgEntry),
 		sseEvents:    newSSEEventRing(200),
@@ -184,21 +183,11 @@ func NewHandler(s *sdk.PluginSDK) *Handler {
 	go h.chatPersistLoop()
 	h.loadChatHistory()
 	if s != nil {
-		go h.trackToolEvents()
 		h.subscribeChatEvents()
-		h.subscribeTerminalStream()
 	}
 	return h
 }
 
-func getStr(m map[string]interface{}, key string) string {
-	if m == nil {
-		return ""
-	}
-	v, _ := m[key].(string)
-	return v
-}
-
 func (h *Handler) getWebUIConfig() (apiKey, username, password string, ttl time.Duration) {
 	ttl = 24 * time.Hour
 	if h.settings == nil {

internal/plugins/webui/handler_chat.go

@@ -122,15 +122,6 @@ func (h *Handler) loadChatHistory() {
 	h.chatMu.Unlock()
 }
 
-func (h *Handler) trackToolEvents() {
-	if h.sdk == nil {
-		return
-	}
-	h.sdk.Subscribe(sdk.EventToolCall, func(ev *sdk.Event) {
-		h.handleToolEvent(ev)
-	})
-}
-
 // subscribeChatEvents 捕获所有通道（cli/qq/webui 等）的对话轮次，
 // 与 handleChat 的注入一起构成完整的全通道对话历史。
 func (h *Handler) subscribeChatEvents() {
@@ -407,80 +398,6 @@ func (h *Handler) pendingAssistantLocked() *ChatMsg {
 	return msg
 }
 
-func (h *Handler) handleToolEvent(ev *sdk.Event) {
-	payload := ev.Payload
-	tool, _ := payload["tool"].(string)
-	args, _ := payload["args"].(map[string]interface{})
-	status, _ := payload["status"].(string)
-	ts := time.Now()
-
-	switch tool {
-	case "cmd_run":
-		exec := CmdExec{
-			Command: getStr(args, "command"),
-			Status:  status,
-			Time:    ts.Format(time.RFC3339),
-		}
-		h.cmdMu.Lock()
-		h.cmdHistory = append(h.cmdHistory, exec)
-		if len(h.cmdHistory) > maxCmdHistory {
-			h.cmdHistory = h.cmdHistory[len(h.cmdHistory)-maxCmdHistory:]
-		}
-		h.cmdMu.Unlock()
-
-	case "terminal_create":
-		id := getStr(args, "id")
-		if id == "" {
-			// agent 调用时不知道生成的 id，从工具结果中回填
-			if res, ok := payload["result"].(map[string]interface{}); ok {
-				id = getStr(res, "id")
-			}
-		}
-		if id == "" {
-			break
-		}
-		cmd := getStr(args, "command")
-		if cmd == "" {
-			if res, ok := payload["result"].(map[string]interface{}); ok {
-				cmd = getStr(res, "command")
-			}
-		}
-		now := time.Now()
-		term := &termState{
-			ID:        id,
-			Command:   cmd,
-			Running:   true,
-			CreatedAt: now.Format(time.RFC3339),
-			created:   now,
-		}
-		h.termMu.Lock()
-		if old, ok := h.termStates[id]; ok {
-			old.Command = cmd
-			old.Running = true
-			old.created = now
-		} else {
-			h.termStates[id] = term
-		}
-		if len(h.termStates) > maxTerminals {
-			for k := range h.termStates {
-				delete(h.termStates, k)
-				break
-			}
-		}
-		h.termMu.Unlock()
-
-	case "terminal_close":
-		id := getStr(args, "id")
-		if id != "" {
-			h.termMu.Lock()
-			if t, ok := h.termStates[id]; ok {
-				t.Running = false
-			}
-			h.termMu.Unlock()
-		}
-	}
-}
-
 // bumpSeqLocked 分配下一个聊天序号（调用方须持 chatMu）。
 // 序号单调递增、随记录落盘，作为 /chat/history?after= 的增量游标。
 func (h *Handler) bumpSeqLocked() int64 {

internal/plugins/webui/handler_terminal.go

@@ -1,88 +1,44 @@
 package webui
 
 import (
-	"time"
+	"net/http"
 
 	sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk"
-	"net/http"
 )
 
-// 终端面：持久终端会话状态、终端接口、命令历史。
+// 终端面：终端会话列表与命令历史接口。
+//
+// 「内核开，两个插件接」后，终端会话与命令历史的权威视图在内核
+// （internal/agent/core/terminal_registry.go）：内核订阅自己的事件总线
+// 归并 EventToolCall（terminal_create/close、cmd_run）与 EventTerminalOutput
+// （agentcli 生命周期 + 输出）。WebUI 不再自己订阅事件攒一份——直接读内核
+// 开放的 TerminalAPI（s.Terminal()），与 CLI 同源同口径。
+//
+// 为什么不塞进 KernelStatus：那是全量快照，前端每 3 秒轮询 /kernel，
+// 把每终端最多 64KB 的输出缓冲背进去会让轮询成本爆炸。
 
-type CmdExec struct {
-	Command  string `json:"command"`
-	Stdout   string `json:"stdout"`
-	Stderr   string `json:"stderr"`
-	ExitCode int    `json:"exit_code"`
-	Status   string `json:"status"`
-	Time     string `json:"time"`
-}
-
-type termState struct {
-	ID        string `json:"id"`
-	Command   string `json:"command"`
-	Running   bool   `json:"running"`
-	Output    string `json:"output"`
-	CreatedAt string `json:"created_at"`
-	Uptime    string `json:"uptime"`
-	created   time.Time
-}
-
-const maxCmdHistory = 100
-
-const maxTerminals = 50
-
-// subscribeTerminalStream 常驻订阅终端实时画面推流（terminal_output 事件），
-// 维护 termStates 的 Running 状态与全量输出缓冲，供 /api/v1/terminals 与前端轮询使用。
-func (h *Handler) subscribeTerminalStream() {
-	if h.sdk == nil {
+// handleTerminals 返回内核权威的终端会话快照。
+func (h *Handler) handleTerminals(w http.ResponseWriter, r *http.Request) {
+	if h.term == nil {
+		writeJSON(w, http.StatusOK, map[string]interface{}{"terminals": []interface{}{}})
 		return
 	}
-	h.sdk.Subscribe(sdk.EventTerminalOutput, func(ev *sdk.Event) {
-		id, _ := ev.Payload["terminal_id"].(string)
-		if id == "" {
-			return
-		}
-		output, _ := ev.Payload["output"].(string)
-		running, _ := ev.Payload["running"].(bool)
-		h.termMu.Lock()
-		ts, ok := h.termStates[id]
-		if !ok {
-			ts = &termState{ID: id, created: time.Now()}
-			h.termStates[id] = ts
-		}
-		ts.Running = running
-		if output != "" {
-			const maxTermOutput = 64 * 1024
-			if len(ts.Output)+len(output) > maxTermOutput {
-				excess := len(ts.Output) + len(output) - maxTermOutput
-				if len(ts.Output) > excess {
-					ts.Output = ts.Output[excess:]
-				} else {
-					ts.Output = ""
-				}
-			}
-			ts.Output += output
-		}
-		h.termMu.Unlock()
-	})
-}
-
-func (h *Handler) handleTerminals(w http.ResponseWriter, r *http.Request) {
-	h.termMu.Lock()
-	terms := make([]*termState, 0, len(h.termStates))
-	for _, ts := range h.termStates {
-		ts.Uptime = time.Since(ts.created).Round(time.Second).String()
-		terms = append(terms, ts)
+	terms := h.term.ListTerminals()
+	if terms == nil {
+		terms = []sdk.TerminalStatus{}
 	}
-	h.termMu.Unlock()
 	writeJSON(w, http.StatusOK, map[string]interface{}{"terminals": terms})
 }
 
+// handleCmdHistory 返回内核权威的命令执行历史快照。
 func (h *Handler) handleCmdHistory(w http.ResponseWriter, r *http.Request) {
-	h.cmdMu.Lock()
-	result := make([]CmdExec, len(h.cmdHistory))
-	copy(result, h.cmdHistory)
-	h.cmdMu.Unlock()
-	writeJSON(w, http.StatusOK, map[string]interface{}{"history": result})
+	if h.term == nil {
+		writeJSON(w, http.StatusOK, map[string]interface{}{"history": []interface{}{}})
+		return
+	}
+	cmds := h.term.CmdHistory()
+	if cmds == nil {
+		cmds = []sdk.CmdExecStatus{}
+	}
+	writeJSON(w, http.StatusOK, map[string]interface{}{"history": cmds})
 }