magic-agent 2.4.3 → 2.6.0

package/internal/client/jobs.go

@@ -67,17 +67,22 @@ 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"`
@@ -91,6 +96,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"`
@@ -121,7 +135,15 @@ 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）。漏掉 → req.Serial == nil → 按「串行」处理 →
+	   并行作业在 core 的 Begin 处又去抢锁，把「并行」架空（切并行后看着没生效）。 */
+	serial := j.Serial
+	req.Serial = &serial
 	if j.ExplicitWorkspace {
 		req.Workspace = j.Workspace
 	}
@@ -152,6 +174,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 +219,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 +247,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
@@ -270,6 +378,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 +390,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 +404,54 @@ 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
+	}
+	live := map[string]bool{}
+	for _, j := range q.jobs {
+		if j != nil && j.State == JobQueued {
+			if id := queuedSessionID(j); id != "" {
+				live[id] = true
+			}
+		}
+	}
+	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 || live[r.RunID] {
+			continue
+		}
+		if r.UpdatedAt.After(cutoff) || r.StartedAt.After(cutoff) {
+			continue
+		}
+		session.RemoveQueued(r.RunID)
+	}
 }
 
 /* ── 提交 / 查询 / 取消 ── */
@@ -350,6 +516,8 @@ 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,
@@ -683,17 +851,24 @@ func (q *jobQueue) dispatch() {
 	})
 	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
 			}
 			q.active[j.Workspace] = j.ID
-		} else if q.active[j.Workspace] != "" {
-			// 并行作业不占槽，但不该和同空间的串行作业抢跑。
-			continue
 		}
 		j.State = JobRunning
 		j.StartedAt = now
@@ -874,6 +1049,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 +1127,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 +1221,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 +1254,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 +1316,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")
 	}
 }