magic-agent 2.6.0 → 2.6.3

package/internal/client/health_identity_test.go

@@ -0,0 +1,84 @@
+package client
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+)
+
+/* /desk/health 必须交代「我这一代进程是谁」（2026-10-27）。
+ *
+ * 为什么值得一条测试：重启换的是**进程**，会话 / 任务 / 设置全在盘上，
+ * 界面重启前后长得一模一样。用户点了「重启服务」看见列表没变，只会说「没效果」
+ * —— 这正是当天真机反馈的原话。而 `instanceId` 帮不上忙：它是**同一台桌面**的稳定
+ * 身份（多入口归一靠它），跨重启必须不变，所以不能用它判断新旧代。
+ *
+ * 判据只能是 `pid` + `startedAt` 这一对。这里钉住三件事：
+ *   1. 两个字段都得在（客户端靠它们证明换代）；
+ *   2. startedAt 是可解析的 RFC3339（客户端做字符串比较，格式漂了就会误判）；
+ *   3. pid 就是本进程（不是某个常量、也不是状态文件里的旧值）。
+ */
+func TestHealthReportsProcessIdentity(t *testing.T) {
+	svc := newTestService(t, fakeCore(t, goodContract))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	read := func() map[string]any {
+		t.Helper()
+		req, err := http.NewRequest(http.MethodGet, srv.URL+"/desk/health", nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		req.Header.Set("X-Magic-Token", "tok")
+		res, err := http.DefaultClient.Do(req)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer res.Body.Close()
+		if res.StatusCode != http.StatusOK {
+			t.Fatalf("期望 200，得到 %d", res.StatusCode)
+		}
+		var got map[string]any
+		if err := json.NewDecoder(res.Body).Decode(&got); err != nil {
+			t.Fatal(err)
+		}
+		return got
+	}
+
+	got := read()
+
+	pid, ok := got["pid"].(float64) // JSON 数字统一解成 float64
+	if !ok {
+		t.Fatalf("health 必须带 pid（客户端靠它证明换代），实际没有或类型不对：%#v", got["pid"])
+	}
+	if int(pid) != os.Getpid() {
+		t.Fatalf("pid 必须是本进程 %d，得到 %v", os.Getpid(), pid)
+	}
+
+	raw, ok := got["startedAt"].(string)
+	if !ok || raw == "" {
+		t.Fatalf("health 必须带 startedAt（RFC3339），实际 %#v", got["startedAt"])
+	}
+	ts, err := time.Parse(time.RFC3339, raw)
+	if err != nil {
+		t.Fatalf("startedAt 必须是可解析的 RFC3339（客户端做字符串比较），得到 %q：%v", raw, err)
+	}
+	/* 启动时刻不该在将来，也不该早得离谱 —— 后者通常意味着拿了包级的零值/编译常量。 */
+	if time.Since(ts) < 0 {
+		t.Fatalf("startedAt 落在将来：%v", ts)
+	}
+	if time.Since(ts) > time.Hour {
+		t.Fatalf("startedAt 早得不合理（%v 之前）：像是没在 New() 里赋值", ts)
+	}
+
+	/* 同一个进程连着问两次，pid 与 startedAt 都必须一模一样 ——
+	   否则客户端会把「还没重启」误判成「换代了」。 */
+	again := read()
+	if again["pid"] != got["pid"] || again["startedAt"] != got["startedAt"] {
+		t.Fatalf("同一进程两次应答的身份必须一致：%v/%v vs %v/%v",
+			got["pid"], got["startedAt"], again["pid"], again["startedAt"])
+	}
+}

package/internal/client/hostenv.go

@@ -0,0 +1,68 @@
+package client
+
+// hostenv.go - 给 core 子进程的准备环境。
+//
+// 为什么在客户端做而不是 core 里做：core 是**被客户端 exec 起来的**，它继承什么
+// 完全由这里决定。宿主 IDE（WorkBuddy）的终端会给客户端塞三样东西：
+//
+//	NODE_OPTIONS=--require=".../app.asar.unpacked/.../node-language-shim.cjs"
+//	ELECTRON_RUN_AS_NODE=1
+//	PATH=<...>/shim/brokered-bin:<...>      ← 假 cat/cp/dd，require 时去连宿主 broker
+//
+// 后果（2026-10-26 真机实测）：引擎的 node 子进程加载宿主 shim → 连不上 broker →
+// `connect failed: Connection refused` → 每条任务 failed，错误看着像引擎坏了。
+// 在 core 一启动就把这三样摘干净，比让每个引擎各自防御可靠。
+//
+// 判据只认 `.asar` / `workbuddy` / `brokered-bin` 这几个特征：用户自己设的
+// NODE_OPTIONS（--max-old-space-size 之类）与正常 PATH 段原样保留。
+
+import (
+	"os"
+	"strings"
+)
+
+// hostShimValue 判断一个值是否指向宿主 Electron 应用的垫片。
+func hostShimValue(v string) bool {
+	l := strings.ToLower(v)
+	return strings.Contains(l, ".asar") || strings.Contains(l, "workbuddy") || strings.Contains(l, "brokered-bin")
+}
+
+// cleanHostEnv 返回一份可以交给 core 的环境：摘掉宿主垫片变量与假命令目录。
+func cleanHostEnv(env []string) []string {
+	out := make([]string, 0, len(env))
+	for _, kv := range env {
+		name, val, ok := strings.Cut(kv, "=")
+		if !ok {
+			out = append(out, kv)
+			continue
+		}
+		switch name {
+		case "ELECTRON_RUN_AS_NODE":
+			continue
+		case "NODE_OPTIONS":
+			if hostShimValue(val) {
+				continue
+			}
+		case "PATH":
+			if cleaned := stripHostShimPath(val); cleaned != val {
+				out = append(out, "PATH="+cleaned)
+				continue
+			}
+		}
+		out = append(out, kv)
+	}
+	return out
+}
+
+// stripHostShimPath 从 PATH 值里摘掉宿主垫片目录，其余段与顺序不动。
+func stripHostShimPath(val string) string {
+	parts := strings.Split(val, string(os.PathListSeparator))
+	kept := parts[:0]
+	for _, p := range parts {
+		if p == "" || hostShimValue(p) {
+			continue
+		}
+		kept = append(kept, p)
+	}
+	return strings.Join(kept, string(os.PathListSeparator))
+}

package/internal/client/hostenv_test.go

@@ -0,0 +1,37 @@
+package client
+
+import (
+	"strings"
+	"testing"
+)
+
+// 2026-10-26 真机：宿主 IDE 的终端把这三个变量塞进客户端，引擎子进程全崩在 require。
+func TestCleanHostEnvDropsShimVars(t *testing.T) {
+	in := []string{
+		`NODE_OPTIONS=--require="/Applications/WorkBuddy.app/Contents/Resources/app.asar.unpacked/cli/vendor/shim/node-language-shim.cjs"`,
+		"ELECTRON_RUN_AS_NODE=1",
+		"PATH=/Applications/WorkBuddy.app/Contents/Resources/app.asar.unpacked/cli/vendor/shim/brokered-bin:/opt/homebrew/bin:/usr/bin",
+		"HOME=/Users/x",
+	}
+	out := cleanHostEnv(in)
+	joined := strings.Join(out, "\n")
+	for _, bad := range []string{"ELECTRON_RUN_AS_NODE", ".asar", "brokered-bin"} {
+		if strings.Contains(joined, bad) {
+			t.Fatalf("还留着 %s：\n%s", bad, joined)
+		}
+	}
+	if !strings.Contains(joined, "PATH=/opt/homebrew/bin:/usr/bin") {
+		t.Fatalf("PATH 被误改：\n%s", joined)
+	}
+	if !strings.Contains(joined, "HOME=/Users/x") {
+		t.Fatal("无关变量被删了")
+	}
+}
+
+// 用户自己设的 NODE_OPTIONS 要留着。
+func TestCleanHostEnvKeepsUserNodeOptions(t *testing.T) {
+	out := cleanHostEnv([]string{"NODE_OPTIONS=--max-old-space-size=4096"})
+	if len(out) != 1 || out[0] != "NODE_OPTIONS=--max-old-space-size=4096" {
+		t.Fatalf("误删：%v", out)
+	}
+}

package/internal/client/jobs.go

@@ -42,6 +42,10 @@ const (
 	JobFailed    = "failed"
 	JobCancelled = "cancelled"
 	JobExpired   = "expired"
+	/* JobJudging 自动模式：已受理、正在判断「与同空间运行中任务是否冲突」。
+	   它不是 dispatch 的候选（调度器只认 JobQueued），所以判定期间不会被抢跑；
+	   判定完成（或失败降级）后回到 JobQueued，由 dispatch 正常准入。见 jobs_auto.go。 */
+	JobJudging = "judging"
 
 	// jobQueuedTTL 排队多久没轮到就过期（避免关机一周后突然跑一堆旧任务）。
 	jobQueuedTTL = 24 * time.Hour
@@ -86,6 +90,12 @@ type Job struct {
 
 	// Serial 是否参与 workspace 单槽串行（默认 true）。
 	Serial bool `json:"serial"`
+	/* Mode 任务模式（2026-10-26，只增）：auto / parallel / serial 三档，
+	   由客户端选择原样记录；空 = 老客户端（只看 Serial）。 */
+	Mode string `json:"mode,omitempty"`
+	/* Auto 自动模式的判定结论（2026-10-26，只增）。Serial 仍是最终裁决，
+	   这里只回答「为什么」—— 界面据此解释「为什么在排队」。 */
+	Auto *JobAuto `json:"auto,omitempty"`
 
 	State    string   `json:"state"`
 	Position int      `json:"position,omitempty"`
@@ -120,6 +130,25 @@ func (j *Job) terminal() bool {
 	return false
 }
 
+/* JobAuto 自动任务模式的判定结论（2026-10-26，只增字段）。
+ *
+ * 为什么单独存一份而不是只留 Serial：用户要看懂「为什么排在我前面那条后面」。
+ * 只给一个布尔的话，界面上只能写「等待中」，用户会以为卡住了（这正是 2026-10-24
+ * 「并行模式还在串行等待」那次报障的观感来源）。
+ *
+ * By 的取值：rule = 规则判定（同会话 / 提示词里的文件交集 / 同空间空闲）；
+ *
+ *	model = 建议引擎判的；undecided = 没判出来（超时/失败/没配引擎），按并行放行。
+ */
+type JobAuto struct {
+	Conflict bool      `json:"conflict"`
+	Level    string    `json:"level"`            // hard | soft | none
+	Reason   string    `json:"reason,omitempty"` // 一句中文理由（界面直接显示）
+	Overlaps []string  `json:"overlaps,omitempty"`
+	By       string    `json:"by,omitempty"` // rule | model | undecided | pending
+	At       time.Time `json:"at,omitempty"`
+}
+
 // askRequest 把作业还原成 core 启动参数需要的请求（不带上 RequestID：那是队列自己的事）。
 func (j *Job) askRequest() askRequest {
 	req := askRequest{
@@ -139,9 +168,10 @@ func (j *Job) askRequest() askRequest {
 		FallbackEngine: j.FallbackEngine,
 		FallbackModel:  j.FallbackModel,
 	}
-	/* ⚠️ 必须回填 Serial：startAsk 按它决定要不要注入 core 侧工作空间锁
-	   （见 service.go 的 EnvWorkspaceLock）。漏掉 → req.Serial == nil → 按「串行」处理 →
-	   并行作业在 core 的 Begin 处又去抢锁，把「并行」架空（切并行后看着没生效）。 */
+	/* ⚠️ 必须回填 Serial：startAsk 按它决定要不要给 core **关掉**工作空间锁
+	   （见 service.go 的 EnvWorkspaceLock；2026-10-26 起锁默认生效）。漏掉 →
+	   req.Serial == nil → 按「串行」处理 → 并行作业在 core 的 Begin 处又重新串起来，
+	   把「并行」架空（切并行后看着没生效）。 */
 	serial := j.Serial
 	req.Serial = &serial
 	if j.ExplicitWorkspace {
@@ -351,6 +381,21 @@ func (q *jobQueue) load() {
 		if err := json.Unmarshal(b, &j); err != nil || strings.TrimSpace(j.ID) == "" {
 			continue
 		}
+		/* 自动判定没跑完就重启：**不重判**（用户 2026-10-26 明确「不需要排队 60 秒后
+		   重新判定」），按并行放行 —— 判定是保护不是闸门，重启后让它继续排队才是事故。 */
+		if j.State == JobJudging {
+			j.State = JobQueued
+			j.Serial = false
+			if j.Auto == nil {
+				j.Auto = &JobAuto{}
+			}
+			j.Auto.Conflict = false
+			j.Auto.Level = "none"
+			j.Auto.By = "undecided"
+			j.Auto.Reason = "服务重启，未完成的判定按并行放行"
+			j.Auto.At = now
+			j.UpdatedAt = now
+		}
 		switch j.State {
 		case JobRunning:
 			/* 服务重启时还在 running：core 是 NoCancel 起的，可能仍在跑。
@@ -429,12 +474,16 @@ func (q *jobQueue) pruneOrphanPlaceholdersLocked() {
 	if q == nil || q.dir == "" || q.svc == nil {
 		return
 	}
-	live := map[string]bool{}
+	/* runID → 作业状态。**不能只记 queued**：占位对应的作业一旦开跑 / 收尾，
+	   占位就必须让位（正常由 syncQueuedSessionLocked 在状态切换时删；但多实例共用
+	   一个作业目录、或那次落盘失败时，这步会漏 —— 现场就是 job 已 done、占位还在）。 */
+	known := map[string]string{}
 	for _, j := range q.jobs {
-		if j != nil && j.State == JobQueued {
-			if id := queuedSessionID(j); id != "" {
-				live[id] = true
-			}
+		if j == nil {
+			continue
+		}
+		if id := queuedSessionID(j); id != "" {
+			known[id] = j.State
 		}
 	}
 	recs, err := session.List()
@@ -444,9 +493,19 @@ func (q *jobQueue) pruneOrphanPlaceholdersLocked() {
 	ours := q.svc.opts.Profile.AppID()
 	cutoff := time.Now().Add(-orphanPlaceholderGrace)
 	for _, r := range recs {
-		if r.State != session.StateQueued || r.Client != ours || live[r.RunID] {
+		if r.State != session.StateQueued || r.Client != ours {
+			continue
+		}
+		if st, ok := known[r.RunID]; ok {
+			if st == JobQueued {
+				continue // 还排着：占位该在
+			}
+			/* 已开跑 / 已终结：占位是陈迹，立刻清掉（不套宽限 —— 它是明确的错状态）。 */
+			session.RemoveQueued(r.RunID)
 			continue
 		}
+		/* 认不出对应作业（作业文件被 prune / 另一个实例的目录 / 换过作业目录）：
+		   给「占位已写、作业还没落盘」那个窗口留宽限，之后才清。 */
 		if r.UpdatedAt.After(cutoff) || r.StartedAt.After(cutoff) {
 			continue
 		}
@@ -459,7 +518,7 @@ func (q *jobQueue) pruneOrphanPlaceholdersLocked() {
 func normalizeWorkspace(ws string) string {
 	ws = strings.TrimSpace(ws)
 	if ws == "" {
-		ws, _ = os.Getwd()
+		ws = defaultWorkspace()
 	}
 	if abs, err := filepath.Abs(ws); err == nil {
 		ws = abs
@@ -467,11 +526,100 @@ func normalizeWorkspace(ws string) string {
 	return filepath.Clean(ws)
 }
 
+/* defaultWorkspace 请求没带 workspace 时，这一轮算在哪个目录。
+ *
+ * 为什么不能直接 os.Getwd()（2026-10-26 实测事故）：
+ * 插件的 cwd 由**启动它的人**决定，不一定是用户的项目。当天那份实例是 `cd /` 起来的，
+ * 于是所有不带 -w 的消息都被归到工作空间 `/`：
+ *   · /desk/health 的 defaultWorkspace 报 `/`，移动端新建会话拿到的工作区就是根目录；
+ *   · 作业文件里写着 "workspace": "/"，而 core 自己登记的是真实 cwd —— 两边对不上；
+ *   · 更麻烦的是 mode=auto 的同空间冲突判定和 core 的工作空间锁都按这个 key 算，
+ *     `/` 变成一个「所有会话都算同一空间」的万能桶，串行/并行全判错。
+ *
+ * 正确顺序：插件 cwd 有意义就用它；cwd 是文件系统根（或者拿不到）时，退回**上一次
+ * 真正用过的工作区**（prefs 里的 lastWorkspace，由客户端每次建会话时写回）。
+ * 两者都没有就只能是 cwd —— 不编一个假路径出来。
+ */
+func defaultWorkspace() string {
+	wd, err := os.Getwd()
+	if err == nil && !isRootDir(wd) {
+		return wd
+	}
+	if last := lastWorkspacePref(); last != "" && !isRootDir(last) {
+		return last
+	}
+	return wd
+}
+
+// isRootDir 判断是不是文件系统根（`/`，Windows 上是 `C:\`）。
+//
+// 根目录不是一个用户项目：没有任何 README、任何 agent 在它下面干活都是错的，
+// 而且它会把「同空间」这个判据退化成「全机所有会话同空间」。
+func isRootDir(p string) bool {
+	p = strings.TrimSpace(p)
+	if p == "" {
+		return false
+	}
+	return filepath.Dir(filepath.Clean(p)) == filepath.Clean(p)
+}
+
+/* lastWorkspacePref 读「上一次真正用过的工作区」（prefs 的 lastWorkspace 字段）。
+ *
+ * 字段由移动端在每次建会话时写进 /desk/prefs（与其它偏好同源，多端共享一份）。
+ * 读不到 / 值不是绝对路径 / 目录已不存在 → 空串，让调用方走兜底。
+ * 这里只做**只读**：默认工作区不该因为在判一个默认值就反过来改用户的配置。
+ */
+func lastWorkspacePref() string {
+	p := mobilePrefsPath()
+	if p == "" {
+		return ""
+	}
+	b, err := os.ReadFile(p)
+	if err != nil || len(b) == 0 {
+		return ""
+	}
+	var v struct {
+		LastWorkspace string `json:"lastWorkspace"`
+	}
+	if err := json.Unmarshal(b, &v); err != nil {
+		return ""
+	}
+	ws := strings.TrimSpace(v.LastWorkspace)
+	if ws == "" || !filepath.IsAbs(ws) {
+		return ""
+	}
+	if st, err := os.Stat(ws); err != nil || !st.IsDir() {
+		return ""
+	}
+	return ws
+}
+
 // submitAsk 入队（或按 request_id 接回原作业）。created=false 表示命中幂等。
 // ⚠️ 返回的是**副本**：调度器随时会把状态改成 running，直接把内部指针交出去
 // 会让 HTTP 响应一边 marshal 一边被改（数据竞争，且客户端可能先看到 running）。
 func (q *jobQueue) submitAsk(req askRequest, engine, source string) (*Job, bool, error) {
 	reqID := strings.TrimSpace(req.RequestID)
+	/* 自动模式要读登记表 / 锁文件判「同空间有没有人在跑」。这份快照必须**锁外**抓：
+	   里面要 stat + PID 探活 + 开文件，占着 q.mu 会把整个调度器卡住。快照过期几毫秒的
+	   代价是「多判一次忙 / 漏判一次」，漏判方向由锁内「本队列同空间 running」兜住。 */
+	/* 任务模式（见 CLIENT-CONTRACT.md「任务模式」）：
+	     auto     → 判冲突，冲突串行、否则并行（下面 autoMode 分支）
+	     parallel → 一律并行，**不判定**（用户显式选择，不要拿 AI 再猜一遍）
+	     serial   → 同空间单槽串行，不判定
+	     空       → 老客户端：沿用 serial 布尔，语义与之前完全一致
+	   模式字段说了算，serial 只当缺省回退 —— 否则客户端只发 mode:"parallel"、
+	   不发 serial 时会被当串行（两种来源打架时以用户选的那个为准）。 */
+	selMode := strings.ToLower(strings.TrimSpace(req.Mode))
+	switch selMode {
+	case "auto", "parallel", "serial":
+	default:
+		selMode = "" // 不认识的值按老口径走，不拿它去改行为
+	}
+	autoMode := selMode == "auto"
+	var snap busySnapshot
+	if autoMode {
+		snap = q.captureBusy(req.Workspace)
+	}
 	q.mu.Lock()
 	if reqID != "" {
 		if id, ok := q.byReq[reqID]; ok {
@@ -501,6 +649,36 @@ func (q *jobQueue) submitAsk(req askRequest, engine, source string) (*Job, bool,
 	if req.Serial != nil {
 		serial = *req.Serial
 	}
+	switch selMode {
+	case "parallel":
+		serial = false
+	case "serial":
+		serial = true
+	}
+	mode := selMode
+	state := JobQueued
+	var auto *JobAuto
+	var peers []queuedCand
+	if autoMode {
+		/* 同空间还在排队的作业也要参与比较：否则用户连发两条「改底部栏」时，
+		   两条都走「空间空闲」快速通道，各判各的，最后同时去改同一个文件。 */
+		peers = q.queuedPeersLocked(ws, "")
+		rule := q.autoRuleLocked(ws, req, snap, peers)
+		if rule.decided {
+			serial = rule.serial
+			level := "none"
+			if serial {
+				level = "hard"
+			}
+			auto = &JobAuto{Conflict: serial, Level: level, Reason: rule.reason, By: rule.by, At: time.Now()}
+		} else {
+			/* 规则判不出来：先挂 judging（不是调度候选，不会被抢跑），
+			   异步去读日志 / 调建议引擎；结果写回后统一回到 queued。 */
+			serial = false
+			state = JobJudging
+			auto = &JobAuto{Conflict: false, Level: "none", Reason: "正在判断是否与运行中的任务冲突", By: "pending", At: time.Now()}
+		}
+	}
 	now := time.Now()
 	j := &Job{
 		ID:                q.nextJobIDLocked(),
@@ -521,7 +699,9 @@ func (q *jobQueue) submitAsk(req askRequest, engine, source string) (*Job, bool,
 		Attachments:       append([]string(nil), req.Attachments...),
 		Team:              req.Team,
 		Serial:            serial,
-		State:             JobQueued,
+		Mode:              mode,
+		Auto:              auto,
+		State:             state,
 		Owner:             JobOwner{Client: strings.TrimSpace(req.Client), Source: source},
 		CreatedAt:         now,
 		UpdatedAt:         now,
@@ -536,6 +716,11 @@ func (q *jobQueue) submitAsk(req askRequest, engine, source string) (*Job, bool,
 	cp.Position = q.positionLocked(j)
 	q.persistLocked(j)
 	q.mu.Unlock()
+	/* 规则没判出来的，交给异步语义判定；它完成后自己把作业送回 queued。 */
+	if autoMode && state == JobJudging {
+		q.startAutoJudge(j.ID, ws, req, snap, peers)
+		return &cp, true, nil
+	}
 	q.signal()
 	return &cp, true, nil
 }
@@ -660,7 +845,7 @@ func (q *jobQueue) waitStarted(ctx contextLike, job *Job, onQueued func(pos int)
 		if run != nil {
 			return run, true
 		}
-		if state != JobQueued && state != JobRunning {
+		if state != JobQueued && state != JobRunning && state != JobJudging {
 			return nil, false
 		}
 		/* ⚠️ 空队列直通时**不能**先发 queued：老客户端按「第一帧是 open」解析，
@@ -690,6 +875,11 @@ type contextLike interface {
 func (q *jobQueue) loop() {
 	tick := time.NewTicker(time.Second)
 	defer tick.Stop()
+	/* 幽灵占位的周期回收：只在启动时做一次的话，服务不重启就永远清不掉 ——
+	   现场症状就是「作业早就 done，列表上那条还用紫色挂着『排队中』」
+	   （2026-10-26 用户：「还是在排队」，占位文件的 mtime 停在受理那一秒）。
+	   30 秒一次足够：这不是关键路径，多扫一遍目录也不该拖慢调度。 */
+	var sweeps int
 	for {
 		select {
 		case <-q.stop:
@@ -700,9 +890,17 @@ func (q *jobQueue) loop() {
 		q.leaseOwned = q.ensureLease()
 		q.reloadNew()
 		q.dispatch()
+		if sweeps++; sweeps%jobSweepEvery == 0 {
+			q.mu.Lock()
+			q.pruneOrphanPlaceholdersLocked()
+			q.mu.Unlock()
+		}
 	}
 }
 
+// jobSweepEvery 每多少个调度拍（1s/拍）扫一次幽灵占位，见 loop。
+const jobSweepEvery = 30
+
 /*
 ── 多实例租约 ──
 
@@ -849,6 +1047,16 @@ func (q *jobQueue) dispatch() {
 		}
 		return cands[i].CreatedAt.Before(cands[k].CreatedAt)
 	})
+	/* 自动模式的同空间占位（2026-10-26）：判为串行的 auto 作业，必须等同空间**所有**
+	   在跑的作业收尾 —— 包括判为并行的那些（它们不占 q.active 的槽）。
+	   不计这一条时的现场：第二条判串行、第一条判并行正在跑 → 第二条照样放行，
+	   自动模式等于没生效。老语义（serial 不等并行作业）保持不动，只对 auto 生效。 */
+	busyAuto := map[string]int{}
+	for _, j := range q.jobs {
+		if j.State == JobRunning {
+			busyAuto[j.Workspace]++
+		}
+	}
 	var admitted []*Job
 	for _, j := range cands {
 		limit := q.max
@@ -868,8 +1076,12 @@ func (q *jobQueue) dispatch() {
 			if q.active[j.Workspace] != "" {
 				continue
 			}
+			if j.Mode == "auto" && busyAuto[j.Workspace] > 0 {
+				continue
+			}
 			q.active[j.Workspace] = j.ID
 		}
+		busyAuto[j.Workspace]++
 		j.State = JobRunning
 		j.StartedAt = now
 		j.UpdatedAt = now
@@ -926,8 +1138,14 @@ func (q *jobQueue) externalBusy(ws string, selfJob string) bool {
 	}
 	q.mu.Lock()
 	selfPID := 0
+	ignoreIdle := false
 	if j := q.jobs[selfJob]; j != nil {
 		selfPID = j.PID
+		/* 自动模式判出来的「串行」，唯一理由是**与运行中的任务冲突** —— 冲突对象只可能是
+		   running / waiting_approval。idle 的常驻会话本轮已经结束、不写文件，还把它当占用，
+		   一条自动串行作业会被同空间一个闲聊着的会话永久挡住（这正是老 externalBusy 的毛病）。
+		   明确的「串行」模式保持原样（那里 idle 也算占用的保守口径不变）。 */
+		ignoreIdle = j.Mode == "auto"
 	}
 	q.mu.Unlock()
 	target := normalizeWorkspace(ws)
@@ -938,6 +1156,9 @@ func (q *jobQueue) externalBusy(ws string, selfJob string) bool {
 		if r.State != session.StateRunning && r.State != session.StateWaitingApproval && r.State != session.StateIdle {
 			continue
 		}
+		if ignoreIdle && r.State == session.StateIdle {
+			continue
+		}
 		w := strings.TrimSpace(r.Workspace)
 		if w == "" {
 			w = strings.TrimSpace(r.Cwd)