magic-agent 1.0.46 → 1.0.108

package/internal/client/requirements.go

@@ -0,0 +1,309 @@
+package client
+
+// requirements.go - 「会话自动聚合成需求」在插件侧的三个口子。
+//
+// 分工（与 core 的 §3.4.1 一一对应）：
+//
+//	GET  /desk/requirements            读清单（纯读，不调模型）
+//	POST /desk/requirements/consolidate 手动「立即整理」一轮（首次 = 按目录初始化）
+//	每轮 /desk/ask 收尾 → 防抖 12s 自动归纳该轮所在工作区（只增量，不初始化）
+//
+// 「首次 = 按目录初始化」的判断在 core（state.bootstrap_at），插件不重复实现：
+// 手动请求不带 --requirement-auto，core 于是会先扫目录反推基线；自动路径带这个标记，
+// 只消费上次游标之后的新会话 —— 否则每轮对话都可能悄悄花几分钟读代码。
+//
+// 为什么自动归纳放在插件、不放在 core：core 是**一次性进程**，一轮跑完就退出，
+// 没有「一轮结束之后」这个概念；只有常驻的插件知道「这一轮刚刚收尾」。
+// 而归纳本身仍在 core（`--consolidate-requirements`）—— 插件只负责挑时机。
+//
+// 为什么防抖 12s：用户连着追问三四句是常态，每句都归纳一次等于把同一段对话
+// 喂给模型三四遍（既慢又容易把同一件事写成三四条）。12s 是业务项目实测下来
+// 「一句说完、下一句还没打完」的经验值，期间再来一轮就顺延、合并成一次。
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+// FeatureRequirements core 侧的能力位（与 internal/agent 的同名常量一致）。
+//
+// 为什么不直接引 agent.FeatureRequirements：插件本来就 import 了 agent（team_flags.go
+// 引了 FeatureSessionTeam 之外的 team 请求类型），但这里刻意写成本包常量是为了让
+// 「插件依赖哪些能力位」在 grep 时只有一处 —— 与 FeatureSessionTeam 的处理方式一致。
+const FeatureRequirements = "feature.requirements"
+
+// reqAutoDebounce 一轮收尾后等多久再归纳（期间再来一轮就顺延）。
+const reqAutoDebounce = 12 * time.Second
+
+// reqConsolidateTimeout 手动/自动归纳的上限。
+//
+// 比 proxyCoreTimeout（45s）长得多：一轮归纳是**一次或多次模型调用**（全量重放还会分片），
+// core 侧单次调用默认 4 分钟。给到 10 分钟覆盖「首次回填一大段历史」这种最慢的情况。
+const reqConsolidateTimeout = 10 * time.Minute
+
+// reqAutoOffEnv 关掉自动归纳的环境变量（排查 / 省额度用）。
+const reqAutoOffEnv = "MAGIC_CLIENT_NO_REQ_AUTO"
+
+// handleRequirements GET /desk/requirements?ws=<ws_id|目录>：
+// 转发 core 的需求清单。
+//
+// ws 留空 = 列全部工作区：移动端/PC 的需求页要一次拿全再在前端按工作区分组。
+func (s *Service) handleRequirements(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeErr(w, http.StatusMethodNotAllowed, "GET only")
+		return
+	}
+	/* 老 core 不认这个 flag（exit 2）。先查能力位并**说清楚为什么** ——
+	   让用户看到「core 太旧，请升级」，比让它报一句 usage error 强得多。 */
+	if !hasStr(s.contract.Features, FeatureRequirements) {
+		writeErr(w, http.StatusNotImplemented,
+			"当前 core 不支持需求聚合（缺少 "+FeatureRequirements+" 能力位，请升级 magic-agent）")
+		return
+	}
+	ws := strings.TrimSpace(r.URL.Query().Get("ws"))
+	if ws == "" {
+		ws = "all"
+	}
+	s.proxyCore(w, r, "--requirements", ws)
+}
+
+// handleRequirementsConsolidate POST /desk/requirements/consolidate：
+// 立即归纳一轮（用户点「整理」）。
+//
+// 请求体：{"workspace":"<ws_id|目录>", "force":false, "all":false,
+//
+//	"engine":"claude", "model":"..."}
+//
+// workspace 留空 = 插件自己的工作目录（与 /desk/health 的 defaultWorkspace 一致 ——
+// 那就是 core 不传 -w 时记录的 cwd）。
+// engine / model 是客户端当前配置的默认引擎与模型（移动端「我的 → 默认引擎」）：
+// 「整理的引擎就是配置的默认引擎」—— 客户端传什么，core 就按什么跑，不再自动替换。
+func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeErr(w, http.StatusMethodNotAllowed, "POST only")
+		return
+	}
+	if !hasStr(s.contract.Features, FeatureRequirements) {
+		writeErr(w, http.StatusNotImplemented,
+			"当前 core 不支持需求聚合（缺少 "+FeatureRequirements+" 能力位，请升级 magic-agent）")
+		return
+	}
+	var body struct {
+		Workspace string `json:"workspace,omitempty"`
+		Force     bool   `json:"force,omitempty"`
+		All       bool   `json:"all,omitempty"`
+		Engine    string `json:"engine,omitempty"`
+		Model     string `json:"model,omitempty"`
+	}
+	// 空 body 是合法调用（全部走默认），所以 Decode 的 EOF 不算错。
+	if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&body); err != nil && err != io.EOF {
+		writeErr(w, http.StatusBadRequest, "请求体不是合法 JSON："+err.Error())
+		return
+	}
+	ws := strings.TrimSpace(body.Workspace)
+	if ws == "" {
+		if wd, err := os.Getwd(); err == nil {
+			ws = wd
+		}
+	}
+	if ws == "" {
+		writeErr(w, http.StatusBadRequest, "workspace 不能为空（传 ws id 或目录）")
+		return
+	}
+	engine := strings.TrimSpace(body.Engine)
+	model := strings.TrimSpace(body.Model)
+	if model != "" && engine == "" {
+		writeErr(w, http.StatusBadRequest, "model 不能脱离 engine 单独指定")
+		return
+	}
+	if engine != "" && !s.opts.Profile.AllowsEngine(engine) {
+		writeErr(w, http.StatusForbidden, fmt.Sprintf("profile 白名单不允许引擎 %q", engine))
+		return
+	}
+	out, err := s.runCoreTimed(r.Context(), reqConsolidateTimeout,
+		consolidateArgs(ws, body.Force, body.All, false, engine, model)...)
+	if err != nil {
+		code := http.StatusBadGateway
+		if isCoreTimeout(err) {
+			code = http.StatusGatewayTimeout
+		}
+		writeErr(w, code, fmt.Sprintf("%s --consolidate-requirements 失败：%v", s.opts.MagicAgent, err))
+		return
+	}
+	writeCoreJSON(w, out)
+}
+
+// consolidateArgs 组归纳命令。
+//
+// engine/model 来自客户端配置的默认引擎（手动「整理」）：传了就用它，core 不再自动换。
+// 自动归纳（auto=true）不传：后台没有「当前设备默认引擎」这个概念，让 core 走自己的
+// 默认（增量用 llm；首次初始化也不会发生，因为 --requirement-auto 明确禁止）。
+func consolidateArgs(ws string, force, all, auto bool, engine, model string) []string {
+	args := []string{"--consolidate-requirements", ws}
+	if force {
+		args = append(args, "--requirement-force")
+	}
+	if all {
+		args = append(args, "--requirement-all")
+	}
+	if auto {
+		// 自动路径只消费新会话，绝不触发首次目录初始化（那会每轮都读一遍代码）。
+		args = append(args, "--requirement-auto")
+	}
+	if e := strings.TrimSpace(engine); e != "" {
+		args = append(args, "--requirement-engine", e)
+		if m := strings.TrimSpace(model); m != "" {
+			args = append(args, "--requirement-model", m)
+		}
+	}
+	return args
+}
+
+// runCoreTimed 与 runCore 同形，但超时可调（归纳不是 45s 能跑完的）。
+func (s *Service) runCoreTimed(ctx context.Context, timeout time.Duration, args ...string) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, s.opts.MagicAgent, args...)
+	// 与 runCore 同一道保险：core 的后代进程握着管道时 Wait 不能永久挂住。
+	cmd.WaitDelay = 5 * time.Second
+	out, err := cmd.Output()
+	if err != nil {
+		if ctx.Err() != nil || errors.Is(err, exec.ErrWaitDelay) {
+			return nil, fmt.Errorf("%w（%s）", errCoreTimeout, timeout)
+		}
+		return nil, err
+	}
+	return out, nil
+}
+
+// isCoreTimeout 判断错误链里是不是「等 core 超时」。
+func isCoreTimeout(err error) bool {
+	return err != nil && strings.Contains(err.Error(), errCoreTimeout.Error())
+}
+
+/* ─────────────── 轮末自动归纳（防抖 + 单飞） ─────────────── */
+
+// pinnedWorkspace 这一轮算在哪个目录。
+//
+// 请求带 -w 用它；没带就是插件自己的 cwd（core spawn 时不换目录，Begin 记下的就是它）。
+// 归一化到绝对路径：客户端可能传相对路径，而 core 侧的 workspace id 是
+// sha1(绝对路径) —— 不归一就归到另一个工作区去了。
+func pinnedWorkspace(reqWorkspace string) string {
+	d := strings.TrimSpace(reqWorkspace)
+	if d == "" {
+		if wd, err := os.Getwd(); err == nil {
+			d = wd
+		}
+	}
+	if d == "" {
+		return ""
+	}
+	if abs, err := filepath.Abs(d); err == nil {
+		d = abs
+	}
+	return d
+}
+
+// reqAuto 自动归纳的调度器：每个工作区一个防抖计时器 + 一个「正在跑」标记。
+type reqAuto struct {
+	mu      sync.Mutex
+	timers  map[string]*time.Timer
+	running map[string]bool
+	queued  map[string]bool // 归纳期间又来了新记忆 → 跑完补一轮
+}
+
+// maybeAutoConsolidate 一轮对话收尾后调用（12s 内再来一轮就顺延）。
+//
+// ws 为空直接返回：不知道这条会话属于哪个目录时**不要猜** —— 归纳到错的工作区
+// 比不归纳危险得多（会往用户的另一份需求文档里塞内容）。
+func (s *Service) maybeAutoConsolidate(ws string) {
+	if strings.TrimSpace(os.Getenv(reqAutoOffEnv)) == "1" {
+		return
+	}
+	ws = strings.TrimSpace(ws)
+	if ws == "" || !hasStr(s.contract.Features, FeatureRequirements) {
+		return
+	}
+	s.reqAuto.mu.Lock()
+	defer s.reqAuto.mu.Unlock()
+	if s.reqAuto.timers == nil {
+		s.reqAuto.timers = map[string]*time.Timer{}
+		s.reqAuto.running = map[string]bool{}
+		s.reqAuto.queued = map[string]bool{}
+	}
+	if t := s.reqAuto.timers[ws]; t != nil {
+		t.Stop() // 顺延：这一批合并成一次
+	}
+	s.reqAuto.timers[ws] = time.AfterFunc(reqAutoDebounce, func() { s.runAutoConsolidate(ws) })
+}
+
+// runAutoConsolidate 真正跑一次自动归纳（单飞 + 补跑）。
+func (s *Service) runAutoConsolidate(ws string) {
+	s.reqAuto.mu.Lock()
+	// 防御：自动归纳也可能被测试 / 维护脚本直接调用（没经过 maybeAutoConsolidate
+	// 的 map 初始化）。这里补齐，避免 nil map 写入 panic。
+	if s.reqAuto.timers == nil {
+		s.reqAuto.timers = map[string]*time.Timer{}
+		s.reqAuto.running = map[string]bool{}
+		s.reqAuto.queued = map[string]bool{}
+	}
+	delete(s.reqAuto.timers, ws)
+	if s.reqAuto.running[ws] {
+		s.reqAuto.queued[ws] = true
+		s.reqAuto.mu.Unlock()
+		return
+	}
+	s.reqAuto.running[ws] = true
+	s.reqAuto.mu.Unlock()
+
+	// 归纳是后台行为：**不绑**任何 HTTP 请求的生命周期，用独立 context。
+	ctx, cancel := context.WithTimeout(context.Background(), reqConsolidateTimeout)
+	out, err := s.runCoreTimed(ctx, reqConsolidateTimeout, consolidateArgs(ws, false, false, true, "", "")...)
+	cancel()
+	if err != nil {
+		s.log.Printf("需求自动归纳失败 %s: %v", ws, err)
+	} else {
+		/* 结果只写日志：这是后台动作，用户没在等它。
+		   但**要能事后查** —— 「刚才明明聊了，需求页却没变」的第一现场就是这里。 */
+		var res struct {
+			Noop    bool   `json:"noop"`
+			Updated int    `json:"updated"`
+			Created int    `json:"created"`
+			Pending int    `json:"pending"`
+			Error   string `json:"error"`
+		}
+		if json.Unmarshal(out, &res) == nil {
+			if res.Error != "" {
+				s.log.Printf("需求自动归纳未完成 %s: %s", ws, res.Error)
+			} else if !res.Noop {
+				s.log.Printf("需求自动归纳完成 %s: 更新 %d · 新建 %d · 待整理 %d",
+					ws, res.Updated, res.Created, res.Pending)
+			}
+		}
+	}
+
+	s.reqAuto.mu.Lock()
+	delete(s.reqAuto.running, ws)
+	again := s.reqAuto.queued[ws]
+	delete(s.reqAuto.queued, ws)
+	s.reqAuto.mu.Unlock()
+	if again {
+		// 归纳期间又来了新记忆：立刻补一轮（不重新防抖 —— 用户已经等过 12s 了）。
+		s.runAutoConsolidate(ws)
+	}
+}
+
+// 编译期断言：能力位常量与 core 侧同值（改错一个字这里就编译不过）。
+var _ = func() bool { return agent.FeatureRequirements == FeatureRequirements }

package/internal/client/requirements_test.go

@@ -0,0 +1,239 @@
+package client
+
+// requirements_test.go - 插件侧需求接口的三条硬约束：
+//   · 老 core 缺能力位 → 501 且点名缺哪个位（不是 400/502 让人猜）；
+//   · 读清单**绝不**触发归纳（只有 --requirements，没有 --consolidate-requirements）；
+//   · 自动归纳只按「这一轮那个目录」触发，且 12s 内再来一轮只跑一次。
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// reqCore 假 core：把收到的 flag 写进一个调用日志，便于断言「到底跑了哪些命令」。
+func reqCore(t *testing.T, features string, logPath string) string {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "magic-agent")
+	script := `#!/bin/sh
+echo "$*" >> ` + logPath + `
+case "$*" in
+  *--contract*)
+    echo '{"contractVersion":2,"features":[` + features + `],"engines":[]}'
+    exit 0
+    ;;
+  *--consolidate-requirements*)
+    echo '{"ok":true,"workspace":"ws-1","dir":"/x","updated":1,"created":0,"pending":0}'
+    exit 0
+    ;;
+  *--requirements*)
+    echo '{"ok":true,"root":"/r","workspaces":[{"id":"ws-1","dir":"/x","name":"x","pending":1,"memory":2,"modules":[],"feature_count":0,"last_consolidated_at":0}]}'
+    exit 0
+    ;;
+esac
+exit 0
+`
+	if err := os.WriteFile(path, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+func TestRequirementsRouteNeedsFeature(t *testing.T) {
+	logPath := filepath.Join(t.TempDir(), "calls.log")
+	core := reqCore(t, `"feature.session.events","feature.session.control"`, logPath)
+	svc := newTestService(t, core)
+
+	req := httptest.NewRequest(http.MethodGet, "/desk/requirements?token=tok", nil)
+	rec := httptest.NewRecorder()
+	svc.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusNotImplemented {
+		t.Fatalf("缺能力位应回 501，实际 %d: %s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), FeatureRequirements) {
+		t.Errorf("报错应点名缺哪个能力位，实际 %s", rec.Body.String())
+	}
+	// 没跑任何 core 命令（除了启动时的 --contract）。
+	calls := readCalls(t, logPath)
+	for _, c := range calls {
+		if strings.Contains(c, "--requirements") {
+			t.Errorf("缺能力位时不该去调 core：%s", c)
+		}
+	}
+}
+
+func TestRequirementsRouteForwardsWS(t *testing.T) {
+	logPath := filepath.Join(t.TempDir(), "calls.log")
+	core := reqCore(t, `"feature.session.events","feature.session.control",`+
+		`"`+FeatureRequirements+`"`, logPath)
+	svc := newTestService(t, core)
+
+	// 不给 ws → 传 all（列全部工作区）。
+	rec := httptest.NewRecorder()
+	svc.Handler().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/desk/requirements?token=tok", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("清单应 200，实际 %d: %s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), `"ws-1"`) {
+		t.Errorf("应原样转发 core 的清单，实际 %s", rec.Body.String())
+	}
+	// 给了 ws → 原样透传。
+	rec2 := httptest.NewRecorder()
+	svc.Handler().ServeHTTP(rec2, httptest.NewRequest(http.MethodGet, "/desk/requirements?token=tok&ws=ws-1", nil))
+	if rec2.Code != http.StatusOK {
+		t.Fatalf("按 ws 查应 200，实际 %d", rec2.Code)
+	}
+	var sawAll, sawWS bool
+	for _, c := range readCalls(t, logPath) {
+		if strings.Contains(c, "--requirements all") {
+			sawAll = true
+		}
+		if strings.Contains(c, "--requirements ws-1") {
+			sawWS = true
+		}
+		// 读清单绝不能顺带归纳：那会把「刷个列表」变成一次模型调用。
+		if strings.Contains(c, "--consolidate-requirements") {
+			t.Errorf("读清单不该触发归纳：%s", c)
+		}
+	}
+	if !sawAll || !sawWS {
+		t.Errorf("应分别透传 all 与 ws-1，实际 %v", readCalls(t, logPath))
+	}
+}
+
+func TestRequirementsConsolidateRoute(t *testing.T) {
+	logPath := filepath.Join(t.TempDir(), "calls.log")
+	core := reqCore(t, `"feature.session.events","feature.session.control",`+
+		`"`+FeatureRequirements+`"`, logPath)
+	svc := newTestService(t, core)
+
+	body := strings.NewReader(`{"workspace":"/proj","force":true,"engine":"claude","model":"opus-4.6"}`)
+	rec := httptest.NewRecorder()
+	svc.Handler().ServeHTTP(rec, httptest.NewRequest(http.MethodPost,
+		"/desk/requirements/consolidate?token=tok", body))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("归纳应 200，实际 %d: %s", rec.Code, rec.Body.String())
+	}
+	var ok bool
+	for _, c := range readCalls(t, logPath) {
+		if strings.Contains(c, "--consolidate-requirements /proj --requirement-force") &&
+			strings.Contains(c, "--requirement-engine claude") &&
+			strings.Contains(c, "--requirement-model opus-4.6") {
+			ok = true
+		}
+	}
+	if !ok {
+		t.Errorf("应透传目录 / force / 配置的默认引擎与模型，实际 %v", readCalls(t, logPath))
+	}
+	// 归纳的结果要能解出核心字段（客户端靠它显示「更新/新建/待整理」）。
+	var res struct {
+		OK      bool `json:"ok"`
+		Updated int  `json:"updated"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &res); err != nil || !res.OK || res.Updated != 1 {
+		t.Errorf("响应应是 core 的归纳结果，实际 %s", rec.Body.String())
+	}
+}
+
+func TestMaybeAutoConsolidate(t *testing.T) {
+	logPath := filepath.Join(t.TempDir(), "calls.log")
+	core := reqCore(t, `"feature.session.events","feature.session.control",`+
+		`"`+FeatureRequirements+`"`, logPath)
+	svc := newTestService(t, core)
+
+	t.Run("空目录不触发", func(t *testing.T) {
+		svc.maybeAutoConsolidate("")
+		svc.reqAuto.mu.Lock()
+		n := len(svc.reqAuto.timers)
+		svc.reqAuto.mu.Unlock()
+		if n != 0 {
+			t.Errorf("不知道目录时不该猜（会往别人的文档里塞内容）")
+		}
+	})
+
+	t.Run("关了开关不触发", func(t *testing.T) {
+		t.Setenv(reqAutoOffEnv, "1")
+		svc.maybeAutoConsolidate("/proj")
+		svc.reqAuto.mu.Lock()
+		n := len(svc.reqAuto.timers)
+		svc.reqAuto.mu.Unlock()
+		if n != 0 {
+			t.Errorf("%s=1 时不该排期", reqAutoOffEnv)
+		}
+	})
+
+	t.Run("同一工作区连续触发只留一个计时器", func(t *testing.T) {
+		t.Setenv(reqAutoOffEnv, "")
+		svc.maybeAutoConsolidate("/proj")
+		svc.maybeAutoConsolidate("/proj")
+		svc.maybeAutoConsolidate("/other")
+		svc.reqAuto.mu.Lock()
+		n := len(svc.reqAuto.timers)
+		for _, timer := range svc.reqAuto.timers {
+			timer.Stop() // 别让 12s 后的归纳真跑起来
+		}
+		svc.reqAuto.mu.Unlock()
+		if n != 2 {
+			t.Errorf("应按工作区去重（2 个目录 = 2 个计时器），实际 %d", n)
+		}
+	})
+}
+
+func TestPinnedWorkspaceIsAbsolute(t *testing.T) {
+	wd, _ := os.Getwd()
+	if got := pinnedWorkspace(""); got != wd {
+		t.Errorf("空 = 插件自己的 cwd（core 记录的也是它），实际 %q", got)
+	}
+	if got := pinnedWorkspace("."); got != wd {
+		t.Errorf("相对路径要归一成绝对路径（ws id 是 sha1(绝对路径)），实际 %q", got)
+	}
+	if got := pinnedWorkspace("/tmp/x"); got != "/tmp/x" {
+		t.Errorf("绝对路径原样，实际 %q", got)
+	}
+}
+
+func readCalls(t *testing.T, path string) []string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return nil
+	}
+	var out []string
+	for _, l := range strings.Split(string(b), "\n") {
+		if s := strings.TrimSpace(l); s != "" {
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
+// 防止误删防抖常量（12s 是产品口径，不是随手写的数字）。
+var _ = func() bool { return reqAutoDebounce == 12*time.Second }
+
+// TestAutoConsolidateMarksAuto 自动归纳必须显式带 --requirement-auto。
+//
+// 不带它 core 会把「首次自动归纳」当成用户手动整理，于是每轮都去扫目录、读代码
+// （几分钟 + 一次带工具的模型调用）。这个标记是「自动路径绝不触发初始化」的开关。
+func TestAutoConsolidateMarksAuto(t *testing.T) {
+	logPath := filepath.Join(t.TempDir(), "calls.log")
+	core := reqCore(t, `"feature.session.events","feature.session.control",`+
+		`"`+FeatureRequirements+`"`, logPath)
+	svc := newTestService(t, core)
+
+	svc.runAutoConsolidate("/proj")
+	found := false
+	for _, c := range readCalls(t, logPath) {
+		if strings.Contains(c, "--consolidate-requirements /proj") && strings.Contains(c, "--requirement-auto") {
+			found = true
+		}
+	}
+	if !found {
+		t.Errorf("自动归纳应带 --requirement-auto，实际 %v", readCalls(t, logPath))
+	}
+}