magic-agent 1.0.49 → 1.0.109

package/internal/cli/team.go

@@ -0,0 +1,374 @@
+package cli
+
+// team.go - 团队模式的 CLI 主流程（--team）。
+//
+// 为什么单独一个文件而不是塞进 runStreamAsk：那条流程围绕**一个引擎的一次流式调用**
+// 展开（streamer.Stream 一次、超时一次、结果一份）。团队模式是「主引擎 + N 个子引擎」，
+// 只有最外层的事件出口与收尾格式和它相同。混在一起会让两边都长出 if —— 而这条路径
+// 恰好是「出问题最难查」的那条。
+//
+// 与 +runStreamAsk 的**共用契约**（必须保持一致，否则客户端会看到两种收尾）：
+//   - 每轮以 result 或 error 收尾；
+//   - --events 下先发 ready，每条事件带 v / seq；
+//   - --save-history 时事件落盘，历史回放与实时渲染同构。
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/darren/magic-agent/internal/agent"
+	"github.com/darren/magic-agent/internal/session"
+	"github.com/darren/magic-agent/internal/team"
+)
+
+// runTeamAsk 执行一轮团队会话。
+func runTeamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
+	/* 先查 --stream：`--team` 不配它时**根本不该**走到这里（runAsk 里也挡了一次），
+	   但分发是按 opts.team 走的 —— 没有这一句，用户会看到「引擎不支持流式」
+	   这种指向引擎的报错，而真正的原因是漏了 --stream（2026-10-21 实测踩到）。 */
+	if !opts.stream {
+		return &usageError{fmt.Errorf(
+			"--team 需要 --stream（团队模式的过程靠事件流呈现：主会话里一张任务列表卡 + 每个子任务一条会话）；" +
+				"加上 --stream 即可，或去掉 --team 走单引擎")}
+	}
+	engine, format, req, err := prepareAsk(cmd, args, opts)
+	if err != nil {
+		return err
+	}
+	if agent.AsStreamer(engine) == nil {
+		return &usageError{fmt.Errorf("engine %q does not support streaming（--team 需要流式能力）", engine.Name())}
+	}
+	routes, err := team.ParseRoutes(opts.teamRoutes)
+	if err != nil {
+		return &usageError{err}
+	}
+	if err := team.ValidateRoutes(routes); err != nil {
+		return &usageError{err}
+	}
+	split, err := team.NormalizeSplit(opts.teamSplit)
+	if err != nil {
+		return &usageError{err}
+	}
+	rules, err := team.ParseRules(opts.teamRules)
+	if err != nil {
+		return &usageError{err}
+	}
+	var teamPerm agent.PermissionTier
+	if raw := strings.TrimSpace(opts.teamPerm); raw != "" {
+		tier, ok := agent.ParsePermissionTier(raw)
+		if !ok {
+			return &usageError{fmt.Errorf("--team-permission 取值无效: %q（可选 %s）",
+				raw, strings.Join(agent.PermissionTiers(), " | "))}
+		}
+		teamPerm = tier
+	}
+
+	stdout, stderr := cmd.OutOrStdout(), cmd.ErrOrStderr()
+	sink := newEventSink(stdout, engine.Name(), opts.events)
+
+	// 会话存档：与 --stream 同一条路径（团队会话同样要能回看）。
+	var sessionLog *sessionWriter
+	if opts.saveHistory {
+		sw, serr := newSessionWriterAuto(sessionLogDir)
+		if serr != nil {
+			fmt.Fprintf(stderr, "magic-agent: 准备会话存档目录失败：%v（流继续）\n", serr)
+		} else {
+			sessionLog = sw
+			defer func() { sessionLog.close() }()
+		}
+	}
+	req.OnSessionID = func(id string) {
+		if sessionLog != nil {
+			sessionLog.setSessionID(id)
+		}
+	}
+	if sessionLog != nil {
+		for _, m := range req.Messages {
+			if m.Role != "user" || strings.TrimSpace(m.Content) == "" {
+				continue
+			}
+			sessionLog.push(sessionEvent{Kind: "user", Text: m.Content, Attachments: req.Attachments})
+		}
+	}
+
+	// 事件出口：--no-thinking 只压思考。
+	// 团队模式下主会话只出现任务列表快照（KindTasks）与汇总，子任务的过程事件
+	// 走各自子会话的日志（见 team_session.go），不再带 parent 转发进来。
+	emit := func(ev agent.StreamEvent) {
+		if ev.Kind == agent.KindThinking && opts.noThinking {
+			return
+		}
+		if format == agent.FormatJSON {
+			_ = sink.stream(ev)
+		} else {
+			switch ev.Kind {
+			case agent.KindThinking:
+				fmt.Fprint(stderr, "… "+ev.Text)
+			case agent.KindText:
+				fmt.Fprint(stdout, ev.Text)
+			case agent.KindToolUse:
+				fmt.Fprint(stderr, "🔧 "+ev.Name+"("+ev.ID+") "+ev.Text+"\n")
+			case agent.KindToolResult:
+				fmt.Fprint(stderr, "   ↳ "+ev.Text+"\n")
+			case agent.KindNotice:
+				fmt.Fprint(stderr, "· "+ev.Text+"\n")
+			case agent.KindTasks:
+				// 快照每次变化都会整份重发：text 模式只打一行摘要，不重画整张表。
+				if line := tasksLine(ev.Text); line != "" {
+					fmt.Fprint(stderr, "☰ "+line+"\n")
+				}
+			case agent.KindTurnFailed:
+				fmt.Fprint(stderr, "✗ 本轮异常收尾："+ev.Reason+"\n")
+			}
+		}
+		if sessionLog != nil {
+			sessionLog.push(sessionEvent{
+				Kind: string(ev.Kind), Text: ev.Text, Name: ev.Name, ID: ev.ID,
+				ToolKind: toolKindOfEvent(ev), Ask: ev.Ask,
+				ItemID: ev.ItemID, ItemRevision: ev.ItemRevision,
+				Status: string(ev.Status), Parent: ev.Parent,
+				SubSessionID: ev.SubSessionID,
+				Error:        ev.Error, Reason: ev.Reason,
+			})
+		}
+	}
+
+	ctx := cmd.Context()
+	if !opts.keepAlive || flagChanged(cmd, "timeout") {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, opts.timeout)
+		defer cancel()
+	}
+	// --control 的打断：取消 ctx → 在跑的子任务进程组一起收。
+	var cancelAll context.CancelFunc
+	if opts.control {
+		ctx, cancelAll = context.WithCancel(ctx)
+		defer cancelAll()
+	}
+
+	h := beginSession(engine.Name(), req, opts.saveRegistry)
+	ctx = withSessionHook(ctx, h)
+	if h != nil {
+		// 开跑前就标上：计划阶段可能几十秒，这期间列表里已经能看到这条会话了。
+		h.SetMode(session.ModeTeam)
+		h.Mark(session.StateRunning)
+	}
+	if sessionLog != nil && h != nil {
+		sessionLog.setRunID(h.RunID())
+	}
+	if h != nil {
+		sink.setRunID(h.RunID())
+	}
+	_ = sink.ready(req.Model)
+
+	if opts.control {
+		ctl := startControlReader(cmd.InOrStdin(), sink, controlHooks{
+			interrupt: func(reason string) { cancelAll() },
+			stop:      func() { cancelAll() },
+			// 团队模式下子任务不共享上下文，也没有单条常驻会话可追加 —— 明确拒绝，
+			// 而不是静默吞掉（调用方以为答上了才是最坏的结果）。
+			answer: func(text string) bool { return false },
+		})
+		defer ctl.Close()
+	}
+
+	runID := ""
+	if h != nil {
+		runID = h.RunID()
+	}
+	res, err := team.Run(ctx, team.Options{
+		Engine:            engine,
+		Model:             req.Model,
+		Prompt:            lastUserText(req.Messages),
+		SystemPrompt:      req.SystemPrompt,
+		Reasoning:         req.Reasoning,
+		SessionID:         req.SessionID,
+		Continue:          req.Continue,
+		Routes:            routes,
+		Parallel:          opts.teamParallel,
+		Split:             split,
+		SplitSimpleCode:   opts.teamSplitCode,
+		Rules:             rules,
+		TaskTimeout:       opts.teamTaskTO,
+		Timeout:           opts.timeout,
+		Workspace:         req.Workspace,
+		RunID:             runID,
+		BaseDir:           opts.teamRunDir,
+		Permission:        teamPerm,
+		PermissionOptions: req.PermissionOptions,
+		Tools:             req.Tools,
+		PlanOnly:          opts.teamPlanOnly,
+		Adaptive:          opts.teamAdaptive,
+		// 每个子任务 = 一条普通会话：登记记录 + 自己的日志，父指针挂在本会话下。
+		OpenSubSession: func(t team.Task, runDir, engine, model string) team.SubSession {
+			return openSubSession(h, opts.saveRegistry, opts.saveHistory, stderr, t, runDir, engine, model)
+		},
+		OnEvent: emit,
+	})
+	if err != nil {
+		finishSession(h, "", session.StateFailed)
+		if format == agent.FormatJSON {
+			_ = sink.event(streamErrorPayload(engine.Name(), err))
+			_ = agent.WriteError(stderr, format, engine.Name(), 1, err)
+		} else {
+			fmt.Fprintf(stderr, "\nmagic-agent: %v\n", err)
+		}
+		return &reportedError{err}
+	}
+	finishSession(h, res.SessionID, session.StateDone)
+	if h != nil {
+		// 收尾前落路由结果（按类别归并）：列表页据此显示「谁在干活」。
+		// 放在 Finish 之后 —— 两者各写一次盘，顺序反过来也没有语义差别，
+		// 但先写终态能让列表页更早看到「已结束」。
+		h.SetAgents(agentRefs(res.Tasks))
+	}
+
+	if format == agent.FormatJSON {
+		out := struct {
+			Type      string     `json:"type"`
+			Engine    string     `json:"engine"`
+			Model     string     `json:"model"`
+			SessionID string     `json:"session_id,omitempty"`
+			Mode      string     `json:"mode"`
+			PlanPath  string     `json:"plan_path,omitempty"`
+			RunDir    string     `json:"run_dir,omitempty"`
+			LatencyMS int64      `json:"latency_ms"`
+			Text      string     `json:"text"`
+			Tasks     []taskView `json:"tasks,omitempty"`
+		}{
+			Type: "result", Engine: engine.Name(), Model: req.Model,
+			SessionID: res.SessionID, Mode: "team",
+			PlanPath: res.PlanPath, RunDir: res.RunDir,
+			LatencyMS: res.Latency.Milliseconds(), Text: res.Text,
+			Tasks: taskViews(res.Tasks),
+		}
+		_ = sink.event(out)
+	} else {
+		fmt.Fprintln(stdout)
+	}
+	return nil
+}
+
+// agentRefs 把子任务结果按「类别 + 引擎 + 模型」归并成登记表里的 Agents。
+//
+// 为什么按类别归并而不是一个任务一条：登记表是列表页的数据源，一个 6 任务的团队会话
+// 会把列表接口撑成 6 条一样的长行，用户看不出差别（同一类多半派给同一个引擎）。
+// 同类但引擎不同（比如 image 一半给了 A 一半给了 B）时各留一条，不合并 —— 那正是
+// 「谁在干活」的真实情况。
+func agentRefs(rs []team.TaskResult) []session.AgentRef {
+	type key struct{ kind, engine, model string }
+	order := make([]key, 0, len(rs))
+	counts := make(map[key]int, len(rs))
+	// 每个类别下**子引擎自己的**会话 id（绑定在主会话下，见 team.TaskResult.SessionID）。
+	sessions := make(map[key][]string, len(rs))
+	for _, r := range rs {
+		if r.Engine == "" {
+			continue // 没引擎 = 没跑起来（skipped），不算「谁在干活」
+		}
+		k := key{kind: r.Kind, engine: r.Engine, model: r.Model}
+		if _, ok := counts[k]; !ok {
+			order = append(order, k)
+		}
+		counts[k]++
+		if r.SessionID != "" {
+			sessions[k] = append(sessions[k], r.SessionID)
+		}
+	}
+	if len(order) == 0 {
+		return nil
+	}
+	out := make([]session.AgentRef, 0, len(order))
+	for _, k := range order {
+		out = append(out, session.AgentRef{
+			Kind: k.kind, Engine: k.engine, Model: k.model,
+			Count: counts[k], Sessions: sessions[k],
+		})
+	}
+	return out
+}
+
+// taskView 收尾 envelope 里的子任务摘要（客户端 / 脚本据此画任务清单）。
+type taskView struct {
+	ID   string `json:"id"`
+	Kind string `json:"kind"`
+	// Role 执行角色（规范名）。任务只写角色，Kind 是它的派生值。
+	Role   string `json:"role,omitempty"`
+	Title  string `json:"title"`
+	Engine string `json:"engine,omitempty"`
+	Model  string `json:"model,omitempty"`
+	// SessionID 子引擎自己的会话 id（绑在主会话下；事件流里不带它，见 internal/team）。
+	SessionID string   `json:"session_id,omitempty"`
+	State     string   `json:"state"`
+	Reason    string   `json:"reason,omitempty"`
+	Output    string   `json:"output,omitempty"`
+	Arts      []string `json:"arts,omitempty"`
+	Missing   []string `json:"missing,omitempty"`
+}
+
+func taskViews(rs []team.TaskResult) []taskView {
+	out := make([]taskView, 0, len(rs))
+	for _, r := range rs {
+		out = append(out, taskView{
+			ID: r.ID, Kind: r.Kind, Role: r.Role, Title: r.Title,
+			Engine: r.Engine, Model: r.Model, SessionID: r.SessionID,
+			State: r.State, Reason: r.Reason,
+			Output: r.OutputPath, Arts: r.Arts, Missing: r.Missing,
+		})
+	}
+	return out
+}
+
+// tasksLine 把任务列表快照压成一行（text 模式用；JSON 模式直接透传快照本身）。
+//
+// 快照是**全量**的（每次状态变化整份重发），所以这里只报「到哪了」：
+// 完成数 + 正在跑 / 失败的任务 id，够人看进度，又不会把 stderr 刷成表格。
+func tasksLine(text string) string {
+	var snap struct {
+		Tasks []struct {
+			ID     string `json:"id"`
+			Status string `json:"status"`
+		} `json:"tasks"`
+	}
+	if json.Unmarshal([]byte(text), &snap) != nil || len(snap.Tasks) == 0 {
+		return ""
+	}
+	done := 0
+	var running, failed, skipped []string
+	for _, t := range snap.Tasks {
+		switch t.Status {
+		case "done":
+			done++
+		case "running":
+			running = append(running, t.ID)
+		case "failed":
+			failed = append(failed, t.ID)
+		case "skipped":
+			skipped = append(skipped, t.ID)
+		}
+	}
+	line := fmt.Sprintf("任务 %d/%d 完成", done, len(snap.Tasks))
+	if len(running) > 0 {
+		line += " · 运行中：" + strings.Join(running, "、")
+	}
+	if len(failed) > 0 {
+		line += " · 失败：" + strings.Join(failed, "、")
+	}
+	if len(skipped) > 0 {
+		line += " · 跳过：" + strings.Join(skipped, "、")
+	}
+	return line
+}
+
+// lastUserText 最后一条 user 消息（团队模式以它为原始诉求）。
+func lastUserText(msgs []agent.Message) string {
+	for i := len(msgs) - 1; i >= 0; i-- {
+		if msgs[i].Role == "user" || msgs[i].Role == "" {
+			return msgs[i].Content
+		}
+	}
+	return ""
+}

package/internal/cli/team_session.go

@@ -0,0 +1,156 @@
+package cli
+
+// team_session.go - 团队子任务的「会话化」实现。
+//
+// 用户 2026-10-22 定稿：拆出来的子任务跟普通会话一样 —— 有自己的登记记录、自己的
+// 日志（点进去能看到完整过程，也能单独 --stop），靠父指针挂在主会话下显示；
+// 主会话里只留一张任务列表卡。
+//
+// team 包不依赖 internal/session 与日志实现，只通过 team.SubSession 把这三件事
+// 委托出来（见 internal/team/subsession.go）；具体落到 session.Handle + sessionWriter
+// 的实现就在本文件。
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/darren/magic-agent/internal/agent"
+	"github.com/darren/magic-agent/internal/session"
+	"github.com/darren/magic-agent/internal/team"
+)
+
+// subSession 一条子任务对应的普通会话。
+type subSession struct {
+	h *session.Handle
+	// log 过程日志（--save-history 才开；空 = 不落盘，过程仍跑）。
+	log *sessionWriter
+}
+
+// openSubSession 为一个子任务开一条会话。
+//
+// 返回 nil 表示这条子任务不单独登记（登记表开不出来）—— team 侧会退回
+// 「只在任务列表里留一行」，不阻断执行。日志写盘失败同样只降级：过程照跑，
+// 只是这条子会话点进去没有历史。
+func openSubSession(parent *session.Handle, saveRegistry, saveHistory bool, warn io.Writer,
+	t team.Task, runDir, engine, model string) team.SubSession {
+
+	var parentRunID, parentSessionID, src, client string
+	if parent != nil {
+		rec := parent.Record()
+		parentRunID, parentSessionID = parent.RunID(), rec.SessionID
+		src, client = rec.Source, rec.Client
+	}
+	h, err := session.Begin(session.BeginOptions{
+		Engine:     engine,
+		Model:      model,
+		Source:     src,
+		Client:     client,
+		Workspace:  team.TaskDir(runDir, t.ID),
+		PromptHead: t.Title,
+		NoPersist:  !saveRegistry,
+		// 父指针让会话列表能把它挂在主会话下面（按父 run_id / session_id 归并）。
+		ParentRunID:     parentRunID,
+		ParentSessionID: parentSessionID,
+	})
+	if err != nil {
+		fmt.Fprintf(warn, "magic-agent: 子任务 %s 的会话登记失败：%v（继续执行，只是不进会话列表）\n", t.ID, err)
+		return nil
+	}
+	sub := &subSession{h: h}
+	if saveHistory {
+		sw, serr := newSessionWriterAuto(sessionLogDir)
+		if serr != nil {
+			fmt.Fprintf(warn, "magic-agent: 子任务 %s 的会话存档目录准备失败：%v（过程不落盘）\n", t.ID, serr)
+		} else {
+			sw.setRunID(h.RunID())
+			// 历史里的第一条 user 消息 = 任务书（用户没说过话，但点进去要看得懂这是哪件事）。
+			sw.push(sessionEvent{Kind: "user", Text: subPrompt(t)})
+			sub.log = sw
+		}
+	}
+	return sub
+}
+
+// subPrompt 子会话历史开头的 user 消息：任务标题 + 完整任务书。
+func subPrompt(t team.Task) string {
+	title := strings.TrimSpace(t.Title)
+	prompt := strings.TrimSpace(t.Prompt)
+	switch {
+	case title == "":
+		return prompt
+	case prompt == "":
+		return title
+	default:
+		return title + "\n\n" + prompt
+	}
+}
+
+func (s *subSession) RunID() string { return s.h.RunID() }
+
+func (s *subSession) SetSessionID(id string) {
+	if strings.TrimSpace(id) == "" {
+		return
+	}
+	s.h.SetSessionID(id)
+	if s.log != nil {
+		s.log.setSessionID(id)
+	}
+}
+
+// Push 子任务的一条过程事件：只写它自己的日志，不进主会话。
+func (s *subSession) Push(ev agent.StreamEvent) {
+	if ev.SessionID != "" {
+		s.SetSessionID(ev.SessionID)
+	}
+	if s.log == nil {
+		return
+	}
+	// 字段与主会话的落盘口径一致（见 team.go 的 emit）：历史回放与实时渲染同构。
+	s.log.push(sessionEvent{
+		Kind: string(ev.Kind), Text: ev.Text, Name: ev.Name, ID: ev.ID,
+		ToolKind: toolKindOfEvent(ev), Ask: ev.Ask,
+		ItemID: ev.ItemID, ItemRevision: ev.ItemRevision,
+		Status: string(ev.Status), Parent: ev.Parent,
+		SubSessionID: ev.SubSessionID,
+		Error:        ev.Error, Reason: ev.Reason,
+	})
+}
+
+// Finish 收尾：写最终状态 + 回填会话 id + 关掉日志。
+func (s *subSession) Finish(sessionID, state, _ string) {
+	if strings.TrimSpace(sessionID) == "" {
+		sessionID = s.h.Record().SessionID
+	}
+	s.h.Finish(sessionID, subSessionState(state))
+	if s.log != nil {
+		if sessionID != "" {
+			s.log.setSessionID(sessionID)
+		}
+		s.log.close()
+		s.log = nil
+	}
+}
+
+// Context 把「子引擎 pid 登记」挂到子任务 ctx 上（--stop 靠它按进程组杀）。
+func (s *subSession) Context(parent context.Context) context.Context {
+	if s.h == nil {
+		return parent
+	}
+	return agent.WithSpawnHook(parent, func(pid int) { s.h.SetPID(pid, true) })
+}
+
+// subSessionState 把子任务的结局翻成会话状态词表。
+//
+// skipped 记成 cancelled：会话侧的词表里没有「跳过」，它的含义就是「没跑，被取消了」。
+func subSessionState(state string) string {
+	switch state {
+	case team.TaskDone, "":
+		return session.StateDone
+	case team.TaskSkipped:
+		return session.StateCancelled
+	default:
+		return session.StateFailed
+	}
+}