magic-agent 1.0.2 → 1.0.3

package/internal/agent/custom_models.go

@@ -18,10 +18,17 @@ package agent
 // 归谁所有：models.json 是 **CLI 自己的**配置文件（CLI 的 models 控制器会读写它）。
 // 所以这里只做**合并**：只补缺失的 id，不删、不改、不动其它字段；无新增时不落盘
 //（避免无谓写盘与 mtime 抖动）。App 缓存一律只读。
+//
+// ⚠️ 硬约束（2026-09-30 补）：目标文件**必须是顶层 JSON 对象**才动它。桌面端
+// WorkBuddy 自己那份 `models.json` 顶层是**数组**（LanguageModel[]），与 CLI 的
+// `{availableModels, models}` 不是同一个格式。若把数组当"解析失败的空文件"整体写回，
+// 就是把对方的模型清单替换成只剩 custom-local 几条 —— 官方模型全丢且不可回滚。
+// 撞上这种文件一律**跳过并在 stderr 说明**；覆盖写之前另留 `.magic-agent.bak` 原文。
 
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/fs"
 	"os"
 	"path/filepath"
@@ -32,6 +39,10 @@ import (
 // customModelsFileName CLI 读自定义模型端点的文件名（见 CLI 的 getModelsPath）。
 const customModelsFileName = "models.json"
 
+// customModelsBackupSuffix 覆盖写之前留的原文备份后缀。
+// 一次误写就能把模型清单清空，留一份可回滚的东西。
+const customModelsBackupSuffix = ".magic-agent.bak"
+
 // customModelIDPrefix 自定义模型 id 前缀（App 与 CLI 共用这个约定）。
 const customModelIDPrefix = "custom-local:"
 
@@ -53,15 +64,29 @@ func syncCustomModelsFromApp(accConfigPath, configDir string) (int, error) {
 	}
 
 	path := filepath.Join(configDir, customModelsFileName)
+	var raw0 []byte // 改动前的原文（覆盖写之前留备份）
 	root := map[string]any{}
 	switch b, err := os.ReadFile(path); {
 	case err == nil:
-		// 解析失败就当空文件：CLI 自己也会这么兜（readModelsJson 失败返回 {models:[]}）。
-		// 但**不覆盖**未识别的字段 —— 解析失败时下面只会写回 models/availableModels。
-		_ = json.Unmarshal(b, &root)
-		if root == nil {
-			root = map[string]any{}
+		raw0 = b
+		/* ⚠️ 只有**顶层是 JSON 对象**才认作 CLI 的 models.json。
+		   桌面端（WorkBuddy）自己那份 models.json 顶层是**数组**（LanguageModel[]），
+		   数组解析不进 map[string]any。以前这里把"解析失败"当空文件继续写回
+		   {models, availableModels} —— 对数组格式来说那等于把对方的模型清单**整体替换**掉：
+		   官方模型全没了，且不可恢复（原注释里"解析失败时不覆盖未识别的字段"对数组不成立，
+		   数组根本装不下未知字段）。这种文件不是 CLI 的格式，一律不动。 */
+		var doc any
+		if err := json.Unmarshal(b, &doc); err != nil {
+			fmt.Fprintf(os.Stderr, "magic-agent: 跳过自定义模型端点同步：%s 不是合法 JSON（保持原文件不动）\n", path)
+			return 0, nil
+		}
+		m, ok := doc.(map[string]any)
+		if !ok {
+			fmt.Fprintf(os.Stderr, "magic-agent: 跳过自定义模型端点同步：%s 顶层不是 JSON 对象"+
+				"（该文件不是 CLI 的 models.json 格式，覆盖写会毁掉里面的模型清单；保持原文件不动）\n", path)
+			return 0, nil
 		}
+		root = m
 	case errors.Is(err, fs.ErrNotExist):
 		// 首次同步：新建
 	default:
@@ -126,6 +151,10 @@ func syncCustomModelsFromApp(accConfigPath, configDir string) (int, error) {
 		return 0, err
 	}
 	// 含第三方 apiKey：与 CLI 自身凭据同级（仅属主可读）。
+	// 覆盖写之前留一份原文备份：一次误写就能清空模型清单，必须可回滚。
+	if len(raw0) > 0 {
+		_ = os.WriteFile(path+customModelsBackupSuffix, raw0, 0o600)
+	}
 	if err := os.WriteFile(path, b, 0o600); err != nil {
 		return 0, err
 	}
@@ -195,3 +224,120 @@ func (c codebuddyCore) effectiveConfigDir() string {
 	}
 	return c.configDir
 }
+
+// ── 事故还原：把被覆盖写坏的桌面端 models.json 修回来 ──────────
+//
+// 背景（2026-09-30 Windows 事故）：Windows 上 CODEBUDDY_CONFIG_DIR 可能指向桌面端
+// 数据目录，于是上面的同步把桌面端那份**数组格式**的 models.json 覆盖成了
+// `{availableModels, models}` 对象格式。桌面端解析不了 → 模型清单整个为空，
+// 用户看到「WorkBuddy 的模型都丢失了」。
+//
+// 还原依据（实测比对同一台机器上的两份文件）：
+//
+//	桌面端数组条目   {id:"MiniMax-M3",   name, vendor, url, apiKey, ...}
+//	我们写的对象条目 {id:"custom-local:MiniMax-M3", name, vendor, url, apiKey, ...}
+//
+// 即**同一批条目、id 差一个 custom-local: 前缀**。所以还原 = 把对象里的 models[]
+// 原样搬成数组，只去掉 id 前缀。官方模型清单不在这个文件里（那是 product.json /
+// acc 缓存的事，桌面端自己拉），所以这里不需要、也不该造官方条目。
+
+// DesktopAppHomeOf 返回引擎对应的桌面端数据目录名（空 = 该引擎没有桌面端）。
+func DesktopAppHomeOf(engine string) string {
+	switch strings.ToLower(strings.TrimSpace(engine)) {
+	case "codebuddy":
+		return ".workbuddy"
+	case "codebuddy-ai":
+		return ".workbuddy-ai"
+	}
+	return ""
+}
+
+// DesktopEngines 列出有桌面端数据目录的引擎（`--repair-models` 的可用值，供提示与校验共用）。
+func DesktopEngines() []string { return []string{"codebuddy", "codebuddy-ai"} }
+
+// RepairDesktopModels 修复被反向同步写坏的桌面端 models.json。
+// 返回（是否真的做了修复, 给人看的说明, 错误）。没有可修的东西时返回 (false, 说明, nil)。
+func RepairDesktopModels(engine string) (bool, string, error) {
+	home := DesktopAppHomeOf(engine)
+	if home == "" {
+		return false, "", fmt.Errorf(
+			"引擎 %q 没有对应的桌面端数据目录，没有可修的 models.json（支持：%s）",
+			strings.TrimSpace(engine), strings.Join(DesktopEngines(), " / "))
+	}
+	dir, err := os.UserHomeDir()
+	if err != nil || dir == "" {
+		dir = os.Getenv("HOME")
+	}
+	if dir == "" {
+		return false, "", fmt.Errorf("定位用户目录失败，无法找到桌面端 models.json")
+	}
+	return repairModelsFile(filepath.Join(dir, home))
+}
+
+// repairModelsFile 就地把 appHome/models.json 从「被覆盖写的对象」还原成桌面端数组。
+//
+// 只认**明确的坏形状**（顶层对象 + models[] 全是 custom-local:* 条目）才动手：
+// 已经是数组、不是合法 JSON、或形状不认识，一律原样不动并说明原因。
+func repairModelsFile(appHome string) (bool, string, error) {
+	path := filepath.Join(appHome, customModelsFileName)
+	b, err := os.ReadFile(path)
+	switch {
+	case errors.Is(err, fs.ErrNotExist):
+		return false, fmt.Sprintf("%s 不存在，无需修复", path), nil
+	case err != nil:
+		return false, "", err
+	}
+
+	var doc any
+	if uerr := json.Unmarshal(b, &doc); uerr != nil {
+		return false, fmt.Sprintf("%s 不是合法 JSON，形状对不上，未改动", path), nil
+	}
+	if _, isArr := doc.([]any); isArr {
+		return false, fmt.Sprintf("%s 已是桌面端的数组格式，无需修复", path), nil
+	}
+	root, ok := doc.(map[string]any)
+	if !ok {
+		return false, fmt.Sprintf("%s 顶层既不是数组也不是对象，未改动", path), nil
+	}
+	raw, _ := root["models"].([]any)
+	if len(raw) == 0 {
+		return false, fmt.Sprintf("%s 里没有 models 数组，不像被我们覆盖写的形状，未改动", path), nil
+	}
+
+	out := make([]any, 0, len(raw))
+	for _, it := range raw {
+		m, ok := it.(map[string]any)
+		if !ok {
+			return false, fmt.Sprintf("%s 的 models 里混有非对象条目，未改动", path), nil
+		}
+		id, _ := m["id"].(string)
+		if !strings.HasPrefix(id, customModelIDPrefix) {
+			return false, fmt.Sprintf("%s 的 models 里混有非 %s 条目（可能不是我们写坏的），未改动",
+				path, customModelIDPrefix), nil
+		}
+		cp := make(map[string]any, len(m))
+		for k, v := range m {
+			cp[k] = v
+		}
+		cp["id"] = strings.TrimPrefix(id, customModelIDPrefix)
+		out = append(out, cp)
+	}
+
+	nb, merr := json.MarshalIndent(out, "", "  ")
+	if merr != nil {
+		return false, "", merr
+	}
+	nb = append(nb, '\n')
+
+	// 先把现场（被写坏的那份）留一份，再落盘。
+	broken := path + ".broken.bak"
+	if werr := os.WriteFile(broken, b, 0o600); werr != nil {
+		return false, "", fmt.Errorf("写备份 %s 失败: %w", broken, werr)
+	}
+	if werr := os.WriteFile(path, nb, 0o600); werr != nil {
+		return false, "", werr
+	}
+	return true, fmt.Sprintf(
+		"已还原 %s：%d 条自定义模型改回桌面端的数组格式（id 去掉 %s 前缀）；原文件备份在 %s",
+		path, len(out), customModelIDPrefix, broken), nil
+}

package/internal/agent/custom_models_test.go

@@ -9,8 +9,11 @@ package agent
 //  2. 幂等：无新增时**不落盘**（内容逐字节不变）
 //  3. 只增不改：既有条目与未识别字段原样保留；availableModels 追加不丢
 //  4. 安全兜底：App 缓存缺失 / 条目 disabled → 不建文件、不报错
+//  5. 陌生文件一律不碰：顶层不是 JSON 对象（桌面端是数组）/ 坏 JSON → 逐字节保持原样，
+//     且覆盖写之前一定留 .magic-agent.bak（见 2026-09-30 Windows 事故用例）
 
 import (
+	"bytes"
 	"encoding/json"
 	"os"
 	"path/filepath"
@@ -182,11 +185,112 @@ func TestSyncCustomModelsFromApp_IdempotentAndMergeOnly(t *testing.T) {
 	}
 }
 
-func TestSyncCustomModelsFromApp_NoSourceNoFile(t *testing.T) {
+// 目标文件顶层不是 JSON 对象（桌面端 WorkBuddy 的 models.json 就是**数组**）时，
+// 必须**一个字都不动**、也不留备份（因为压根没写）。
+//
+// 为什么是关键回归：以前把"解析不进 map"当空文件继续写回 {models, availableModels}，
+// 等于把对方的模型清单整体替换成只剩 custom-local 几条 —— 官方模型全丢且不可回滚。
+func TestSyncCustomModelsFromApp_RefusesNonObjectFile(t *testing.T) {
+	// 桌面端 models.json 的真实形状：顶层数组，条目是 LanguageModel。
+	desktop := []byte(`[
+  {
+    "id": "MiniMax-M3",
+    "name": "MiniMax-M3",
+    "vendor": "MiniMax",
+    "url": "https://api.minimaxi.com/v1/chat/completions",
+    "apiKey": "sk-user-own"
+  },
+  {
+    "id": "glm-5.3",
+    "name": "glm-5.3",
+    "url": "https://open.bigmodel.cn/api/paas/v4",
+    "apiKey": "sk-user-own-2"
+  }
+]`)
+
+	cases := []struct {
+		name    string
+		content []byte
+	}{
+		{"顶层是数组（桌面端格式）", desktop},
+		{"坏 JSON", []byte("{oops")},
+		{"顶层是字符串", []byte(`"just a string"`)},
+		{"顶层是数字", []byte(`42`)},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			dir := t.TempDir()
+			acc := filepath.Join(dir, "acc.json")
+			writeJSON(t, acc, appCacheFixture())
+			cfg := filepath.Join(dir, "config")
+			if err := os.MkdirAll(cfg, 0o700); err != nil {
+				t.Fatal(err)
+			}
+			path := filepath.Join(cfg, customModelsFileName)
+			if err := os.WriteFile(path, tc.content, 0o600); err != nil {
+				t.Fatal(err)
+			}
+
+			added, err := syncCustomModelsFromApp(acc, cfg)
+			if err != nil {
+				t.Errorf("应静默跳过，不该报错: %v", err)
+			}
+			if added != 0 {
+				t.Errorf("added = %d, want 0", added)
+			}
+
+			after, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatalf("原文件必须还在: %v", err)
+			}
+			if !bytes.Equal(after, tc.content) {
+				t.Errorf("原文件被改写了！\nbefore=%s\nafter =%s", tc.content, after)
+			}
+			if _, err := os.Stat(path + customModelsBackupSuffix); !os.IsNotExist(err) {
+				t.Errorf("没写就不该留备份")
+			}
+		})
+	}
+}
+
+// 真的要覆盖写时，必须先把原文留成 <models.json>.magic-agent.bak（可回滚）。
+func TestSyncCustomModelsFromApp_BacksUpBeforeOverwrite(t *testing.T) {
 	dir := t.TempDir()
+	acc := filepath.Join(dir, "acc.json")
+	writeJSON(t, acc, appCacheFixture())
 	cfg := filepath.Join(dir, "config")
+	if err := os.MkdirAll(cfg, 0o700); err != nil {
+		t.Fatal(err)
+	}
 	path := filepath.Join(cfg, customModelsFileName)
 
+	before := []byte("{\n  \"models\": [],\n  \"availableModels\": [\"hy3\"]\n}\n")
+	if err := os.WriteFile(path, before, 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	added, err := syncCustomModelsFromApp(acc, cfg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if added == 0 {
+		t.Fatal("本次应有新增（触发落盘）")
+	}
+
+	bak, err := os.ReadFile(path + customModelsBackupSuffix)
+	if err != nil {
+		t.Fatalf("覆盖写之前应留备份: %v", err)
+	}
+	if !bytes.Equal(bak, before) {
+		t.Errorf("备份内容应为改动前的原文\nwant=%s\ngot =%s", before, bak)
+	}
+}
+
+func TestSyncCustomModelsFromApp_NoSourceNoFile(t *testing.T) {
+	dir := t.TempDir()
+	cfg := filepath.Join(dir, "config")
+	path := filepath.Join(cfg, customModelsFileName)
 	cases := []struct{ name, acc string }{
 		{"acc 路径为空", ""},
 		{"acc 文件不存在", filepath.Join(dir, "nope.json")},
@@ -221,7 +325,17 @@ func TestSyncCustomModelsFromApp_NoSourceNoFile(t *testing.T) {
 	}
 }
 
-func TestSyncCustomModelsFromApp_CorruptExistingFileRebuilt(t *testing.T) {
+/* 既有 models.json 无法确认为「CLI 自己的格式」时，一律**不碰**，而不是重建。
+ *
+ * 这条契约是 2026-09-30 改的（Windows 事故）。原行为是「解析失败当空文件，重建」，
+ * 理由看起来无害（CLI 自己也这么兜底）。实际后果是把**别人的**文件整体替换掉：
+ * 桌面端 WorkBuddy 的 models.json 顶层是数组，数组解析不进 map[string]any，
+ * 于是被当成「坏文件」重建 → 里面 61 条官方模型全没了，只剩 8 条 custom-local，
+ * 而且没有备份，不可回滚。
+ *
+ * 宁可少同步一次端点（CLI 会自己报 "has no endpoint url configured"），
+ * 也不要毁掉一份不是我们管的配置。 */
+func TestSyncCustomModelsFromApp_CorruptExistingFileLeftUntouched(t *testing.T) {
 	dir := t.TempDir()
 	acc := filepath.Join(dir, "acc.json")
 	writeJSON(t, acc, appCacheFixture())
@@ -229,16 +343,25 @@ func TestSyncCustomModelsFromApp_CorruptExistingFileRebuilt(t *testing.T) {
 	if err := os.MkdirAll(cfg, 0o700); err != nil {
 		t.Fatal(err)
 	}
-	// 既有 models.json 坏了：应重建（CLI 自己也这么兜：读失败当空），且不崩
-	if err := os.WriteFile(filepath.Join(cfg, customModelsFileName), []byte("{oops"), 0o600); err != nil {
+	path := filepath.Join(cfg, customModelsFileName)
+	broken := []byte("{oops")
+	if err := os.WriteFile(path, broken, 0o600); err != nil {
 		t.Fatal(err)
 	}
+
 	added, err := syncCustomModelsFromApp(acc, cfg)
 	if err != nil {
-		t.Fatalf("坏文件应可恢复: %v", err)
+		t.Fatalf("不认识的文件应静默跳过，不该报错: %v", err)
 	}
-	if added != 2 {
-		t.Errorf("added = %d, want 2", added)
+	if added != 0 {
+		t.Errorf("added = %d, want 0（不碰未知格式）", added)
+	}
+	after, rerr := os.ReadFile(path)
+	if rerr != nil {
+		t.Fatalf("原文件必须还在: %v", rerr)
+	}
+	if !bytes.Equal(after, broken) {
+		t.Errorf("原文件被改写了：%s", after)
 	}
 }
 

package/internal/agent/env.go

@@ -80,9 +80,17 @@ func ChildEnvWith(extraEnv []string) []string {
 }
 
 // envDenied 判断某环境变量是否不允许传给子 CLI。
+//
+// ⚠️ 大小写不敏感（2026-09-30 修，Windows 事故）：环境变量名在 **Windows 上本身
+// 不区分大小写**，父会话用 `server__port` / `Server__Port` 这类大小写写出来时，
+// 原来的逐字符比较会**漏剔除** —— 子 CLI 于是仍读到父进程的监听端口，再起一个服务
+// 撞上 EADDRINUSE，表现为「一进登录界面就卡死 / 嵌套调用永远没结果」。
+// Unix 上变量名区分大小写，折叠大小写只会**更保守**（多剔除几个父会话风格的名字），
+// 不会少剔除，故这里两个平台统一按大写比较。
 func envDenied(name string) bool {
-	if strings.HasPrefix(name, serverEnvPrefix) {
+	upper := strings.ToUpper(name)
+	if strings.HasPrefix(upper, serverEnvPrefix) {
 		return true
 	}
-	return envDenylist[name]
+	return envDenylist[upper]
 }

package/internal/agent/env_test.go

@@ -86,6 +86,43 @@ func TestEnvironStripsPythonVars(t *testing.T) {
 	}
 }
 
+// Windows 的变量名不区分大小写：父会话若写成混合大小写，也必须被剔除。
+// 2026-09-30 事故：漏剔除 → 子 CLI 仍读到父进程端口 → EADDRINUSE 永久挂起，
+// 表现就是「一进登录界面就上不去」。
+func TestEnvDeniedCaseInsensitive(t *testing.T) {
+	cases := map[string]bool{
+		"server__port":         true,
+		"Server__Port":         true,
+		"server__host":         true,
+		"codebuddy_session_id": true,
+		"Codebuddy_Session_Id": true,
+		"pythonhome":           true,
+		"PATH":                 false,
+		"HOME":                 false,
+		// 仍必须放行：引擎靠它选配置目录（见 codebuddyAccountEnv）
+		"codebuddy_config_dir": false,
+	}
+	for name, want := range cases {
+		if got := envDenied(name); got != want {
+			t.Errorf("envDenied(%q) = %v, want %v", name, got, want)
+		}
+	}
+}
+
+// 混合大小写的父会话变量在 environ() 里也必须不见。
+func TestEnvironStripsMixedCaseServerPrefix(t *testing.T) {
+	t.Setenv("server__port", "58311")
+	t.Setenv("Server__Host", "127.0.0.1")
+	t.Setenv("codebuddy_session_id", "should-be-stripped")
+
+	for _, kv := range environ() {
+		name, _, _ := strings.Cut(kv, "=")
+		if envDenied(name) {
+			t.Errorf("被拒绝的变量仍出现在子 CLI 环境里: %s", kv)
+		}
+	}
+}
+
 func TestEnvDenied(t *testing.T) {
 	cases := map[string]bool{
 		"SERVER__PORT":                true,

package/internal/agent/repair_models_test.go

@@ -0,0 +1,194 @@
+package agent
+
+// repair_models_test.go - 事故还原（--repair-models 的落地逻辑，见 custom_models.go）。
+//
+// 场景来自 2026-09-30 Windows 事故：桌面端 models.json 是**数组**，被反向同步覆盖成
+// `{availableModels, models}` 对象后桌面端解析不了，模型清单整个为空。
+// 这里锁住三件事：
+//  1. 明确的坏形状 → 还原成数组，id 去掉 custom-local: 前缀，且先留 .broken.bak
+//  2. 已经是数组 → 一个字都不动
+//  3. 形状对不上（坏 JSON / 空对象 / models 里混着非 custom-local 条目）→ 一律不动
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// clobberedFixture 造一份「被我们覆盖写坏」的 models.json：顶层对象 + 全 custom-local 条目。
+func clobberedFixture() []byte {
+	return []byte(`{
+  "availableModels": [
+    "custom-local:MiniMax-M3",
+    "custom-local:glm-5.3"
+  ],
+  "models": [
+    {
+      "id": "custom-local:MiniMax-M3",
+      "name": "MiniMax-M3",
+      "vendor": "MiniMax",
+      "url": "https://api.minimaxi.com/v1/chat/completions",
+      "apiKey": "sk-user-own",
+      "supportsImages": false
+    },
+    {
+      "id": "custom-local:glm-5.3",
+      "name": "glm-5.3",
+      "vendor": "Zhipu",
+      "url": "https://open.bigmodel.cn/api/paas/v4",
+      "apiKey": "sk-user-own-2"
+    }
+  ]
+}
+`)
+}
+
+func TestRepairModelsFile_RestoresArrayFormat(t *testing.T) {
+	appHome := t.TempDir()
+	path := filepath.Join(appHome, customModelsFileName)
+	if err := os.WriteFile(path, clobberedFixture(), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	repaired, note, err := repairModelsFile(appHome)
+	if err != nil {
+		t.Fatalf("repair: %v", err)
+	}
+	if !repaired {
+		t.Fatalf("坏形状应被还原，note=%q", note)
+	}
+
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var arr []map[string]any
+	if err := json.Unmarshal(b, &arr); err != nil {
+		t.Fatalf("还原后应是数组: %v（内容 %s）", err, b)
+	}
+	if len(arr) != 2 {
+		t.Fatalf("条数 = %d, want 2", len(arr))
+	}
+	for _, m := range arr {
+		id, _ := m["id"].(string)
+		if id == "" || strings.HasPrefix(id, customModelIDPrefix) {
+			t.Errorf("id 必须去掉 %s 前缀，实际 %q", customModelIDPrefix, id)
+		}
+	}
+	if arr[0]["id"] != "MiniMax-M3" {
+		t.Errorf("首条 id = %v, want MiniMax-M3", arr[0]["id"])
+	}
+	// 端点与密钥必须原样保留（丢了就只能手抄）
+	if arr[0]["url"] != "https://api.minimaxi.com/v1/chat/completions" || arr[0]["apiKey"] != "sk-user-own" {
+		t.Errorf("端点/密钥没保留: %v", arr[0])
+	}
+
+	// 现场必须留备份，且备份是坏的那份原文
+	bak, err := os.ReadFile(path + ".broken.bak")
+	if err != nil {
+		t.Fatalf("应留 .broken.bak: %v", err)
+	}
+	if !bytes.Equal(bak, clobberedFixture()) {
+		t.Error(".broken.bak 应为被写坏的原文")
+	}
+}
+
+func TestRepairModelsFile_LeavesGoodShapesAlone(t *testing.T) {
+	// 桌面端原生数组格式
+	native := []byte("[\n  {\n    \"id\": \"MiniMax-M3\",\n    \"url\": \"https://x/v1\"\n  }\n]\n")
+
+	cases := []struct {
+		name    string
+		content []byte
+	}{
+		{"已是数组（桌面端原生格式）", native},
+		{"坏 JSON", []byte("{oops")},
+		{"空 JSON 对象", []byte("{}")},
+		{"顶层是字符串", []byte(`"nope"`)},
+		{"models 里混着非 custom-local 条目", []byte(`{"models":[{"id":"hy3","url":"https://x"}]}`)},
+		{"models 是空数组", []byte(`{"models":[],"availableModels":[]}`)},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			appHome := t.TempDir()
+			path := filepath.Join(appHome, customModelsFileName)
+			if err := os.WriteFile(path, tc.content, 0o600); err != nil {
+				t.Fatal(err)
+			}
+
+			repaired, _, err := repairModelsFile(appHome)
+			if err != nil {
+				t.Fatalf("形状对不上应静默不改，不该报错: %v", err)
+			}
+			if repaired {
+				t.Errorf("形状对不上不该动手")
+			}
+			after, rerr := os.ReadFile(path)
+			if rerr != nil {
+				t.Fatal(rerr)
+			}
+			if !bytes.Equal(after, tc.content) {
+				t.Errorf("原文件被改写了\nbefore=%s\nafter =%s", tc.content, after)
+			}
+			if _, serr := os.Stat(path + ".broken.bak"); !os.IsNotExist(serr) {
+				t.Errorf("没还原就不该留 .broken.bak")
+			}
+		})
+	}
+}
+
+func TestRepairModelsFile_MissingFileIsNoop(t *testing.T) {
+	appHome := t.TempDir()
+	repaired, note, err := repairModelsFile(appHome)
+	if err != nil {
+		t.Fatalf("没有文件不该报错: %v", err)
+	}
+	if repaired {
+		t.Error("没有文件时不谈还原")
+	}
+	if note == "" {
+		t.Error("应给出「不存在、无需修复」的说明，不静默")
+	}
+}
+
+// 幂等：还原过一次之后，再跑一次必须什么都不做（已经是数组）。
+func TestRepairModelsFile_Idempotent(t *testing.T) {
+	appHome := t.TempDir()
+	path := filepath.Join(appHome, customModelsFileName)
+	if err := os.WriteFile(path, clobberedFixture(), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if repaired, _, err := repairModelsFile(appHome); err != nil || !repaired {
+		t.Fatalf("首次应还原: repaired=%v err=%v", repaired, err)
+	}
+	first, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	repaired, _, err := repairModelsFile(appHome)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if repaired {
+		t.Error("第二次不该再动手")
+	}
+	second, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(first, second) {
+		t.Error("第二次不该改动文件")
+	}
+}
+
+// 引擎名到桌面端数据目录的映射：不认识的名字必须报错，而不是猜一个目录去写。
+func TestRepairDesktopModels_UnknownEngine(t *testing.T) {
+	if _, _, err := RepairDesktopModels("no-such-engine"); err == nil {
+		t.Fatal("没有桌面端目录的引擎应报错")
+	}
+}

package/internal/cli/ask.go

@@ -44,24 +44,27 @@ import (
 
 // askOptions 根命令的全部参数。
 type askOptions struct {
-	engine       string
-	model        string
-	system       string
-	prompt       string
-	file         string
-	attach       []string // 附件（截图/图片）路径；与提示词一起发给引擎
-	tools        string
-	timeout      time.Duration
-	retries      int
-	backoff      time.Duration
-	output       string
-	verbose      bool
-	engines      bool
-	contract     bool // 输出带版本的契约 envelope（--contract；客户端启动校验用）
-	noModels     bool
-	login        string // 拉起某引擎自己的交互式登录会话（--login <engine>）
-	events       bool   // --stream 的事件流带契约版本与行号（--events；客户端消费用）
-	control      bool   // 从 stdin 读 NDJSON 控制命令（--control；打断 / 收工 / 回审批）
+	engine   string
+	model    string
+	system   string
+	prompt   string
+	file     string
+	attach   []string // 附件（截图/图片）路径；与提示词一起发给引擎
+	tools    string
+	timeout  time.Duration
+	retries  int
+	backoff  time.Duration
+	output   string
+	verbose  bool
+	engines  bool
+	contract bool // 输出带版本的契约 envelope（--contract；客户端启动校验用）
+	noModels bool
+	login    string // 拉起某引擎自己的交互式登录会话（--login <engine>）
+	// repairModels 还原被反向同步写坏的桌面端 models.json（--repair-models <engine>）：
+	// 2026-09-30 Windows 事故的收尾手段，见 internal/agent/custom_models.go 的事故还原一节。
+	repairModels string
+	events       bool // --stream 的事件流带契约版本与行号（--events；客户端消费用）
+	control      bool // 从 stdin 读 NDJSON 控制命令（--control；打断 / 收工 / 回审批）
 	jsonOut      bool
 	stream       bool
 	noThinking   bool
@@ -145,6 +148,7 @@ func bindAskFlags(cmd *cobra.Command, opts *askOptions) {
 	f.BoolVar(&opts.contract, "contract", false, "输出桌面/移动客户端契约：{\"contractVersion\":N,\"engines\":[...]}（engines 与 --engines 同构，另含 capabilities 静态能力字段）。默认不探测模型（快）；要模型写 --no-models=false")
 	f.BoolVar(&opts.noModels, "no-models", false, "配合 --engines / --contract：跳过各引擎的模型探测（只列引擎与可用性，不启动 CLI）")
 	f.StringVar(&opts.login, "login", "", "拉起指定引擎自己的交互式登录会话（如 codebuddy / codebuddy-ai）：自动带上该引擎的账号环境，进去执行 /login 即可；登录态落在该引擎自己的票据上，两个账号互不顶号")
+	f.StringVar(&opts.repairModels, "repair-models", "", "还原被覆盖写坏的桌面端 models.json（如 codebuddy / codebuddy-ai）：把对象格式改回桌面端的数组格式，官方模型清单不动；只在形状确实是坏的时候才改，且先留 .broken.bak 备份")
 	f.BoolVar(&opts.jsonOut, "json", false, "兼容保留：--engines 已默认 JSON，本 flag 不再需要")
 	f.BoolVar(&opts.stream, "stream", false, "流式输出：正文/思考增量实时打到 stdout（text 模式思考走 stderr）")
 	f.BoolVar(&opts.events, "events", false, "配合 --stream：事件流带契约版本与行号（每行加 v / seq，并先发一行 ready），供客户端消费；老消费者不要开（形状与 --stream 不同）")

package/internal/cli/login.go

@@ -14,6 +14,7 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	"sync"
 
 	"github.com/darren/magic-agent/internal/agent"
 	"github.com/spf13/cobra"
@@ -40,7 +41,11 @@ func runLogin(cmd *cobra.Command, opts *askOptions) error {
 		return err
 	}
 
-	// stdio 直通：交互式界面必须拿到真的 TTY。
+	/* stdio 直通：交互式界面必须拿到真的 TTY。
+	   ⚠️ 这里**刻意不设进程组**（普通引擎调用走 configureProcAttr 自成一组）：
+	   交互式 TUI 必须在**前台进程组**里，否则它从 tty 读输入会被 SIGTTIN 停住 ——
+	   表现就是「一进登录界面就卡住」。代之以「登记子进程 + 退出前带走」的清理
+	   （见 loginChild / stopLoginChild），保证它不会变成占着账号的孤儿。 */
 	c := exec.Command(bin, args...)
 	c.Stdin, c.Stdout, c.Stderr = os.Stdin, os.Stdout, os.Stderr
 	c.Env = agent.ChildEnvWith(extraEnv)
@@ -49,20 +54,72 @@ func runLogin(cmd *cobra.Command, opts *askOptions) error {
 	}
 
 	// 提示走 stderr：stdout 留给子进程的交互界面，不被污染。
+	// 第三行是给「上一次登录没成功」的情形：残留的登录态得先清掉，否则会一直登不上。
 	fmt.Fprintf(cmd.ErrOrStderr(),
 		"magic-agent: 已按 %s 的账号环境启动 %s\n"+
-			"            在里面执行 /login 完成登录（退出后本命令结束）\n", eng.Name(), bin)
+			"            在里面执行 /login 完成登录（退出后本命令结束）\n"+
+			"            若上一次登录没成功、这次进去仍登不上：先执行 /logout 清掉残留登录态，再执行 /login\n",
+		eng.Name(), bin)
 
-	if runErr := c.Run(); runErr != nil {
+	if startErr := c.Start(); startErr != nil {
+		return fmt.Errorf("启动 %s 失败: %w", bin, startErr)
+	}
+	setLoginChild(c)
+	defer clearLoginChild()
+
+	if runErr := c.Wait(); runErr != nil {
 		var ee *exec.ExitError
 		if errors.As(runErr, &ee) {
 			return fmt.Errorf("%s 会话退出码 %d", eng.Name(), ee.ExitCode())
 		}
-		return fmt.Errorf("启动 %s 失败: %w", bin, runErr)
+		return fmt.Errorf("%s 会话异常: %w", eng.Name(), runErr)
 	}
 	return nil
 }
 
+/* ── 交互式登录子进程的清理登记 ──────────────────────────────
+ *
+ * 为什么单独记一笔：登录是**唯一**不走进程组管理的子进程（理由见上面 runLogin 的
+ * 注释 —— 交互式 TUI 必须留在前台组里）。因此它既不在会话登记表（--stop 管不到），
+ * 也不会被 installSignalStop 的「杀会话」路径带走。一旦 magic-agent 被 SIGTERM
+ * （桌面壳的「停止」按钮、`kill <pid>`）终止，这个 CLI 就成孤儿，继续占着该账号的
+ * 配置目录 / 端口，下一次 --login 起来会撞上残留状态 —— 用户看到的就是
+ * 「登录失败后再也登不上」。所以退出前必须补一刀。
+ */
+var (
+	loginMu    sync.Mutex
+	loginChild *exec.Cmd
+)
+
+// setLoginChild 登记正在跑的登录子进程。
+func setLoginChild(c *exec.Cmd) {
+	loginMu.Lock()
+	loginChild = c
+	loginMu.Unlock()
+}
+
+// clearLoginChild 注销（登录会话正常结束 / 启动失败时调用）。
+func clearLoginChild() {
+	setLoginChild(nil)
+}
+
+/* stopLoginChild 杀掉正在跑的登录子进程（若在），返回是否真的动了手。
+ *
+ * 用**单进程**信号（group=false）：它本来就与 magic-agent 同组，负 pid 会把
+ * magic-agent 自己一起杀掉。
+ */
+func stopLoginChild() bool {
+	loginMu.Lock()
+	c := loginChild
+	loginChild = nil
+	loginMu.Unlock()
+	if c == nil || c.Process == nil {
+		return false
+	}
+	_ = agent.KillPID(c.Process.Pid, false)
+	return true
+}
+
 // loginCapableEngines 列出实现了 LoginRunner 的引擎名（报错提示用）。
 func loginCapableEngines() string {
 	var names []string

package/internal/cli/login_test.go

@@ -0,0 +1,99 @@
+package cli
+
+// login_test.go - `--login` 的参数校验与「退出前带走登录子进程」的清理契约。
+//
+// 这两件事都是「登录失败后再也登不上」那个用户问题的直接成因：
+//   - 参数写错时给一句看得懂的中文（而不是 cobra 的英文裸报错，且退出码要对）；
+//   - 登录 TUI 必须留在前台进程组里（否则读 tty 被 SIGTTIN 停住），代价是
+//     magic-agent 被 SIGTERM / 关终端时必须主动把它带走，不能留成占着账号的孤儿。
+
+import (
+	"errors"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// `--login` 后面没跟引擎名：必须给出中文 usage（点名可用引擎），且算参数错（exit 2）。
+// cobra 在解析阶段就报错（走不到 runLogin），所以这条靠 SetFlagErrorFunc 兜住。
+func TestLoginWithoutEngineNameIsUsageError(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--login")
+	if err == nil {
+		t.Fatal("--login 缺引擎名应报错")
+	}
+	msg := err.Error()
+	if !strings.Contains(msg, "需要引擎名") {
+		t.Errorf("应是中文用法提示，实际 %q", msg)
+	}
+	/* ⚠️ 不断言「提示里点名了 codebuddy」：包内用例会在 Engines() 首次调用前
+	   agent.Register 假引擎，触发 registry 的已知脆弱点（内置引擎整体不注册，
+	   见 agent/engine.go 的守卫注释），那时可用引擎列表本来就是空的。
+	   这里只锚定稳定契约：中文提示 + usage（exit 2）。 */
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}
+
+// 未知引擎名：usage 错误 + 列出可用引擎，不静默启一个空 bin。
+func TestLoginUnknownEngine(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--login", "no-such-engine")
+	if err == nil {
+		t.Fatal("未知引擎应报错")
+	}
+	if !strings.Contains(err.Error(), "未知引擎") {
+		t.Errorf("错误应点名未知引擎，实际 %q", err.Error())
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}
+
+// 不支持交互式登录的引擎：明确说不必用 --login，而不是硬造一条命令。
+func TestLoginEngineWithoutLoginRunner(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--login", "claude")
+	if err == nil {
+		t.Fatal("claude 不支持 --login，应报错")
+	}
+	if !strings.Contains(err.Error(), "不需要 --login") {
+		t.Errorf("错误应说明该引擎不需要 --login，实际 %q", err.Error())
+	}
+}
+
+// 登录子进程必须能被 stopLoginChild 收掉（进程真死）。
+// 为什么值得测：登录是唯一不进进程组的子进程，孤儿化正是「登录失败后再也登不上」的成因。
+//
+// 判据用 c.Wait()（真回收）而不是 PIDAlive —— 被 SIGKILL 的子进程在没人 Wait 之前
+// 是僵尸，仍然会被 kill(pid, 0) 判成「活着」，拿它当判据会假红。
+func TestStopLoginChildKillsProcess(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("用 sleep 当靶子，Windows 另论")
+	}
+	c := exec.Command("sleep", "60")
+	if err := c.Start(); err != nil {
+		t.Fatalf("起靶子进程失败: %v", err)
+	}
+	setLoginChild(c)
+
+	if !stopLoginChild() {
+		t.Fatal("stopLoginChild 应报告动了手")
+	}
+
+	done := make(chan error, 1)
+	go func() { done <- c.Wait() }()
+	select {
+	case werr := <-done:
+		var ee *exec.ExitError
+		if !errors.As(werr, &ee) {
+			t.Fatalf("靶子应被信号杀掉，实际 err=%v", werr)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("登录子进程未被收掉（5s 内没退出）")
+	}
+
+	// 已经清空：再调一次不应再动手（幂等，避免误杀复用的 pid）。
+	if stopLoginChild() {
+		t.Error("注销后再调 stopLoginChild 不应再动手")
+	}
+}

package/internal/cli/repair.go

@@ -0,0 +1,60 @@
+package cli
+
+// repair.go - `--repair-models <engine>`：还原被反向同步写坏的桌面端 models.json。
+//
+// 为什么要有它：2026-09-30 的 Windows 事故里，magic-agent 把桌面端（WorkBuddy）那份
+// **数组格式**的 models.json 覆盖成了 `{availableModels, models}` 对象格式，桌面端
+// 解析不了 → 模型清单整个为空。同步那一侧已经加了「陌生形状一律不动」的硬约束，
+// 但**已经坏掉的现场**需要一条能自己走回来的路 —— 否则用户只能手抄 apiKey。
+//
+// 还原逻辑在 agent.RepairDesktopModels（见 custom_models.go 的事故还原一节）：
+// 只认明确的坏形状才动手，动手前先留 .broken.bak。
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/darren/magic-agent/internal/agent"
+	"github.com/spf13/cobra"
+)
+
+// runRepairModels 处理 `--repair-models <engine>`。
+func runRepairModels(cmd *cobra.Command, opts *askOptions) error {
+	name := strings.TrimSpace(opts.repairModels)
+	if name == "" {
+		return &usageError{fmt.Errorf(
+			"--repair-models 需要引擎名：magic-agent --repair-models <engine>（可用：%s）",
+			strings.Join(agent.DesktopEngines(), " / "))}
+	}
+
+	// 引擎名先在这里校验：这是**参数错**（exit 2），而不是运行期失败（exit 1）。
+	// agent 层还会再兜一次，但那属于「不该发生」的安全网。
+	if agent.DesktopAppHomeOf(name) == "" {
+		return &usageError{fmt.Errorf("引擎 %q 没有对应的桌面端数据目录，没有可修的 models.json（可用：%s）",
+			name, strings.Join(agent.DesktopEngines(), " / "))}
+	}
+
+	repaired, note, err := agent.RepairDesktopModels(name)
+	if err != nil {
+		return err
+	}
+
+	// 机器可读的一行结果走 stdout（与 --sessions / --stop 同一族）；人看的说明走 stderr。
+	if eerr := json.NewEncoder(cmd.OutOrStdout()).Encode(map[string]any{
+		"engine":   name,
+		"repaired": repaired,
+		"note":     note,
+	}); eerr != nil {
+		return eerr
+	}
+	out := cmd.ErrOrStderr()
+	fmt.Fprintf(out, "magic-agent: %s\n", note)
+	if !repaired {
+		// 没改动不是失败，但必须说清「没动」，不静默（本项目铁律）。
+		fmt.Fprintf(out, "magic-agent: 未改动任何文件。形状对不上就不动，避免二次破坏。\n")
+		return nil
+	}
+	fmt.Fprintf(out, "magic-agent: 已还原。请重开桌面端确认模型清单；官方模型由桌面端自己拉取，不在这个文件里。\n")
+	return nil
+}

package/internal/cli/repair_test.go

@@ -0,0 +1,51 @@
+package cli
+
+// repair_test.go - `--repair-models` 的参数校验。
+//
+// 落地逻辑（形状识别 / 还原 / 备份 / 幂等）在 internal/agent/repair_models_test.go，
+// 这里只锁 CLI 层的契约：引擎名缺失或不支持桌面端时是**参数错**（exit 2），
+// 而不是被当成 prompt 发给引擎。
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestRepairModelsWithoutEngineNameIsUsageError(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--repair-models")
+	if err == nil {
+		t.Fatal("--repair-models 缺引擎名应报错")
+	}
+	if !strings.Contains(err.Error(), "需要引擎名") {
+		t.Errorf("应是中文用法提示，实际 %q", err.Error())
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}
+
+// 显式给空串同样走校验（与 --login 同一取舍：用「传过没有」而不是「值非空」判断）。
+func TestRepairModelsEmptyEngineIsUsageError(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--repair-models", "")
+	if err == nil {
+		t.Fatal("空引擎名应报错")
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}
+
+// 没有桌面端数据目录的引擎：参数错，并点名可用值。
+func TestRepairModelsUnsupportedEngine(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--repair-models", "claude")
+	if err == nil {
+		t.Fatal("claude 没有桌面端 models.json，应报错")
+	}
+	msg := err.Error()
+	if !strings.Contains(msg, "没有对应的桌面端数据目录") {
+		t.Errorf("错误应说明该引擎没有桌面端目录，实际 %q", msg)
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}

package/internal/cli/root.go

@@ -129,6 +129,7 @@ func NewRootCommand() *cobra.Command {
   magic-agent --engines                           # 列出引擎、可用性与各引擎支持的模型（JSON 数组）
   magic-agent --engines --no-models               # 只列引擎与可用性（跳过模型探测，不启动 CLI）
   magic-agent --engines --json                    # 等价（--json 为兼容保留）
+  magic-agent --repair-models codebuddy           # 还原被覆盖写坏的桌面端 models.json（事故收尾，先留 .broken.bak）
 
 四档权限模型（--permission，仅 claude / codebuddy / codebuddy-ai 生效）：
   把「哪些动作自动放行 + 放行不了时由谁裁决」收敛成四档，映射到 Claude Code 的参数：
@@ -399,6 +400,9 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 			case flagChanged(cmd, "login"):
 				// 用「传过没有」而不是「值非空」判断：`--login ""` 也要走参数校验（提示要引擎名）
 				return runLogin(cmd, opts)
+			case flagChanged(cmd, "repair-models"):
+				// 同上：`--repair-models ""` 要走参数校验，而不是掉进「提问」分支报 empty prompt。
+				return runRepairModels(cmd, opts)
 			case opts.listSessions:
 				return runSessions(cmd, opts)
 			case flagChanged(cmd, "session-log"):
@@ -426,6 +430,23 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 		},
 	}
 	bindAskFlags(root, opts)
+	/* `--login` / `--repair-models` 忘带引擎名时，cobra 在解析阶段就报错，**走不到**
+	   runLogin / runRepairModels 的校验分支，默认文案是英文的
+	   "flag needs an argument: ..."（且退出码 1）。这里翻成与传空串一致的中文
+	   usage（exit 2），免得用户只看到一句看不懂的报错。 */
+	root.SetFlagErrorFunc(func(_ *cobra.Command, err error) error {
+		if err == nil || !strings.Contains(err.Error(), "flag needs an argument") {
+			return err
+		}
+		switch {
+		case strings.Contains(err.Error(), "login"):
+			return &usageError{fmt.Errorf("--login 需要引擎名：magic-agent --login <engine>（可用：%s）", loginCapableEngines())}
+		case strings.Contains(err.Error(), "repair-models"):
+			return &usageError{fmt.Errorf("--repair-models 需要引擎名：magic-agent --repair-models <engine>（可用：%s）",
+				strings.Join(agent.DesktopEngines(), " / "))}
+		}
+		return err
+	})
 	// 无子命令设计：禁用 cobra 自动注入的 completion 命令，
 	// 保证 "magic-agent completion" 也只是被当作 prompt 而非隐藏子命令。
 	root.CompletionOptions.DisableDefaultCmd = true

package/internal/cli/session.go

@@ -72,11 +72,18 @@ func stopActiveSession() {
 // 为什么必须做：引擎 CLI 在**独立进程组**里（Setpgid），调用方对 magic-agent
 // 发 SIGTERM / kill(-magic-agent-pid) 时，引擎子进程不在那一组里 → 会变成孤儿继续跑
 // （观物台「停止」按钮踩的就是这个）。这里在退出前补一刀。
+//
+// 覆盖三处孤儿来源：
+//   - 当前活动会话（stopActiveSession）；
+//   - 交互式登录子进程（stopLoginChild）—— 它必须待在前台组里读 tty，因而
+//     比普通引擎更「自己管不了」，只能在这里记一笔带走（见 login.go）；
+//   - 关终端（SIGHUP）：与 SIGTERM 同路。
 func installSignalStop() {
 	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
+	signal.Notify(ch, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
 	go func() {
 		<-ch
+		stopLoginChild()
 		stopActiveSession()
 		os.Exit(exitInterrupted)
 	}()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magic-agent",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "专业的 agent CLI 代理工具 - 统一 claude / codebuddy / trae / llm / codex / openclaw 引擎",
   "license": "MIT",
   "bin": {