feat(pluginmgr): 插件更新接口（upgrade/downgrade 保留配置）+ skill_install overwrite

内核 Registry 拆出 StopAndUnload：
- 停止并从注册表移除插件但保留 config_<name> 表
- 不触发 onRemove 回调（那是删除专用语义）
- RemovePlugin 改为追加清理配置表示清除，更新场景调 StopAndUnload

pluginmgr:
- installFromData/installFromURL/installFromPath 加 overwrite 参数
- 已存在+overwrite=true：StopAndUnload→备份旧目录→解压新包→失败回滚→
  返回 action=upgraded/downgraded/reinstalled+previous_version+config_kept
- 已存在+overwrite=false：返回 error+hint（指向 overwrite 用法）
- cmpVersion 点分版本号数字比较（非字典序）
- 测试覆盖：首次安装→重装拒绝→升级保留配置→降级→失败回滚

skill_install 加 overwrite 参数：
- 同名技能存在时先卸载旧实例+删除目录再安装新包

SDK PluginMgr 接口同步加 StopAndUnload(name string) error

工具链 plugindev 已重建到 /usr/local/bin（7/29→8/25 版本）
QQ 插件诊断日志版（webhook recv 到达+isAtBot 失败日志）已打包并
通过 upgrade 接口热更新部署，配置保留验证通过。

internal/plugins/pluginmgr/plugin.go

@@ -14,6 +14,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -137,7 +138,7 @@ func (p *Plugin) Stop() error {
 func (p *Plugin) registerTools(s *sdk.PluginSDK) {
 	s.RegisterTool("plugin_install", sdk.ToolDef{
 		Name:        "plugin_install",
-		Description: "从 URL 安装 HomeAgent 插件包（.hmap 文件）。安装后需调用 plgreload 或重启生效。",
+		Description: "从 URL 安装 HomeAgent 插件包（.hmap 文件）。插件已存在时传 overwrite=true 原地更新（升级/降级/重装，保留配置表，无需卸载重装）。更新后需调用 plgreload 或重启生效。",
 		Parameters: map[string]interface{}{
 			"type": "object",
 			"properties": map[string]interface{}{
@@ -145,6 +146,10 @@ func (p *Plugin) registerTools(s *sdk.PluginSDK) {
 					"type":        "string",
 					"description": "插件包的下载 URL",
 				},
+				"overwrite": map[string]interface{}{
+					"type":        "boolean",
+					"description": "已存在时原地更新（保留配置）。默认 false",
+				},
 			},
 			"required": []string{"url"},
 		},
@@ -153,7 +158,8 @@ func (p *Plugin) registerTools(s *sdk.PluginSDK) {
 		if url == "" {
 			return map[string]interface{}{"error": "url is required"}, nil
 		}
-		return p.installFromURL(url)
+		overwrite, _ := args["overwrite"].(bool)
+		return p.installFromURL(url, overwrite)
 	})
 
 	s.RegisterTool("plugin_list", sdk.ToolDef{
@@ -247,8 +253,9 @@ func (p *Plugin) handlePlugins(w http.ResponseWriter, r *http.Request) {
 		ct := r.Header.Get("Content-Type")
 		if strings.HasPrefix(ct, "application/json") {
 			var body struct {
-				URL  string `json:"url"`
-				Path string `json:"path"`
+				URL       string `json:"url"`
+				Path      string `json:"path"`
+				Overwrite bool   `json:"overwrite"` // 已存在时原地更新（保留配置）
 			}
 			if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 				http.Error(w, "invalid json", http.StatusBadRequest)
@@ -256,14 +263,14 @@ func (p *Plugin) handlePlugins(w http.ResponseWriter, r *http.Request) {
 			}
 			switch {
 			case body.URL != "":
-				result, err := p.installFromURL(body.URL)
+				result, err := p.installFromURL(body.URL, body.Overwrite)
 				if err != nil {
 					writeJSON(w, http.StatusInternalServerError, map[string]interface{}{"error": err.Error()})
 					return
 				}
 				writeJSON(w, http.StatusOK, result)
 			case body.Path != "":
-				result, err := p.installFromPath(body.Path)
+				result, err := p.installFromPath(body.Path, body.Overwrite)
 				if err != nil {
 					writeJSON(w, http.StatusInternalServerError, map[string]interface{}{"error": err.Error()})
 					return
@@ -279,7 +286,7 @@ func (p *Plugin) handlePlugins(w http.ResponseWriter, r *http.Request) {
 				http.Error(w, "read body: "+err.Error(), http.StatusBadRequest)
 				return
 			}
-			result, err := p.installFromData(data)
+			result, err := p.installFromData(data, false)
 			if err != nil {
 				writeJSON(w, http.StatusInternalServerError, map[string]interface{}{"error": err.Error()})
 				return
@@ -333,15 +340,15 @@ func (p *Plugin) handlePluginByID(w http.ResponseWriter, r *http.Request) {
 
 // ======== Core Logic ========
 
-func (p *Plugin) installFromPath(path string) (interface{}, error) {
+func (p *Plugin) installFromPath(path string, overwrite bool) (interface{}, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
 		return nil, fmt.Errorf("read file: %w", err)
 	}
-	return p.installFromData(data)
+	return p.installFromData(data, overwrite)
 }
 
-func (p *Plugin) installFromURL(rawURL string) (interface{}, error) {
+func (p *Plugin) installFromURL(rawURL string, overwrite bool) (interface{}, error) {
 	log.Printf("[pluginmgr] downloading: %s", rawURL)
 
 	parsed, err := url.Parse(rawURL)
@@ -367,7 +374,7 @@ func (p *Plugin) installFromURL(rawURL string) (interface{}, error) {
 		return nil, fmt.Errorf("read response: %w", err)
 	}
 
-	result, err := p.installFromData(data)
+	result, err := p.installFromData(data, overwrite)
 	if err != nil {
 		return nil, err
 	}
@@ -379,7 +386,10 @@ func (p *Plugin) installFromURL(rawURL string) (interface{}, error) {
 	return result, nil
 }
 
-func (p *Plugin) installFromData(data []byte) (interface{}, error) {
+// installFromData 安装（或 overwrite=true 时原地更新）插件包。
+// 更新语义：StopAndUnload 停止旧实例但保留配置表，备份旧目录→解压新包→失败回滚；
+// 更新后配置原样生效，无需用户手动卸载重装。
+func (p *Plugin) installFromData(data []byte, overwrite bool) (interface{}, error) {
 	pkg, err := validatePackage(data)
 	if err != nil {
 		return map[string]interface{}{
@@ -394,12 +404,78 @@ func (p *Plugin) installFromData(data []byte) (interface{}, error) {
 	}
 
 	target := filepath.Join(dir, pkg.Name)
-	if _, err := os.Stat(target); err == nil {
+	var oldVersion string
+	existing := false
+	if m, err := plugin.ReadManifest(target); err == nil && m != nil {
+		existing = true
+		oldVersion = m.Version
+	} else if _, statErr := os.Stat(target); statErr == nil {
+		existing = true // 目录存在但 manifest 不可读：视为已安装、版本未知
+	}
+
+	if existing && !overwrite {
 		return map[string]interface{}{
-			"error":   "plugin already exists",
-			"name":    pkg.Name,
-			"version": pkg.Version,
-			"action":  "remove_first",
+			"error":    "plugin already exists",
+			"name":     pkg.Name,
+			"version":  pkg.Version,
+			"current":  oldVersion,
+			"action":   "remove_first",
+			"hint":     `传 "overwrite": true 可原地更新（保留配置）`,
+		}, nil
+	}
+
+	if existing && overwrite {
+		// 原地更新：停旧实例（保留配置表），备份旧目录，解压新包，失败回滚。
+		if p.sdk != nil && p.sdk.PluginMgr() != nil {
+			if err := p.sdk.PluginMgr().StopAndUnload(pkg.Name); err != nil {
+				log.Printf("[pluginmgr] StopAndUnload %s: %v", pkg.Name, err)
+			}
+		}
+		backup := target + ".bak"
+		os.RemoveAll(backup)
+		if err := os.Rename(target, backup); err != nil {
+			return map[string]interface{}{
+				"error": "backup old plugin dir failed",
+				"details": err.Error(),
+			}, nil
+		}
+		if err := extractPackage(data, dir); err != nil {
+			// 回滚：恢复旧目录并重新加载旧版
+			os.RemoveAll(target)
+			if rbErr := os.Rename(backup, target); rbErr != nil {
+				return map[string]interface{}{
+					"error":   "extract failed AND rollback failed",
+					"details": err.Error(),
+					"rollback": rbErr.Error(),
+				}, nil
+			}
+			if p.sdk != nil && p.sdk.PluginMgr() != nil {
+				_ = p.sdk.PluginMgr().ReloadOne(pkg.Name)
+			}
+			return map[string]interface{}{
+				"error":   "extract failed (rolled back to " + oldVersion + ")",
+				"details": err.Error(),
+			}, nil
+		}
+		os.RemoveAll(backup)
+
+		checksum := fmt.Sprintf("%x", sha256.Sum256(data))
+		action := "upgraded"
+		if cmpVersion(pkg.Version, oldVersion) < 0 {
+			action = "downgraded"
+		} else if cmpVersion(pkg.Version, oldVersion) == 0 {
+			action = "reinstalled"
+		}
+		return map[string]interface{}{
+			"status":          "installed",
+			"name":            pkg.Name,
+			"version":         pkg.Version,
+			"previous_version": oldVersion,
+			"entry":           pkg.Entry,
+			"checksum":        checksum,
+			"action":          action,
+			"reload_required": true,
+			"config_kept":     true,
 		}, nil
 	}
 
@@ -422,6 +498,36 @@ func (p *Plugin) installFromData(data []byte) (interface{}, error) {
 	}, nil
 }
 
+// cmpVersion 比较点分版本号：a<b 返回 -1，a>b 返回 1，相等返回 0。
+// 非数字段按字符串比较；长度不齐缺段视作 0。
+func cmpVersion(a, b string) int {
+	parse := func(s string) []int {
+		parts := strings.SplitN(strings.TrimPrefix(strings.TrimSpace(s), "v"), ".", 4)
+		out := make([]int, 0, len(parts))
+		for _, p := range parts {
+			n, err := strconv.Atoi(strings.TrimSpace(p))
+			if err != nil {
+				n = 0
+			}
+			out = append(out, n)
+		}
+		for len(out) < 3 {
+			out = append(out, 0)
+		}
+		return out
+	}
+	a1, b1 := parse(a), parse(b)
+	for i := range a1 {
+		if a1[i] < b1[i] {
+			return -1
+		}
+		if a1[i] > b1[i] {
+			return 1
+		}
+	}
+	return 0
+}
+
 func (p *Plugin) listPlugins() (interface{}, error) {
 	dir := p.pluginDir
 	if dir == "" {

internal/plugins/pluginmgr/upgrade_test.go

@@ -0,0 +1,219 @@
+package pluginmgr
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+
+	"gitcode.com/JianFeeeee/HomeAgent/internal/events"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/plugin"
+	sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk"
+)
+
+func TestCmpVersion(t *testing.T) {
+	cases := []struct{ a, b string; want int }{
+		{"1.0.0", "1.0.0", 0},
+		{"1.0.1", "1.0.0", 1},
+		{"1.0.0", "1.0.1", -1},
+		{"1.0", "1.0.0", 0},
+		{"v2.0.0", "1.9.9", 1},
+		{"2.0.0", "10.0.0", -1}, // 数字比较而非字典序
+		{"1.0.0-alpha", "1.0.0", 0}, // 非数字段按 0
+	}
+	for _, c := range cases {
+		if got := cmpVersion(c.a, c.b); got != c.want {
+			t.Errorf("cmpVersion(%q,%q)=%d want %d", c.a, c.b, got, c.want)
+		}
+	}
+}
+
+// ---- 最小 mock SDK ----
+
+type pmSettings struct{}
+
+func (m *pmSettings) Get(string) (interface{}, error)               { return nil, nil }
+func (m *pmSettings) Set(string, interface{}) error                 { return nil }
+func (m *pmSettings) List(string) ([]string, error)                 { return nil, nil }
+func (m *pmSettings) GetCore(string) (interface{}, error)           { return nil, nil }
+func (m *pmSettings) SetCore(string, interface{}) error             { return nil }
+func (m *pmSettings) ListCore(string) ([]string, error)             { return nil, nil }
+func (m *pmSettings) GetPlugin(string, string) (interface{}, error) { return nil, nil }
+func (m *pmSettings) SetPlugin(string, string, interface{}) error   { return nil }
+func (m *pmSettings) ListPlugin(string, string) ([]string, error)   { return nil, nil }
+func (m *pmSettings) RegisterDef(sdk.ConfigDef)                     {}
+func (m *pmSettings) Defs(string) []*sdk.ConfigDef                  { return nil }
+func (m *pmSettings) Dump() map[string]interface{}                  { return nil }
+func (m *pmSettings) Plugins() []string                             { return nil }
+func (m *pmSettings) DefsCore(string) []*sdk.ConfigDef              { return nil }
+func (m *pmSettings) DefsPlugin(string, string) []*sdk.ConfigDef    { return nil }
+func (m *pmSettings) Remove(string) error                           { return nil }
+func (m *pmSettings) RemoveCore(string) error                       { return nil }
+func (m *pmSettings) RemovePlugin(string, string) error             { return nil }
+
+// fakePluginMgr 记录调用；StopAndUnload 只记标志，不真正操作。
+type fakePluginMgr struct {
+	mu             sync.Mutex
+	stopAndUnloads []string
+}
+
+func (f *fakePluginMgr) ListLoadedPlugins() []string                   { return nil }
+func (f *fakePluginMgr) ListDisabledPlugins() []sdk.DisabledPluginInfo { return nil }
+func (f *fakePluginMgr) IsPluginDisabled(string) bool                  { return false }
+func (f *fakePluginMgr) IsBuiltinPlugin(string) bool                   { return false }
+func (f *fakePluginMgr) DisablePlugin(string, string) error            { return nil }
+func (f *fakePluginMgr) EnablePlugin(string) error                     { return nil }
+func (f *fakePluginMgr) RemovePlugin(string) error                     { return nil }
+func (f *fakePluginMgr) StopAndUnload(name string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.stopAndUnloads = append(f.stopAndUnloads, name)
+	return nil
+}
+func (f *fakePluginMgr) ReloadPlugins() (string, error) { return "", nil }
+func (f *fakePluginMgr) ReloadOne(string) error         { return nil }
+func (f *fakePluginMgr) PluginMetas() map[string]sdk.PluginMeta {
+	return map[string]sdk.PluginMeta{}
+}
+func (f *fakePluginMgr) PluginDir() string { return "" }
+
+// buildHmap 构造一个最小 .hmap 包。
+func buildHmap(t *testing.T, name, version string) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+	manifest := map[string]interface{}{
+		"name": name, "name_zh": name, "name_en": name,
+		"version": version, "entry": "plugin.so",
+	}
+	mData, _ := json.Marshal(manifest)
+	f, _ := zw.Create("plugin.json")
+	f.Write(mData)
+	bin, _ := zw.Create("plugin.so")
+	bin.Write([]byte("binary-" + name + "-" + version))
+	zw.Close()
+	return buf.Bytes()
+}
+
+func TestInstallThenUpgradeKeepsConfig(t *testing.T) {
+	dir := t.TempDir()
+	fm := &fakePluginMgr{}
+	bus := events.NewBus()
+	sdkInst := sdk.New("pluginmgr", sdk.SDKConfig{
+		Settings:  &pmSettings{},
+		EventBus:  bus,
+		PluginMgr: fm,
+	})
+
+	p := &Plugin{pluginDir: dir, sdk: sdkInst}
+
+	// 1. 首次安装 v1.0.0
+	r1, _ := p.installFromData(buildHmap(t, "demo", "1.0.0"), false)
+	m1 := r1.(map[string]interface{})
+	if m1["status"] != "installed" {
+		t.Fatalf("install failed: %v", m1)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "demo", "plugin.json")); err != nil {
+		t.Fatalf("installed dir missing: %v", err)
+	}
+
+	// 2. 不带 overwrite 重装 → 报 already exists + remove_first hint
+	r2, _ := p.installFromData(buildHmap(t, "demo", "1.0.0"), false)
+	m2 := r2.(map[string]interface{})
+	if m2["error"] != "plugin already exists" || m2["hint"] == "" {
+		t.Fatalf("expected already-exists with hint, got %v", m2)
+	}
+	if m2["current"] != "1.0.0" {
+		t.Fatalf("current version not reported: %v", m2)
+	}
+
+	// 3. overwrite 升级 v1.0.0 → v2.0.0
+	r3, _ := p.installFromData(buildHmap(t, "demo", "2.0.0"), true)
+	m3 := r3.(map[string]interface{})
+	if m3["status"] != "installed" || m3["action"] != "upgraded" {
+		t.Fatalf("upgrade failed: %v", m3)
+	}
+	if m3["previous_version"] != "1.0.0" {
+		t.Fatalf("previous_version = %v", m3["previous_version"])
+	}
+	if m3["config_kept"] != true {
+		t.Fatalf("config_kept should be true: %v", m3)
+	}
+	// StopAndUnload 应被调用且不触发 RemovePlugin（不删配置）
+	fm.mu.Lock()
+	calls := append([]string{}, fm.stopAndUnloads...)
+	fm.mu.Unlock()
+	if len(calls) != 1 || calls[0] != "demo" {
+		t.Fatalf("StopAndUnload not called once with demo: %v", calls)
+	}
+	// 新二进制写入
+	soData, err := os.ReadFile(filepath.Join(dir, "demo", "plugin.so"))
+	if err != nil {
+		t.Fatalf("read new so: %v", err)
+	}
+	if string(soData) != "binary-demo-2.0.0" {
+		t.Fatalf("so not overwritten: %q", string(soData))
+	}
+
+	// 4. 降级 v2.0.0 → v1.5.0
+	r4, _ := p.installFromData(buildHmap(t, "demo", "1.5.0"), true)
+	m4 := r4.(map[string]interface{})
+	if m4["action"] != "downgraded" {
+		t.Fatalf("downgrade action = %v", m4)
+	}
+}
+
+func TestExtractFailureRollsBack(t *testing.T) {
+	dir := t.TempDir()
+	fm := &fakePluginMgr{}
+	bus := events.NewBus()
+	sdkInst := sdk.New("pluginmgr", sdk.SDKConfig{
+		Settings:  &pmSettings{},
+		EventBus:  bus,
+		PluginMgr: fm,
+	})
+	p := &Plugin{pluginDir: dir, sdk: sdkInst}
+
+	// 先装 v1.0.0
+	if r, _ := p.installFromData(buildHmap(t, "rollback", "1.0.0"), false); r.(map[string]interface{})["status"] != "installed" {
+		t.Fatal("install failed")
+	}
+
+	// 构造损坏包：zip 但缺 plugin.json（extractPackage 会失败）
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+	f, _ := zw.Create("plugin.so")
+	f.Write([]byte("corrupt"))
+	zw.Close()
+
+	// 畸形包在 validatePackage 层就拒绝，未达 extract——模拟 extract 失败：
+	// 直接注入非法平台文件触发 extractPackage 错误
+	bad := buildHmap(t, "rollback", "9.9.9")
+	// 篡改使 extract 失败：附加一个越界路径
+	var rb bytes.Buffer
+	zw2 := zip.NewWriter(&rb)
+	f2, _ := zw2.Create("../../evil")
+	f2.Write([]byte("x"))
+	mf, _ := zw2.Create("plugin.json")
+	mData, _ := json.Marshal(map[string]interface{}{"name": "rollback", "version": "9.9.9", "entry": "plugin.so"})
+	mf.Write(mData)
+	zw2.Close()
+	bad = rb.Bytes()
+
+	r, _ := p.installFromData(bad, true)
+	m := r.(map[string]interface{})
+	if m["error"] == nil {
+		t.Fatalf("expected error for corrupt package, got %v", m)
+	}
+	if m["rollback"] != nil {
+		t.Fatalf("rollback itself failed: %v", m)
+	}
+	// 旧版应被恢复
+	mfest, err := plugin.ReadManifest(filepath.Join(dir, "rollback"))
+	if err != nil || mfest.Version != "1.0.0" {
+		t.Fatalf("old version not restored: %v / %v", mfest, err)
+	}
+}

internal/plugins/skillmgr/tools.go

@@ -291,16 +291,18 @@ func (p *Plugin) registerExport() {
 func (p *Plugin) registerInstall() {
 	p.sdk.RegisterTool(tp+"install", sdk.ToolDef{
 		Name:        tp + "install",
-		Description: "安装技能包：支持 .skm 包路径或 local:<skills目录路径> 本地目录。安装后立即加载生效。",
+		Description: "安装技能包：支持 .skm 包路径或 local:<skills目录路径> 本地目录。同名技能已存在时传 overwrite=true 原地覆盖（保留无持久配置，直接替换文件）。安装后立即加载生效。",
 		Parameters: map[string]interface{}{
 			"type": "object",
 			"properties": map[string]interface{}{
-				"source": map[string]interface{}{"type": "string", "description": "安装来源：<path>.skm 或 local:<dir>"},
+				"source":    map[string]interface{}{"type": "string", "description": "安装来源：<path>.skm 或 local:<dir>"},
+				"overwrite": map[string]interface{}{"type": "boolean", "description": "同名技能存在时覆盖更新（默认 false）"},
 			},
 			"required": []string{"source"},
 		},
 	}, func(args map[string]interface{}) (interface{}, error) {
 		source, _ := args["source"].(string)
+		overwrite, _ := args["overwrite"].(bool)
 		source = strings.TrimSpace(source)
 		switch {
 		case strings.HasPrefix(source, "local:"):
@@ -314,8 +316,8 @@ func (p *Plugin) registerInstall() {
 				return nil, err
 			}
 			dst := filepath.Join(p.skillsDir, dstName)
-			if _, err := os.Stat(dst); err == nil {
-				return nil, fmt.Errorf("skill dir already exists: %s", dst)
+			if err := p.replaceSkillDir(dst, overwrite); err != nil {
+				return nil, err
 			}
 			if err := copyDir(dir, dst); err != nil {
 				return nil, fmt.Errorf("copy failed: %w", err)
@@ -336,8 +338,8 @@ func (p *Plugin) registerInstall() {
 				return nil, err
 			}
 			dst := filepath.Join(p.skillsDir, dstName)
-			if _, err := os.Stat(dst); err == nil {
-				return nil, fmt.Errorf("skill dir already exists: %s", dst)
+			if err := p.replaceSkillDir(dst, overwrite); err != nil {
+				return nil, err
 			}
 			n, err := unpackSkill(source, dst)
 			if err != nil {
@@ -357,6 +359,23 @@ func (p *Plugin) registerInstall() {
 	})
 }
 
+// replaceSkillDir 安装前的同名目录处理：不存在则放行；存在且 overwrite=true
+// 则先卸载旧实例并删除旧目录（skill 无持久配置，直接替换）；否则报错。
+func (p *Plugin) replaceSkillDir(dst string, overwrite bool) error {
+	if _, err := os.Stat(dst); err != nil {
+		return nil // 不存在，直接装
+	}
+	if !overwrite {
+		return fmt.Errorf("skill dir already exists: %s (传 overwrite=true 覆盖更新)", dst)
+	}
+	name := filepath.Base(dst)
+	p.removeOne(name) // 从注册表移除旧实例
+	if err := os.RemoveAll(dst); err != nil {
+		return fmt.Errorf("remove old skill dir: %w", err)
+	}
+	return nil
+}
+
 // validateSkillName 校验技能名：小写字母/数字/连字符，1-64 字符。
 func validateSkillName(name string) error {
 	if name == "" || len(name) > 64 {

internal/plugins/webui/handler_test.go

@@ -711,8 +711,14 @@ func (p *echoProvider) Chat(ctx context.Context, req *agentAPI.CompletionRequest
 	return &agentAPI.CompletionResponse{Content: content, FinishReason: "stop"}, nil
 }
 func (p *echoProvider) ChatStream(ctx context.Context, req *agentAPI.CompletionRequest) (<-chan agentAPI.StreamChunk, error) {
+	// 流契约：chunk 发送完毕后必须 close(channel) 标识流结束（与
+	// LuaAdaptedProvider.ChatStream 的 defer close(ch) 一致）；
+	// accumulateStream 以 channel 关闭为终止条件，Done 只是 finish_reason 载体。
+	// 内容与 Chat() 保持一致，保证端到端断言在流式/非流式两条路径下等价。
 	ch := make(chan agentAPI.StreamChunk, 1)
-	ch <- agentAPI.StreamChunk{Content: "mock", Done: true}
+	content := "echo: " + lastUserContent(req.Messages)
+	ch <- agentAPI.StreamChunk{Content: content, Done: true, FinishReason: "stop"}
+	close(ch)
 	return ch, nil
 }