perf(webui)+feat(config): 聊天记录写盘节流 + 配置库空闲页回收

两条都是我上一封里点出、你说继续的问题。

① 聊天记录：每条消息都整段重写 → 节流合并写
   原来 persistChatLocked 每次变更就整段重写记录文件，而一轮对话会触发多次
   （用户消息、每个工具事件、收尾消息）。200 条上限下文件可达数 MB，单轮就能
   放大出几十 MB 写。文件里还留着一个 chatSaveThrottle=3s 常量——声明了但从未
   被使用（疑似上次 revert 的遗留），等于节流从来没生效。
   现在：persistChatLocked 只置脏 + 唤醒写盘协程；chatPersistLoop 去抖
   chatSaveThrottle(3s)、并以 chatSaveMaxDelay(10s) 兜底（持续输出也不会无限拖延）；
   写盘前把快照拷出来，**不持 chatMu 做文件 IO**；写失败重新标脏下轮重试。
   插件 Stop 里调 Handler.Close()：停协程 + 强制落最后一次（幂等），否则丢最后一轮。

   实测（临时实例，连发 3 条消息）：3s 窗口内记录文件**尚未创建**（节流生效）；
   SIGTERM 后文件出现且 6 条（3 用户 + 3 助手，无 LLM key 故为错误回复）全在
   ——关停落盘没丢。

② config.db：SQLite 的 DELETE 不缩文件 → 空闲页够多时 VACUUM
   新增 ConfigRegistry.MaybeCompact(minFreeBytes, minRatio)：空闲页 >= 1MB 且
   占页数 >= 25% 才做一次 VACUUM，避免每次启动都重写整库。库里是 WAL 模式，
   VACUUM 之后必须再 wal_checkpoint(TRUNCATE)，否则主库文件看着没变小。
   调用点放在插件加载**之后**（大值的搬走/删除发生在插件 Start 里，之前调没意义）。

   实测（一个刚被搬走 5MB 聊天记录的实例）：
     freelist 1288 页 × 4096B；启动日志「配置库已压缩: 5394432 -> 118784 字节」
     config.db 5,394,432 → 118,784 字节；记录文件 5,279,491 字节完好未动。

测试：TestChatPersistenceIsThrottled（节流窗口内不写盘 + Close 必落盘 + Close 幂等）、
TestMaybeCompactReclaimsFreePages（删大值后文件确实变小 + 数据完好 + 阈值不达标时不白做功）。

internal/plugins/webui/handler.go

@@ -92,6 +92,16 @@ type Handler struct {
 	// 插件设置 history_file 可改）。
 	history *historyStore
 
+	// 聊天记录写盘节流：chatDirty 由 persistChatLocked 置位，
+	// chatPersistLoop 合并连续变更后落盘（chatSaveThrottle 去抖 +
+	// chatSaveMaxDelay 兜底），Close 前强制落最后一次。
+	chatDirty      bool
+	chatDirtySince time.Time
+	chatSaveWake   chan struct{}
+	chatStop       chan struct{}
+	chatLoopDone   chan struct{}
+	chatCloseOnce  sync.Once
+
 	chatMsgMu    sync.Mutex
 	chatMsgCache map[string]*chatMsgEntry // client_msg_id -> 首次处理结果
 	chatMsgOrder []string                 // FIFO 淘汰序
@@ -146,7 +156,12 @@ func NewHandler(s *sdk.PluginSDK) *Handler {
 		// 聊天记录独立存储：默认 <data>/webui_chat_history.json，
 		// 插件设置 history_file 可改（相对路径按 data 目录解析）。
 		history: newHistoryStore(resolveHistoryFile(settingString(se, "history_file"), webDataDir)),
+
+		chatSaveWake: make(chan struct{}, 1),
+		chatStop:     make(chan struct{}),
+		chatLoopDone: make(chan struct{}),
 	}
+	go h.chatPersistLoop()
 	h.loadChatHistory()
 	if s != nil {
 		go h.trackToolEvents()

internal/plugins/webui/handler_chat.go

@@ -276,6 +276,98 @@ func (h *Handler) subscribeChatEvents() {
 
 // pendingAssistantLocked 返回 chatHistory 中当前进行中的 assistant 消息（已持有 chatMu）。
 // 仅当最后一条是 assistant 且尚未产出最终内容时视为进行中，避免跨轮次误合并。
+// chatSaveThrottle 控制写盘频率：变更后延迟这么久落盘，合并连续更新。
+const chatSaveThrottle = 3 * time.Second
+
+// chatSaveMaxDelay 是连续写入时的强制落盘上限：聊天再密也不超过这么久。
+const chatSaveMaxDelay = 10 * time.Second
+
+// persistChatLocked 标记聊天记录待写盘（调用方已持 chatMu）。
+//
+// 真正的写盘在 chatPersistLoop 里做，并带节流：原先这里是**每条消息都整段
+// 重写一次记录文件**，而一轮对话会触发多次（用户消息、每个工具事件、收尾消息）——
+// 200 条上限下文件可达数 MB，于是单轮就放大出几十 MB 写。
+func (h *Handler) persistChatLocked() {
+	if h.history == nil {
+		return
+	}
+	if !h.chatDirty {
+		h.chatDirtySince = time.Now()
+	}
+	h.chatDirty = true
+	select {
+	case h.chatSaveWake <- struct{}{}:
+	default: // 已有待处理信号，合并即可
+	}
+}
+
+// chatPersistLoop 把聊天记录按节流节奏落盘，直到 Close。
+func (h *Handler) chatPersistLoop() {
+	defer close(h.chatLoopDone)
+	timer := time.NewTimer(chatSaveThrottle)
+	timer.Stop()
+	defer timer.Stop()
+	for {
+		select {
+		case <-h.chatStop:
+			h.flushChat() // 关停前把最后一次变更写下去
+			return
+		case <-h.chatSaveWake:
+			delay := chatSaveThrottle
+			h.chatMu.Lock()
+			if !h.chatDirtySince.IsZero() {
+				if left := chatSaveMaxDelay - time.Since(h.chatDirtySince); left < delay {
+					if left < 0 {
+						left = 0
+					}
+					delay = left
+				}
+			}
+			h.chatMu.Unlock()
+			timer.Reset(delay)
+		case <-timer.C:
+			h.flushChat()
+		}
+	}
+}
+
+// flushChat 把当前聊天记录快照写盘。文件 IO 不持 chatMu（快照拷出来再写），
+// 写失败则重新标脏，等下一轮重试。
+func (h *Handler) flushChat() {
+	if h.history == nil {
+		return
+	}
+	h.chatMu.Lock()
+	if !h.chatDirty {
+		h.chatMu.Unlock()
+		return
+	}
+	h.chatDirty = false
+	h.chatDirtySince = time.Time{}
+	msgs := make([]ChatMsg, len(h.chatHistory))
+	copy(msgs, h.chatHistory)
+	h.chatMu.Unlock()
+
+	if err := h.history.Save(msgs); err != nil {
+		log.Printf("[webui] 写聊天记录 %s 失败（稍后重试）: %v", h.history.Path(), err)
+		h.chatMu.Lock()
+		h.chatDirty = true
+		if h.chatDirtySince.IsZero() {
+			h.chatDirtySince = time.Now()
+		}
+		h.chatMu.Unlock()
+	}
+}
+
+// Close 停掉写盘协程并把最后一次变更落盘（幂等）。
+// 由插件 Stop 调用；不这样做会丢掉最后一轮对话。
+func (h *Handler) Close() {
+	h.chatCloseOnce.Do(func() {
+		close(h.chatStop)
+		<-h.chatLoopDone
+	})
+}
+
 func (h *Handler) pendingAssistantLocked() *ChatMsg {
 	if h.pendingIdx < 0 || h.pendingIdx >= len(h.chatHistory) {
 		return nil
@@ -287,16 +379,6 @@ func (h *Handler) pendingAssistantLocked() *ChatMsg {
 	return msg
 }
 
-func (h *Handler) persistChatLocked() {
-	if h.history == nil {
-		return
-	}
-	// 写独立文件（原子替换）。失败只告警：聊天记录不该影响对话主流程。
-	if err := h.history.Save(h.chatHistory); err != nil {
-		log.Printf("[webui] 写聊天记录 %s 失败: %v", h.history.Path(), err)
-	}
-}
-
 func (h *Handler) handleToolEvent(ev *sdk.Event) {
 	payload := ev.Payload
 	tool, _ := payload["tool"].(string)
@@ -371,9 +453,6 @@ func (h *Handler) handleToolEvent(ev *sdk.Event) {
 	}
 }
 
-// chatSaveThrottle 控制写盘频率：最多每 3 秒写一次
-const chatSaveThrottle = 3 * time.Second
-
 func (h *Handler) addChatMsg(msg ChatMsg) {
 	h.chatMu.Lock()
 	h.chatHistory = append(h.chatHistory, msg)

internal/plugins/webui/handler_test.go

@@ -1246,3 +1246,49 @@ func TestHistoryStoreSaveIsAtomicAndRoundTrips(t *testing.T) {
 		t.Fatalf("回读不一致：%+v", got)
 	}
 }
+
+// TestChatPersistenceIsThrottled 钉住聊天记录写盘节流：
+// 连续变更不得每条都整段重写文件，但 Close 前必须把最后一次落盘（否则丢对话）。
+func TestChatPersistenceIsThrottled(t *testing.T) {
+	dir := t.TempDir()
+	file := filepath.Join(dir, "chat.json")
+
+	cfgReg := internalConfig.NewConfigRegistry("")
+	webuiCfg := cfgReg.PluginConfig("webui")
+	webuiCfg.RegisterDef(internalConfig.ConfigDef{Key: "history_file", Default: ""})
+	webuiCfg.Set("history_file", file)
+
+	s := testSDK(sdk.SDKConfig{
+		Settings: sdk.NewSettings("webui", cfgReg),
+		Config:   sdk.NewConfig(&types.Config{}),
+		EventBus: events.NewBus(),
+	})
+	h := NewHandler(s)
+	if h.history.Path() != file {
+		t.Fatalf("history 路径应为 %s，实际 %s", file, h.history.Path())
+	}
+
+	// 模拟一轮对话里的连续变更（用户消息 + 多个工具事件 + 收尾）
+	base := time.Now()
+	for i := 0; i < 20; i++ {
+		h.chatMu.Lock()
+		h.chatHistory = append(h.chatHistory, ChatMsg{
+			Role: "assistant", Content: "消息", Time: base.Add(time.Duration(i) * time.Second).Format(time.RFC3339),
+		})
+		h.persistChatLocked()
+		h.chatMu.Unlock()
+	}
+	// 节流窗口内不应落盘
+	if _, err := os.Stat(file); err == nil {
+		t.Fatal("节流窗口（3s）内不应已经写盘")
+	}
+
+	// Close 必须把最后一次变更落下去
+	h.Close()
+	msgs := newHistoryStore(file).Load()
+	if len(msgs) != 20 {
+		t.Fatalf("Close 后应有 20 条记录，实际 %d", len(msgs))
+	}
+	// Close 幂等
+	h.Close()
+}

internal/plugins/webui/plugin.go

@@ -294,6 +294,11 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 }
 
 func (p *Plugin) Stop() error {
+	// 先停聊天记录写盘协程并落最后一次，再关服务器：
+	// 写盘是节流的（chatSaveThrottle），不显式关会丢掉最后一轮对话。
+	if p.handler != nil {
+		p.handler.Close()
+	}
 	if p.server != nil {
 		return p.server.Close()
 	}