magic-agent 1.0.3 → 1.0.49

package/internal/cli/ask.go

@@ -71,12 +71,18 @@ type askOptions struct {
 	maxTokens    int
 	temperature  float64
 	tempSet      bool
+	reasoning    string // 推理档位（--reasoning；默认 max）
 	jsonSchema   string // 内联 JSON Schema（仅 llm 引擎走 --schema）
 	session      string // 会话续接 id（空 = 新会话，默认）
 	continueF    bool   // 续接最近一次会话（-c/--continue；不需要 id）
 	workspace    string // 工作目录（-w/--workspace；空 = 用调用方 cwd）
 	stop         string // 停止指定会话/运行（--stop <session_id|run_id>）
-	listSessions bool   // 列出会话登记表（--sessions）
+	// deleteSession 删除指定会话/运行（--delete-session <session_id|run_id>）：
+	// 登记记录 + 事件日志 + 标题覆盖一起删。与插件的 DELETE /desk/session/{id} 同一份实现
+	// （见 internal/session/delete.go）——「一端删了、另一端还在」的根因就是删除没落在
+	// 大家共用的那份数据上（2026-10-19 用户：「从pc端删除的会话移动端还在显示」）。
+	deleteSession string
+	listSessions  bool // 列出会话登记表（--sessions）
 	// sessionLog 读一段会话的**事件历史**（--session-log <session_id|run_id>）。
 	// 为什么要有它：会话的「查询」能力原先只在 HTTP 插件里（/desk/session/{id}/messages），
 	// 而 magic-agent 自己不跑服务、由调用方（如掌天瓶）直接 exec CLI —— 所以读历史
@@ -84,10 +90,41 @@ type askOptions struct {
 	sessionLog string
 	// logAfter 增量续读游标（--after <seq>，仅配合 --session-log）：
 	// 调用方报「我已看到 seq=N」，只回 seq > N 的部分。断线重连时不必重传整段历史。
-	logAfter  uint64
-	keepAlive bool          // 常驻会话：首轮结束后不退出，等 --append 追加（需配合 --stream）
-	appendTo  string        // 向常驻会话追加消息（--append <session_id|run_id>）
-	idle      time.Duration // 常驻会话空闲收工时长（--idle，仅 --keep-alive 有效）
+	logAfter uint64
+	// logBefore 反向翻页游标（--before <skip>，仅配合 --session-log）：
+	// 从文件尾**跳过多少条**已画事件，再往前取一页。
+	// 为什么不用 seq：同一会话每次续跑都是新进程，旧版 writer 的 seq 每轮从 1 重来，
+	// 拿 seq 当全局游标会在 run 边界处把更早的历史整段滤掉（见 session.ReadSessionLogBefore）。
+	// 为什么要它：长会话默认只画最近一轮，向上滚动时按页补更早的历史 ——
+	// 全量读一遍几百 MB，客户端等不起，也没必要。
+	logBefore uint64
+	// logLimit 反向翻页每页条数（--limit，仅配合 --before）。默认 200。
+	logLimit int
+	// logLean 输出时略去 snapshot（--session-log-lean，仅配合 --session-log）。
+	// 为什么要它：snapshot 是「该 item 到此刻的累积整段」，每条增量都带一份，
+	// 长会话的日志因此二次方膨胀（实测 9.4 万条思考事件 = 283MB 快照，整份 338MB）。
+	// 回放侧只用增量 text，所以输出裁掉它不影响画面，读取却快数倍。
+	logLean bool
+	// saveHistory 是否把流式会话的事件**落盘存档**（--save-history；默认关）。
+	// 存档 = <dir>/<session_id>.jsonl，供 --session-log / 客户端回放历史。
+	// ⚠️ 与「会话登记表」（run-*.json）不是一回事：那个由 saveRegistry 管
+	// （--sessions / --stop / --append 靠它寻址）；这个纯粹为了回看。
+	saveHistory bool
+	// saveRegistry 是否把会话**登记落盘**（--save-registry；默认关）。
+	// 不开时磁盘上没有 <run_id>.json：--sessions / --stop 看不见它，
+	// --append 只能按 run_id 走约定路径（见 session.AppendSocketPath）。
+	saveRegistry bool
+	keepAlive    bool          // 常驻会话：首轮结束后不退出，等 --append 追加（需配合 --stream）
+	appendTo     string        // 向常驻会话追加消息（--append <session_id|run_id>）
+	idle         time.Duration // 常驻会话空闲收工时长（--idle，仅 --keep-alive 有效）
+
+	// 会话标题（2026-10-15；见 internal/session/title.go）。
+	// 归纳口径收进 core 后，客户端不再各自实现 —— 否则 PC 与移动端标题不一致，
+	// 且从移动端发起的会话没人替它归纳。
+	summarizeTitle string // --summarize-title <id>：归纳并写入覆盖表
+	sessionTitle   string // --session-title <id>：只读已存标题（不调 LLM）
+	titleForce     bool   // --title-force：已有覆盖也重新归纳
+	titleEngine    string // --title-engine：归纳用哪个引擎（默认 llm）
 
 	// 四档权限模型（见 internal/agent/permission.go）。仅 claude / codebuddy 接线。
 	permission     string   // 档位：manual | accept-edits | auto | full
@@ -101,7 +138,7 @@ type askOptions struct {
 // newAskOptions 返回带默认值的选项集。
 //   - 默认输出 json：固定单行 envelope，程序解析最友好；人看用 -o text。
 //   - 默认引擎 codebuddy：hy3 免费模型开箱即用。
-//   - 默认超时 600s：10 分钟，覆盖 codebuddy 慢响应场景。
+//   - 默认超时 1h：覆盖带工具循环的长任务（2026-10-10 由 600s 上调）。
 //   - 默认常驻（keepAlive）：claude/codebuddy 的流式调用自动成为常驻会话，
 //     任务跑着的时候就能 `--append` 追加需求（用户 2026-09-18：「keep-alive要是默认的」）。
 //     用 --keep-alive=false 关掉；非流式 / 不支持追加的引擎会自动忽略它。
@@ -109,7 +146,7 @@ func newAskOptions() *askOptions {
 	return &askOptions{
 		engine:    "codebuddy",
 		output:    "json",
-		timeout:   600 * time.Second,
+		timeout:   time.Hour,
 		keepAlive: true,
 	}
 }
@@ -124,22 +161,33 @@ func bindAskFlags(cmd *cobra.Command, opts *askOptions) {
 	f.StringVarP(&opts.workspace, "workspace", "w", "", "工作目录（workspace）：在该目录里执行引擎；codex 走原生 -C，claude/codebuddy/trae/dsh 用子进程 cwd，llm/arkclaw/openclaw 不支持（忽略并提示）")
 	f.StringVarP(&opts.file, "file", "f", "", "从文件读 prompt（\"-\" = stdin）")
 	f.StringArrayVarP(&opts.attach, "attach", "a", nil, "附件路径（截图/图片等），可重复或逗号分隔；与提示词一起发给引擎（各引擎落地方式见 --engines 的 attachments 字段）")
-	f.StringVar(&opts.tools, "tools", "off", "工具开关: off | on | 逗号分隔白名单(如 Bash,Read)")
-	f.StringVar(&opts.session, "session", "", "会话续接 id（空=新会话；传入上次输出里的 session_id 继续同一会话；arkclaw 传 contextId；dsh 不支持续接）")
+	f.StringVar(&opts.tools, "tools", "on", "工具开关: off | on | 逗号分隔白名单(如 Bash,Read)（默认 on，2026-10-01 与 engine.toolsOrDefault 默认同步反转）")
+	f.StringVar(&opts.session, "session", "", "会话续接 id（空=新会话；传入上次输出里的 session_id 继续同一会话；arkclaw 传 contextId；dsh 走 headless 的 --session-id，见 --help 的 dsh 一节）")
 	f.BoolVarP(&opts.continueF, "continue", "c", false, "续接当前目录最近一次会话（不需要 session id；与 --session 同时给时 --session 优先）")
-	f.StringVar(&opts.stop, "stop", "", "停止指定会话/运行：传 session_id 或 run_id（--sessions 可见），杀掉它的引擎进程组")
-	f.BoolVar(&opts.listSessions, "sessions", false, "列出会话登记表（JSON 数组：run_id / session_id / pid / engine / state / 起止时间）")
+	f.StringVar(&opts.stop, "stop", "", "停止指定会话/运行：传 session_id 或 run_id（--sessions 可见），杀掉它的引擎进程组。只停得掉**已存档**的会话（--save-registry）")
+	f.BoolVar(&opts.listSessions, "sessions", false, "列出会话登记表（JSON 数组：run_id / session_id / pid / engine / source / client / state / 起止时间）。全机视图，不按 client 过滤；只列**已存档**的会话（--save-registry，默认关）")
+	f.StringVar(&opts.deleteSession, "delete-session", "", "删除一条会话：登记记录 + 事件日志 + 标题覆盖一起删（传 session_id 或 run_id）。删除是**全机生效**的 —— 各端读的是同一份登记表，一端删了处处都看不到。幂等（id 不认识也算成功）")
 	/* 会话历史的**读取**命令。与 --sessions（列表）、--stop、--append 同一族：
 	   调用方（掌天瓶等）exec CLI 就能拿到会话数据，不需要 magic-agent 跑任何服务。 */
 	f.StringVar(&opts.sessionLog, "session-log", "", "读一段会话的事件历史（JSON：{session,events}）。传 session_id 或 run_id（--sessions 可见）")
+	f.StringVar(&opts.summarizeTitle, "summarize-title", "", "把一条会话归纳成标题（AI 摘要，≤12 字）并写入标题表。传 session_id 或 run_id。客户端不要再各自实现归纳 —— 这是唯一口径")
+	f.StringVar(&opts.sessionTitle, "session-title", "", "读一条会话**已存**的标题（JSON：{id,title}），不调 LLM。没有覆盖时回落到 prompt_head。列表页取标题走这条，别逐行调 --summarize-title")
+	f.BoolVar(&opts.titleForce, "title-force", false, "配合 --summarize-title：已有标题也重新归纳（默认命中缓存就直接返回，省一次 LLM 调用）")
+	f.StringVar(&opts.titleEngine, "title-engine", "llm", "--summarize-title 用哪个引擎归纳（默认 llm：纯文本、不带工具）")
 	f.Uint64Var(&opts.logAfter, "after", 0, "配合 --session-log：增量续读，只回 seq > N 的事件（另附 count/after/lastSeq/snapshotRequired）")
+	f.Uint64Var(&opts.logBefore, "before", 0, "配合 --session-log：向上翻更早的历史，从文件尾跳过 N 条已画事件再取一页（0 = 最新一页；下一页把返回的 nextBefore 传回来。另附 count/before/nextBefore/firstSeq/more；与 --after 互斥）")
+	f.IntVar(&opts.logLimit, "limit", 200, "配合 --before：每页最多返回多少条事件（默认 200）")
+	f.BoolVar(&opts.logLean, "session-log-lean", false, "配合 --session-log：输出省掉 snapshot（回放只用增量 text；长会话体积可降 ~85%，读取快数倍）。只影响输出，磁盘存档不变；老客户端不传该参数时行为不变")
+	f.BoolVar(&opts.saveHistory, "save-history", false, "把流式会话的事件落盘存档（<dir>/<session_id>.jsonl；引擎还没吐 session_id 时先落 <run_id>.jsonl，拿到 id 后改名），供 --session-log 与客户端回放历史。默认关（一次性调用不留痕）；要回看历史/跨进程续看时才开")
+	f.BoolVar(&opts.saveRegistry, "save-registry", false, "把会话登记落盘（<dir>/<run_id>.json），让 --sessions / --stop 事后能按 id 寻址。默认关（不留痕）；要列表/停止/按 session_id 追加时才开")
 	f.BoolVar(&opts.keepAlive, "keep-alive", true, "常驻会话：首轮结束后不退出、等 --append 追加（需 --stream）。claude/codebuddy 默认开；dsh 默认关（显式传 --keep-alive 开启）；其余引擎不支持")
 	f.StringVar(&opts.appendTo, "append", "", "向常驻会话追加一条消息：传 session_id 或 run_id，内容用 -p/位置参数给")
 	f.DurationVar(&opts.idle, "idle", 5*time.Minute, "常驻会话空闲收工时长（默认 5m；0 = 本轮结束就收工，追加窗口只在任务运行期间）")
 	f.IntVar(&opts.maxTokens, "max-tokens", 0, "输出 token 上限（0=不指定；claude/codebuddy 经 --settings 注入，llm 透传，trae/dsh 忽略）")
 	f.Float64Var(&opts.temperature, "temperature", -1, "采样温度（-1=不指定；仅 llm 引擎透传，其余引擎忽略）")
+	f.StringVar(&opts.reasoning, "reasoning", "max", "推理/思考档位: minimal | low | medium | high | xhigh | max | off（默认 max；claude/codebuddy 走 --effort，codex 走 -c model_reasoning_effort；其余引擎无此参数，忽略）")
 	f.StringVar(&opts.jsonSchema, "json-schema", "", "JSON Schema 内联字符串（llm / openclaw / dsh / arkclaw 引擎；启用结构化输出与 JSON 后处理）")
-	f.DurationVarP(&opts.timeout, "timeout", "t", 600*time.Second, "单次尝试超时（默认 600s=10m）")
+	f.DurationVarP(&opts.timeout, "timeout", "t", time.Hour, "单次尝试超时（默认 1h）")
 	f.IntVarP(&opts.retries, "retries", "r", 0, "失败重试次数（默认 0）")
 	f.DurationVar(&opts.backoff, "backoff", 2*time.Second, "首次重试退避间隔（指数翻倍，上限 30s）")
 	f.StringVarP(&opts.output, "output", "o", "json", "输出格式: json | text")
@@ -157,7 +205,7 @@ func bindAskFlags(cmd *cobra.Command, opts *askOptions) {
 	bindPermissionFlags(cmd, opts)
 }
 
-// bindPermissionFlags 注册四档权限模型的 flags（仅 claude / codebuddy 生效）。
+// bindPermissionFlags 注册四档权限模型的 flags（仅 claude / codebuddy / dsh 生效）。
 //
 // 默认档 full 是**刻意**的：改造前 claude/codebuddy 在 --tools 非 off 时恒传
 // --dangerously-skip-permissions / -y，语义正是第 4 档。把默认值改成别的档位
@@ -166,10 +214,10 @@ func bindAskFlags(cmd *cobra.Command, opts *askOptions) {
 func bindPermissionFlags(cmd *cobra.Command, opts *askOptions) {
 	f := cmd.PersistentFlags()
 	f.StringVar(&opts.permission, "permission", string(agent.DefaultPermissionTier),
-		"权限档位: manual | accept-edits | auto | full（默认 full=保持既有行为；仅 claude/codebuddy/codebuddy-ai 生效）\n"+
+		"权限档位: manual | accept-edits | auto | full（默认 full=保持既有行为；仅 claude/codebuddy/codebuddy-ai/dsh 生效）\n"+
 			"  manual        沙箱开启，只读放行，其余逐项由用户确认\n"+
 			"  accept-edits  沙箱开启，编辑放行，命令仍逐条确认\n"+
-			"  auto          沙箱开启，越界由内置 LLM Guardian 判定（推荐）\n"+
+			"  auto          沙箱开启，越界由内置 LLM Guardian 判定（推荐；dsh 无分类器，退化为「沙箱内放行」）\n"+
 			"  full          沙箱关闭，命令直接在宿主机执行，无审批")
 	f.StringArrayVar(&opts.sandboxExclude, "sandbox-exclude", nil,
 		"始终在沙箱外执行的命令（如 docker,watchman）；可重复或逗号分隔（manual/accept-edits/auto 有效）")
@@ -406,7 +454,7 @@ func resolvePermissionTier(engineName, raw string, explicit bool) (agent.Permiss
 	}
 	if explicit && !agent.PermissionSupported(engineName) {
 		return "", &usageError{fmt.Errorf(
-			"--permission 暂不支持 %s 引擎（当前仅 claude、codebuddy、codebuddy-ai；各引擎能力见 --engines 的 permission 字段）",
+			"--permission 暂不支持 %s 引擎（当前仅 claude、codebuddy、codebuddy-ai、dsh；各引擎能力见 --engines 的 permission 字段）",
 			engineName)}
 	}
 	return tier, nil
@@ -421,7 +469,7 @@ func runAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 
 	// 会话登记 + spawn 钩子：把引擎子进程 pid 记下来，之后任何进程都能
 	// `magic-agent --stop <session_id>` 精确停掉它（见 internal/session）。
-	h := beginSession(engine.Name(), req)
+	h := beginSession(engine.Name(), req, opts.saveRegistry)
 	ctx := withSessionHook(cmd.Context(), h)
 
 	runner := &agent.Runner{
@@ -449,14 +497,21 @@ func runAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 // beginSession 落一条 running 记录（失败不阻断调用：登记表只是可运维性）。
 // PID 先填自身 pid 兜底 —— HTTP 直连这类没有子进程的引擎也能被 --stop 停掉
 // （杀 magic-agent 自己即中止该次调用）；子进程起来后 spawn 钩子会覆盖成引擎 pid。
-func beginSession(engine string, req agent.Request) *session.Handle {
+//
+// ⚠️ saveRegistry=false 时**不落盘**（用户 2026-10-12：「会话登记也不需要」）：
+// 句柄照常分配（run_id 要给常驻会话的追加入口命名），只是磁盘上不留记录 ——
+// 代价是 --sessions / --stop 看不见它，--append 只能按 run_id 走约定路径。
+func beginSession(engine string, req agent.Request, saveRegistry bool) *session.Handle {
 	h, err := session.Begin(session.BeginOptions{
 		Engine:     engine,
 		Model:      req.Model,
+		Source:     os.Getenv(session.EnvSource),
+		Client:     os.Getenv(session.EnvClient),
 		Workspace:  req.Workspace,
 		SessionID:  req.SessionID,
 		PromptHead: firstUserText(req.Messages),
 		PID:        os.Getpid(),
+		NoPersist:  !saveRegistry,
 	})
 	if err != nil {
 		return nil
@@ -535,15 +590,26 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 	stdout, stderr := cmd.OutOrStdout(), cmd.ErrOrStderr()
 	sink := newEventSink(stdout, engine.Name(), opts.events)
 
-	// 「看历史」持久化：每条事件落盘到 <dir>/<session_id>.jsonl，
-	// 移动端进入会话详情时先读这个文件渲染历史，再开 SSE 接续。
-	// 不写盘也不会让流失败；所有写盘错误都进 stderr 警告、流继续（写盘是个独立 goroutine）。
-	sessionLog, err := newSessionWriterAuto(sessionLogDir)
-	if err != nil {
-		fmt.Fprintf(stderr, "magic-agent: 准备会话持久化目录失败：%v（流继续）\n", err)
-		sessionLog = nil
-	} else {
-		defer func() { sessionLog.close() }()
+	/* 「看历史」存档（--save-history，**默认关**）：每条事件落盘到
+	   <dir>/<session_id>.jsonl，移动端/桌面端进入会话详情时先读它渲染历史，再开 SSE 接续。
+
+	   为什么默认不落（用户 2026-10-12：「加一个参数 默认不存档」）：落盘是**副作用**，
+	   而绝大多数调用（CLI 手工跑一轮、CI、脚本编排、批量任务）**没人会回看**，
+	   写下来的 jsonl 却会一直堆在磁盘上（登记表有 24h 保留期在清，这个没有 ——
+	   prune 只删 *.json）。要回放的调用方自己显式开：magic-client 就是这么干的
+	   （它的 /desk/ask 恒传 --save-history）。
+
+	   ⚠️ 不写盘也不会让流失败；所有写盘错误都进 stderr 警告、流继续
+	   （写盘是个独立 goroutine，见 sessionlog.go 的三条约束）。 */
+	var sessionLog *sessionWriter
+	if opts.saveHistory {
+		sw, err := newSessionWriterAuto(sessionLogDir)
+		if err != nil {
+			fmt.Fprintf(stderr, "magic-agent: 准备会话存档目录失败：%v（流继续）\n", err)
+		} else {
+			sessionLog = sw
+			defer func() { sessionLog.close() }()
+		}
 	}
 	// 把 session_id 推到 writer：CLI 这边的 OnSessionID 回调（引擎流里见到 init 行就调）
 	// 写新 id，writer 自己的写盘 goroutine 读出来开文件。
@@ -568,7 +634,9 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 			if m.Role != "user" || strings.TrimSpace(m.Content) == "" {
 				continue
 			}
-			sessionLog.push(sessionEvent{Kind: "user", Text: m.Content})
+			// 附件挂在 user 事件上：引擎事件里没有附件信息（`image` 只对应助手产出），
+			// 只有落这里，历史回放才复原得出「那一轮带了哪张图」。
+			sessionLog.push(sessionEvent{Kind: "user", Text: m.Content, Attachments: req.Attachments})
 		}
 	}
 
@@ -583,10 +651,19 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 		// ⚠️ 这里只走**引擎事件**。用户提问（kind:"user"）与失败（kind:"error"）
 		//    不由流事件触发，见上面 runStreamAsk 里的 push 与下面的 error 分支。
 		/* ToolKind 与 SSE 流同源（同一个 toolKindOfEvent）：历史回放与实时渲染
-		   因此画出同一种卡，而不是各按工具名猜一套（见 agent/toolkind.go）。 */
+		   因此画出同一种卡，而不是各按工具名猜一套（见 agent/toolkind.go）。
+		   状态收敛三元组同样落盘 —— 历史回放按 (item_id, item_revision)
+		   覆盖式 upsert，语义与实时流完全一致。
+		   ⚠️ **不落 Snapshot**（2026-10-20）：它是「该 item 到此刻的累积整段」，
+		   每条增量都带一份 ⇒ 二次方膨胀（实测一条会话 1.8GB，95.6% 是它）。
+		      落盘只留增量 text + 收敛三元组；回放侧只用增量自己拼。
+		      实时流（NDJSON）仍照旧带 snapshot —— 那是多端同步要的两回事。 */
 		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),
+			Error:  ev.Error, Reason: ev.Reason,
 		})
 	}
 	if format == agent.FormatJSON {
@@ -622,13 +699,19 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 				// ⚠️ headless 下 claude 会在模型提问后**自行拒绝**（模型拿不到答案），
 				// 要真正作答得把答案作为后续 user 消息补进去（agent.EncodeAskFollowUp）。
 				fmt.Fprint(stderr, "❓ "+ev.Text+"\n")
+			case agent.KindTurnFailed:
+				// 本轮异常收尾（引擎没给 result 行）。打 stderr：stdout 是正文通道，
+				// 往里写错误会让 `> file` 存下一堆垃圾。真正的失败 envelope 由下面
+				// runStreamAsk 的 error 分支写（stdout 一条 error 事件），这里只
+				// 保证 text 模式的调用方也**看得见**这一轮没有正常结束。
+				fmt.Fprint(stderr, "✗ 本轮异常收尾："+ev.Reason+"\n")
 			}
 			wireLogger(ev)
 		}
 	}
 
 	// 超时：常驻会话的存活由 --idle（空闲收工）决定，所以常驻生效时只有调用方**显式**给 -t
-	// 才套总超时；否则不设上限（长任务 + 追加不受 600s 默认值限制）。
+	// 才套总超时；否则不设上限（长任务 + 追加不受 1h 默认值限制）。
 	ctx := cmd.Context()
 	/* --control 要能主动打断：在（可能的）超时之上再套一层可取消的 ctx。
 	   打断与超时走同一条路径 —— 引擎进程组由 Stream 侧按 ctx 收拾。 */
@@ -644,9 +727,39 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 	}
 
 	// 会话登记 + spawn 钩子（与 runAsk 同一套：--stop 靠它拿到引擎 pid）。
-	h := beginSession(engine.Name(), req)
+	h := beginSession(engine.Name(), req, opts.saveRegistry)
 	ctx = withSessionHook(ctx, h)
 
+	/* 把「本次运行 id」也交给存档 writer（2026-10-15）：引擎还没吐 session_id 时，
+	   日志就先落到 <run_id>.jsonl —— 于是
+	     · 「刚开跑、还不知道 id」的会话在别的客户端里**当场可读**（此前文件还没有名字，
+	       读出来是空历史，看起来像「这条会话没有内容」）；
+	     · 引擎**整轮都不给 id** 的形态（dsh 的 headless 回退轮）不再白开 --save-history
+	       （此前那些事件一直躺在内存 buffer 里，收工时被丢光）。
+	   拿到 id 后 writer 自己改名为 <session_id>.jsonl（见 sessionlog.go 的 renameTo）。 */
+	if sessionLog != nil {
+		sessionLog.setRunID(h.RunID())
+	}
+
+	/* 会话 id **一拿到就回填登记表**，不等收尾（2026-10-16 修）。
+	   在此之前只有收尾（finishSession → Handle.Finish）才写这个字段，于是「正在跑的会话」
+	   在磁盘上（以及客户端的会话列表里）只有 run_id：
+	     · 列表按 session_id 去重的语义在这段时间**完全失效** —— 一条会话会以 run_id 为键
+	       另开一行（标题归纳也落在 run_id 上，用户看到的就是「同一段对话裂成两条任务」）；
+	     · 客户端点开这样的行，回传的是 run_id（它以为是会话 id）—— run_id 不是引擎的会话
+	       id，续接必然接不上（引擎报未知会话 / 静默另起一段）。
+	   长任务尤其致命：一轮跑 30 分钟以上，这扇窗口就开 30 分钟。
+	   ⚠️ SetSessionID 自己幂等（值没变直接返回），所以逐事件调用不会带来额外落盘。 */
+	if h != nil {
+		prevOnSessionID := req.OnSessionID
+		req.OnSessionID = func(id string) {
+			if prevOnSessionID != nil {
+				prevOnSessionID(id)
+			}
+			h.SetSessionID(id)
+		}
+	}
+
 	// 常驻会话（默认开，claude/codebuddy 的流式调用）：开追加入口等 --append，
 	// 空闲 --idle 后优雅收工（关闭通道 → 引擎 stdin EOF → 正常收尾）。
 	var ka *keepAlive
@@ -681,8 +794,29 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 	}
 
 	// ready 握手（仅 --events）：客户端据此确认「谁在跑、契约版本是多少」。
+	// run_id 一并带出：新会话首轮引擎可能整轮都不吐 session_id，客户端只有拿到
+	// run_id 才能把这条运行中的轮次对应回登记表里以 run_id 为键的会话。
+	if h != nil {
+		sink.setRunID(h.RunID())
+	}
 	_ = sink.ready(req.Model)
 
+	/* 事件级别的 id 兜底也要接上日志 writer（2026-10-18，用户：「runid 不能统一记成 sessionid 吗」）。
+	   `OnSessionID` 只是 id 的**一条**来源：codex 这一脉从不调它，只在事件上带 session_id。
+	   此前事件级兜底只回填了登记表（见下面 onEvent 里的 h.SetSessionID），writer 没接 ——
+	   于是出现「登记表里有 session_id、日志文件却永远叫 <run_id>.jsonl」这种半截状态：
+	   客户端按 session_id 点开就读到空历史（列表 has_log=true、详情说「还没有事件」）。
+	   写盘时就把名字定成终名之后，读取端不必再猜文件叫哪个名字。
+	   ⚠️ 独立于 h：--save-history 可以不开登记表，那时这条兜底是唯一的 id 来源。
+	   空 id 由 setSessionID 自己跳过（它必须跳过，理由见那里的注释）。 */
+	if sessionLog != nil {
+		inner := onEvent
+		onEvent = func(ev agent.StreamEvent) {
+			sessionLog.setSessionID(ev.SessionID)
+			inner(ev)
+		}
+	}
+
 	/* ── 会话状态的中途写入（2026-09-29，对齐 anywhere 的 TimelineStatus）──
 	   引擎**停下来等用户**（提问 / 工具待授权）时，这条会话仍然活着，但没在跑 ——
 	   界面上该显示「等审批」而不是「生成中」。用户作答、或这一轮的任何后续事件到达时
@@ -692,6 +826,9 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 	if h != nil {
 		inner := onEvent
 		onEvent = func(ev agent.StreamEvent) {
+			// 会话锚点：引擎把 id 挂在事件上时同样立刻回填（覆盖不调 OnSessionID 的引擎，
+			// 见上面那段注释）。空 id 由 SetSessionID 自己跳过。
+			h.SetSessionID(ev.SessionID)
 			if ev.Kind == agent.KindAsk {
 				h.Mark(session.StateWaitingApproval)
 			} else {
@@ -701,6 +838,39 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 		}
 	}
 
+	/* 斜杠命令节点（2026-10-10，跨引擎渲染覆盖 P0-3）：引擎都不上报 command 的
+	   生命周期，core 依输入形态自己补 —— 与上面 user 事件同族（core 自己合成、
+	   不走引擎流）。最后一条 user 消息是 /xxx 形态时：开跑前发 status="running"，
+	   流收尾后再发终态帧（见下面 Stream 返回处）。实时 SSE 与历史落盘同源，
+	   历史回放免费还原。
+	   ⚠️ 走 sink.stream + wireLogger，不经 onEvent —— 此刻 onEvent 已被 keep-alive
+	      与 Mark 包了好几层，合成事件不该再进那些簿记；text 模式下 stdout 是正文
+	      通道，只落盘、不外发。
+	   ⚠️ 只覆盖本轮初始消息：--append 追加进来的 /xxx 走 ka 通道直进引擎，core
+	      不经手，不合成（有需要再补）。 */
+	lastUserMsg := ""
+	for _, m := range req.Messages {
+		if m.Role == "user" && strings.TrimSpace(m.Content) != "" {
+			lastUserMsg = strings.TrimSpace(m.Content)
+		}
+	}
+	isCommand := isSlashCommand(lastUserMsg)
+	emitCommand := func(status agent.StreamStatus) {
+		if !isCommand {
+			return
+		}
+		ev := agent.StreamEvent{Kind: agent.KindCommand, Text: lastUserMsg, Status: status}
+		if format == agent.FormatJSON {
+			_ = sink.stream(ev)
+			wireLogger(ev)
+			return
+		}
+		if sessionLog != nil {
+			sessionLog.push(sessionEvent{Kind: string(agent.KindCommand), Text: lastUserMsg, Status: string(status)})
+		}
+	}
+	emitCommand(agent.StatusRunning)
+
 	res, err := streamer.Stream(ctx, req, onEvent)
 	interrupted := ctl != nil && ctl.WasInterrupted()
 	if interrupted {
@@ -708,6 +878,18 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 		   「这一轮真的结束了」。失败链本身就是 context canceled，不必再包一层。 */
 		_ = sink.notice("interrupted", map[string]any{"reason": "control"})
 	}
+	/* 命令节点收尾帧（P0-3）：放在失败分支**之前** —— 任何出口（成功/打断/失败）
+	   都要有「跑完了」的帧，否则历史里会留一条永远「进行中」的命令。终态取值对齐
+	   前端 qaStatus 词表（completed / cancelled / failed）。 */
+	if isCommand {
+		cmdStatus := agent.StreamStatus("completed")
+		if interrupted {
+			cmdStatus = agent.StreamStatus("cancelled")
+		} else if err != nil {
+			cmdStatus = agent.StreamStatus("failed")
+		}
+		emitCommand(cmdStatus)
+	}
 	if err != nil {
 		/* 被打断 ≠ 失败（2026-09-29）：这里的 err 就是 context canceled，但「用户喊停」
 		   与「引擎报错」是两件事 —— 混成 failed 之后左栏只能显示「失败」，
@@ -782,6 +964,33 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 	return nil
 }
 
+// isSlashCommand 判断一条用户输入是不是斜杠命令（/init /compact 这类）。
+//
+// 规则从宽取「像命令」的形状：以 / 开头、命令词是 ASCII 字母数字（- _ 允许），
+// 后面跟参数或直接结束都算。中文正文以 / 开头的场景（路径、算式）极少以整条
+// 消息的形态出现；误判的代价也只是历史里多一条标记行，不影响正文渲染。
+func isSlashCommand(content string) bool {
+	s := strings.TrimSpace(content)
+	if !strings.HasPrefix(s, "/") {
+		return false
+	}
+	word := s[1:]
+	if i := strings.IndexAny(word, " \t\n\r"); i >= 0 {
+		word = word[:i]
+	}
+	if word == "" {
+		return false
+	}
+	for _, r := range word {
+		switch {
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '_', r == '-':
+		default:
+			return false
+		}
+	}
+	return true
+}
+
 // writeStreamEventJSON 输出一行流式事件 NDJSON。
 //
 // 输出 schema（所有事件共享 {type,text}）：
@@ -862,6 +1071,16 @@ func prepareAsk(cmd *cobra.Command, args []string, opts *askOptions) (agent.Engi
 	if opts.temperature < -1 {
 		return nil, "", agent.Request{}, &usageError{fmt.Errorf("--temperature must be >= 0 or omitted, got %v", opts.temperature)}
 	}
+	if !agent.ValidReasoningLevel(opts.reasoning) {
+		return nil, "", agent.Request{}, &usageError{fmt.Errorf(
+			"--reasoning 取值无效: %q（可选 minimal | low | medium | high | xhigh | max | off）", opts.reasoning)}
+	}
+	reasoning := agent.ReasoningLevel(opts.reasoning)
+	// 默认值是 max，不应对无参引擎刷提示；只有用户显式指定才说明「被忽略」。
+	if flagChanged(cmd, "reasoning") && reasoning != "" && !agent.ReasoningSupportOf(engine.Name()) {
+		fmt.Fprintf(cmd.ErrOrStderr(),
+			"magic-agent: 提示：%s 引擎没有推理档位参数，--reasoning %s 已忽略\n", engine.Name(), reasoning)
+	}
 	toolsMode, err := parseToolsMode(opts.tools)
 	if err != nil {
 		return nil, "", agent.Request{}, err
@@ -877,18 +1096,25 @@ func prepareAsk(cmd *cobra.Command, args []string, opts *askOptions) (agent.Engi
 			"magic-agent: 提示：当前 --tools off（不调用任何工具），--permission %s 不会生效；如需工具请加 --tools on\n", tier)
 	}
 	// 常驻会话默认值按引擎区分（见 kaEnabled / agent.AppendDefaultOn），但只在
-	// 「流式 + 引擎支持追加」时才有意义。显式 `--keep-alive` 却没满足条件 → 明确报错；
-	// 默认值不满足条件 → 静默忽略（不影响原有调用）。
+	// 「流式 + 引擎支持追加 + 本平台有追加入口」时才有意义。显式 `--keep-alive`
+	// 却不满足条件 → 明确报错；默认值不满足条件 → 静默忽略（不影响原有调用）。
 	if flagChanged(cmd, "keep-alive") && opts.keepAlive {
 		if !opts.stream {
 			return nil, "", agent.Request{}, &usageError{fmt.Errorf(
 				"--keep-alive 是常驻会话（首轮结束后等 --append 追加），必须配合 --stream：追加轮次的输出要靠事件流送出")}
 		}
+		// 平台检查放在引擎检查**之后**：先说「这个引擎不支持」更有信息量，
+		// 再说「这台机器开不出来」。两者都成立时，平台原因才是最终拦路虎。
 		if !agent.AppendSupportOf(engine.Name()) {
 			return nil, "", agent.Request{}, &usageError{fmt.Errorf(
 				"--keep-alive 暂不支持 %s 引擎（当前支持 claude、codebuddy、codebuddy-ai：靠 stream-json 输入持续收 user 消息；"+
 					"dsh：靠 SDK 通道对同一会话继续 prompt）", engine.Name())}
 		}
+		if !session.AppendTransportAvailable() {
+			return nil, "", agent.Request{}, &usageError{fmt.Errorf(
+				"--keep-alive 暂不支持 Windows：追加入口依赖 unix domain socket，本平台没有等价通道。" +
+					"去掉 --keep-alive 即可正常流式调用（提示词已改走 stdin，多行内容在 Windows 上同样是完整的）")}
+		}
 	}
 	if opts.idle < 0 {
 		return nil, "", agent.Request{}, &usageError{fmt.Errorf("--idle 不能为负（收到 %v；0 = 本轮结束就收工）", opts.idle)}
@@ -1006,6 +1232,7 @@ func prepareAsk(cmd *cobra.Command, args []string, opts *askOptions) (agent.Engi
 		SessionID:    strings.TrimSpace(opts.session),
 		Continue:     opts.continueF,
 		Workspace:    workspace,
+		Reasoning:    reasoning,
 		Permission:   tier,
 		PermissionOptions: agent.PermissionOptions{
 			ExcludedCommands:    opts.sandboxExclude,

package/internal/cli/ask_test.go

@@ -12,7 +12,7 @@ package cli
 //	- 引擎/格式参数校验错误 → exit 2
 //
 // 默认值契约（newAskOptions 与 bindAskFlags 双处维护，须一致）：
-//	engine=codebuddy, output=json, timeout=600s, tools=off
+//	engine=codebuddy, output=json, timeout=1h, tools=off
 
 import (
 	"bytes"
@@ -260,6 +260,7 @@ func TestRootShorthandAsk(t *testing.T) {
 }
 
 // -p 与位置参数组合：-p 在前、args 在后；--tools 透传到 Request。
+// ⚠️ 2026-10-01 默认从 off 改成 on —— 此处断言随之反转。
 func TestPromptFlagCombinedWithArgs(t *testing.T) {
 	capEng := &capturingEngine{name: "fake-cap"}
 	registerFake(capEng)
@@ -272,9 +273,9 @@ func TestPromptFlagCombinedWithArgs(t *testing.T) {
 	if !strings.HasPrefix(got, "主问题") || !strings.Contains(got, "附加 上下文") {
 		t.Errorf("prompt = %q, want -p 在前 + args 在后", got)
 	}
-	// 默认 tools=off 透传
-	if !agent.ToolsIsOff(capEng.lastTools) {
-		t.Errorf("default tools should be off, got %#v", capEng.lastTools)
+	// 默认 tools=on 透传（2026-10-01 反转）
+	if !agent.ToolsIsOn(capEng.lastTools) {
+		t.Errorf("default tools should be on (2026-10-01), got %#v", capEng.lastTools)
 	}
 }
 
@@ -409,7 +410,7 @@ func TestParseToolsMode(t *testing.T) {
 	}
 }
 
-// 默认值契约：engine=codebuddy / output=json / timeout=600s。
+// 默认值契约：engine=codebuddy / output=json / timeout=1h。
 func TestDefaults(t *testing.T) {
 	opts := newAskOptions()
 	if opts.engine != "codebuddy" {
@@ -418,8 +419,8 @@ func TestDefaults(t *testing.T) {
 	if opts.output != "json" {
 		t.Errorf("default output = %q, want json", opts.output)
 	}
-	if opts.timeout != 600_000_000_000 { // 600s
-		t.Errorf("default timeout = %v, want 600s", opts.timeout)
+	if opts.timeout != time.Hour {
+		t.Errorf("default timeout = %v, want 1h", opts.timeout)
 	}
 }
 
@@ -478,7 +479,7 @@ func TestStreamPassesExplicitTimeoutToEngine(t *testing.T) {
 		t.Errorf("引擎收到的 req.Timeout = %v want 15m（显式 -t 未透传）", eng.lastTimeout)
 	}
 
-	// 没给 -t → 不透传：别去覆盖引擎自己的默认（如 llm 的条目级 timeout、openclaw 的 600s）。
+	// 没给 -t → 不透传：别去覆盖引擎自己的默认（如 llm 的条目级 timeout、openclaw 自己的 --timeout）。
 	eng.lastTimeout = -1
 	if _, _, err := runAskCmd(t, "", "-e", "fake-stream-timeout", "--stream", "hi"); err != nil {
 		t.Fatalf("--stream: %v", err)
@@ -704,6 +705,7 @@ func (m *modelListEngine) ModelCredits(context.Context) map[string]string {
 // 直接返回"无动态来源"。t.Cleanup 自动还原。
 func stubModelProbe(t *testing.T) {
 	t.Helper()
+	clearModelListCache()
 	prev := probeEngineModels
 	probeEngineModels = func(ctx context.Context, l agent.ModelLister) ([]string, error) {
 		if _, ok := l.(*modelListEngine); ok {
@@ -869,15 +871,17 @@ func TestEnginesFlagNoModelsSkipsProbe(t *testing.T) {
 // ask / engines / version / completion 子命令均已删除：
 // 这些词不再被识别为子命令——作为位置参数它们就是普通 prompt。
 // 真实执行会走引擎调用（测试环境无 codebuddy CLI，报 unknown engine），
-// 这里用 cobra 命令树直接断言不存在任何子命令。
+// 这里用 cobra 命令树直接断言只剩 `client` 这一个（它管的是另一个常驻进程，
+// 与「提问」不是同一种形态，见 clientcmd.go）。
 func TestSubcommandsRemoved(t *testing.T) {
 	cmd := NewRootCommand()
-	if subs := cmd.Commands(); len(subs) != 0 {
+	subs := cmd.Commands()
+	if len(subs) != 1 || subs[0].Name() != "client" {
 		names := make([]string, 0, len(subs))
 		for _, s := range subs {
 			names = append(names, s.Name())
 		}
-		t.Errorf("root should have no subcommands, got %v", names)
+		t.Errorf("root should have only the client subcommand, got %v", names)
 	}
 }