magic-agent 2.6.0 → 2.6.3

package/internal/client/workspace_default_test.go

@@ -0,0 +1,158 @@
+package client
+
+// workspace_default_test.go - 默认工作区不能退化成文件系统根（2026-10-26 实测事故）。
+//
+// 事故现场：插件被 `cd /` 起来 → /desk/health 的 defaultWorkspace 报 `/` →
+// 移动端新建会话的工作区就是根目录。后果不只是「文件写在 /」：
+//   · 作业文件写 "workspace": "/"，而 core 自己登记的是真实 cwd，两边对不上；
+//   · mode=auto 的同空间冲突判定、core 的工作空间锁都按这个 key 算 ——
+//     `/` 变成「全机所有会话同一个空间」的万能桶，串行/并行全判错。
+//
+// 所以这里钉住三件事：根目录不当默认、有 cwd 就用 cwd、cwd 是根时退回上次用过的工作区。
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// writePrefs 往 prefs 文件写一份配置（只写关心的字段）。
+func writePrefs(t *testing.T, v map[string]any) string {
+	t.Helper()
+	p := mobilePrefsPath()
+	if p == "" {
+		t.Fatal("mobilePrefsPath() 为空")
+	}
+	if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	b, err := json.Marshal(v)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(p, b, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	return p
+}
+
+// withTempHome 把 HOME 指向临时目录（prefs 落在 $HOME/.magic-agent 下）。
+func withTempHome(t *testing.T) string {
+	t.Helper()
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	return home
+}
+
+// TestIsRootDir 根目录的唯一判据：自己和自己的父目录相同。
+func TestIsRootDir(t *testing.T) {
+	cases := []struct {
+		path string
+		want bool
+	}{
+		{"/", true},
+		{"/tmp", false},
+		{"/Users/x/project", false},
+		{"", false},
+	}
+	for _, c := range cases {
+		if got := isRootDir(c.path); got != c.want {
+			t.Errorf("isRootDir(%q) = %v, want %v", c.path, got, c.want)
+		}
+	}
+}
+
+// TestDefaultWorkspaceUsesCwd cwd 有意义时就用它，不去翻 prefs。
+func TestDefaultWorkspaceUsesCwd(t *testing.T) {
+	withTempHome(t)
+	proj := t.TempDir()
+	if err := os.Chdir(proj); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = os.Chdir("/Users") })
+
+	// prefs 里放一个别的目录，确认 cwd 优先。
+	if err := os.WriteFile(mobilePrefsPath(), []byte(`{"lastWorkspace":"/tmp"}`), 0o600); err != nil {
+		// 目录可能不存在，先建
+		_ = os.MkdirAll(filepath.Dir(mobilePrefsPath()), 0o700)
+		_ = os.WriteFile(mobilePrefsPath(), []byte(`{"lastWorkspace":"/tmp"}`), 0o600)
+	}
+
+	// 注意：真实路径可能带 /private 前缀（macOS 的 /tmp 是软链），所以比较 EvalSymlinks。
+	want, _ := filepath.EvalSymlinks(proj)
+	got, _ := filepath.EvalSymlinks(defaultWorkspace())
+	if got != want {
+		t.Errorf("defaultWorkspace() = %q, want cwd %q", got, want)
+	}
+}
+
+// TestDefaultWorkspaceFallsBackWhenCwdIsRoot cwd 是 `/` 时退回上次用过的工作区。
+//
+// 这条是本次事故的直接回归测试。
+func TestDefaultWorkspaceFallsBackWhenCwdIsRoot(t *testing.T) {
+	withTempHome(t)
+	last := t.TempDir()
+	writePrefs(t, map[string]any{"lastWorkspace": last})
+
+	if err := os.Chdir("/"); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = os.Chdir("/Users") })
+
+	want, _ := filepath.EvalSymlinks(last)
+	got, _ := filepath.EvalSymlinks(defaultWorkspace())
+	if got != want {
+		t.Errorf("cwd 为 / 时 defaultWorkspace() = %q, want 上次工作区 %q", got, want)
+	}
+	if isRootDir(got) {
+		t.Errorf("默认工作区仍然退化成了根目录 %q", got)
+	}
+}
+
+// TestDefaultWorkspaceIgnoresBadPrefs prefs 里的值不可用时不能当默认。
+//
+// 三种坏值：不是绝对路径、目录已不存在、字段缺失。任一条被当成默认工作区，
+// 都会让会话归到一个不该归的地方（相对路径还会按插件 cwd 解释，等于又回到根目录）。
+func TestDefaultWorkspaceIgnoresBadPrefs(t *testing.T) {
+	withTempHome(t)
+	if err := os.Chdir("/"); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = os.Chdir("/Users") })
+
+	bad := []struct {
+		name string
+		v    map[string]any
+	}{
+		{"相对路径", map[string]any{"lastWorkspace": "relative/dir"}},
+		{"目录不存在", map[string]any{"lastWorkspace": "/definitely/not/here/xyz"}},
+		{"字段缺失", map[string]any{"engine": "dsh"}},
+		{"空串", map[string]any{"lastWorkspace": ""}},
+	}
+	for _, c := range bad {
+		t.Run(c.name, func(t *testing.T) {
+			writePrefs(t, c.v)
+			got := defaultWorkspace()
+			// 没有可用兜底时只能回到 cwd（/），但绝不能是 prefs 里的坏值。
+			if c.v["lastWorkspace"] != "" && c.v["lastWorkspace"] != nil {
+				if got == c.v["lastWorkspace"] {
+					t.Errorf("采纳了不可用的 lastWorkspace %v", c.v["lastWorkspace"])
+				}
+			}
+			if got != "/" && !filepath.IsAbs(got) {
+				t.Errorf("返回值不是绝对路径：%q", got)
+			}
+		})
+	}
+}
+
+// TestLastWorkspacePrefRejectsMissingDir 已删除的目录不算「上次用过的工作区」。
+func TestLastWorkspacePrefRejectsMissingDir(t *testing.T) {
+	withTempHome(t)
+	gone := filepath.Join(t.TempDir(), "deleted")
+	writePrefs(t, map[string]any{"lastWorkspace": gone})
+	if got := lastWorkspacePref(); got != "" {
+		t.Errorf("目录已不存在却仍返回 %q", got)
+	}
+}

package/internal/client/workspacelockenv_test.go

@@ -0,0 +1,54 @@
+package client
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/darren/magic-agent/internal/session"
+)
+
+/*
+工作空间锁开关的下发口径（2026-10-26）。
+
+	为什么单独立一个文件、而不塞进 startAsk 的用例里：这条判据翻转的代价极隐蔽。
+	core 的锁从「选入式」改成「默认生效」之后，**不传变量**的含义从「不排」变成了
+	「排」。于是原先「串行才传 =1」的写法会在无人察觉时把并行模式串起来 ——
+	界面上的表现是「切了并行，任务还是一个一个跑」，没人会先怀疑环境变量。
+
+	锁的两端（core / 插件）分属两个包，任何一端单独改都会被另一端静默抵消，
+	所以这条不变量必须在这里被钉死。
+*/
+func TestWorkspaceLockEnvForSerial(t *testing.T) {
+	got := workspaceLockEnv(nil)
+	if len(got) != 0 {
+		t.Fatalf("serial 未指定应按串行处理、什么都不传，实际 %v", got)
+	}
+}
+
+func TestWorkspaceLockEnvSerialLeavesDefault(t *testing.T) {
+	serial := true
+	got := workspaceLockEnv(&serial)
+	/* 不写 `=1` 是刻意的：core 的默认值就是开，显式写一遍只是多一个会和
+	   workspaceLockEnabled 的解析口径分叉的地方。 */
+	if len(got) != 0 {
+		t.Fatalf("串行作业不该追加任何变量（core 默认即开），实际 %v", got)
+	}
+}
+
+func TestWorkspaceLockEnvParallelDisables(t *testing.T) {
+	serial := false
+	got := workspaceLockEnv(&serial)
+	if len(got) != 1 {
+		t.Fatalf("并行作业必须且只能追加一条变量，实际 %v", got)
+	}
+	want := session.EnvWorkspaceLock + "=0"
+	if got[0] != want {
+		t.Fatalf("并行作业应下发 %q，实际 %q", want, got[0])
+	}
+	/* 值必须是 core 认的「关」：workspaceLockEnabled 只把 "0"/"false"/"off"/"no"
+	   当关闭。写成 "false" 也行，但拼错成 "no " / "OFF " 之类就静默失效了 ——
+	   这里断言到字面量，改 core 的解析口径时会立刻被这条测试拽住。 */
+	if !strings.HasSuffix(got[0], "=0") {
+		t.Fatalf("关闭值必须是 core 认得的写法，实际 %q", got[0])
+	}
+}

package/internal/config/config.go

@@ -71,6 +71,12 @@ const (
 	EnvCBGWPassword = "MAGIC_AGENT_CBGW_PASSWORD"
 )
 
+// feishu 一节支持的环境变量覆盖名（魔法值与其他节一致，都是 MAGIC_AGENT_ 前缀）。
+const (
+	EnvFeishuAppID     = "MAGIC_AGENT_FEISHU_APP_ID"
+	EnvFeishuAppSecret = "MAGIC_AGENT_FEISHU_APP_SECRET"
+)
+
 // EnvSystemPrompt 默认系统提示词的环境变量覆盖名。
 const EnvSystemPrompt = "MAGIC_AGENT_SYSTEM_PROMPT"
 
@@ -98,6 +104,40 @@ type Config struct {
 	 * ⚠️ 与 `arkclaw` 节的分工：`arkclaw` 是**历史保留的单实例**（老配置照旧生效，
 	 * 行为一个字不改）；`agents` 是新增的**多实例**通道。两者互不影响。 */
 	Agents []AgentConfig `json:"agents"`
+
+	/* Feishu 飞书推送（2026-10-26）的自建应用凭据：magic-client 用它把「任务完成 /
+	 * 待确认」推到用户本人的飞书。只有 magic-client 读它，core 引擎不用；
+	 * 移动端「我的 → 通知 → 飞书」也可以直接录（落 ~/.magic-agent/feishu-notify.json，0600），
+	 * 那边优先级更高。环境变量 MAGIC_AGENT_FEISHU_APP_ID / _APP_SECRET 也认（见 EnvFeishu*）。 */
+	Feishu FeishuConfig `json:"feishu"`
+}
+
+/* FeishuConfig 飞书自建应用（机器人）凭据。
+ *
+ *	{ "feishu": { "app_id": "cli_xxxx", "app_secret": "xxxx" } }
+ *
+ * 别名：app_id | appId | appId ；app_secret | appSecret | secret。 */
+type FeishuConfig struct {
+	AppID     string `json:"app_id"`
+	AppSecret string `json:"app_secret"`
+}
+
+// UnmarshalJSON 宽松解析：三个 app id 键名、三个 secret 键名任选其一。
+func (f *FeishuConfig) UnmarshalJSON(b []byte) error {
+	var raw struct {
+		AppID     string `json:"app_id"`
+		AppIDAlt  string `json:"appId"`
+		AppIDAlt2 string `json:"appid"`
+		Secret    string `json:"app_secret"`
+		SecretAlt string `json:"appSecret"`
+		SecretA3  string `json:"secret"`
+	}
+	if err := json.Unmarshal(b, &raw); err != nil {
+		return err
+	}
+	f.AppID = firstNonEmpty(raw.AppID, raw.AppIDAlt, raw.AppIDAlt2)
+	f.AppSecret = firstNonEmpty(raw.Secret, raw.SecretAlt, raw.SecretA3)
+	return nil
 }
 
 // UnmarshalJSON 宽松解析顶层键：systemPrompt / system_prompt / system 任选其一。
@@ -112,10 +152,12 @@ func (c *Config) UnmarshalJSON(b []byte) error {
 		SystemPromptAlt  string          `json:"system_prompt"`
 		SystemPromptAlt2 string          `json:"system"`
 		Agents           []AgentConfig   `json:"agents"`
+		Feishu           FeishuConfig    `json:"feishu"`
 	}
 	if err := json.Unmarshal(b, &raw); err != nil {
 		return err
 	}
+	c.Feishu = raw.Feishu
 	c.ArkClaw = raw.ArkClaw
 	// 四个键名任选其一（同一语义的多种写法；都写时按上面的优先级取第一个非空节）。
 	c.CodeBuddyGateway = firstNonEmptySection(raw.CBGW, raw.CBGWAlt, raw.CBGWAlt2, raw.CBGWAlt3)
@@ -407,6 +449,12 @@ func applyEnv(c Config) Config {
 	if v := strings.TrimSpace(os.Getenv(EnvCBGWPassword)); v != "" {
 		c.CodeBuddyGateway.Password = v
 	}
+	if v := strings.TrimSpace(os.Getenv(EnvFeishuAppID)); v != "" {
+		c.Feishu.AppID = v
+	}
+	if v := strings.TrimSpace(os.Getenv(EnvFeishuAppSecret)); v != "" {
+		c.Feishu.AppSecret = v
+	}
 	return c
 }
 

package/internal/judge/judge.go

@@ -0,0 +1,315 @@
+// Package judge - 判断「本轮任务」与「同一工作空间里正在跑的任务」会不会互相破坏。
+//
+// 为什么需要它（2026-10-26 用户：「任务模式增加自动 在新会话的时候判断是否可能与其他
+// 运行中会话冲突 如果冲突走串行 否则默认走并行」）：锁与进程信号只能回答「有没有人在跑」，
+// 回答不了「在跑什么」—— 同一空间里一个会话在改底部栏、另一个在写这个功能的文档，
+// 两者并行完全安全；而两个都要改 client-ui-mobile/index.html 就必须排队。
+// 这个判断是**语义**的，只能由模型来做（结构化的文件交集在插件侧先用规则筛一遍）。
+//
+// ── 为什么放在 core 而不是各客户端 ──
+// 提示词、输出解析、引擎调用只有一份；客户端（magic-client 的作业队列）exec 这一条即可。
+// 与 `--suggest-followups` / `--summarize-title` 同一套旁路范式：独立进程、ToolsOff、
+// 不带 SessionID，不续接也不污染用户正在聊的上下文，不写会话登记 / 日志。
+//
+// ── 三条纪律 ──
+//  1. **必须快**：调用方只给 2.5s 预算（判定挡在任务开跑前）。所以不思考、不跑工具、
+//     输出限 200 token；超了一律由调用方按「默认并行」放行，绝不拖住用户。
+//  2. **只说结论**：conflict 布尔 + 一句中文理由（必须落到具体文件/功能点，便于界面
+//     解释「为什么排队」）。理由不许编造输入里没有的东西。
+//  3. **判不出来不算冲突**：模型失败/超时返回 error，调用方走 undecided → 并行。
+package judge
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+// 默认参数。判定是「开跑前的闸门」，宁可放行也不能让用户干等。
+const (
+	// DefaultEngine 默认 llm：纯文本、无工具、启动最快（CLI 系引擎单是启动就要 2-4s，
+	// 塞不进判定预算）。
+	DefaultEngine = "llm"
+	// DefaultTimeout core 侧兜底；插件侧给 2.5s，到点直接放弃（按并行放行）。
+	/* DefaultTimeout 内层上限（core 自己的判定预算）。外层（magic-client 的异步判定）
+	   给 4.5s，这里留 1s 给「起进程 + 收尾」，别让两层同时到点。 */
+	DefaultTimeout = 3500 * time.Millisecond
+	// MaxPromptRunes 本轮提示词上限（判定只需要「要动什么」，不需要全文）。
+	MaxPromptRunes = 2000
+	// MaxCandidates 最多同时比较几个运行中会话：多了提示词放不下，也判不准。
+	MaxCandidates = 6
+	// MaxFilesPerCandidate 每个候选最多带多少条已改文件（按最近优先）。
+	MaxFilesPerCandidate = 60
+	// MaxRecentRunes 候选「近况」上限。
+	MaxRecentRunes = 800
+	// MaxReasonRunes 理由上限（界面一行放得下）。
+	MaxReasonRunes = 120
+	// maxTokens 只够输出一个短 JSON。
+	maxTokens = 200
+)
+
+// Candidate 一个「正在运行、可能冲突」的会话。
+type Candidate struct {
+	// ID 会话 id（session_id 优先，没有则 run_id）：只用于回传给调用方做归属判断。
+	ID string `json:"id"`
+	// Title 会话标题（core 归纳过的那份，没有就是首问）。
+	Title string `json:"title,omitempty"`
+	// Recent 近况：最近几条用户诉求或助手动作的要点，由调用方从会话日志抽取。
+	Recent string `json:"recent,omitempty"`
+	// Files 这个会话**已经改动过**的文件（日志里 tool_kind=file_change 的参数路径）。
+	// 这是最硬的冲突证据：两边文件集合有交集时，调用方可以跳过模型直接判冲突。
+	Files []string `json:"files,omitempty"`
+}
+
+// RequestBody `--judge-conflict` 的 stdin/文件形状。
+type RequestBody struct {
+	Prompt     string      `json:"prompt"`
+	Candidates []Candidate `json:"candidates"`
+	// Engine / Model 用哪个引擎判（空 = DefaultEngine）。由调用方传用户配的「建议引擎」。
+	Engine string `json:"engine,omitempty"`
+	Model  string `json:"model,omitempty"`
+}
+
+// Request 一次判定的输入（引擎与超时由 CLI 层填）。
+type Request struct {
+	Prompt     string
+	Candidates []Candidate
+	Engine     string
+	Model      string
+	Timeout    time.Duration
+}
+
+// Result 判定结论（也是 `--judge-conflict` 的 stdout 形状）。
+type Result struct {
+	// Conflict 是否冲突。true = 调用方应把本轮改为串行等待。
+	Conflict bool `json:"conflict"`
+	// Level hard | soft | none：severity 只用于文案（hard=文件/功能直接重叠，
+	// soft=相关但不确定，none=不相干）。**是否排队只看 Conflict**，两者不一致时以 Conflict 为准。
+	Level string `json:"level"`
+	// Reason 一句中文理由，必须提到具体文件或功能点（界面直接显示这句）。
+	Reason string `json:"reason"`
+	// Overlaps 冲突点（文件名 / 功能名），界面据此高亮。
+	Overlaps []string `json:"overlaps,omitempty"`
+	// Engine / Model 实际判定的引擎与模型（排查「为什么每次都 undecided」用）。
+	Engine string `json:"engine"`
+	Model  string `json:"model,omitempty"`
+	// ElapsedMS 这次判定花了多久。
+	ElapsedMS int64 `json:"elapsedMs"`
+	// By 判定依据：model = 模型给的结论；rule = 调用方用文件交集直接定的（judge 包不产出）；
+	// undecided = 没判出来（调用方补的）。这里恒为 "model"。
+	By string `json:"by"`
+}
+
+// Prompt 拼判定提示词。刻意短：每个候选只给「标题 + 近况 + 文件」，不给整段历史。
+func Prompt(prompt string, cands []Candidate) string {
+	var b strings.Builder
+	b.WriteString("判断「本轮任务」与「正在运行的任务」并行时会不会互相破坏。\n")
+	b.WriteString("冲突 = 动同一批文件 / 同一功能点 / 同一份产物（同一个页面、同一个接口、同一份配置、同一篇文章）。\n")
+	b.WriteString("不冲突 = 同仓库里改彼此独立的模块；一边改代码一边写该代码的文档；跑构建与改另一个模块。\n\n")
+	b.WriteString("本轮任务：\n")
+	b.WriteString(clipRunes(strings.TrimSpace(prompt), MaxPromptRunes))
+	b.WriteString("\n\n正在运行：\n")
+	for i, c := range cands {
+		if i >= MaxCandidates {
+			break
+		}
+		b.WriteString("- ")
+		if t := strings.TrimSpace(c.Title); t != "" {
+			b.WriteString(clipRunes(t, 80))
+		} else {
+			b.WriteString("(未命名会话)")
+		}
+		if r := strings.TrimSpace(c.Recent); r != "" {
+			b.WriteString("｜近况：")
+			b.WriteString(clipRunes(r, MaxRecentRunes))
+		}
+		if len(c.Files) > 0 {
+			b.WriteString("｜已改：")
+			b.WriteString(strings.Join(tailStrings(c.Files, MaxFilesPerCandidate), ", "))
+		}
+		b.WriteString("\n")
+	}
+	b.WriteString("\n只输出 JSON：{\"conflict\":true|false,\"level\":\"hard|soft|none\",\"reason\":\"中文一句话\",\"overlaps\":[\"…\"]}\n")
+	b.WriteString("reason 必须点出具体的文件或功能点（例如「都要改 index.html 的底部栏」），不许笼统；")
+	b.WriteString("不冲突就写「互不相干」并说明各自动的模块；不许编造输入里没有的文件或功能。")
+	return b.String()
+}
+
+// Schema 结构化输出（llm / dsh / arkclaw 等支持 --json-schema 的引擎走它）。
+func Schema() *agent.JSONSchema {
+	return &agent.JSONSchema{
+		Type: "object",
+		Properties: map[string]map[string]any{
+			"conflict": {"type": "boolean"},
+			"level":    {"type": "string", "enum": []string{"hard", "soft", "none"}},
+			"reason":   {"type": "string"},
+			"overlaps": {"type": "array", "items": map[string]any{"type": "string"}},
+		},
+		Required: []string{"conflict", "level", "reason"},
+	}
+}
+
+// Judge 跑一次判定。调用方给的预算到了就返回 error（由调用方按并行放行）。
+func Judge(ctx context.Context, in Request) (Result, error) {
+	prompt := strings.TrimSpace(in.Prompt)
+	if prompt == "" {
+		return Result{}, fmt.Errorf("冲突判定：缺少本轮提示词")
+	}
+	cands := make([]Candidate, 0, len(in.Candidates))
+	for _, c := range in.Candidates {
+		if strings.TrimSpace(c.Title) == "" && strings.TrimSpace(c.Recent) == "" && len(c.Files) == 0 {
+			continue // 三条信息全空：这个候选帮不上任何忙，别占提示词
+		}
+		cands = append(cands, c)
+		if len(cands) >= MaxCandidates {
+			break
+		}
+	}
+	if len(cands) == 0 {
+		// 没有可比对象 = 不可能冲突。这不是错误，直接给结论，省一次模型调用。
+		return Result{Conflict: false, Level: "none", Reason: "没有正在运行的同空间任务", By: "rule"}, nil
+	}
+
+	name := strings.TrimSpace(in.Engine)
+	if name == "" {
+		name = DefaultEngine
+	}
+	if agent.Lookup(name) == nil {
+		return Result{}, fmt.Errorf("冲突判定：未知引擎 %q", name)
+	}
+	timeout := in.Timeout
+	if timeout <= 0 {
+		timeout = DefaultTimeout
+	}
+	cctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	start := time.Now()
+
+	msg := Prompt(prompt, cands)
+	res, err := runOnce(cctx, name, strings.TrimSpace(in.Model), msg, timeout, start)
+	if err == nil {
+		return res, nil
+	}
+	/* 主引擎失败：预算还够就落一次 llm（1-2s，判定用的小模型足够）。
+	   不再试用户配的「建议备用引擎」—— 那是给生成建议用的，判定多一跳只会把 2.5s 吃光。 */
+	if name == DefaultEngine || cctx.Err() != nil {
+		return Result{}, err
+	}
+	remain := timeout - time.Since(start)
+	if remain < 800*time.Millisecond {
+		return Result{}, err
+	}
+	return runOnce(cctx, DefaultEngine, "", msg, remain, start)
+}
+
+// runOnce 用指定引擎跑一次，并解析成 Result。
+func runOnce(ctx context.Context, name, model, msg string, budget time.Duration, start time.Time) (Result, error) {
+	engine := agent.Lookup(name)
+	if engine == nil {
+		return Result{}, fmt.Errorf("冲突判定：未知引擎 %q", name)
+	}
+	attemptCtx, cancel := context.WithTimeout(ctx, budget)
+	defer cancel()
+	runner := &agent.Runner{Engine: engine, Timeout: budget}
+	resp, err := runner.Run(attemptCtx, agent.Request{
+		Model: model,
+		// 判定纯文本：不给工具、不思考（与 --suggest-followups 同口径）。
+		Tools:      agent.ToolsOff,
+		NoThinking: true,
+		Reasoning:  "minimal",
+		MaxTokens:  maxTokens,
+		Messages:   []agent.Message{{Role: "user", Content: msg}},
+		JSONSchema: Schema(),
+	})
+	if err != nil {
+		return Result{}, err
+	}
+	out, perr := Parse(resp.Text)
+	if perr != nil {
+		return Result{}, perr
+	}
+	if out.Level == "" {
+		out.Level = "none"
+	}
+	if out.Conflict && out.Level == "none" {
+		out.Level = "soft" // 模型说冲突但没给档位：按最轻的冲突算，别把「不冲突」写在冲突旁边
+	}
+	out.Engine = engine.Name()
+	out.Model = resp.Model
+	out.ElapsedMS = time.Since(start).Milliseconds()
+	out.By = "model"
+	return out, nil
+}
+
+// Parse 从模型输出里抠出 JSON（容忍 ```json 围栏、前后解释文字）。
+func Parse(text string) (Result, error) {
+	raw := strings.TrimSpace(text)
+	if raw == "" {
+		return Result{}, fmt.Errorf("冲突判定：模型没有输出")
+	}
+	if i := strings.Index(raw, "{"); i > 0 {
+		raw = raw[i:]
+	}
+	if j := strings.LastIndex(raw, "}"); j >= 0 && j+1 < len(raw) {
+		raw = raw[:j+1]
+	}
+	var out Result
+	if err := json.Unmarshal([]byte(raw), &out); err != nil {
+		return Result{}, fmt.Errorf("冲突判定：输出不是 JSON（%v）：%s", err, clipRunes(raw, 120))
+	}
+	out.Level = normalizeLevel(out.Level)
+	out.Reason = clipRunes(strings.TrimSpace(out.Reason), MaxReasonRunes)
+	out.Overlaps = cleanList(out.Overlaps)
+	return out, nil
+}
+
+func normalizeLevel(s string) string {
+	switch strings.ToLower(strings.TrimSpace(s)) {
+	case "hard":
+		return "hard"
+	case "soft":
+		return "soft"
+	case "none", "":
+		return "none"
+	default:
+		return "soft" // 认不出的档位按「可能相关」处理，不放大成 hard
+	}
+}
+
+// cleanList 去空、去重、限长（模型常把同一个文件名重复列两遍）。
+func cleanList(in []string) []string {
+	out := make([]string, 0, len(in))
+	seen := map[string]bool{}
+	for _, s := range in {
+		v := strings.TrimSpace(s)
+		if v == "" || seen[v] {
+			continue
+		}
+		seen[v] = true
+		out = append(out, clipRunes(v, 80))
+		if len(out) >= 8 {
+			break
+		}
+	}
+	return out
+}
+
+func clipRunes(s string, max int) string {
+	if max <= 0 || utf8.RuneCountInString(s) <= max {
+		return s
+	}
+	return string([]rune(s)[:max])
+}
+
+// tailStrings 取最后 n 条（日志按时间追加，越靠后越新）。
+func tailStrings(in []string, n int) []string {
+	if n <= 0 || len(in) <= n {
+		return in
+	}
+	return in[len(in)-n:]
+}