magic-agent 2.4.3 → 2.6.3

package/internal/client/jobs_auto.go

@@ -0,0 +1,571 @@
+package client
+
+// jobs_auto.go - 「自动」任务模式：开跑前判断本轮与同工作空间运行中任务是否冲突。
+//
+// 用户口径（2026-10-26）：「同一工作空间需要根据会话历史总结 + 本轮提示词判断跟运行中
+// 的任务干的事是否冲突，冲突就串行等待」；「先规则再走建议引擎快速判断，默认并行」；
+// 「不需要排队 60 秒后重新判定」。
+//
+// ── 为什么判定不能放进队列锁 ──
+// submitAsk 全程持 q.mu（幂等、上限、位置都在里面算）。模型调用要 1-2s，塞进锁里会把
+// **整个调度器**卡停 —— 所以判定分两段：
+//   · 锁内只做**规则**（纯内存 + 一份外部快照）：同会话必串、同空间无候选直接并行；
+//   · 规则判不出来 → 作业挂 JobJudging，goroutine 去读日志 / 调模型，完了再回锁里
+//     写结论并改回 JobQueued，交给 dispatch 正常准入。
+//
+// JobJudging **不是 dispatch 的候选**（dispatch 只认 JobQueued），所以判定期间不会被抢跑。
+//
+// ── 为什么默认并行 ──
+// 判定是保护不是闸门：建议引擎没配、超时、报错、输出解析不了，一律按并行放行并标
+// undecided。宁可偶尔撞上（用户可切「串行」兜底），也不能让一次模型抽风把任务卡死。
+//
+// ── 为什么不重判 ──
+// 判为串行的作业进 queued，等主任务收尾后由 dispatch 按「同空间空闲」自然放行
+// （jobs.go 的 active 槽）—— 冲突对象已经消失，不需要再问一次模型。
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/darren/magic-agent/internal/agent"
+	"github.com/darren/magic-agent/internal/judge"
+	"github.com/darren/magic-agent/internal/session"
+)
+
+const (
+	/* autoJudgeBudget 一次语义判定的总预算（读日志 + 模型）。到点即按并行放行。
+	   为什么从 2.5s 放到 4.5s（2026-10-26 实测）：判定是**异步**的，提交那一刻就返回了
+	   judging，用户根本不等它 —— 预算紧只会让冷启动（引擎 CLI 起进程 + 首包）超时被杀，
+	   结果全是 undecided 并行，自动模式等于没开。实测 2.5s 下 dsh/llm 偶发 signal: killed，
+	   4.5s 留足冷启动余量；核心内的 3.5s 是内层上限，这边是外层兜底。 */
+	autoJudgeBudget = 4500 * time.Millisecond
+	// autoDigestEvents 每个候选最多回看多少条日志事件（抽文件 / 近况）。
+	autoDigestEvents = 400
+	// autoDigestFiles 每个候选最多带多少个已改文件。
+	autoDigestFiles = 60
+	// autoRecentRunes 候选「近况」长度上限。
+	autoRecentRunes = 800
+)
+
+// autoJudgeSlots 语义判定的并发闸：2 = 允许两条提交同时判。
+// 拿不到闸（已经在判别的）立即按「并行 + undecided」放行 —— 判定绝不能变成排队。
+var autoJudgeSlots = make(chan struct{}, 2)
+
+// busyCand 一个「正在运行、可能与本轮冲突」的会话快照。
+type busyCand struct {
+	ID        string    // session_id 优先，回落 run_id（读日志/展示用）
+	SessionID string    // 会话 id（追问同一条时用来判「同一会话」）
+	RunID     string    // 运行 id
+	Title     string    // core 归纳的标题；空则用首问
+	Workspace string    // 原始工作空间（空 = 默认空间）
+	State     string    // running | waiting_approval
+	StartedAt time.Time // 越早越先跑，冲突提示里优先展示
+}
+
+// busySnapshot 提交那一刻的「外部占用」快照。
+//
+// 为什么在锁外抓：读登记表要 stat + PID 探活，读锁文件要开文件，不该占着 q.mu。
+// 快照过期几毫秒的代价是「多判一次忙」或「漏判一次」—— 漏判方向由锁内那条
+// 「本队列同空间 running」兜住，不会真并发出两条。
+type busySnapshot struct {
+	cands    []busyCand // 同空间的运行中会话（running / waiting_approval）
+	lockHeld bool       // 同空间的工作空间锁被活进程持有（core Begin 后、登记表刷新前的窗口）
+}
+
+// autoRule 锁内规则判定的结论。
+type autoRule struct {
+	decided bool   // true = 规则已经能定；false = 需要语义判定
+	serial  bool   // decided 时有效
+	reason  string // 中文理由（界面直接显示）
+	by      string // rule
+}
+
+// spaceKeyOf 工作空间的比较键（与 core 的锁键同口径 + 两条团队目录归一）。
+//
+// 为什么复用 session.LockKey 而不是自己 Abs/Clean：core 抢锁用的就是它，
+// 两边各写一份迟早在「尾斜杠算不算同一个」上分叉；它的注释也明说导出就是给客户端判同目录用的。
+func spaceKeyOf(p string) string {
+	key, _ := session.LockKey(p)
+	return normalizeTeamSpace(key)
+}
+
+// normalizeTeamSpace 团队运行目录归到父空间。
+//
+// 团队子任务的会话把 workspace 记成 <ws>/.magic/team/<run>/<task>（internal/team/execute.go），
+// 字面上不是父空间。不归一会导致「团队正在跑」被当成别的空间 —— 自动模式判空闲、并行开跑，
+// 而它们其实在同一份代码上动。默认空间（~/.magic-agent/team/<run>）同理，归到该目录。
+func normalizeTeamSpace(key string) string {
+	if key == "" {
+		return ""
+	}
+	sep := string(filepath.Separator)
+	if i := strings.Index(key, sep+".magic"+sep+"team"+sep); i > 0 {
+		return key[:i]
+	}
+	if home, err := os.UserHomeDir(); err == nil && home != "" {
+		base := filepath.Join(home, ".magic-agent", "team")
+		if key == base || strings.HasPrefix(key, base+sep) {
+			return base
+		}
+	}
+	return key
+}
+
+// sameSpace 两个比较键是否同一个空间。Windows 上盘符大小写不敏感（d:\ws 与 D:\ws 是同一处），
+// 其余平台保持精确比较（Linux 上 Foo 与 foo 是两个目录）。
+func sameSpace(a, b string) bool {
+	if a == b {
+		return true
+	}
+	if runtime.GOOS == "windows" {
+		return strings.EqualFold(a, b)
+	}
+	return false
+}
+
+// captureBusy 抓同空间的外部占用（锁 + 登记表）。锁外调用。
+func (q *jobQueue) captureBusy(ws string) busySnapshot {
+	var snap busySnapshot
+	key := spaceKeyOf(ws)
+	if key == "" {
+		return snap
+	}
+	/* ① 工作空间锁：core 是「先抢锁、再写 running」，Finish 才释放 ——
+	   被活进程持有 = 此刻**确有一轮在写**。这是最精确的信号，也天然排除 idle
+	   （常驻会话本轮结束就放锁了）。 */
+	if h, ok := session.LockHolderFor(ws); ok && h.PID > 0 && agent.PIDAlive(h.PID) {
+		snap.lockHeld = true
+	}
+	/* ② 登记表：CLI 直接跑的、别的客户端的、团队主/子任务。
+	   List() 读侧已把死进程归成 gone，所以这里看到的 running 一定是活的。
+	   idle 不算：本轮已结束、只是进程挂着等追加，不占文件。 */
+	recs, err := session.List()
+	if err != nil {
+		return snap
+	}
+	for _, r := range recs {
+		if r.State != session.StateRunning && r.State != session.StateWaitingApproval {
+			continue
+		}
+		w := strings.TrimSpace(r.Workspace)
+		if w == "" {
+			w = strings.TrimSpace(r.Cwd)
+		}
+		if w == "" {
+			continue
+		}
+		if !sameSpace(spaceKeyOf(w), key) {
+			continue
+		}
+		id := strings.TrimSpace(r.SessionID)
+		if id == "" {
+			id = strings.TrimSpace(r.RunID)
+		}
+		if id == "" {
+			continue
+		}
+		/* 标题：core 归纳过的那份优先（与列表页同一口径），没有就回落首问。 */
+		title := strings.TrimSpace(session.TitleFor(id))
+		if title == "" {
+			title = strings.TrimSpace(r.PromptHead)
+		}
+		snap.cands = append(snap.cands, busyCand{
+			ID:        id,
+			SessionID: strings.TrimSpace(r.SessionID),
+			RunID:     strings.TrimSpace(r.RunID),
+			Title:     title,
+			Workspace: w,
+			State:     r.State,
+			StartedAt: r.StartedAt,
+		})
+	}
+	sort.Slice(snap.cands, func(i, j int) bool { return snap.cands[i].StartedAt.Before(snap.cands[j].StartedAt) })
+	if len(snap.cands) > judge.MaxCandidates {
+		snap.cands = snap.cands[:judge.MaxCandidates]
+	}
+	return snap
+}
+
+// queuedCand 同空间**已受理但还没开跑**的作业（queued / judging）。
+//
+// 为什么要把它也算进冲突比较（2026-10-26）：用户连发两条「改底部栏」时，第一条走
+// 「空间空闲」快速通道判并行、第二条也走同一条通道 —— 两条都不看对方，就会同时去改
+// 同一个文件。它们没有会话日志（还没跑），但**提示词本身就是意图**，足够模型判断。
+type queuedCand struct {
+	ID      string
+	Prompt  string
+	Session string
+}
+
+// queuedPeersLocked 抓同空间还在排队的作业（调用方持 q.mu）。
+func (q *jobQueue) queuedPeersLocked(ws, selfID string) []queuedCand {
+	key := spaceKeyOf(ws)
+	var out []queuedCand
+	for _, j := range q.jobs {
+		if j == nil || j.ID == selfID || j.Workspace == "" {
+			continue
+		}
+		if j.State != JobQueued && j.State != JobJudging {
+			continue
+		}
+		if !sameSpace(spaceKeyOf(j.Workspace), key) {
+			continue
+		}
+		out = append(out, queuedCand{ID: j.ID, Prompt: strings.TrimSpace(j.Prompt), Session: strings.TrimSpace(j.Session)})
+		if len(out) >= judge.MaxCandidates {
+			break
+		}
+	}
+	return out
+}
+
+/*
+autoRuleLocked 锁内规则判定。只碰内存（q.jobs）与传进来的快照，不做任何 I/O。
+
+	规则优先级（命中即定）：
+	 ① 同一会话还在跑 → 必串（两个进程会同时写同一份会话日志，与「事」无关，是硬约束）；
+	 ② 同空间没有任何运行中会话、队列里也没有在跑的作业 → 并行（零成本快速通道，
+	    覆盖绝大多数提交：空间空闲时根本不需要问模型）；
+	 ③ 否则规则判不出来 → 交给语义判定。
+*/
+func (q *jobQueue) autoRuleLocked(ws string, req askRequest, snap busySnapshot, peers []queuedCand) autoRule {
+	key := spaceKeyOf(ws)
+	sid := strings.TrimSpace(req.Session)
+	queueRunning := false
+	for _, j := range q.jobs {
+		if j == nil || j.Workspace == "" || !sameSpace(spaceKeyOf(j.Workspace), key) {
+			continue
+		}
+		if sid != "" && strings.TrimSpace(j.Session) == sid && (j.State == JobQueued || j.State == JobRunning || j.State == JobJudging) {
+			return autoRule{decided: true, serial: true, by: "rule",
+				reason: "同一条会话还有一轮没结束"}
+		}
+		if j.State == JobRunning {
+			queueRunning = true
+		}
+	}
+	if len(snap.cands) == 0 && len(peers) == 0 && !snap.lockHeld && !queueRunning {
+		return autoRule{decided: true, serial: false, by: "rule",
+			reason: "同空间没有正在运行的任务"}
+	}
+	return autoRule{}
+}
+
+// autoVerdict 异步判定的结果。
+type autoVerdict struct {
+	serial   bool
+	reason   string
+	level    string
+	overlaps []string
+	by       string // rule | model | undecided
+}
+
+// startAutoJudge 起一个 goroutine 做语义判定；无论成败都会把作业从 judging 送到 queued。
+func (q *jobQueue) startAutoJudge(jobID, ws string, req askRequest, snap busySnapshot, peers []queuedCand) {
+	go func() {
+		v := autoVerdict{serial: false, reason: "未判定，按并行放行", level: "none", by: "undecided"}
+		select {
+		case autoJudgeSlots <- struct{}{}:
+			defer func() { <-autoJudgeSlots }()
+			v = q.judgeNow(ws, req, snap, peers)
+		default:
+			// 已经有两条在判：不排队等（判定绝不能拖慢提交），直接按并行放行。
+		}
+		q.finishJudge(jobID, v)
+	}()
+}
+
+// finishJudge 把判定结论写回作业并放回 queued（由 dispatch 正常准入）。
+//
+// ⚠️ 只动**还在 judging** 的作业：判定期间用户可能已经取消它（state=cancelled），
+// 那种情况绝不能改回 queued —— 否则取消掉的任务会复活。
+func (q *jobQueue) finishJudge(jobID string, v autoVerdict) {
+	q.mu.Lock()
+	j := q.jobs[jobID]
+	if j == nil || j.State != JobJudging {
+		q.mu.Unlock()
+		return
+	}
+	now := time.Now()
+	j.Serial = v.serial
+	j.Auto = &JobAuto{
+		Conflict: v.serial,
+		Level:    v.level,
+		Reason:   strings.TrimSpace(v.reason),
+		Overlaps: v.overlaps,
+		By:       v.by,
+		At:       now,
+	}
+	j.State = JobQueued
+	j.UpdatedAt = now
+	q.persistLocked(j)
+	q.recomputePositionsLocked()
+	q.mu.Unlock()
+	q.signal()
+}
+
+// judgeNow 真正干活：抽候选摘要 → 文件交集规则 → 建议引擎快速判定。
+func (q *jobQueue) judgeNow(ws string, req askRequest, snap busySnapshot, peers []queuedCand) autoVerdict {
+	deadline := time.Now().Add(autoJudgeBudget)
+	dir, _ := session.DefaultLogDir()
+
+	cands := make([]judge.Candidate, 0, len(snap.cands)+len(peers))
+	for _, c := range snap.cands {
+		if time.Now().After(deadline) {
+			break
+		}
+		title, recent, files := digestOf(dir, c)
+		cands = append(cands, judge.Candidate{ID: c.ID, Title: title, Recent: recent, Files: files})
+	}
+	/* 还没开跑的排队作业：没有日志，但提示词就是它的意图（见 queuedCand 的注释）。 */
+	for _, p := range peers {
+		if strings.TrimSpace(p.Prompt) == "" {
+			continue
+		}
+		cands = append(cands, judge.Candidate{ID: p.ID, Title: clipText(p.Prompt, 40), Recent: clipText(p.Prompt, 200)})
+	}
+
+	/* 规则第二段：两边的**已改文件**有交集 → 直接判冲突，不花模型的钱。
+	   「本轮要改什么文件」还没发生，只能从提示词里认出显式写出来的路径
+	   （用户常写「改 client-ui-mobile/index.html 的底部栏」）。 */
+	if reason, overlaps := promptFileOverlap(req.Prompt, cands); len(overlaps) > 0 {
+		return autoVerdict{serial: true, reason: reason, level: "hard", overlaps: overlaps, by: "rule"}
+	}
+
+	if q.svc == nil || strings.TrimSpace(q.svc.opts.MagicAgent) == "" {
+		return autoVerdict{serial: false, reason: "没有可用的 core，按并行放行", by: "undecided"}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), autoJudgeBudget)
+	defer cancel()
+	payload, _ := json.Marshal(judge.RequestBody{
+		Prompt:     strings.TrimSpace(req.Prompt),
+		Candidates: cands,
+		Engine:     strings.TrimSpace(req.JudgeEngine),
+		Model:      strings.TrimSpace(req.JudgeModel),
+	})
+	cmd := newCoreCmd(ctx, q.svc.opts.MagicAgent, "--judge-conflict", "-")
+	cmd.Stdin = bytes.NewReader(payload)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		/* 超时单独说清楚：内核报的是 "signal: killed"，界面上显示这个等于没说。 */
+		if ctx.Err() == context.DeadlineExceeded {
+			return autoVerdict{serial: false, reason: "判定超时，按并行放行", by: "undecided"}
+		}
+		why := strings.TrimSpace(stderr.String())
+		if why == "" {
+			why = err.Error()
+		}
+		return autoVerdict{serial: false, reason: "判定失败，按并行放行：" + clipText(why, 80), by: "undecided"}
+	}
+	var res judge.Result
+	if err := json.Unmarshal(stdout.Bytes(), &res); err != nil {
+		return autoVerdict{serial: false, reason: "判定结果解析失败，按并行放行", by: "undecided"}
+	}
+	reason := strings.TrimSpace(res.Reason)
+	if reason == "" {
+		reason = "模型未给出理由"
+	}
+	level := res.Level
+	if level == "" {
+		level = "none"
+	}
+	return autoVerdict{serial: res.Conflict, reason: reason, level: level, overlaps: res.Overlaps, by: "model"}
+}
+
+// digestOf 从一个运行中会话的日志里抽「标题 / 近况 / 已改文件」。
+//
+// 只读尾部 400 条（Lean 模式）：判定要的是「最近在干什么」，不是完整历史。
+// 读不到日志不是错误（会话可能刚起还没落盘）：返回空摘要，让模型按标题判。
+func digestOf(dir string, c busyCand) (title, recent string, files []string) {
+	title = strings.TrimSpace(c.Title)
+	if dir == "" {
+		return title, "", nil
+	}
+	/* 隔离环境（测试 / 多实例）下登记表走 MAGIC_AGENT_SESSIONS、日志却仍按 HOME 落 ——
+	   两边不同目录时这里找不到该会话，摘要会读成空（判定只剩标题可用）。
+	   回退到登记表目录：core 写日志与写登记用的是同一个 id，放在一起就能读到。 */
+	if session.ResolveLogID(dir, c.ID) == "" {
+		if alt := session.Dir(); alt != "" && alt != dir && session.ResolveLogID(alt, c.ID) != "" {
+			dir = alt
+		}
+	}
+	logID := session.ResolveLogID(dir, c.ID)
+	if logID == "" {
+		logID = c.ID
+	}
+	/* alignTo 传 nil：对齐会把页首切到最后一条正文，**把更早的文件改动丢掉** ——
+	   而文件清单正是判定最硬的证据。这里要连续的一段历史，不是「一轮的起点」。 */
+	evs, _, _, err := session.ReadSessionLogBeforeLean(dir, logID, 0, autoDigestEvents, nil, sessionEventMapFromJSON)
+	if err != nil || len(evs) == 0 {
+		return title, "", nil
+	}
+	var texts []string
+	seen := map[string]bool{}
+	for _, ev := range evs {
+		switch eventType(ev) {
+		case "text":
+			if t := strings.TrimSpace(strField(ev, "text")); t != "" {
+				texts = append(texts, t)
+			}
+		case "tool_use":
+			if fileKey, ok := ev["tool_kind"]; !ok || strOf(fileKey) != "file_change" {
+				continue
+			}
+			for _, p := range pathsInToolInput(strField(ev, "text")) {
+				if seen[p] {
+					continue
+				}
+				seen[p] = true
+				files = append(files, p)
+			}
+		}
+	}
+	/* 近况取最后两段正文（越靠后越新），压成一行；文件取最后 N 个（最近的改动）。 */
+	if n := len(texts); n > 0 {
+		tail := texts
+		if n > 2 {
+			tail = texts[n-2:]
+		}
+		recent = clipText(strings.Join(tail, " "), autoRecentRunes)
+	}
+	if len(files) > autoDigestFiles {
+		files = files[len(files)-autoDigestFiles:]
+	}
+	return title, recent, files
+}
+
+// promptFileOverlap 「本轮提示词里显式写出的路径」∩「候选已改文件」。
+//
+// 只是提示词里的路径，不是真正的改动计划 —— 所以只在**精确命中**（文件名或路径后缀一致）
+// 时判冲突，避免把「提到 index.html」硬说成冲突。
+func promptFileOverlap(prompt string, cands []judge.Candidate) (string, []string) {
+	if strings.TrimSpace(prompt) == "" {
+		return "", nil
+	}
+	p := strings.ReplaceAll(prompt, "\\", "/")
+	var overlaps []string
+	for _, c := range cands {
+		for _, f := range c.Files {
+			ff := strings.TrimSpace(strings.ReplaceAll(f, "\\", "/"))
+			if ff == "" {
+				continue
+			}
+			// 命中的两种形态：完整路径出现在提示词里；或文件名（末段）出现且带扩展名。
+			hit := strings.Contains(p, ff)
+			if !hit {
+				base := filepath.Base(ff)
+				if strings.Contains(base, ".") && len([]rune(base)) >= 6 && strings.Contains(p, base) {
+					hit = true
+				}
+			}
+			if hit {
+				overlaps = append(overlaps, ff)
+				if len(overlaps) >= 6 {
+					break
+				}
+			}
+		}
+		if len(overlaps) >= 6 {
+			break
+		}
+	}
+	if len(overlaps) == 0 {
+		return "", nil
+	}
+	return "本轮和运行中的任务都要改 " + strings.Join(overlaps, "、"), overlaps
+}
+
+// pathsInToolInput 从工具参数 JSON 里抽文件路径（各引擎的键名不一致）。
+func pathsInToolInput(text string) []string {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return nil
+	}
+	var m map[string]any
+	if err := json.Unmarshal([]byte(text), &m); err != nil {
+		return nil
+	}
+	var out []string
+	add := func(v any) {
+		s := strings.TrimSpace(strOf(v))
+		if s == "" || seenIn(out, s) {
+			return
+		}
+		out = append(out, s)
+	}
+	for _, k := range []string{"file_path", "path", "notebook_path", "filename", "file"} {
+		if v, ok := m[k]; ok {
+			add(v)
+		}
+	}
+	if len(out) == 0 {
+		/* 认不出键名时扫一遍值：看起来像路径的才收（含分隔符或以盘符开头），
+		   避免把「一句话」当成文件名塞进提示词。 */
+		for _, v := range m {
+			s := strings.TrimSpace(strOf(v))
+			if s == "" {
+				continue
+			}
+			/* 带空白的多半是一句描述（"*** Update File: /a/b.md"），不是路径 ——
+			   收进来只会把整句话塞进提示词，反而干扰判定。 */
+			if strings.ContainsAny(s, " \t\r\n") {
+				continue
+			}
+			if strings.ContainsAny(s, "/\\") || filepath.IsAbs(s) {
+				add(s)
+			}
+		}
+	}
+	return out
+}
+
+func seenIn(list []string, want string) bool {
+	for _, v := range list {
+		if v == want {
+			return true
+		}
+	}
+	return false
+}
+
+func eventType(m map[string]any) string { return strings.TrimSpace(strOf(m["type"])) }
+
+func strField(m map[string]any, k string) string {
+	if v, ok := m[k]; ok {
+		return strOf(v)
+	}
+	return ""
+}
+
+func strOf(v any) string {
+	switch t := v.(type) {
+	case string:
+		return t
+	case nil:
+		return ""
+	default:
+		b, err := json.Marshal(t)
+		if err != nil {
+			return ""
+		}
+		return string(b)
+	}
+}
+
+// clipText 按 rune 截断（中文不能按字节切）。
+func clipText(s string, max int) string {
+	r := []rune(strings.TrimSpace(s))
+	if max <= 0 || len(r) <= max {
+		return string(r)
+	}
+	return string(r[:max])
+}