magic-agent 2.3.0 → 2.3.9

package/internal/client/jobs_test.go

@@ -0,0 +1,369 @@
+package client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+/* 服务端作业队列的回归闸门（2026-10-23）：
+   · 同一 workspace 串行、不同 workspace 并行；
+   · request_id 幂等（重复提交不多跑一遍）；
+   · 排队中可取消，取消后不会偷偷开跑；
+   · 落盘 + 重启恢复（queued 留着、running 标失败）。 */
+
+// jobCore 假 core：记下每一次「真正开跑」的参数，然后停在 stdin 上等 stop。
+func jobCore(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "magic-agent")
+	script := `#!/bin/sh
+case "$*" in
+  *--contract*)
+    echo '{"contractVersion":2,"features":["feature.session.events","feature.session.control"],"engines":[{"engine":"claude","ok":true,"capabilities":["session.stream"]}]}'
+    exit 0
+    ;;
+  *--engines*)
+    echo '[{"engine":"claude","ok":true,"capabilities":["session.stream"]}]'
+    exit 0
+    ;;
+  *--sessions*)
+    echo '[]'
+    exit 0
+    ;;
+esac
+if [ -n "$JOB_TEST_LOG" ]; then
+  printf '%s\n' "$*" >> "$JOB_TEST_LOG"
+fi
+echo '{"v":1,"seq":1,"type":"ready","engine":"claude"}'
+echo '{"v":1,"seq":2,"type":"text","text":"ok"}'
+while IFS= read -r line; do
+  case "$line" in
+    *'"stop"'*) echo '{"v":1,"seq":3,"type":"result"}'; exit 0 ;;
+  esac
+done
+`
+	if err := os.WriteFile(path, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+func jobTestService(t *testing.T, core string) (*Service, string) {
+	t.Helper()
+	dir := t.TempDir()
+	logPath := filepath.Join(dir, "runs.log")
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", filepath.Join(dir, "jobs"))
+	t.Setenv("MAGIC_CLIENT_MAX_RUNNING", "8")
+	t.Setenv("JOB_TEST_LOG", logPath)
+	svc, err := New(Options{MagicAgent: core, Profile: DefaultProfile(), Token: "tok"})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	/* 收尾：先停调度循环并给假 core 发 stop，等后台把最后一笔状态写完，
+	   再让 t.TempDir 去删目录（否则会和作业落盘抢文件）。 */
+	t.Cleanup(func() {
+		svc.jobs.close()
+		time.Sleep(300 * time.Millisecond)
+	})
+	return svc, logPath
+}
+
+func postJob(t *testing.T, base string, req map[string]any) *Job {
+	t.Helper()
+	b, _ := json.Marshal(req)
+	r, _ := http.NewRequest(http.MethodPost, base+"/desk/jobs", bytes.NewReader(b))
+	r.Header.Set("X-Magic-Token", "tok")
+	resp, err := http.DefaultClient.Do(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusAccepted {
+		msg, _ := io.ReadAll(resp.Body)
+		t.Fatalf("POST /desk/jobs 应 2xx，实际 %d（%s）", resp.StatusCode, msg)
+	}
+	var out struct {
+		Job *Job `json:"job"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil || out.Job == nil {
+		t.Fatalf("作业响应不合法：%v", err)
+	}
+	return out.Job
+}
+
+func getJob(t *testing.T, base, id string) *Job {
+	t.Helper()
+	r, _ := http.NewRequest(http.MethodGet, base+"/desk/jobs/"+id, nil)
+	r.Header.Set("X-Magic-Token", "tok")
+	resp, err := http.DefaultClient.Do(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	var j Job
+	if err := json.NewDecoder(resp.Body).Decode(&j); err != nil {
+		t.Fatalf("GET /desk/jobs/{id} 解析失败：%v", err)
+	}
+	return &j
+}
+
+func waitJob(t *testing.T, base, id string, want func(*Job) bool, timeout time.Duration) *Job {
+	t.Helper()
+	deadline := time.Now().Add(timeout)
+	var last *Job
+	for time.Now().Before(deadline) {
+		last = getJob(t, base, id)
+		if want(last) {
+			return last
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	t.Fatalf("作业 %s 未在 %s 内达到期望状态，最后：%+v", id, timeout, last)
+	return nil
+}
+
+func readRuns(t *testing.T, path string) []string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return nil
+	}
+	var out []string
+	for _, ln := range strings.Split(strings.TrimSpace(string(b)), "\n") {
+		if strings.TrimSpace(ln) != "" {
+			out = append(out, ln)
+		}
+	}
+	return out
+}
+
+func TestJobsSerialPerWorkspace(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+	ws := t.TempDir()
+
+	j1 := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "一", "workspace": ws, "serial": true, "request_id": "r1"})
+	if j1.State != JobQueued {
+		t.Errorf("刚提交应是 queued，实际 %s", j1.State)
+	}
+	waitJob(t, srv.URL, j1.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+
+	j2 := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "二", "workspace": ws, "serial": true, "request_id": "r2"})
+	time.Sleep(600 * time.Millisecond) // 给调度器足够时间：它**不该**开第二条
+	j2 = getJob(t, srv.URL, j2.ID)
+	if j2.State != JobQueued {
+		t.Fatalf("同 workspace 第二条必须排队，实际 %s", j2.State)
+	}
+	if got := len(readRuns(t, runs)); got != 1 {
+		t.Fatalf("同 workspace 只应有 1 次真正开跑，实际 %d：%v", got, readRuns(t, runs))
+	}
+
+	// 取消排队的第二条：它绝不能之后偷偷开跑。
+	cr, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j2.ID+"/cancel", nil)
+	cr.Header.Set("X-Magic-Token", "tok")
+	resp, err := http.DefaultClient.Do(cr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	j2 = waitJob(t, srv.URL, j2.ID, func(j *Job) bool { return j.State == JobCancelled }, 3*time.Second)
+	if j2.State != JobCancelled {
+		t.Fatalf("取消失败：%+v", j2)
+	}
+
+	// 停掉第一条，槽位释放。
+	cr2, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j1.ID+"/cancel", nil)
+	cr2.Header.Set("X-Magic-Token", "tok")
+	if resp, err := http.DefaultClient.Do(cr2); err == nil {
+		resp.Body.Close()
+	}
+	waitJob(t, srv.URL, j1.ID, func(j *Job) bool { return j.terminal() }, 5*time.Second)
+	time.Sleep(300 * time.Millisecond)
+	if got := len(readRuns(t, runs)); got != 1 {
+		t.Fatalf("被取消的排队条目不应开跑，实际开跑 %d 次：%v", got, readRuns(t, runs))
+	}
+}
+
+func TestJobsParallelAcrossWorkspaces(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	wsA, wsB := t.TempDir(), t.TempDir()
+	a := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "a", "workspace": wsA, "serial": true, "request_id": "pa"})
+	b := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "b", "workspace": wsB, "serial": true, "request_id": "pb"})
+	waitJob(t, srv.URL, a.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	waitJob(t, srv.URL, b.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	if got := len(readRuns(t, runs)); got != 2 {
+		t.Fatalf("不同 workspace 应并行开跑（2 次），实际 %d：%v", got, readRuns(t, runs))
+	}
+	for _, id := range []string{a.ID, b.ID} {
+		r, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+id+"/cancel", nil)
+		r.Header.Set("X-Magic-Token", "tok")
+		if resp, err := http.DefaultClient.Do(r); err == nil {
+			resp.Body.Close()
+		}
+	}
+}
+
+func TestJobsIdempotentRequestID(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+	ws := t.TempDir()
+	body := map[string]any{"engine": "claude", "prompt": "只跑一次", "workspace": ws, "serial": false, "request_id": "same-id"}
+
+	j1 := postJob(t, srv.URL, body)
+	j2 := postJob(t, srv.URL, body)
+	if j1.ID != j2.ID {
+		t.Fatalf("同一 request_id 应返回同一个作业：%s vs %s", j1.ID, j2.ID)
+	}
+	waitJob(t, srv.URL, j1.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	time.Sleep(400 * time.Millisecond)
+	if got := len(readRuns(t, runs)); got != 1 {
+		t.Fatalf("幂等失败：同一 request_id 开跑了 %d 次", got)
+	}
+	r, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j1.ID+"/cancel", nil)
+	r.Header.Set("X-Magic-Token", "tok")
+	if resp, err := http.DefaultClient.Do(r); err == nil {
+		resp.Body.Close()
+	}
+}
+
+func TestJobQueueRecoversAfterRestart(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", dir)
+	now := time.Now()
+	running := Job{
+		ID: "job-running", Workspace: "/tmp/ws", Engine: "claude", Prompt: "旧的",
+		State: JobRunning, Serial: true, CreatedAt: now.Add(-time.Minute), UpdatedAt: now.Add(-time.Minute),
+	}
+	queued := Job{
+		ID: "job-queued", RequestID: "req-old", Workspace: "/tmp/ws", Engine: "claude", Prompt: "排队的",
+		State: JobQueued, Serial: true, CreatedAt: now, UpdatedAt: now, ExpiresAt: now.Add(time.Hour),
+	}
+	for _, j := range []Job{running, queued} {
+		b, _ := json.Marshal(j)
+		if err := os.WriteFile(filepath.Join(dir, j.ID+".json"), b, 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	svc := &Service{opts: Options{Profile: DefaultProfile()}, log: log.New(io.Discard, "", 0), runs: map[string]*askRun{}}
+	q := newJobQueue(svc)
+	defer q.close()
+	gotRun := q.get("job-running")
+	if gotRun == nil || gotRun.State != JobFailed {
+		t.Fatalf("running 残留应标失败，实际 %+v", gotRun)
+	}
+	if !strings.Contains(gotRun.Error, "重启") {
+		t.Errorf("失败原因应说明重启，实际 %q", gotRun.Error)
+	}
+	gotQueued := q.get("job-queued")
+	if gotQueued == nil || gotQueued.State != JobQueued {
+		t.Fatalf("带 request_id 的 queued 应保留，实际 %+v", gotQueued)
+	}
+}
+
+func TestAskIdempotentRequestID(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	req := askRequest{Engine: "claude", Prompt: "重复提交", RequestID: "dup-ask"}
+	s1 := openSSE(t, srv.URL, "tok", req)
+	defer s1.close()
+	ev1 := s1.next(t)
+	id1, _ := ev1["id"].(string)
+
+	/* 第二次提交（模拟断线后重连 / 另一个标签页）：应接回同一轮，而不是再起一个 core。 */
+	s2 := openSSE(t, srv.URL, "tok", req)
+	defer s2.close()
+	ev2 := s2.next(t)
+	id2, _ := ev2["id"].(string)
+
+	if id1 == "" || id1 != id2 {
+		t.Fatalf("同一 request_id 的两条 /desk/ask 应接回同一轮：%q vs %q", id1, id2)
+	}
+	time.Sleep(400 * time.Millisecond)
+	if got := len(readRuns(t, runs)); got != 1 {
+		t.Fatalf("同一 request_id 只应开跑一次，实际 %d", got)
+	}
+}
+
+func TestJobsListAndSnapshot(t *testing.T) {
+	svc, _ := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+	ws := t.TempDir()
+	j := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "列表", "workspace": ws, "serial": false, "request_id": "list-1"})
+
+	// 列表里能看到它（带位置字段）。
+	r, _ := http.NewRequest(http.MethodGet, srv.URL+"/desk/jobs?workspace="+ws, nil)
+	r.Header.Set("X-Magic-Token", "tok")
+	resp, err := http.DefaultClient.Do(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	var out struct {
+		Jobs []*Job `json:"jobs"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		t.Fatal(err)
+	}
+	found := false
+	for _, it := range out.Jobs {
+		if it.ID == j.ID {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("列表里应能看到刚提交的作业：%+v", out.Jobs)
+	}
+
+	// 事件快照：开跑后应能拿到 ready/text。
+	waitJob(t, srv.URL, j.ID, func(x *Job) bool { return x.State == JobRunning }, 5*time.Second)
+	deadline := time.Now().Add(3 * time.Second)
+	ok := false
+	for time.Now().Before(deadline) {
+		er, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("%s/desk/jobs/%s/events?after=0", srv.URL, j.ID), nil)
+		er.Header.Set("X-Magic-Token", "tok")
+		eresp, err := http.DefaultClient.Do(er)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var snap struct {
+			Events []map[string]any `json:"events"`
+		}
+		_ = json.NewDecoder(eresp.Body).Decode(&snap)
+		eresp.Body.Close()
+		for _, ev := range snap.Events {
+			if ev["type"] == "ready" {
+				ok = true
+			}
+		}
+		if ok {
+			break
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	if !ok {
+		t.Fatal("作业事件快照里应能看到 core 的 ready")
+	}
+	r2, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j.ID+"/cancel", nil)
+	r2.Header.Set("X-Magic-Token", "tok")
+	if resp, err := http.DefaultClient.Do(r2); err == nil {
+		resp.Body.Close()
+	}
+}

package/internal/client/requirements.go

@@ -21,6 +21,7 @@ package client
 // 「一句说完、下一句还没打完」的经验值，期间再来一轮就顺延、合并成一次。
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -82,12 +83,13 @@ func (s *Service) handleRequirements(w http.ResponseWriter, r *http.Request) {
 // handleRequirementsConsolidate POST /desk/requirements/consolidate：
 // 立即归纳一轮（用户点「整理」）。
 //
-// 请求体：{"workspace":"<ws_id|目录>", "force":false, "all":false,
+// 请求体：{"workspace":"<ws_id|目录>", "module":"<模块名>", "force":false,
 //
-//	"engine":"claude", "model":"..."}
+//	"all":false, "engine":"claude", "model":"..."}
 //
 // workspace 留空 = 插件自己的工作目录（与 /desk/health 的 defaultWorkspace 一致 ——
 // 那就是 core 不传 -w 时记录的 cwd）。
+// module 留空 = 整理整个空间；给了就只整理那一个模块（移动端二级页的「整理」）。
 // engine / model 是客户端当前配置的默认引擎与模型（移动端「我的 → 默认引擎」）：
 // 「整理的引擎就是配置的默认引擎」—— 客户端传什么，core 就按什么跑，不再自动替换。
 func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.Request) {
@@ -102,6 +104,7 @@ func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.R
 	}
 	var body struct {
 		Workspace string `json:"workspace,omitempty"`
+		Module    string `json:"module,omitempty"`
 		Force     bool   `json:"force,omitempty"`
 		All       bool   `json:"all,omitempty"`
 		Engine    string `json:"engine,omitempty"`
@@ -122,6 +125,7 @@ func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.R
 		writeErr(w, http.StatusBadRequest, "workspace 不能为空（传 ws id 或目录）")
 		return
 	}
+	module := strings.TrimSpace(body.Module)
 	engine := strings.TrimSpace(body.Engine)
 	model := strings.TrimSpace(body.Model)
 	if model != "" && engine == "" {
@@ -133,7 +137,7 @@ func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.R
 		return
 	}
 	out, err := s.runCoreTimed(r.Context(), reqConsolidateTimeout,
-		consolidateArgs(ws, body.Force, body.All, false, engine, model)...)
+		consolidateArgs(ws, module, body.Force, body.All, false, engine, model)...)
 	if err != nil {
 		code := http.StatusBadGateway
 		if isCoreTimeout(err) {
@@ -150,8 +154,11 @@ func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.R
 // engine/model 来自客户端配置的默认引擎（手动「整理」）：传了就用它，core 不再自动换。
 // 自动归纳（auto=true）不传：后台没有「当前设备默认引擎」这个概念，让 core 走自己的
 // 默认（增量用 llm；首次初始化也不会发生，因为 --requirement-auto 明确禁止）。
-func consolidateArgs(ws string, force, all, auto bool, engine, model string) []string {
+func consolidateArgs(ws, module string, force, all, auto bool, engine, model string) []string {
 	args := []string{"--consolidate-requirements", ws}
+	if module != "" {
+		args = append(args, "--requirement-module", module)
+	}
 	if force {
 		args = append(args, "--requirement-force")
 	}
@@ -178,14 +185,27 @@ func (s *Service) runCoreTimed(ctx context.Context, timeout time.Duration, args
 	cmd := exec.CommandContext(ctx, s.opts.MagicAgent, args...)
 	// 与 runCore 同一道保险：core 的后代进程握着管道时 Wait 不能永久挂住。
 	cmd.WaitDelay = 5 * time.Second
-	out, err := cmd.Output()
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
 	if err != nil {
 		if ctx.Err() != nil || errors.Is(err, exec.ErrWaitDelay) {
 			return nil, fmt.Errorf("%w（%s）", errCoreTimeout, timeout)
 		}
+		/* core 失败时也会先把结构化结果写到 stdout（`{ok:false,error:"..."}`），
+		   再返回非零退出码。Output() 会把它丢掉，界面只剩一句「exit status 1」——
+		   用户看不到真正原因（例如「模块不存在」）。这里把 stdout 交回调用方，
+		   由它按 JSON 里的 error 展示；真的一个字都没输出才退化成 stderr/退出码。 */
+		if stdout.Len() > 0 {
+			return stdout.Bytes(), nil
+		}
+		if msg := strings.TrimSpace(stderr.String()); msg != "" {
+			return nil, fmt.Errorf("%s", msg)
+		}
 		return nil, err
 	}
-	return out, nil
+	return stdout.Bytes(), nil
 }
 
 // isCoreTimeout 判断错误链里是不是「等 core 超时」。
@@ -270,7 +290,7 @@ func (s *Service) runAutoConsolidate(ws string) {
 
 	// 归纳是后台行为：**不绑**任何 HTTP 请求的生命周期，用独立 context。
 	ctx, cancel := context.WithTimeout(context.Background(), reqConsolidateTimeout)
-	out, err := s.runCoreTimed(ctx, reqConsolidateTimeout, consolidateArgs(ws, false, false, true, "", "")...)
+	out, err := s.runCoreTimed(ctx, reqConsolidateTimeout, consolidateArgs(ws, "", false, false, true, "", "")...)
 	cancel()
 	if err != nil {
 		s.log.Printf("需求自动归纳失败 %s: %v", ws, err)

package/internal/client/requirements_test.go

@@ -131,6 +131,23 @@ func TestRequirementsConsolidateRoute(t *testing.T) {
 	if !ok {
 		t.Errorf("应透传目录 / force / 配置的默认引擎与模型，实际 %v", readCalls(t, logPath))
 	}
+	// 二级页「整理」：module 要原样透传给 core，否则会退化成整空间。
+	recMod := httptest.NewRecorder()
+	bodyMod := strings.NewReader(`{"workspace":"/proj","module":"登录","engine":"claude"}`)
+	svc.Handler().ServeHTTP(recMod, httptest.NewRequest(http.MethodPost,
+		"/desk/requirements/consolidate?token=tok", bodyMod))
+	if recMod.Code != http.StatusOK {
+		t.Fatalf("模块级归纳应 200，实际 %d: %s", recMod.Code, recMod.Body.String())
+	}
+	var sawModule bool
+	for _, c := range readCalls(t, logPath) {
+		if strings.Contains(c, "--consolidate-requirements /proj --requirement-module 登录") {
+			sawModule = true
+		}
+	}
+	if !sawModule {
+		t.Errorf("应透传 --requirement-module 登录，实际 %v", readCalls(t, logPath))
+	}
 	// 归纳的结果要能解出核心字段（客户端靠它显示「更新/新建/待整理」）。
 	var res struct {
 		OK      bool `json:"ok"`
@@ -141,6 +158,40 @@ func TestRequirementsConsolidateRoute(t *testing.T) {
 	}
 }
 
+// TestRequirementsConsolidateSurfacesCoreError core 失败时先写 JSON 再 exit 1，
+// 插件不能把它吞成「exit status 1」——界面要能显示「模块不存在」这类真正原因。
+func TestRequirementsConsolidateSurfacesCoreError(t *testing.T) {
+	dir := t.TempDir()
+	core := filepath.Join(dir, "magic-agent")
+	script := `#!/bin/sh
+case "$*" in
+  *--contract*)
+    echo '{"contractVersion":2,"features":["feature.session.events","feature.session.control","` + FeatureRequirements + `"],"engines":[]}'
+    exit 0
+    ;;
+  *--consolidate-requirements*)
+    echo '{"ok":false,"workspace":"ws-1","module":"不存在","error":"模块不存在: 不存在"}'
+    exit 1
+    ;;
+esac
+exit 0
+`
+	if err := os.WriteFile(core, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	svc := newTestService(t, core)
+	rec := httptest.NewRecorder()
+	body := strings.NewReader(`{"workspace":"ws-1","module":"不存在"}`)
+	svc.Handler().ServeHTTP(rec, httptest.NewRequest(http.MethodPost,
+		"/desk/requirements/consolidate?token=tok", body))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("core 的结构化失败应原样回传，实际 %d: %s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "模块不存在") {
+		t.Errorf("应保留 core 的 error 文案，实际 %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",`+