magic-agent 2.4.3 → 2.6.3

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
@@ -67,20 +71,31 @@ type Job struct {
 	// ExplicitWorkspace 原请求是否显式带了 -w：恢复时原样下发，不能替用户改写默认语义。
 	ExplicitWorkspace bool `json:"explicit_workspace,omitempty"`
 
-	Session     string       `json:"session,omitempty"`
-	Engine      string       `json:"engine"`
-	Model       string       `json:"model,omitempty"`
-	Prompt      string       `json:"prompt"`
-	Permission  string       `json:"permission,omitempty"`
-	Reasoning   string       `json:"reasoning,omitempty"`
-	Idle        string       `json:"idle,omitempty"`
-	NoThinking  bool         `json:"no_thinking,omitempty"`
-	Hosted      bool         `json:"hosted,omitempty"`
-	Attachments []string     `json:"attachments,omitempty"`
-	Team        *teamRequest `json:"team,omitempty"`
+	Session    string `json:"session,omitempty"`
+	Engine     string `json:"engine"`
+	Model      string `json:"model,omitempty"`
+	Prompt     string `json:"prompt"`
+	Permission string `json:"permission,omitempty"`
+	Reasoning  string `json:"reasoning,omitempty"`
+	Idle       string `json:"idle,omitempty"`
+	NoThinking bool   `json:"no_thinking,omitempty"`
+	Hosted     bool   `json:"hosted,omitempty"`
+	// FallbackEngine / FallbackModel 主引擎的备用（2026-10-24，只增字段）。
+	// 作业会落盘（排队 / 重启续跑），所以必须一起存 —— 只在请求期存在的话，
+	// 排队到真正启动时备用就丢了（实测：/desk/ask 直接提交能降级，走作业队列不能）。
+	FallbackEngine string       `json:"fallback_engine,omitempty"`
+	FallbackModel  string       `json:"fallback_model,omitempty"`
+	Attachments    []string     `json:"attachments,omitempty"`
+	Team           *teamRequest `json:"team,omitempty"`
 
 	// 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"`
@@ -91,6 +106,15 @@ type Job struct {
 	SessionID string `json:"session_id,omitempty"`
 	PID       int    `json:"pid,omitempty"`
 	Error     string `json:"error,omitempty"`
+	// FallbackUsed / FallbackUsedEngine / FallbackUsedModel 本轮由备用答的案
+	// （2026-10-26，只增字段；「配了什么」是上面的 Fallback*，「用没用上」是这里）。
+	//
+	// 作业记录是排查主备的**唯一现场**：以前只有「配了什么」，没有「用没用上」，
+	// 用户报「主备没生效」时无从判断（2026-10-26 现场就是如此）。
+	// 由服务端扫事件流里 type=fallback 的帧回填；没降级时不出现。
+	FallbackUsed       bool   `json:"fallback_used,omitempty"`
+	FallbackUsedEngine string `json:"fallback_engine_used,omitempty"`
+	FallbackUsedModel  string `json:"fallback_model_used,omitempty"`
 
 	CreatedAt time.Time `json:"created_at"`
 	StartedAt time.Time `json:"started_at,omitempty"`
@@ -106,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{
@@ -121,7 +164,16 @@ func (j *Job) askRequest() askRequest {
 		Attachments: append([]string(nil), j.Attachments...),
 		Team:        j.Team,
 		Client:      j.Owner.Source,
-	}
+		// 备用引擎跟着作业一起还原（否则排队到开跑时降级配置就丢了）。
+		FallbackEngine: j.FallbackEngine,
+		FallbackModel:  j.FallbackModel,
+	}
+	/* ⚠️ 必须回填 Serial：startAsk 按它决定要不要给 core **关掉**工作空间锁
+	   （见 service.go 的 EnvWorkspaceLock；2026-10-26 起锁默认生效）。漏掉 →
+	   req.Serial == nil → 按「串行」处理 → 并行作业在 core 的 Begin 处又重新串起来，
+	   把「并行」架空（切并行后看着没生效）。 */
+	serial := j.Serial
+	req.Serial = &serial
 	if j.ExplicitWorkspace {
 		req.Workspace = j.Workspace
 	}
@@ -152,6 +204,12 @@ type jobQueue struct {
 const envJobsDir = "MAGIC_CLIENT_JOBS_DIR"
 const envMaxRunning = "MAGIC_CLIENT_MAX_RUNNING"
 
+// parallelHeadroom 全局并发满员（max）后，并行作业仍可借用的放行余量。
+// 并行作业是交互式轻活（客户端并行模式下的聊天），不该被一批长任务压死 ——
+// 2026-10-24 事故：4 个长任务占满 max=4，手机发条「hi」在队列里干等 6 分钟。
+// 只给余量而非不设限：防 UI 故障连环提交把引擎进程数打爆。
+const parallelHeadroom = 4
+
 func newJobQueue(s *Service) *jobQueue {
 	dir := strings.TrimSpace(os.Getenv(envJobsDir))
 	if dir == "" {
@@ -191,7 +249,14 @@ func (q *jobQueue) path(id string) string { return filepath.Join(q.dir, id+".jso
 
 // persistLocked 原子写一条作业（tmp + rename）；调用方须持 q.mu（或独占该 Job）。
 func (q *jobQueue) persistLocked(j *Job) {
-	if q == nil || q.dir == "" || j == nil {
+	if q == nil || j == nil {
+		return
+	}
+	/* 会话登记表跟着作业状态走（2026-10-24 用户：「没跑也先登记啊」）：
+	   queued 的作业**受理即登记**，列表页不用先看到「真开跑」才有这条；
+	   开跑 / 终结时抹掉占位，交给 core 自己那条 running 记录。 */
+	q.syncQueuedSessionLocked(j)
+	if q.dir == "" {
 		return
 	}
 	b, err := json.MarshalIndent(j, "", "  ")
@@ -212,6 +277,79 @@ func (q *jobQueue) persist(j *Job) {
 	q.persistLocked(j)
 }
 
+// queuedSessionID 排队占位的登记 id：客户端的幂等键优先（客户端据此把本地那条
+// 「等待中」与登记行认成同一条），没有才用 job id。
+// core 自己的 run_id 是 run-… 前缀，正常不会与它们相撞。
+func queuedSessionID(j *Job) string {
+	if j == nil {
+		return ""
+	}
+	if id := strings.TrimSpace(j.RequestID); id != "" && safeFileNameID(id) {
+		return id
+	}
+	return j.ID
+}
+
+// safeFileNameID 客户端给的 request_id 会变成登记文件名（<run_id>.json）：
+// 只接受字母 / 数字 / - _ .（且不能是 . / ..），其余一律退回 job id ——
+// 不让一个自定义 request_id 把文件写到登记目录外面去。
+func safeFileNameID(id string) bool {
+	if id == "" || id == "." || id == ".." || len(id) > 96 {
+		return false
+	}
+	for _, r := range id {
+		switch {
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '-', r == '_', r == '.':
+		default:
+			return false
+		}
+	}
+	return true
+}
+
+// syncQueuedSessionLocked 让会话登记表与作业状态一致（调用方须持 q.mu）。
+//
+// 只在「排队中 + 新会话」时写占位：追问（j.Session 非空）本来就是已有会话的一条
+// 排队消息，不该再冒出一行新会话；开跑 / 终结后占位必须抹掉，否则列表里会同时有
+// 占位行和 core 的真记录。
+func (q *jobQueue) syncQueuedSessionLocked(j *Job) {
+	if q == nil || j == nil {
+		return
+	}
+	id := queuedSessionID(j)
+	if id == "" {
+		return
+	}
+	if j.State != JobQueued || strings.TrimSpace(j.Session) != "" {
+		session.RemoveQueued(id)
+		return
+	}
+	client := ""
+	if q.svc != nil {
+		client = q.svc.opts.Profile.AppID()
+	}
+	cwd, _ := os.Getwd()
+	rec := session.Record{
+		RunID:      id,
+		Engine:     j.Engine,
+		Model:      j.Model,
+		Source:     j.Owner.Source,
+		Client:     client,
+		Cwd:        cwd,
+		PromptHead: j.Prompt,
+		StartedAt:  j.CreatedAt,
+	}
+	/* workspace 的口径与 core 的 Begin 一致：只有**显式选了空间**才算 Workspace；
+	   没选时列表按空 workspace 归到「任务」段（core 那时用 cwd）。 */
+	if j.ExplicitWorkspace {
+		rec.Workspace = j.Workspace
+	}
+	if j.Team != nil {
+		rec.Mode = session.ModeTeam
+	}
+	_ = session.RegisterQueued(rec) // 登记失败不该影响作业本身：最多这条列表晚一点出现
+}
+
 func (q *jobQueue) removeFile(id string) {
 	if q == nil || q.dir == "" {
 		return
@@ -243,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 起的，可能仍在跑。
@@ -270,6 +423,9 @@ func (q *jobQueue) load() {
 			}
 		case JobDone, JobFailed, JobCancelled, JobExpired:
 			if !j.UpdatedAt.IsZero() && now.Sub(j.UpdatedAt) > jobKeepTerminal {
+				/* 作业文件都要清了，排队占位（如果上次崩在「终态已落盘、占位还没删」
+				   的窗口里）也一并清掉，别留一条永远排队的幽灵行。 */
+				session.RemoveQueued(queuedSessionID(&j))
 				_ = os.Remove(filepath.Join(q.dir, e.Name()))
 				continue
 			}
@@ -279,6 +435,13 @@ func (q *jobQueue) load() {
 			j.UpdatedAt = now
 		}
 		q.jobs[j.ID] = &j
+		/* 与登记表对账：queued 的占位必须存在（受理时写过，这里幂等补一次）；
+		   其余状态一律不留占位 —— 真开跑后由 core 自己的记录接手。 */
+		if j.State == JobQueued {
+			q.syncQueuedSessionLocked(&j)
+		} else {
+			session.RemoveQueued(queuedSessionID(&j))
+		}
 		if j.RequestID != "" {
 			q.byReq[j.RequestID] = j.ID
 		}
@@ -286,6 +449,68 @@ func (q *jobQueue) load() {
 			q.byAsk[j.AskID] = j.ID
 		}
 	}
+	q.pruneOrphanPlaceholdersLocked()
+}
+
+/*
+orphanPlaceholderGrace 占位写入与作业文件落盘之间有一个极小窗口（persistLocked 先写登记、
+
+	再写作业文件，见其注释），启动对账时给新占位留一点余地，免得把「另一个进程刚提交」的
+	那一条当成陈迹删掉。
+*/
+var orphanPlaceholderGrace = time.Minute
+
+// pruneOrphanPlaceholdersLocked 清掉**作业已经不存在**的排队占位（幽灵「等待中」行）。
+//
+// 何时会出现（2026-10-24 用户：「清掉」）：占位是受理那一刻写的（core 的 RegisterQueued），
+// 正常由 syncQueuedSessionLocked 在开跑 / 终结时删掉。但作业文件被 prune、服务崩在
+// 「占位已写、作业还没落盘」之后、或换过作业目录（MAGIC_CLIENT_JOBS_DIR）时，占位就
+// 没人认领了 —— 它 PID=0、state 永远 queued，列表上一直挂着「等待中」，点也点不开。
+//
+// 口径：只看**本客户端**写的占位（Record.Client == 本 profile 的 AppID）—— 别的 magic-*
+// 应用有自己的作业目录，本进程无从判断它们是否还排着，不能替它们删。RunID 命中任一
+// queued 作业（queuedSessionID）即保留。调用方须持 q.mu。
+func (q *jobQueue) pruneOrphanPlaceholdersLocked() {
+	if q == nil || q.dir == "" || q.svc == nil {
+		return
+	}
+	/* runID → 作业状态。**不能只记 queued**：占位对应的作业一旦开跑 / 收尾，
+	   占位就必须让位（正常由 syncQueuedSessionLocked 在状态切换时删；但多实例共用
+	   一个作业目录、或那次落盘失败时，这步会漏 —— 现场就是 job 已 done、占位还在）。 */
+	known := map[string]string{}
+	for _, j := range q.jobs {
+		if j == nil {
+			continue
+		}
+		if id := queuedSessionID(j); id != "" {
+			known[id] = j.State
+		}
+	}
+	recs, err := session.List()
+	if err != nil {
+		return
+	}
+	ours := q.svc.opts.Profile.AppID()
+	cutoff := time.Now().Add(-orphanPlaceholderGrace)
+	for _, r := range recs {
+		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
+		}
+		session.RemoveQueued(r.RunID)
+	}
 }
 
 /* ── 提交 / 查询 / 取消 ── */
@@ -293,7 +518,7 @@ func (q *jobQueue) load() {
 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
@@ -301,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 {
@@ -335,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(),
@@ -350,10 +694,14 @@ func (q *jobQueue) submitAsk(req askRequest, engine, source string) (*Job, bool,
 		Idle:              req.Idle,
 		NoThinking:        req.NoThinking,
 		Hosted:            req.Hosted,
+		FallbackEngine:    strings.TrimSpace(req.FallbackEngine),
+		FallbackModel:     strings.TrimSpace(req.FallbackModel),
 		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,
@@ -368,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
 }
@@ -492,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」解析，
@@ -522,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:
@@ -532,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
+
 /*
 ── 多实例租约 ──
 
@@ -681,20 +1047,41 @@ 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 {
-		if q.running >= q.max {
-			break
+		limit := q.max
+		if !j.Serial {
+			// 并行作业（交互式轻活）满员后仍有余量可借：交互不该被长任务压死。
+			// 用 continue 而不是 break —— FIFO 里排在串行作业后面的并行作业不陪绑。
+			limit += parallelHeadroom
 		}
+		if q.running >= limit {
+			continue
+		}
+		/* 串行作业占住工作空间单槽；并行作业不占槽、也不让路 ——
+		   客户端把模式从串行切到并行后，同空间的排队作业要能立刻跟着已经在跑的
+		   串行作业一起放出去（真正的互斥由 core 侧工作空间锁只对串行注入来保证，
+		   见 startAsk）。 */
 		if j.Serial {
 			if q.active[j.Workspace] != "" {
 				continue
 			}
+			if j.Mode == "auto" && busyAuto[j.Workspace] > 0 {
+				continue
+			}
 			q.active[j.Workspace] = j.ID
-		} else if q.active[j.Workspace] != "" {
-			// 并行作业不占槽，但不该和同空间的串行作业抢跑。
-			continue
 		}
+		busyAuto[j.Workspace]++
 		j.State = JobRunning
 		j.StartedAt = now
 		j.UpdatedAt = now
@@ -751,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)
@@ -763,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)
@@ -874,6 +1270,12 @@ func (q *jobQueue) runEnded(run *askRun) {
 	if rid != "" {
 		j.RunID = rid
 	}
+	// 主备结论落作业记录（2026-10-26）：配了什么上面有，用没用上在这里。
+	if fbe, fbm := run.fallbackState(); fbe != "" {
+		j.FallbackUsed = true
+		j.FallbackUsedEngine = fbe
+		j.FallbackUsedModel = fbm
+	}
 	j.UpdatedAt = time.Now()
 	// 先释放（running-- / 清 active），再算位置；否则自己会被当成「还在跑」。
 	if j.Serial && q.active[j.Workspace] == j.ID {
@@ -946,6 +1348,49 @@ func (q *jobQueue) cancelByRequest(requestID, reason string) bool {
 	return q.cancel(id, reason)
 }
 
+// updateSerial 更新作业的串行/并行标志：客户端把任务模式切了之后，已排队但还没开跑的
+// 作业要立刻按新模式裁决，而不是沿用提交那一刻的快照 —— 不然「串行切并行」要等整条
+// 串行队消化完才生效。只认排队中的作业：running 的模式在拉起 core 时（工作空间锁注入
+// 与否）已经定死，改了也不生效，所以原样返回 updated=false。
+func (q *jobQueue) updateSerial(id string, serial bool) (*Job, bool) {
+	q.mu.Lock()
+	j := q.jobs[id]
+	if j == nil {
+		q.mu.Unlock()
+		return nil, false
+	}
+	if j.State != JobQueued {
+		cp := *j
+		cp.Position = q.positionLocked(j)
+		q.mu.Unlock()
+		return &cp, false
+	}
+	j.Serial = serial
+	j.UpdatedAt = time.Now()
+	q.recomputePositionsLocked()
+	q.persistLocked(j)
+	cp := *j
+	cp.Position = q.positionLocked(j)
+	q.mu.Unlock()
+	q.signal() // 唤醒调度循环：并行化的排队作业可能现在就能放行
+	return &cp, true
+}
+
+// updateSerialByRequest 按客户端幂等键更新（客户端还没拿到 job id 时用）。
+func (q *jobQueue) updateSerialByRequest(requestID string, serial bool) (*Job, bool) {
+	requestID = strings.TrimSpace(requestID)
+	if requestID == "" {
+		return nil, false
+	}
+	q.mu.Lock()
+	id := q.byReq[requestID]
+	q.mu.Unlock()
+	if id == "" {
+		return nil, false
+	}
+	return q.updateSerial(id, serial)
+}
+
 /* ── HTTP ── */
 
 // handleJobs /desk/jobs：GET 列表 / POST 提交。
@@ -997,7 +1442,7 @@ func (s *Service) handleJobs(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-// handleJobsSub /desk/jobs/{id}、/{id}/events、/{id}/cancel、/events（全局流）。
+// handleJobsSub /desk/jobs/{id}、/{id}/events、/{id}/cancel、/{id}/update、/events（全局流）。
 func (s *Service) handleJobsSub(w http.ResponseWriter, r *http.Request) {
 	if s.jobs == nil {
 		writeErr(w, http.StatusServiceUnavailable, "作业队列未初始化")
@@ -1030,10 +1475,37 @@ func (s *Service) handleJobsSub(w http.ResponseWriter, r *http.Request) {
 		writeJSON(w, http.StatusOK, map[string]any{"cancelled": true})
 		return
 	}
+	/* POST /desk/jobs/update {request_id, serial}：按幂等键改排队作业的串行/并行
+	   （客户端切任务模式时同步旧排队条目；只对排队中的作业生效）。 */
+	if rest == "update" {
+		if r.Method != http.MethodPost {
+			writeErr(w, http.StatusMethodNotAllowed, "POST only")
+			return
+		}
+		var body struct {
+			RequestID string `json:"request_id"`
+			Serial    *bool  `json:"serial"`
+		}
+		if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body); err != nil {
+			writeErr(w, http.StatusBadRequest, "请求体不是合法 JSON："+err.Error())
+			return
+		}
+		if body.Serial == nil {
+			writeErr(w, http.StatusBadRequest, "缺少 serial 字段")
+			return
+		}
+		job, updated := s.jobs.updateSerialByRequest(body.RequestID, *body.Serial)
+		if job == nil {
+			writeErr(w, http.StatusNotFound, "没有这个 request_id 对应的作业："+body.RequestID)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"job": job, "updated": updated})
+		return
+	}
 	parts := strings.Split(rest, "/")
 	id := parts[0]
 	if id == "" {
-		writeErr(w, http.StatusNotFound, "用法：GET /desk/jobs/{id}[?after=]，POST /desk/jobs/{id}/cancel")
+		writeErr(w, http.StatusNotFound, "用法：GET /desk/jobs/{id}[?after=]，POST /desk/jobs/{id}/cancel|update")
 		return
 	}
 	action := ""
@@ -1065,8 +1537,30 @@ func (s *Service) handleJobsSub(w http.ResponseWriter, r *http.Request) {
 		}
 		ok := s.jobs.cancel(id, "客户端取消")
 		writeJSON(w, http.StatusOK, map[string]any{"cancelled": ok, "job": s.jobs.get(id)})
+	case "update":
+		if r.Method != http.MethodPost {
+			writeErr(w, http.StatusMethodNotAllowed, "POST only")
+			return
+		}
+		var body struct {
+			Serial *bool `json:"serial"`
+		}
+		if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body); err != nil {
+			writeErr(w, http.StatusBadRequest, "请求体不是合法 JSON："+err.Error())
+			return
+		}
+		if body.Serial == nil {
+			writeErr(w, http.StatusBadRequest, "缺少 serial 字段")
+			return
+		}
+		job, updated := s.jobs.updateSerial(id, *body.Serial)
+		if job == nil {
+			writeErr(w, http.StatusNotFound, "没有这个作业："+id)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"job": job, "updated": updated})
 	default:
-		writeErr(w, http.StatusNotFound, "用法：GET /desk/jobs/{id}[?after=]，POST /desk/jobs/{id}/cancel")
+		writeErr(w, http.StatusNotFound, "用法：GET /desk/jobs/{id}[?after=]，POST /desk/jobs/{id}/cancel|update")
 	}
 }