magic-agent 2.4.3 → 2.6.3

package/internal/cli/requirements.go

@@ -22,6 +22,7 @@ package cli
 
 import (
 	"fmt"
+	"io"
 	"strings"
 
 	"github.com/spf13/cobra"
@@ -69,6 +70,23 @@ func runRequirements(cmd *cobra.Command, opts *askOptions) error {
 	return printJSON(cmd.OutOrStdout(), out)
 }
 
+// runRequirementsGraph 会话↔需求关系图谱：`--requirements-graph all|<ws_id|目录>`。
+//
+// 只读（与 --requirements 同族，客户端每刷一次都调，绝不能触发 LLM）。
+// 聚合 relations.jsonl + 文档目录 → {ok,root,workspaces:[{id,name,dir,nodes,edges}]}。
+func runRequirementsGraph(cmd *cobra.Command, opts *askOptions) error {
+	where := strings.TrimSpace(opts.reqGraph)
+	if where == "*" {
+		where = "all"
+	}
+	b, err := requirements.BuildGraph(where)
+	if err != nil {
+		return fmt.Errorf("--requirements-graph %s: %w", where, err)
+	}
+	_, err = cmd.OutOrStdout().Write(append(b, '\n'))
+	return err
+}
+
 // runConsolidateRequirements 立即归纳一轮：`--consolidate-requirements <ws_id|目录|.>`。
 //
 // `.` = 当前目录（与 `-w` 的默认语义一致：用户站在哪个项目里，整理的就是哪个项目）。
@@ -103,6 +121,35 @@ func runConsolidateRequirements(cmd *cobra.Command, opts *askOptions) error {
 	return printJSON(cmd.OutOrStdout(), res)
 }
 
+// runRequirementShot 给一个功能点追加一张「页面完成情况」截图：
+// `--requirement-shot [<ws|dir>]` + `--requirement-name` / `--requirement-caption`。
+//
+// PNG 内容走 **stdin**（不走命令行参数）：图片动辄几百 KB，放进 argv 会撞 Windows
+// 命令行长度上限，也会把二进制搅进进程列表。stdin 的好处是调用方可以管线接。
+func runRequirementShot(cmd *cobra.Command, opts *askOptions) error {
+	where := strings.TrimSpace(opts.reqShot)
+	if where == "." {
+		where = ""
+	}
+	name := strings.TrimSpace(opts.reqShotName)
+	if name == "" {
+		return &usageError{fmt.Errorf("--requirement-shot 需要 --requirement-name <功能点名>")}
+	}
+	png, err := io.ReadAll(io.LimitReader(cmd.InOrStdin(), requirements.MaxShotBytes+1))
+	if err != nil {
+		return fmt.Errorf("--requirement-shot: 读取 stdin 失败: %w", err)
+	}
+	res, err := requirements.AttachShot(where, opts.reqModule, name, opts.reqShotCap, png)
+	if err != nil && !requirements.IsBusy(err) {
+		if res.Error == "" {
+			res.Error = err.Error()
+		}
+		_ = printJSON(cmd.OutOrStdout(), res)
+		return fmt.Errorf("--requirement-shot %s: %s", where, err)
+	}
+	return printJSON(cmd.OutOrStdout(), res)
+}
+
 // bindRequirementFlags 注册需求聚合的 flags。
 //
 // --requirements / --consolidate-requirements 的值都可以留空（空串是合法输入：
@@ -110,6 +157,7 @@ func runConsolidateRequirements(cmd *cobra.Command, opts *askOptions) error {
 func bindRequirementFlags(cmd *cobra.Command, opts *askOptions) {
 	f := cmd.PersistentFlags()
 	f.StringVar(&opts.requirements, "requirements", "", "列出需求清单（工作区 → 模块 → 功能点，JSON：{ok,root,workspaces}）。值留空 = 列全部；给 ws id 或目录 = 只列那一个。只读，不调模型")
+	f.StringVar(&opts.reqGraph, "requirements-graph", "", "会话↔需求关系图谱（JSON：{ok,root,workspaces:[{nodes,edges}]}，nodes 带 type=session|feature）。值留空 = 全部；只读，不调模型")
 	f.StringVar(&opts.consolidateReqs, "consolidate-requirements", "", "立即把会话记忆归纳成需求文档（会调模型）。值留空 = 当前目录；给 ws id 或目录 = 归纳那一个")
 	f.BoolVar(&opts.reqForce, "requirement-force", false, "配合 --consolidate-requirements：没有未归纳的记忆也跑一轮（手动「立即整理」）")
 	f.BoolVar(&opts.reqAll, "requirement-all", false, "配合 --consolidate-requirements：全量重放历史记忆（回填 / 滚动校正）。仍走增量合并，只增不减，不会推翻已有内容")
@@ -118,4 +166,7 @@ func bindRequirementFlags(cmd *cobra.Command, opts *askOptions) {
 	f.StringVar(&opts.reqModule, "requirement-module", "", "配合 --consolidate-requirements：只整理这个模块（空 = 整个空间）。不推进空间游标，不触发首次目录初始化")
 	f.DurationVar(&opts.reqTimeout, "requirement-timeout", requirements.DefaultTimeout, "配合 --consolidate-requirements：单次模型调用超时（默认归纳 4m / 首次目录初始化 9m）")
 	f.BoolVar(&opts.reqAuto, "requirement-auto", false, "配合 --consolidate-requirements：自动归纳（不触发首次按目录初始化；插件轮末 / 每日兜底用）")
+	f.StringVar(&opts.reqShot, "requirement-shot", "", "给功能点追加一张「页面完成情况」截图（PNG 走 stdin）。值留空 = 当前目录；给 ws id 或目录 = 那个空间")
+	f.StringVar(&opts.reqShotName, "requirement-name", "", "配合 --requirement-shot：功能点名（= 文档名）")
+	f.StringVar(&opts.reqShotCap, "requirement-caption", "", "配合 --requirement-shot：截图的标注说明")
 }

package/internal/cli/root.go

@@ -33,6 +33,7 @@ package cli
 //	    --temperature <t>    采样温度（仅 llm 引擎透传 -o temperature，其余忽略）
 //	--engines            列出引擎、可用性与支持的模型（JSON 数组；--json 兼容保留）
 //	--no-models          配合 --engines：跳过模型探测（只列引擎，快）
+//	--quotas             只查各引擎账号的额度与每日签到（不探测引擎/不启动 CLI，秒级）
 //	--stop <id>          停止指定会话/运行（session_id 或 run_id），杀掉它的引擎进程组
 //	--delete-session <id> 删除一条会话：登记记录 + 事件历史 + 标题覆盖一起删，**全机生效**
 //	                     （各端读同一份登记表，一端删了处处都看不到）。幂等
@@ -185,7 +186,7 @@ llm 引擎（包装 simonw/LLM CLI，模型/密钥由它自管）：
   每个可用引擎的模型清单都从它自己的权威入口现取现算，CLI 升级/新注册模型后自动跟随：
     claude    ~/.claude/settings.json（顶层 model + env 里 ANTHROPIC_*MODEL[*_NAME]）
     codebuddy codebuddy --help 里 --model 自带的 "Currently supported: (...)" 清单
-    trae      trae-cli models --json
+    trae      traex models --json
     llm       llm models
     codex     codex debug models
     openclaw  openclaw models list --json
@@ -202,7 +203,7 @@ llm 引擎（包装 simonw/LLM CLI，模型/密钥由它自管）：
   codex     npm install -g @openai/codex
   openclaw  npm install -g openclaw@latest
   dsh       npm i -g @deepseek-ai/dsh
-  trae      sh -c "$(curl -L https://trae.cn/trae-cli/install.sh)"
+  trae      sh -c "$(curl -fsSL https://trae.cn/trae-cli/install_v2.sh)"   # Windows: irm https://trae.cn/trae-cli/install_v2.ps1 | iex
   llm       python3 -m venv ~/.llm-venv && ~/.llm-venv/bin/pip install llm
   命令一律取自各 CLI 的官方安装方式；**没有可执行安装路径的引擎不给该字段**
   （codebuddy / codebuddy-ai 是桌面端 GUI 应用，arkclaw 靠配置文件），
@@ -468,6 +469,9 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 			case flagChanged(cmd, "repair-models"):
 				// 同上：`--repair-models ""` 要走参数校验，而不是掉进「提问」分支报 empty prompt。
 				return runRepairModels(cmd, opts)
+			case flagChanged(cmd, "checkin"):
+				// 同上：`--checkin ""` 要走参数校验。
+				return runCheckin(cmd, opts)
 			case opts.listSessions:
 				return runSessions(cmd, opts)
 			case flagChanged(cmd, "session-log"):
@@ -482,6 +486,9 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 			case flagChanged(cmd, "suggest-followups"):
 				// 值可以是 "-"（stdin），所以用「传过没有」判，而不是「值非空」。
 				return runSuggestFollowups(cmd, opts)
+			case flagChanged(cmd, "judge-conflict"):
+				// 同上：值可以是 "-"（stdin）。
+				return runJudgeConflict(cmd, opts)
 			case flagChanged(cmd, "title-force"):
 				// --title-force 只在 --summarize-title 下成立：单给它必然是调用方误解了
 				// （想要「强制重新归纳」却没给 id）。明说，不静默忽略。
@@ -500,9 +507,15 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 			case flagChanged(cmd, "requirements"):
 				// 读清单：值留空 = 列全部工作区（`--requirements ""` 也是合法调用）。
 				return runRequirements(cmd, opts)
+			case flagChanged(cmd, "requirements-graph"):
+				// 读图谱：值留空 = 全部工作区。只读，不调模型。
+				return runRequirementsGraph(cmd, opts)
 			case flagChanged(cmd, "consolidate-requirements"):
 				// 写：跑一轮归纳。值留空 = 当前目录。
 				return runConsolidateRequirements(cmd, opts)
+			case flagChanged(cmd, "requirement-shot"):
+				// 写：给功能点追加一张完成情况截图（PNG 走 stdin）。
+				return runRequirementShot(cmd, opts)
 			case flagChanged(cmd, "requirement-force"), flagChanged(cmd, "requirement-all"),
 				flagChanged(cmd, "requirement-engine"), flagChanged(cmd, "requirement-model"),
 				flagChanged(cmd, "requirement-timeout"), flagChanged(cmd, "requirement-auto"):
@@ -510,6 +523,10 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 				// 静默忽略就等于「传了参数什么都没发生」。
 				return &usageError{fmt.Errorf("--requirement-force / -all / -engine / -model / -timeout / -auto " +
 					"只在 --consolidate-requirements 下成立：请配合它使用")}
+			case flagChanged(cmd, "requirement-name"), flagChanged(cmd, "requirement-caption"):
+				// 这两个是 --requirement-shot 的修饰项（截图落在哪个功能点、标注写什么）。
+				return &usageError{fmt.Errorf("--requirement-name / --requirement-caption " +
+					"只在 --requirement-shot 下成立：请配合它使用")}
 			case flagChanged(cmd, "stop"):
 				// 用「传过没有」而不是「值非空」判断：`--stop ""` 也要走参数校验
 				//（exit 2 提示要 id），而不是掉进「提问」分支报 empty prompt。
@@ -523,6 +540,8 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 				return runContract(cmd, opts)
 			case opts.engines:
 				return runEngines(cmd, opts)
+			case opts.quotas:
+				return runQuotas(cmd)
 			case opts.team:
 				// 团队模式必须排在 --stream 之前：它自己就是流式路径的一种运行模式
 				//（同一套 ready / seq / result 收尾），但内部编排完全不同。
@@ -701,20 +720,28 @@ var (
 // key 一般用引擎名（codebuddy / codebuddy-ai / trae …）；命中且未过期的缓存直接返回，
 // 不触碰 CLI / 文件。底层走 probeEngineModels / probeEngineCredits（可被测试替换）。
 // ListModels 出错或返回空清单时**不缓存**（视为瞬时态，下次重探）。
-func cachedModelList(ctx context.Context, key string, l agent.ModelLister) (models []string, credits map[string]string, note string) {
+//
+// noSource 区分两种"拿不到模型"的语义（见 agent.ErrNoModelSource）：
+//   - true  = 引擎**本来就不提供**模型清单（arkclaw 按 claw_id 绑模型、
+//     codebuddy-gateway 用网关进程的模型）—— 它不是故障，调用方不该因此隐藏引擎；
+//   - false = 有来源但这次探测失败（CLI 退出码非 0 / 空清单）—— 可以隐藏或置灰。
+//
+// 以前两者只靠 note 字符串表达，客户端只能看"note 是否为空"一刀切，
+// 把 arkclaw / MagicAI / codebuddy-gateway 一起隐藏了（2026-10 报障）。
+func cachedModelList(ctx context.Context, key string, l agent.ModelLister) (models []string, credits map[string]string, note string, noSource bool) {
 	modelListCacheMu.Lock()
 	if it, ok := modelListCache[key]; ok && time.Now().Before(it.expiresAt) {
 		modelListCacheMu.Unlock()
-		return it.models, it.credits, ""
+		return it.models, it.credits, "", false
 	}
 	modelListCacheMu.Unlock()
 
 	models, err := probeEngineModels(ctx, l)
 	if err != nil {
-		return nil, nil, err.Error()
+		return nil, nil, err.Error(), errors.Is(err, agent.ErrNoModelSource)
 	}
 	if len(models) == 0 {
-		return nil, nil, "no models reported"
+		return nil, nil, "no models reported", false
 	}
 	if cl, ok := l.(agent.ModelCreditLister); ok {
 		credits = probeEngineCredits(ctx, cl)
@@ -726,7 +753,7 @@ func cachedModelList(ctx context.Context, key string, l agent.ModelLister) (mode
 		expiresAt: time.Now().Add(modelListCacheTTL),
 	}
 	modelListCacheMu.Unlock()
-	return models, credits, ""
+	return models, credits, "", false
 }
 
 // clearModelListCache 清空模型清单缓存（测试用，避免用例之间互相命中缓存）。
@@ -767,7 +794,7 @@ func flagChanged(cmd *cobra.Command, name string) bool {
 //	                  实测只有「受理帧 + 整段正文」，见 internal/agent/arkclaw_stream.go
 //
 // 模型**一律现取现算、不硬编码**：各引擎用自己 CLI/配置文件里的权威入口
-// （trae-cli models / llm models / codex debug models / openclaw models list /
+// （traex models / llm models / codex debug models / openclaw models list /
 // codebuddy --help / claude settings.json）。探测要真的启动 CLI（只读子命令），
 // 故并发执行并套 agent.DefaultModelProbeTimeout；--no-models 可整段跳过（只列引擎，快）。
 // --json 为兼容旧调用保留（本函数不再区分，恒为 JSON）。
@@ -818,11 +845,53 @@ func emitEngineRows(cmd *cobra.Command, opts *askOptions, envelope bool) error {
 		Version    string   `json:"version,omitempty"`
 		Models     []string `json:"models,omitempty"`
 		ModelsNote string   `json:"models_note,omitempty"`
+		/* ModelsSource 模型清单的**来源语义**（machine-readable，取代"靠 models_note
+		   猜"的做法；只增字段不升 contractVersion）：
+		     dynamic —— models 可用；
+		     none    —— 引擎本身不提供模型选择（模型绑在 claw_id / 网关进程上），
+		                **不是故障**：调用方应保留这一行并显示「引擎默认」；
+		     failed  —— 有动态来源但本次探测失败（CLI 非 0 退出等），可隐藏或置灰。
+		   旧 core 没有该字段，调用方按 models_note 前缀兜底（见 shared/conversation.js）。 */
+		ModelsSource string `json:"models_source,omitempty"`
 		// ModelCredits 各模型的积分倍率（machine-readable，model → 倍率数字字符串，
 		// 如 "fast-model":"0.34"，源于客户端 "x0.34 credits"；与 models 同源同链探测，
 		// 仅实现了 agent.ModelCreditLister 的引擎给出 —— 目前 codebuddy / codebuddy-ai）。
 		// 客户端不给倍率的模型（custom-local）不出现在 map 里。
 		ModelCredits map[string]string `json:"model_credits,omitempty"`
+		// ModelVendors 各模型的供应商展示名（model → 供应商，如 "Volcengine"）；
+		// 与 models 同形同链，键已剥 `custom-local:` 前缀。只用于**选择器的第二行**，
+		// 不参与 -m / 落库。仅实现 agent.ModelVendorLister 的引擎给出（目前 codebuddy 系），
+		// 其余引擎省略该字段（新增字段，不升 contractVersion）。
+		ModelVendors map[string]string `json:"model_vendors,omitempty"`
+		// CreditLeft 账号当前**剩余积分**（decimal 字符串，如 "5939.2"；单位 credits）。
+		// 仅实现了 agent.CreditLister 的引擎给出（codebuddy / codebuddy-ai），
+		// 各自读自己票据（codebuddy-ai 读隔离目录），查不到就省略该字段。
+		// 新增（2026-10-24，只增字段不升 contractVersion）。
+		CreditLeft string `json:"credit_left,omitempty"`
+		// CreditSuffix CreditLeft / ModelQuota 的单位后缀（缺省「积分」）。llm 的
+		// MiniMax 套餐额度是百分比，给 "%" —— 客户端据此显示「5h 98% · 周 53%」。
+		// 新增（2026-10-25，只增字段不升 contractVersion）。
+		CreditSuffix string `json:"credit_suffix,omitempty"`
+		// ModelQuota 按**模型**给出的套餐额度快照（model id → {interval_left, weekly_left}，
+		// 两个窗口的剩余百分比，单位见 credit_suffix）。仅实现了 agent.ModelQuotaLister
+		// 的引擎给出 —— 目前是 llm（MiniMax 套餐；只挂在走 MiniMax 端点的模型上）。
+		// 新增（2026-10-25，只增字段不升 contractVersion）。
+		ModelQuota map[string]agent.QuotaWindows `json:"model_quota,omitempty"`
+		// CheckinToday 今天是否已领每日积分（true / false）；拿不到状态时**省略**该字段
+		// （nil 指针），客户端据此决定要不要画「领取」按钮。
+		// 新增（2026-10-24，只增字段不升 contractVersion）。
+		CheckinToday *bool `json:"checkin_today,omitempty"`
+		// CheckinCredit 今日可领积分（字符串，如 "100"；活动没开 / 拿不到时省略）。
+		CheckinCredit string `json:"checkin_credit,omitempty"`
+		// LoggedIn 该账号槽位是否已登录（仅实现 agent.LoginChecker 的多账号引擎给出：
+		// codebuddy / codebuddy-ai）。客户端据此**只显示已登录的账号** ——
+		// 「登录了几个账号就显示几个」，而不是固定两行。
+		// 新增（2026-10-25，只增字段不升 contractVersion）；老 core 没有该字段时客户端按「显示」处理。
+		LoggedIn *bool `json:"logged_in,omitempty"`
+		// Account 该账号槽位登录的**账号昵称**（如 "Darren" / "玲"；仅 codebuddy 系给出，
+		// 来自票据里的 account.nickname）。选择器把它画在引擎名下面，一眼看出这行是哪个号。
+		// 新增（2026-10-25，只增字段不升 contractVersion）。
+		Account string `json:"account,omitempty"`
 		// Workspace 该引擎「指定工作目录」的落地方式（machine-readable，供调用方决定是否下发）：
 		//   flag:-C 原生 flag（codex）；cwd 子进程 cwd（claude/codebuddy/trae）；
 		//   none    无落地通道（llm/arkclaw/openclaw/codebuddy-gateway，参数会被忽略）
@@ -896,6 +965,16 @@ func emitEngineRows(cmd *cobra.Command, opts *askOptions, envelope bool) error {
 		if ok {
 			r.Bin, r.Note = note, ""
 		}
+		/* 多账号引擎（codebuddy 系）：这个槽位有没有登录。没登录的槽位客户端不显示，
+		   所以「登录了几个账号就显示几个」；探测本身不依赖它（模型清单照旧给）。 */
+		if lc, okl := e.(agent.LoginChecker); okl {
+			loggedIn := lc.LoggedIn()
+			r.LoggedIn = &loggedIn
+		}
+		/* 账号昵称：选择器里两个 codebuddy 槽位只差引擎名，标上「这行是哪个号」。 */
+		if al, okl := e.(agent.AccountLister); okl {
+			r.Account = al.AccountName()
+		}
 		/* 安装 / 升级命令：**可用时也给**（同一条命令重跑一遍 = 升级到最新版）。
 		   没有可执行安装路径的引擎留空 —— 见 InstallCommandOf 的说明，不编命令。 */
 		r.Install = agent.InstallCommandOf(e.Name())
@@ -914,20 +993,66 @@ func emitEngineRows(cmd *cobra.Command, opts *askOptions, envelope bool) error {
 				rows[i].Version = agent.EngineVersionOf(cmd.Context(), bin)
 			}(i, r.Bin)
 		}
+		/* 账号剩余额度（codebuddy 系积分 / llm 的 MiniMax 套餐百分比）：只读本机票据
+		   或 models.json + 一次只读请求。与模型探测并发跑；查不到就不给该字段。 */
+		if cl, okc := e.(agent.CreditLister); okc {
+			eng := e
+			wg.Add(1)
+			go func(i int, l agent.CreditLister) {
+				defer wg.Done()
+				left := l.CreditLeft(cmd.Context())
+				rows[i].CreditLeft = left
+				if left != "" {
+					if u, oku := eng.(agent.CreditUnitLister); oku {
+						rows[i].CreditSuffix = u.CreditUnit()
+					}
+				}
+			}(i, cl)
+		}
+		/* 模型级套餐额度（llm 的 MiniMax 模型）：同一账号一份快照，挂到每个走该端点的模型。 */
+		if mq, okm := e.(agent.ModelQuotaLister); okm {
+			eng := e
+			wg.Add(1)
+			go func(i int, l agent.ModelQuotaLister) {
+				defer wg.Done()
+				q := l.ModelQuota(cmd.Context())
+				if len(q) == 0 {
+					return
+				}
+				rows[i].ModelQuota = q
+				if u, oku := eng.(agent.CreditUnitLister); oku {
+					rows[i].CreditSuffix = u.CreditUnit()
+				}
+			}(i, mq)
+		}
+		/* 每日签到状态（同上，仅 codebuddy 系）：今天是否已领 + 可领多少，
+		   客户端据此画「领取」按钮；拿不到就省略两个字段。 */
+		if ck, okc := e.(agent.Checkiner); okc {
+			wg.Add(1)
+			go func(i int, c agent.Checkiner) {
+				defer wg.Done()
+				if info, known := c.CheckinStatus(cmd.Context()); known {
+					claimed := info.CheckedToday
+					rows[i].CheckinToday = &claimed
+					rows[i].CheckinCredit = info.DailyCredit
+				}
+			}(i, ck)
+		}
 		if !ok {
 			continue
 		}
 		lister := agent.ModelListerOf(e)
 		if lister == nil {
 			rows[i].ModelsNote = "no dynamic model source"
+			rows[i].ModelsSource = "none"
 			continue
 		}
 		wg.Add(1)
-		go func(i int, name string, l agent.ModelLister) {
+		go func(i int, name string, l agent.ModelLister, eng agent.Engine) {
 			defer wg.Done()
 			ctx, cancel := context.WithTimeout(cmd.Context(), agent.DefaultModelProbeTimeout)
 			defer cancel()
-			models, credits, note := cachedModelList(ctx, name, l)
+			models, credits, note, noSource := cachedModelList(ctx, name, l)
 			// codebuddy 系：展示时剥掉自定义模型 id 的 "custom-local:" 前缀（噪点）；
 			// -m 实际传值时由引擎按裸名补回前缀（见 codebuddyCore.modelArg），
 			// 自定义模型依旧可用。
@@ -938,15 +1063,36 @@ func emitEngineRows(cmd *cobra.Command, opts *askOptions, envelope bool) error {
 			switch {
 			case note != "":
 				rows[i].ModelsNote = note
+				// 语义型"没有模型源"≠ 探测失败：前者保留可选项（模型由 claw_id /
+				// 网关进程决定），后者才让调用方隐藏。
+				if noSource {
+					rows[i].ModelsSource = "none"
+				} else {
+					rows[i].ModelsSource = "failed"
+				}
 			case len(models) == 0:
 				rows[i].ModelsNote = "no models reported"
+				rows[i].ModelsSource = "failed"
 			default:
 				rows[i].Models = models
+				rows[i].ModelsSource = "dynamic"
 				if credits != nil {
 					rows[i].ModelCredits = credits
 				}
 			}
-		}(i, e.Name(), lister)
+			/* 供应商展示名（选择器第二行）：与 models 同形，键同样剥前缀。
+			   拿不到就整个省略 —— 界面据此决定画不画第二行（dsh 的第二行是路由，
+			   走的是另一条「id 里自带 route/」的路径，与此无关）。 */
+			if vl := agent.ModelVendorListOf(eng); vl != nil {
+				vendors := vl.ModelVendors(ctx)
+				if name == "codebuddy" || name == "codebuddy-ai" {
+					vendors = agent.StripCustomLocalPrefixCredits(vendors)
+				}
+				if len(vendors) > 0 {
+					rows[i].ModelVendors = vendors
+				}
+			}
+		}(i, e.Name(), lister, e)
 	}
 	wg.Wait()
 	if !envelope {

package/internal/cli/session.go

@@ -385,25 +385,95 @@ func runSessions(cmd *cobra.Command, opts *askOptions) error {
 		// 所以非流式跑出来的会话没有历史可回放 —— 客户端要拿它判断「这条点开有东西看吗」，
 		// 而让客户端自己去拼日志路径就是把本仓库的内部布局当接口用。
 		HasLog bool `json:"has_log"`
+		/* WorkspaceLocked 这条会话所在的目录当前是不是被**别人**占着工作空间锁
+		   （2026-10-26，多客户端仲裁）。
+
+		   为什么要有这个字段：core 现在默认对同 workspace 串行（见 workspace_lock.go），
+		   但**等待发生在 Begin 里**，客户端在发请求的那一刻看不到「我要等」——
+		   用户看到的只是「点了没反应 / 转很久」。把这个判断上移到列表里，
+		   客户端就能在按下发送之前就说「这个目录正被手机端占着，已排队」。
+		   ⚠️ 只增字段，老客户端忽略即可（不升契约版本）。 */
+		WorkspaceLocked bool `json:"workspace_locked,omitempty"`
+		// LockHolder 占着这个目录的那一端是谁（pid / client / source / run_id）。
+		// 只在 WorkspaceLocked 为真时给；用户的追问永远是「谁在占」，只有 pid 答不了。
+		LockHolder *session.LockHolder `json:"lock_holder,omitempty"`
 	}
 	logDir, _ := sessionLogDir()
+	/* 锁的查询按**目录**去重：一屏几十条会话大多在同一个 workspace 上，
+	   逐行读一次锁文件既浪费又要处理「同一目录答案不一致」的边界。
+	   这里先收集涉及的目录，各查一次。 */
+	lockOf := map[string]*session.LockHolder{}
+	lockOfWorkspace := func(ws string) *session.LockHolder {
+		key, _ := session.LockKey(ws)
+		if h, ok := lockOf[key]; ok {
+			return h
+		}
+		var out *session.LockHolder
+		if h, ok := session.LockHolderFor(ws); ok && h.PID != os.Getpid() {
+			/* 排除自己：列表页说「你自己占着这个目录」是噪音 ——
+			   用户关心的是「我要不要等别人」。 */
+			out = &h
+		}
+		lockOf[key] = out
+		return out
+	}
+	/* 标题表与状态表各取**一次**快照（2026-10-26 修）：
+	   这两个查询原本逐行调用，而每次调用都会让底层把整张表深拷贝一遍（缓存不能交给
+	   调用方乱改）+ 加一次锁。407 行 = 814 次全表拷贝。列表页要的只是 O(1) 查表，
+	   拷一次就够 —— 语义不变（TitleOf / StatusOf 与 TitleForAny / StatusForAny 同口径）。 */
+	titles := session.TitleSnapshot()
+	statuses := session.StatusSnapshot()
 	rows := make([]row, 0, len(records))
 	for _, r := range records {
 		/* 标题的键可能是 session_id，也可能是 run_id（首轮归纳时引擎还没吐 id，见
 		   session.TitleForAny）—— 两个都认，且**一次取定**，免得两个客户端因为
 		   「谁先拿到 id」而显示不同标题。取不到才回落 prompt_head（= 还没归纳）。 */
-		title := session.TitleForAny(r.SessionID, r.RunID)
+		title := session.TitleOf(titles, r.SessionID, r.RunID)
 		summarized := title != ""
 		if title == "" {
 			title = r.PromptHead
 		}
+		hasLog := session.HasSessionLogIn(logDir, r.SessionID, r.RunID)
+		/* 排队占位（服务端作业队列预登记，state=queued）还没有会话日志，归纳必然失败。
+		   这里直接报「已定稿」，客户端就不会每轮列表刷新都去打一次 --summarize-title。
+		   真开跑后 core 那条记录照常走归纳。 */
+		if r.State == session.StateQueued {
+			summarized = true
+		}
+		/* 结构性不可能归纳：**已经有 session_id、却没有事件日志**。
+		   这种会话每一次归纳都必然失败，重试一万次结果一样，所以直接报「已定稿」，
+		   客户端别再去打那一发（否则它永远停在「待归纳」，每次刷新重来一遍）。
+
+		   为什么必然失败（见 runSummarizeTitle）：归纳的输入必须是**首问**，首问只从
+		   事件日志里取；日志读不到时唯一的兜底是 prompt_head，而那条兜底**只在还没有
+		   session_id 时**才允许（有 id = 至少第二轮，prompt_head 记的是当前这轮追问，
+		   拿它归纳等于把标题改成最新追问 —— 正是「标题每次追问都在变」那个老问题）。
+		   于是 `sessionID != "" && 无日志` 落进「读不到首问」的硬失败分支。
+
+		   什么时候会落到这个组合：引擎当时是非流式跑的（日志只在 --stream 时写）、
+		   或日志被清理而登记还在。两者都不会自己好转 —— 除非用户明确要求 `--title-force`
+		   重来（客户端的手动「重新归纳」按钮照常能打）。 */
+		if !summarized && r.SessionID != "" && !hasLog {
+			summarized = true
+		}
 		/* 统一状态：一条会话一个值（各轮的行给出同一个），决定客户端画「进行中 / 已完成」。
 		   没有条目（改造前的老记录）才回落这一轮的 state。alive 也**按它算** ——
 		   否则一行里 status=idle、alive=true 自相矛盾，客户端又会分叉。 */
-		status := session.StatusForAny(r.SessionID, r.RunID)
+		status := session.StatusOf(statuses, r.SessionID, r.RunID)
 		if status == "" {
 			status = r.State
 		}
+		/* 这个会话所在目录当前被谁占着（空 workspace 用 cwd 兜底，与锁的归一一致）。
+		   只有**活着的**会话才关心：已收尾的会话不给这个字段，免得列表上到处是
+		   「锁被占着」的陈旧提示（锁文件可能因为进程刚退出还没删）。 */
+		var holder *session.LockHolder
+		if session.IsLiveState(status) {
+			ws := r.Workspace
+			if ws == "" {
+				ws = r.Cwd
+			}
+			holder = lockOfWorkspace(ws)
+		}
 		rows = append(rows, row{
 			RunID:           r.RunID,
 			SessionID:       r.SessionID,
@@ -425,7 +495,9 @@ func runSessions(cmd *cobra.Command, opts *askOptions) error {
 			TitleSummarized: summarized,
 			StartedAt:       r.StartedAt.Format("2006-01-02 15:04:05"),
 			UpdatedAt:       r.UpdatedAt.Format("2006-01-02 15:04:05"),
-			HasLog:          session.HasSessionLogIn(logDir, r.SessionID, r.RunID),
+			HasLog:          hasLog,
+			WorkspaceLocked: holder != nil,
+			LockHolder:      holder,
 		})
 	}
 	return printJSON(cmd.OutOrStdout(), rows)

package/internal/cli/session_test.go

@@ -157,10 +157,20 @@ func TestAskRegistersSession(t *testing.T) {
 	if r.Alive {
 		t.Error("已结束的会话不该标 alive")
 	}
-	// 记录文件确实落在指定目录
+	/* 记录文件确实落在指定目录。
+	   ⚠️ 只数 `.json`（2026-10-26）：工作空间锁默认启用之后，同一个目录里还会多出
+	   `locks/` 子目录（见 internal/session/workspace_lock.go）。原来按目录项数断言
+	   「= 1」会因为多了这个子目录而假失败 —— 它数的是「目录里有几样东西」，
+	   而这里想验的是「登记记录落在哪」，两者本来就不是一回事。 */
 	entries, _ := os.ReadDir(dir)
-	if len(entries) != 1 {
-		t.Errorf("目录里文件数 = %d want 1", len(entries))
+	nJSON := 0
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasSuffix(e.Name(), ".json") {
+			nJSON++
+		}
+	}
+	if nJSON != 1 {
+		t.Errorf("目录里登记记录数 = %d want 1（entries=%v）", nJSON, entries)
 	}
 }
 
@@ -339,3 +349,72 @@ func mustSessions(t *testing.T) string {
 	}
 	return out
 }
+
+// TestSessionsMarksUnsortedWhenSummarizeImpossible 有 session_id 却没有事件日志的会话，
+// 归纳**必然失败**（见 runSummarizeTitle 里「读不到首问」那条硬失败分支），列表要直接
+// 报「已定稿」—— 否则客户端每轮刷新都去打一发 --summarize-title，永远是失败，永远重来。
+//
+// 为什么这个标记必须由 core 给：客户端只看得到 title（恒非空，回落 prompt_head）与
+// title_summarized，它**没有**能力判断「这个组合注定失败」——那依赖归纳的输入从哪来，
+// 是 CLI 的内部知识。让客户端自己猜就会分叉。
+func TestSessionsMarksUnsortedWhenSummarizeImpossible(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(session.EnvDir, dir)
+	oldLog := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = oldLog }()
+	SessionLogDirOverride = t.TempDir() // 空目录：任何会话都没有事件日志
+
+	/* 造两条记录：一条会拿到 session_id（引擎吐 id，归纳必然读不到首问），
+	   一条不吐 id（首轮，prompt_head 就是首问，归纳**有**机会成功）。
+	   用真实的调用链造（假引擎 + --save-registry），不手写记录文件 ——
+	   writeRecord 没导出，而且手写的记录容易和 Read 侧的归一规则脱节。 */
+	registerFake(&sidEngine{name: "fake-hard-sid", text: "ok", sid: "sid-hard-fail"})
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-hard-sid", "有 id 没日志"); err != nil {
+		t.Fatalf("造带 id 的记录失败: %v", err)
+	}
+	registerFake(&stringEngine{name: "fake-no-sid", text: "ok"})
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-no-sid", "没 id 也没日志"); err != nil {
+		t.Fatalf("造无 id 的记录失败: %v", err)
+	}
+
+	var rows []struct {
+		RunID           string `json:"run_id"`
+		SessionID       string `json:"session_id"`
+		TitleSummarized bool   `json:"title_summarized"`
+		HasLog          bool   `json:"has_log"`
+	}
+	out := mustSessions(t)
+	if err := json.Unmarshal([]byte(out), &rows); err != nil {
+		t.Fatalf("--sessions 输出不是 JSON：%v", err)
+	}
+	bySID := map[string]struct {
+		TitleSummarized bool
+		HasLog          bool
+	}{}
+	for _, r := range rows {
+		bySID[r.SessionID] = struct {
+			TitleSummarized bool
+			HasLog          bool
+		}{r.TitleSummarized, r.HasLog}
+	}
+
+	hard, ok := bySID["sid-hard-fail"]
+	if !ok {
+		t.Fatalf("有 session_id 的那条没出现在列表里：%s", out)
+	}
+	if hard.HasLog {
+		t.Error("前置条件不成立：这条本来就没有日志")
+	}
+	if !hard.TitleSummarized {
+		t.Error("有 session_id + 无日志 = 归纳必然失败，列表必须报 title_summarized=true（别再让客户端重试）")
+	}
+
+	// 没有 session_id 的那条：SessionID 为空串。
+	soft, ok := bySID[""]
+	if !ok {
+		t.Fatalf("没有 session_id 的那条没出现在列表里：%s", out)
+	}
+	if soft.TitleSummarized {
+		t.Error("没有 session_id 的会话归纳有机会成功（prompt_head 就是首问），不该被标成已定稿")
+	}
+}

package/internal/cli/sessionlog.go

@@ -118,6 +118,12 @@ type sessionEvent struct {
 	// Error / Reason 异常收尾的原因（仅 turn_failed），与事件流同源。
 	Error  string `json:"error,omitempty"`
 	Reason string `json:"reason,omitempty"`
+	/* 失败分类（2026-10-25，仅 turn_failed）：与事件流同名同义（见 events.go 的
+	   streamEventPayload）。落盘它是为了让**历史回放画出同一张卡** —— 额度用尽
+	   那一轮翻回去看，仍应是「额度卡」而不是普通失败卡。 */
+	ErrorKind string `json:"error_kind,omitempty"`
+	ErrorCode string `json:"error_code,omitempty"`
+	ResetAt   string `json:"reset_at,omitempty"`
 	// Attachments 用户提问携带的附件（仅 kind:"user" 有）。引擎事件里没有附件信息
 	// （`image` 事件只对应助手**产出**），所以只有落在这里，历史回放才复原得出
 	// 「那一轮用了哪张图」—— 移动端据此在历史气泡里画出缩略图。

package/internal/cli/sessionlog_test.go

@@ -216,10 +216,30 @@ func TestSessionWriterRealisticStream(t *testing.T) {
 	if len(evs) != 7 {
 		t.Fatalf("ReadSessionLog 期望 7 条，实得 %d", len(evs))
 	}
+
+	/* 额度卡三项要**落盘**（2026-10-25）：只走实时流不带它们，用户翻历史时那一轮就退回
+	   普通失败卡 —— 「当时看到的」和「事后回看的」长成两张脸，是本仓库反复踩过的那类问题。 */
+	sw2, err := newSessionWriterAuto(sessionLogDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sw2.setSessionID("sess-quota")
+	sw2.push(sessionEvent{
+		Kind: "turn_failed", Status: "failed",
+		Error: "429 You have exceeded the 5-hour usage quota.", Reason: "429 You have exceeded the 5-hour usage quota.",
+		ErrorKind: "quota", ErrorCode: "429", ResetAt: "2026-10-25T15:07:27+08:00",
+	})
+	drain(t, sw2)
+	back, err := ReadSessionLog("", "sess-quota")
+	if err != nil || len(back) != 1 {
+		t.Fatalf("读回额度那一轮失败：%v（%d 条）", err, len(back))
+	}
+	if back[0].ErrorKind != "quota" || back[0].ErrorCode != "429" || back[0].ResetAt != "2026-10-25T15:07:27+08:00" {
+		t.Errorf("落盘丢了额度字段：%+v", back[0])
+	}
 }
 
-/* ── 2026-10-15：日志不再等 session_id 才创建 ──
-   用户要求：「不等终点事件就应该创建会话落库，这样多个客户端马上就能看到正在跑的会话」。
+/* ── 2026-10-15：日志不再等 session_id 才创建 ──   用户要求：「不等终点事件就应该创建会话落库，这样多个客户端马上就能看到正在跑的会话」。
    此前日志要等引擎吐 session_id 才知道文件名 → 正在跑的会话读出来永远是空历史；
    引擎整轮不给 id 时（dsh 的 headless 回退轮）更是收工就把内存 buffer 丢光。 */