magic-agent 2.6.0 → 2.6.3

package/internal/client/jobs_auto_test.go

@@ -0,0 +1,431 @@
+package client
+
+// jobs_auto_test.go - 「自动」任务模式的判定闸门（2026-10-26）。
+//
+// 钉住的口径（用户定稿）：
+//   · 先规则再走建议引擎：合同一顿快速通道不调模型；同会话 / 文件交集直接判串行；
+//   · 判定失败、超时、没配引擎 → **默认并行**（保护不是闸门，不能把任务卡死）；
+//   · judging 不是调度候选 → 判定期间绝不能被抢跑；
+//   · 重启后不重判：judging 残留按并行放行（用户明确「不需要 60 秒后重新判定」）；
+//   · 同空间连发两条：第二条必须看得见第一条（queued 也算候选），否则两条同时改同一个文件。
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/darren/magic-agent/internal/judge"
+	"github.com/darren/magic-agent/internal/session"
+)
+
+func autoTestQueue(t *testing.T, core string) *jobQueue {
+	t.Helper()
+	dir := t.TempDir()
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", filepath.Join(dir, "jobs"))
+	t.Setenv(session.EnvDir, filepath.Join(dir, "sessions"))
+	svc := &Service{
+		opts: Options{MagicAgent: core, Profile: DefaultProfile()},
+		log:  log.New(io.Discard, "", 0),
+		runs: map[string]*askRun{},
+	}
+	q := newJobQueue(svc)
+	t.Cleanup(func() {
+		q.close()
+		time.Sleep(150 * time.Millisecond)
+	})
+	return q
+}
+
+// fakeJudgeCore 只会 --judge-conflict 的假 core（判定用，不跑任务）。
+func fakeJudgeCore(t *testing.T, body string) string {
+	t.Helper()
+	if runtime.GOOS == "windows" {
+		t.Skip("假 core 用 sh 脚本；Windows 上的判定逻辑由纯函数测试覆盖")
+	}
+	dir := t.TempDir()
+	path := filepath.Join(dir, "magic-agent")
+	script := "#!/bin/sh\ncat >/dev/null\necho '" + body + "'\n"
+	if err := os.WriteFile(path, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+// writeRunningSession 直接在登记表里落一条「正在跑」的记录（PID 用本测试进程，探活会通过）。
+func writeRunningSession(t *testing.T, ws, runID, sid, title string) {
+	t.Helper()
+	dir := session.Dir()
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	rec := session.Record{
+		RunID: runID, SessionID: sid, PID: os.Getpid(), Engine: "claude",
+		Workspace: ws, PromptHead: title,
+		State: session.StateRunning, StartedAt: time.Now(), UpdatedAt: time.Now(),
+	}
+	b, _ := json.Marshal(rec)
+	if err := os.WriteFile(filepath.Join(dir, runID+".json"), b, 0o600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func waitJobState(t *testing.T, q *jobQueue, id string, want func(*Job) bool) *Job {
+	t.Helper()
+	deadline := time.Now().Add(3 * time.Second)
+	var last *Job
+	for time.Now().Before(deadline) {
+		if last = q.get(id); last != nil && want(last) {
+			return last
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+	t.Fatalf("作业 %s 未达到期望状态，最后：%+v（auto=%+v）", id, last, last.GetAuto())
+	return last
+}
+
+// GetAuto 测试辅助：避免 nil 指针。
+func (j *Job) GetAuto() *JobAuto {
+	if j == nil || j.Auto == nil {
+		return &JobAuto{}
+	}
+	return j.Auto
+}
+
+func TestAutoIdleSpaceRunsParallelWithoutModel(t *testing.T) {
+	ws := t.TempDir()
+	q := autoTestQueue(t, "")
+	j, created, err := q.submitAsk(askRequest{Prompt: "改一下底部栏", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil || !created {
+		t.Fatalf("submitAsk: err=%v created=%v", err, created)
+	}
+	if j.State != JobQueued || j.Serial {
+		t.Fatalf("空间空闲应直接并行（queued + serial=false），实际 state=%s serial=%v", j.State, j.Serial)
+	}
+	if j.GetAuto().By != "rule" {
+		t.Errorf("空闲快速通道应标 by=rule（不调模型），实际 %q", j.GetAuto().By)
+	}
+	if j.Mode != "auto" {
+		t.Errorf("作业应记住 mode=auto，实际 %q", j.Mode)
+	}
+}
+
+func TestAutoSameSessionForcesSerial(t *testing.T) {
+	ws := t.TempDir()
+	q := autoTestQueue(t, "")
+	q.mu.Lock()
+	q.jobs["job-running"] = &Job{
+		ID: "job-running", Workspace: ws, Session: "sess-1", Engine: "claude",
+		Prompt: "上一轮", State: JobRunning, Serial: false,
+	}
+	q.mu.Unlock()
+
+	j, _, err := q.submitAsk(askRequest{Prompt: "追问一句", Mode: "auto", Session: "sess-1", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !j.Serial {
+		t.Fatalf("同一会话还有一轮没结束，必须串行，实际 serial=%v", j.Serial)
+	}
+	if j.GetAuto().By != "rule" {
+		t.Errorf("同会话是硬规则，应标 by=rule，实际 %q", j.GetAuto().By)
+	}
+}
+
+func TestAutoUndecidedFallsBackToParallel(t *testing.T) {
+	ws := t.TempDir()
+	// 没有可用 core → 语义判定必然失败 → 按并行放行，且如实标 undecided。
+	q := autoTestQueue(t, "")
+	writeRunningSession(t, ws, "run-busy", "sess-busy", "改底部栏")
+
+	j, _, err := q.submitAsk(askRequest{Prompt: "写个 README", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if j.State != JobJudging {
+		t.Fatalf("有运行中候选时应先进 judging，实际 %s", j.State)
+	}
+	/* 判定完成后队列会立刻准入选（本测试没有可跑的 core，可能转 running/failed）——
+	   这里只验判定结论本身：不再 pending，且按并行放行。 */
+	got := waitJobState(t, q, j.ID, func(x *Job) bool { return x.GetAuto().By != "pending" && x.State != JobJudging })
+	if got.Serial {
+		t.Fatalf("判定失败必须按并行放行，实际 serial=true（auto=%+v）", got.Auto)
+	}
+	if got.GetAuto().By != "undecided" {
+		t.Errorf("应标 by=undecided，实际 %q", got.GetAuto().By)
+	}
+	if !strings.Contains(got.GetAuto().Reason, "并行") {
+		t.Errorf("理由要说明按并行放行，实际 %q", got.GetAuto().Reason)
+	}
+}
+
+func TestAutoModelConflictQueues(t *testing.T) {
+	ws := t.TempDir()
+	core := fakeJudgeCore(t, `{"conflict":true,"level":"hard","reason":"都要改 index.html","overlaps":["index.html"]}`)
+	q := autoTestQueue(t, core)
+	writeRunningSession(t, ws, "run-busy", "sess-busy", "改底部栏")
+
+	j, _, err := q.submitAsk(askRequest{Prompt: "改底部栏的配色", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := waitJobState(t, q, j.ID, func(x *Job) bool { return x.State == JobQueued })
+	if !got.Serial {
+		t.Fatalf("模型判冲突应转串行，实际 serial=false（auto=%+v）", got.Auto)
+	}
+	if got.GetAuto().By != "model" {
+		t.Errorf("应标 by=model，实际 %q", got.GetAuto().By)
+	}
+	if !strings.Contains(got.GetAuto().Reason, "index.html") {
+		t.Errorf("理由应带冲突点，实际 %q", got.GetAuto().Reason)
+	}
+}
+
+func TestAutoModelClearRunsParallel(t *testing.T) {
+	ws := t.TempDir()
+	core := fakeJudgeCore(t, `{"conflict":false,"level":"none","reason":"互不相干：一个改前端一个写文档"}`)
+	q := autoTestQueue(t, core)
+	writeRunningSession(t, ws, "run-busy", "sess-busy", "改底部栏")
+
+	j, _, err := q.submitAsk(askRequest{Prompt: "补一段说明文档", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := waitJobState(t, q, j.ID, func(x *Job) bool { return x.GetAuto().By != "pending" && x.State != JobJudging })
+	if got.Serial {
+		t.Fatalf("模型判不冲突应并行，实际 serial=true（auto=%+v）", got.Auto)
+	}
+	if got.GetAuto().By != "model" {
+		t.Errorf("应标 by=model，实际 %q", got.GetAuto().By)
+	}
+}
+
+/*
+连发两条：第一条判并行（空间空闲），第二条必须看得见它。
+
+	不把 queued 算进候选时的现场是：两条都走「空间空闲」快速通道、都不看对方，
+	最后两个进程同时改同一个文件 —— 正是自动模式要防的那件事。
+*/
+func TestAutoSeesQueuedPeer(t *testing.T) {
+	ws := t.TempDir()
+	core := fakeJudgeCore(t, `{"conflict":true,"level":"hard","reason":"都要改同一个页面"}`)
+	q := autoTestQueue(t, core)
+
+	first, _, err := q.submitAsk(askRequest{Prompt: "改底部栏的配色", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if first.State != JobQueued || first.Serial {
+		t.Fatalf("第一条在空闲空间应直接并行，实际 state=%s serial=%v", first.State, first.Serial)
+	}
+	// 第一条还没开跑（测试不发 dispatch），此时提交第二条。
+	second, _, err := q.submitAsk(askRequest{Prompt: "改底部栏的图标大小", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if second.State != JobJudging {
+		t.Fatalf("同空间还有排队作业时应进判定，实际 %s", second.State)
+	}
+	got := waitJobState(t, q, second.ID, func(x *Job) bool { return x.GetAuto().By != "pending" })
+	if !got.Serial {
+		t.Fatalf("第二条与排队中的第一条冲突，应串行，实际 serial=false（auto=%+v）", got.Auto)
+	}
+}
+
+func TestAutoJudgingNotDispatchable(t *testing.T) {
+	ws := t.TempDir()
+	q := autoTestQueue(t, "")
+	q.mu.Lock()
+	q.jobs["job-judge"] = &Job{
+		ID: "job-judge", Workspace: ws, Engine: "claude", Prompt: "判定中",
+		State: JobJudging, Serial: false, CreatedAt: time.Now(), UpdatedAt: time.Now(),
+	}
+	q.mu.Unlock()
+
+	q.dispatch()
+	if got := q.get("job-judge"); got.State != JobJudging {
+		t.Fatalf("judging 不能被 dispatch 抢跑，实际 %s", got.State)
+	}
+	if q.runOf("job-judge") != nil {
+		t.Fatal("judging 期间不应有正在跑的轮次")
+	}
+}
+
+func TestAutoJudgingRecoversAsParallelAfterRestart(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", dir)
+	t.Setenv(session.EnvDir, filepath.Join(dir, "sessions"))
+	j := Job{
+		ID: "job-judging", RequestID: "req-judging", Workspace: "/tmp/ws", Engine: "claude",
+		Prompt: "判定中被重启", Mode: "auto", State: JobJudging, Serial: false,
+		Auto:      &JobAuto{By: "pending", Reason: "正在判断"},
+		CreatedAt: time.Now(), UpdatedAt: time.Now(), ExpiresAt: time.Now().Add(time.Hour),
+	}
+	b, _ := json.Marshal(j)
+	if err := os.WriteFile(filepath.Join(dir, j.ID+".json"), b, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	svc := &Service{opts: Options{Profile: DefaultProfile()}, log: log.New(io.Discard, "", 0), runs: map[string]*askRun{}}
+	q := newJobQueue(svc)
+	defer q.close()
+
+	got := q.get("job-judging")
+	if got == nil || got.State != JobQueued {
+		t.Fatalf("judging 残留重启后应转 queued，实际 %+v", got)
+	}
+	if got.Serial {
+		t.Error("重启不重判 → 必须按并行放行")
+	}
+	if got.GetAuto().By != "undecided" {
+		t.Errorf("应标 undecided，实际 %q", got.GetAuto().By)
+	}
+}
+
+func TestSpaceKeyNormalizesTeamRunDir(t *testing.T) {
+	ws := filepath.Join(string(filepath.Separator), "tmp", "proj")
+	run := filepath.Join(ws, ".magic", "team", "run-abc", "t1")
+	if got, want := spaceKeyOf(run), spaceKeyOf(ws); got != want {
+		t.Fatalf("团队运行目录应归到父空间：%q != %q", got, want)
+	}
+	// 尾斜杠 / 相对路径写法要归到同一个键（core 的锁键同口径）。
+	if !sameSpace(spaceKeyOf(ws+string(filepath.Separator)), spaceKeyOf(ws)) {
+		t.Error("尾斜杠应归一到同一个空间")
+	}
+}
+
+func TestPromptFileOverlap(t *testing.T) {
+	cands := []judge.Candidate{
+		{Files: []string{"client-ui-mobile/index.html", "docs/a.md"}},
+	}
+	// 完整路径
+	if _, ov := promptFileOverlap("改 client-ui-mobile/index.html 的底部栏", cands); len(ov) == 0 {
+		t.Error("提示词里写出完整路径应判冲突")
+	}
+	// 文件名（带扩展名）
+	if _, ov := promptFileOverlap("把 index.html 的底部栏调窄", cands); len(ov) == 0 {
+		t.Error("提示词里写出文件名应判冲突")
+	}
+	// 不相干
+	if _, ov := promptFileOverlap("写一篇公众号文章", cands); len(ov) != 0 {
+		t.Errorf("不相干的提示词不该判冲突，实际 %v", ov)
+	}
+}
+
+func TestPathsInToolInput(t *testing.T) {
+	cases := map[string]string{
+		`{"file_path":"/a/b.go"}`:              "/a/b.go",
+		`{"path":"src/x.ts"}`:                  "src/x.ts",
+		`{"notebook_path":"n.ipynb"}`:          "n.ipynb",
+		`{"patch":"*** Update File: /a/b.md"}`: "", // 认不出就老实返回空，别瞎猜
+	}
+	for in, want := range cases {
+		got := pathsInToolInput(in)
+		if want == "" {
+			if len(got) != 0 {
+				t.Errorf("输入 %s 不该抽出路径，实际 %v", in, got)
+			}
+			continue
+		}
+		found := false
+		for _, g := range got {
+			if g == want {
+				found = true
+			}
+		}
+		if !found {
+			t.Errorf("输入 %s 应抽出 %q，实际 %v", in, want, got)
+		}
+	}
+}
+
+// autoHTTPCore 既是任务 core（NDJSON + 等 stop）又是判定 core（--judge-conflict 回 JSON）。
+// 直接以 jobCore 为底：它已经处理了 --contract / --engines / --sessions 探测分支。
+func autoHTTPCore(t *testing.T, verdict string) string {
+	t.Helper()
+	base := jobCore(t)
+	b, err := os.ReadFile(base)
+	if err != nil {
+		t.Fatal(err)
+	}
+	branch := "case \"$*\" in\n  *--judge-conflict*)\n    cat >/dev/null\n    echo '" + verdict + "'\n    exit 0\n    ;;\n"
+	out := strings.Replace(string(b), "case \"$*\" in\n", branch, 1)
+	if out == string(b) {
+		t.Fatal("没找到 jobCore 的 case 分支，判定 core 打桩失败")
+	}
+	path := filepath.Join(t.TempDir(), "magic-agent")
+	if err := os.WriteFile(path, []byte(out), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+// 端到端（HTTP 层）：mode=auto 的请求要原样落进作业记录，判定结论要能被客户端读到。
+func TestAutoModeOverHTTP(t *testing.T) {
+	ws := t.TempDir()
+	core := autoHTTPCore(t, `{"conflict":true,"level":"hard","reason":"都要改 index.html","overlaps":["index.html"]}`)
+	svc, _ := jobTestService(t, core)
+	base := httptest.NewServer(svc.Handler())
+	defer base.Close()
+	writeRunningSession(t, ws, "run-busy", "sess-busy", "改底部栏")
+
+	job := postJob(t, base.URL, map[string]any{
+		"engine": "claude", "prompt": "改底部栏配色", "workspace": ws, "mode": "auto",
+	})
+	if job.Mode != "auto" {
+		t.Fatalf("作业应记住 mode=auto，实际 %q", job.Mode)
+	}
+
+	got := waitJob(t, base.URL, job.ID, func(j *Job) bool {
+		return j.Auto != nil && j.Auto.By == "model"
+	}, 5*time.Second)
+	if !got.Serial {
+		t.Fatalf("模型判冲突应串行，实际 serial=false（auto=%+v）", got.Auto)
+	}
+	if !strings.Contains(got.Auto.Reason, "index.html") {
+		t.Errorf("理由应带冲突点，实际 %q", got.Auto.Reason)
+	}
+	if got.Mode != "auto" {
+		t.Errorf("GET 也要带 mode，实际 %q", got.Mode)
+	}
+}
+
+// 显式模式必须**说了算**（2026-10-26 用户：「模式判断要拦截每个会话，如果不是
+// 自动就按选择模式处理」）：只发 mode、不发 serial 时不能被缺省串行吃掉。
+func TestExplicitModeWinsOverSerialFlag(t *testing.T) {
+	cases := []struct {
+		name   string
+		mode   string
+		serial *bool
+		want   bool
+	}{
+		{"parallel 不管 serial=true", "parallel", boolPtr(true), false},
+		{"parallel 不带 serial", "parallel", nil, false},
+		{"serial 不管 serial=false", "serial", boolPtr(false), true},
+		{"serial 不带 serial", "serial", nil, true},
+		{"auto 不消费 serial（走判定）", "auto", boolPtr(true), false},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			ws := t.TempDir()
+			q := autoTestQueue(t, ws)
+			j, _, err := q.submitAsk(askRequest{
+				Prompt: "跑一下", Workspace: ws, Mode: c.mode, Serial: c.serial,
+			}, "claude", "pc")
+			if err != nil {
+				t.Fatalf("submitAsk: %v", err)
+			}
+			if j.Serial != c.want {
+				t.Fatalf("mode=%q serial=%v → Serial=%v，期望 %v", c.mode, c.serial, j.Serial, c.want)
+			}
+			if c.mode != "auto" && j.Mode != c.mode {
+				t.Fatalf("mode=%q 没记到作业上，实际 %q", c.mode, j.Mode)
+			}
+		})
+	}
+}

package/internal/client/plugins.go

@@ -31,7 +31,8 @@ import (
 type pluginStep struct {
 	Args     []string
 	Optional bool
-	SkipNote string // Optional 步骤跳过时展示的原因
+	SkipNote string   // Optional 步骤跳过时展示的原因
+	Env      []string // 非空 = 用它替代继承的父进程环境（见 npmEnv）
 }
 
 func (p pluginStep) Command() string { return strings.Join(p.Args, " ") }
@@ -342,6 +343,9 @@ func runPluginStep(ctx context.Context, st pluginStep, onLine func(string)) (int
 		return 0, errors.New("空命令")
 	}
 	cmd := exec.CommandContext(ctx, st.Args[0], st.Args[1:]...)
+	if len(st.Env) > 0 {
+		cmd.Env = st.Env
+	}
 	pr, pw, err := os.Pipe()
 	if err != nil {
 		return 1, err

package/internal/client/prefs.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"strings"
 )
 
 /* 移动端「环境配置」的远端存储（2026-10-22 用户：
@@ -97,3 +98,69 @@ func (s *Service) handlePrefs(w http.ResponseWriter, r *http.Request) {
 		writeErr(w, http.StatusMethodNotAllowed, "只支持 GET / PUT")
 	}
 }
+
+// defaultEngineModel 读「我的 → 默认引擎/模型」（2026-10-26 用户：
+// 「手动自动都要默认设置的引擎」）。
+//
+// 手动「整理」是从请求体拿的（移动端每次点都带 engine/model）；后台自动归纳没有
+// 请求体，只能自己去读 —— 与移动端同一份权威存储：/desk/prefs 落的
+// ~/.magic-agent/mobile-prefs.json（键名由移动端定义，这里只按约定取两个）。
+//
+// 不做任何猜测或回退：配置里没设引擎就是空串（core 走自己的默认 llm），
+// **不**用「备用引擎」替补 —— 备用是主引擎失败时才切的东西，不是默认值。
+// 模型只在引擎非空时才返回（core 侧 model 不能脱离 engine 单独指定）。
+func (s *Service) defaultEngineModel() (string, string) {
+	p := mobilePrefsPath()
+	if p == "" {
+		return "", ""
+	}
+	b, err := os.ReadFile(p)
+	if err != nil || len(b) == 0 {
+		return "", ""
+	}
+	var v map[string]any
+	if err := json.Unmarshal(b, &v); err != nil {
+		return "", ""
+	}
+	engine := strings.TrimSpace(prefString(v[prefKeyEngine]))
+	if engine == "" {
+		return "", ""
+	}
+	// 白名单同样要过：白名单外的引擎 core 会拒绝，自动归纳每轮都失败等于没跑。
+	if !s.opts.Profile.AllowsEngine(engine) {
+		s.logf("需求自动归纳: 默认引擎 %q 不在 profile 白名单里，回落 core 默认", engine)
+		return "", ""
+	}
+	return engine, strings.TrimSpace(prefString(v[prefKeyModel]))
+}
+
+// 移动端 /desk/prefs 里的键名（客户端定义、服务端不解释；这里只读这两个）。
+const (
+	prefKeyEngine = "magic.engine"
+	prefKeyModel  = "magic.model"
+)
+
+// prefString 把配置值规整成字符串（值理论上都是字符串，但坏文件兜一下）。
+func prefString(v any) string {
+	if s, ok := v.(string); ok {
+		return s
+	}
+	return ""
+}
+
+// logf 防御性写日志：Options.Logger 可空（单测 / 内嵌调用），nil 时**不能 panic** ——
+// 自动归纳是后台弱路径，日志丢了可以接受，把客户端带崩不行。
+func (s *Service) logf(format string, args ...any) {
+	if s.log == nil {
+		return
+	}
+	s.log.Printf(format, args...)
+}
+
+// modelSuffix 日志里拼「 · 模型」；没配模型时只留引擎名。
+func modelSuffix(model string) string {
+	if model == "" {
+		return ""
+	}
+	return " · " + model
+}

package/internal/client/procstart_linux.go

@@ -0,0 +1,59 @@
+package client
+
+import (
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// init 在 Linux 上把 procStart 换成精确的版本：/proc/self/stat 的字段 22（starttime，单位
+// 是开机后的时钟滴答）+ btime（/proc/stat），算出本进程真正被拉起的那一刻。
+// 只关系到「盘上的 magic-agent 是不是本进程启动后才被 npm 换掉的」（见 replacedAfterStart），
+// 读不到就保留 mtime 兜底，不影响任何正常路径。
+func init() {
+	start, ok := linuxProcessStart()
+	if !ok {
+		return
+	}
+	procStart = func() (time.Time, bool) { return start, true }
+}
+
+func linuxProcessStart() (time.Time, bool) {
+	b, err := os.ReadFile("/proc/self/stat")
+	if err != nil {
+		return time.Time{}, false
+	}
+	// comm 可能带空格和括号：从最后一个 ')' 之后才开始数字段。之后第一个字段是 3（state），
+	// starttime 是第 22 个 ⇒ 下标 22-3 = 19。
+	s := string(b)
+	i := strings.LastIndexByte(s, ')')
+	if i < 0 {
+		return time.Time{}, false
+	}
+	fields := strings.Fields(s[i+1:])
+	if len(fields) < 20 {
+		return time.Time{}, false
+	}
+	ticks, err := strconv.ParseUint(fields[19], 10, 64)
+	if err != nil {
+		return time.Time{}, false
+	}
+	sb, err := os.ReadFile("/proc/stat")
+	if err != nil {
+		return time.Time{}, false
+	}
+	var btime uint64
+	for _, ln := range strings.Split(string(sb), "\n") {
+		if strings.HasPrefix(ln, "btime ") {
+			btime, _ = strconv.ParseUint(strings.TrimSpace(ln[len("btime "):]), 10, 64)
+			break
+		}
+	}
+	if btime == 0 {
+		return time.Time{}, false
+	}
+	// USER_HZ 在 Linux 上恒为 100（内核导出给用户态的时钟刻度，不随 CONFIG_HZ 变）。
+	sec := btime + ticks/100
+	return time.Unix(int64(sec), int64(ticks%100)*10_000_000), true
+}

package/internal/client/publicurl.go

@@ -0,0 +1,82 @@
+package client
+
+/* publicurl.go - 公网入口（cloudflared quick tunnel 域名）的**落盘**。
+ *
+ * 为什么（2026-10-25 用户：「重启也尽量不要变 cloudflare 域名就可以了」）：
+ * 隧道是壳（掌天瓶）起的，quick tunnel 的域名只在**隧道重起**时才会变；magic-client
+ * 重启根本不碰 cloudflared，域名本该原样不变。但域名探测结果以前只存在内存里 ——
+ * 客户端一重启就丢，`/desk/health` 头几次请求报 `publicUrl: ""`，手机于是退回局域网
+ * 地址：用户看到的就是「重启后地址变了」。
+ *
+ * 所以把探测到的域名落盘（profile 数据目录的 `public-url`），启动即读回当「上次已知」：
+ *   · 隧道没重起 → 域名正确，手机一条连接都不用改；
+ *   · 隧道真重起了 → 后台探测在 publicTTL 内换成新域名；
+ *   · cloudflared 比客户端起得慢 → 宽限期（publicGrace）内不采纳「探不到」，
+ *     已知域名先顶着，别在这一小段里把用户推到局域网地址上。
+ */
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// publicGrace 重启后的宽限期：这段时间里探测不到隧道也**不撤掉**已落盘的域名。
+//
+// 顺带解决的是「壳重启」这个场景：cloudflared 要几百毫秒到几秒才把 metrics 端口开起来，
+// 客户端如果抢在前面探空并清掉已知域名，手机就会在这段空窗里换地址。
+const publicGrace = 90 * time.Second
+
+// publicURLFile 落盘文件（与 instance-id 同目录：同一份 profile = 同一台桌面）。
+func publicURLFile(prof Profile) string {
+	dir := strings.TrimSpace(prof.DataDir())
+	if dir == "" {
+		return ""
+	}
+	return filepath.Join(dir, "public-url")
+}
+
+// loadSavedPublicURL 读上次落盘的域名；没有/读不出 → 空串。
+func (s *Service) loadSavedPublicURL() string {
+	p := publicURLFile(s.opts.Profile)
+	if p == "" {
+		return ""
+	}
+	b, err := os.ReadFile(p)
+	if err != nil {
+		return ""
+	}
+	u := strings.TrimSpace(string(b))
+	if !strings.HasPrefix(u, "https://") && !strings.HasPrefix(u, "http://") {
+		return "" // 半截写入 / 手改坏了：当作没有，别把垃圾地址发给手机
+	}
+	return strings.TrimRight(u, "/")
+}
+
+// savePublicURL 落盘当前域名（0600）。写不下不是致命错：本次仍能用，只是下次重启会重新探。
+func (s *Service) savePublicURL(u string) {
+	p := publicURLFile(s.opts.Profile)
+	if p == "" || strings.TrimSpace(u) == "" {
+		return
+	}
+	if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
+		return
+	}
+	_ = os.WriteFile(p, []byte(strings.TrimSpace(u)+"\n"), 0o600)
+}
+
+// clearSavedPublicURL 删掉落盘的域名（连续探测确认隧道真的没了）。
+func (s *Service) clearSavedPublicURL() {
+	p := publicURLFile(s.opts.Profile)
+	if p == "" {
+		return
+	}
+	_ = os.Remove(p)
+}
+
+// publicURLOrEmpty 供交接用：拿当前已知的公网域名（不触发等待）。
+func (s *Service) publicURLOrEmpty() string {
+	u := s.publicURL()
+	return strings.TrimRight(strings.TrimSpace(u), "/")
+}

package/internal/client/requirements.go

@@ -482,9 +482,17 @@ func (s *Service) runAutoConsolidate(ws string) {
 	s.reqAuto.running[ws] = true
 	s.reqAuto.mu.Unlock()
 
+	/* 引擎/模型：**与手动「整理」同一口径** —— 「整理的引擎就是配置的默认引擎」。
+	   后台没有请求体可带，于是从唯一的权威配置源（/desk/prefs 落的那份 JSON）读；
+	   读不到（还没配过 / 文件坏了）= 传空，core 仍按自己的默认（llm）跑，与旧行为一致。 */
+	engine, model := s.defaultEngineModel()
+	if engine != "" {
+		s.logf("需求自动归纳 %s: 引擎 %s%s", ws, engine, modelSuffix(model))
+	}
+
 	// 归纳是后台行为：**不绑**任何 HTTP 请求的生命周期，用独立 context。
 	ctx, cancel := context.WithTimeout(context.Background(), reqConsolidateTimeout)
-	out, err := s.runCoreTimed(ctx, reqConsolidateTimeout, consolidateArgs(ws, "", false, false, true, "", "")...)
+	out, err := s.runCoreTimed(ctx, reqConsolidateTimeout, consolidateArgs(ws, "", false, false, true, engine, model)...)
 	cancel()
 	if err != nil {
 		s.log.Printf("需求自动归纳失败 %s: %v", ws, err)