@spzxg/cli-ui 0.3.0 → 0.4.0

package/dist/{cli-ui-index-C8TOk7M3.js → cli-ui-index-O0krpZBg.js}

@@ -1,4 +1,4 @@
-import { g as yu, c as ft, a as xu } from "./cli-ui-embed-hutDQhkT.js";
+import { g as yu, c as ft, a as xu } from "./cli-ui-embed-D7xtcvGG.js";
 function vu(e, t) {
   for (var n = 0; n < t.length; n++) {
     const i = t[n];

package/dist/cli-ui.js

@@ -1,4 +1,4 @@
-import { C as a, b as i, d as r, e as t, f as o, h as C, i as l, j as n, k as m, m as d, l as u, n as w, o as B, p as f } from "./cli-ui-embed-hutDQhkT.js";
+import { C as a, b as i, d as r, e as t, f as o, h as C, i as l, j as n, k as m, m as d, l as u, n as w, o as B, p as f } from "./cli-ui-embed-D7xtcvGG.js";
 export {
   a as CliBoard,
   i as CliBrowserView,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spzxg/cli-ui",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "任务中心（cli-task-center）对话任务的前端积木：cli-msglist 消息对话列表、cli-chat 对话，数据全部来自 center 服务。",
   "main": "src/index.ts",

package/src/chat/CliChat.tsx

@@ -4,7 +4,7 @@
 import { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState, type CSSProperties } from "react";
 import type { CliEvent, CliStore, CliStoreOptions } from "../core/store.js";
 import { useCliState, useCliStore, useCliStoreContext, useComponentEvents, withOwnProvider, type ResultHandlers } from "../core/provider.js";
-import { convKey, emptyConv, isNewInJob, isRunning, parseConvKey, runningTurn, TERMINAL_JOB, viewMessages } from "../core/conversation.js";
+import { convKey, emptyConv, isChatTask, isNewInJob, isRunning, parseConvKey, runningTurn, TERMINAL_JOB, viewMessages } from "../core/conversation.js";
 import type { AskAnswers, AskQuestion, Msg } from "../core/types.js";
 import { Icon } from "../ui/icons.js";
 import { agentLabel as labelOf, fmtTokens, formatAnswersText, modelLabel } from "../ui/format.js";
@@ -76,6 +76,19 @@ const REASON_TEXT: Record<string, string> = {
   node_reassigned: "执行机器换到了别的产品线", node_lost: "执行节点长时间连不上",
 };
 
+// 一次性任务（含续派）的子任务状态（center TaskStatus）。
+const BATCH_STATUS: Record<string, { dotCls: DotCls; statusText: string }> = {
+  succeeded: { dotCls: "g", statusText: "子任务已完成" }, failed: { dotCls: "x", statusText: "子任务失败" }, cancelled: { dotCls: "x", statusText: "子任务已取消" },
+  dispatching: { dotCls: "a", statusText: "正在派发" }, running: { dotCls: "a", statusText: "运行中" }, verifying: { dotCls: "a", statusText: "正在核对结果" },
+  queued: { dotCls: "a", statusText: "等待执行" }, blocked: { dotCls: "a", statusText: "等待执行" }, paused: { dotCls: "a", statusText: "已暂停" },
+  orphaned: { dotCls: "a", statusText: "执行节点暂时连不上，恢复后继续" },
+};
+function batchStatusView(taskStatus: string | null, jobStatus: string | null): { dotCls: DotCls; statusText: string } {
+  if (taskStatus && BATCH_STATUS[taskStatus]) return BATCH_STATUS[taskStatus];
+  if (jobStatus && TERMINAL_JOB.has(jobStatus)) return { dotCls: jobStatus === "succeeded" ? "g" : "x", statusText: jobStatus === "succeeded" ? "已完成" : jobStatus === "cancelled" ? "已取消" : "已失败" };
+  return { dotCls: "a", statusText: "进行中" };
+}
+
 /** 「智能体在工作」那一行：跑了多久，很久没输出时提示可能卡住。与 Operator 的 RunningIndicator 一致。 */
 const QUIET_AFTER_MS = 180_000;
 function RunningIndicator({ agent, agentName, startedAt, lastActivityRef }: { agent: string | null; agentName: string; startedAt: number | null; lastActivityRef: React.MutableRefObject<number> }) {
@@ -107,7 +120,6 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
   // 配置按内容比较：宿主每次渲染传新对象也不会让消息行全部重渲染。
   const configKey = JSON.stringify(config ?? {});
   const cfg = useMemo(() => resolveChatConfig(config), [configKey]); // eslint-disable-line react-hooks/exhaustive-deps
-  const readOnly = !!readOnlyProp || !cfg.composer.show;
   const store = useCliStore();
   const selected = useCliState((s) => s.selected);
   // 显示哪个对话：
@@ -157,13 +169,21 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
   })), [allMessages, cfg.transcript.tools]);
   const running = conv ? isRunning(conv) : false;
   const job = entry?.job;
-  // 这个对话对应的子任务：指定了就是它，否则对话任务的第一个（「新开」时借用第一个的智能体显示）。
-  const task = (taskId ? job?.tasks?.find((t) => t.id === taskId) : undefined) ?? (taskId ? undefined : job?.tasks?.[0]);
+  // 一次性任务（含续派，不是对话任务）：只读查看其中一个子任务——没有轮次，不能发消息、结束、回答。
+  // 例外是对话式子任务（续派时 mode=conversation）：当对话用，随时能接着发（= 续派一条接着它），不显示子任务状态。
+  const batch = !!conv?.batch || (!!job && job.mode !== "conversation");
+  const chat = !!taskId && isChatTask(conv);
+  const readOnly = !!readOnlyProp || !cfg.composer.show || (batch && !chat);
+  // 这个对话对应的子任务：指定了就是它，否则对话任务的第一个（「新开」时借用第一个的智能体显示）；
+  // 一次性任务没指定时是实时流挑的那个（最近一个派发过的）。
+  const shownTaskId = taskId ?? (batch ? conv?.task?.id : undefined);
+  const task = (shownTaskId ? job?.tasks?.find((t) => t.id === shownTaskId) : undefined) ?? (shownTaskId || batch ? undefined : job?.tasks?.[0]);
   const info = taskId ? job?.conversation?.conversations?.find((c) => c.task_id === taskId) : undefined;
   const agent = task?.agent ?? conv?.turns[conv.turns.length - 1]?.agent ?? null;
   const agentText = labelOf(agent);
   const jobStatus = conv?.job?.status ?? job?.status ?? null;
-  const jobEnded = !!jobStatus && TERMINAL_JOB.has(jobStatus);
+  // 对话式子任务没有「结束」：大任务结束了，再发一条会重新打开它。
+  const jobEnded = !chat && !!jobStatus && TERMINAL_JOB.has(jobStatus);
   // 只关掉了这一个对话（对话任务还开着）：按「这个对话已结束」显示，不能再发消息。
   const convClosed = !jobEnded && !!(conv?.task?.closed ?? info?.closed);
   const status = convClosed ? "succeeded" : jobStatus;
@@ -176,15 +196,18 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
   const continuedBy = conv?.continuedBy ?? (taskId ? null : job?.conversation?.continued_by_job_id ?? null);
   const jobTitle = job?.title ?? conv?.job?.title;
   // 对话任务里有几个对话时，标题是「对话任务 / 这个对话」。
-  const manyConvs = (job?.conversation?.conversations?.length ?? 0) > 1;
-  const convName = conv?.task?.title ?? info?.title ?? task?.title;
+  const manyConvs = (batch ? job?.tasks?.length ?? 0 : job?.conversation?.conversations?.length ?? 0) > 1;
+  // 对话式子任务：流里的是这个对话最新的那条消息，名称取打开的那个子任务。
+  const convName = chat ? task?.title ?? conv?.task?.title : conv?.task?.title ?? info?.title ?? task?.title;
   const convTitle = isNew ? `${jobTitle ? `${jobTitle} / ` : ""}新对话`
-    : taskId && manyConvs && convName && convName !== jobTitle ? `${jobTitle ?? "对话"} / ${convName}`
+    : (taskId || batch) && manyConvs && convName && convName !== jobTitle ? `${jobTitle ?? "对话"} / ${convName}`
       : jobTitle ?? (key ? "对话" : "新对话");
   const awaitingAnswer = useMemo(() => hasOpenAsk(messages), [messages]);
   const lastTurn = conv?.turns[conv.turns.length - 1];
   const awaiting = !ended && !running && !!lastTurn?.asked && lastTurn.status === "succeeded";
-  const loading = !!key && !isNew && !!conv && !conv.hasTranscript && !conv.turns.length && conv.stream !== "error";
+  // 一次性任务的子任务还没派发（没有节点对话）、或者流已经结束还没有转录：不再转圈，转录里有说明。
+  const loading = !!key && !isNew && !!conv && !conv.hasTranscript && !conv.turns.length && conv.stream !== "error" && conv.stream !== "ended" && !(conv.batch && !conv.remoteTaskId);
+  const batchStatus = batch ? conv?.batchTask?.status ?? task?.status ?? null : null;
 
   // 用量：任务详情里的累计 + 实时流里上次刷新后的增量（「新开」的对话还没有用量，不借第一个对话的）。
   const usageTask = isNew ? undefined : task;
@@ -194,12 +217,13 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
 
   const { dotCls, statusText } = useMemo((): { dotCls: DotCls; statusText: string } => {
     if (!key || isNew) return { dotCls: "r", statusText: "未开始" };
+    if (batch && !chat) return batchStatusView(batchStatus, jobStatus);
     if (ended) return { dotCls: status === "succeeded" ? "g" : "x", statusText: REASON_TEXT[closedReason ?? ""] ?? (status === "succeeded" ? "已结束" : status === "cancelled" ? "已取消" : "已失败") };
     if (awaiting) return { dotCls: "a", statusText: "需要你处理" };
     if (running) return { dotCls: "a", statusText: "运行中" };
     if (status === "queued") return { dotCls: "a", statusText: "等待执行节点" };
     return { dotCls: "a", statusText: "进行中" };
-  }, [key, isNew, ended, status, closedReason, awaiting, running]);
+  }, [key, isNew, batch, chat, batchStatus, jobStatus, ended, status, closedReason, awaiting, running]);
 
   // ── 处理器（引用稳定，MessageView 的 memo 才有效） ──
   // 输入框之外的操作（回答提问、撤回排队、结束对话、停止）失败时在顶部提示，不静默吞掉。
@@ -259,7 +283,7 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
         : send(formatAnswersText(questions, answers));
       await report(sent, "回答没有发出去");
     },
-    onCancelQueued: readOnly ? undefined : (m: Msg) => { const id = latest.current.key; if (id && m.turnId) void report(store.cancelTurn(id, m.turnId), "撤回失败").catch(() => undefined); },
+    onCancelQueued: readOnly || batch ? undefined : (m: Msg) => { const id = latest.current.key; if (id && m.turnId) void report(store.cancelTurn(id, m.turnId), "撤回失败").catch(() => undefined); },
     // 后端能直接处理的浏览器动作（Operator 后端）才给；center 不提供，卡片按 Operator「没有浏览器能力」时的样子显示。
     onInput: readOnly || !store.client.submitInput ? undefined : async (inputId: string, values: string[]) => {
       const id = latest.current.key;
@@ -287,7 +311,7 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
       const at = list.findIndex((m) => m.id === msgId);
       for (let j = (at === -1 ? list.length : at) - 1; j >= 0; j--) if (list[j].role === "user") { void report(send(list[j].content), "重试没有发出去").catch(() => undefined); return; }
     },
-  }), [readOnly, send, store, go, report, fileOpen]);
+  }), [readOnly, batch, send, store, go, report, fileOpen]);
   const stop = useCallback(async () => {
     const { key: id, conv: c } = latest.current;
     const turn = c ? runningTurn(c) : null;
@@ -517,7 +541,7 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
               <StatusDot cls={dotCls} running={running} awaiting={awaiting} title={statusText} />
               <span className="cv">{statusText}</span>
             </span>}
-            {h.close && key && !isNew && allowClose && !readOnly && !ended && (
+            {h.close && key && !isNew && allowClose && !readOnly && !ended && !batch && (
               <button className="btn btn-line btn-sm" onClick={() => setClosing("confirm")} disabled={closing === "busy"} title={taskId ? "只结束这个对话：之后它不再接收消息，正在跑的一轮会被中止；同一任务里的其他对话不受影响" : "结束这个对话：之后不再接收消息，正在跑的一轮会被中止"}>{Icon.stop()} 结束对话</button>
             )}
           </div>
@@ -541,7 +565,7 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
               {(!key || isNew) && cfg.empty.show && (
                 <div className="hero cli-hero">
                   <div className="h-ic">{Icon.bolt()}</div>
-                  <div className="h-status"><StatusDot cls="r" /> 新对话 · 尚未开始</div>
+                  {cfg.transcript.status && <div className="h-status"><StatusDot cls="r" /> 新对话 · 尚未开始</div>}
                   <h2>{cfg.empty.title}</h2>
                   {isNew && <p className="h-desc">在「{jobTitle ?? "这个任务"}」里新开一个对话：和任务里的其他对话共用同一个工作区（能看到彼此产出的文件），对话内容各自独立。</p>}
                   {cfg.empty.description && <p className="h-desc">{cfg.empty.description}</p>}
@@ -590,8 +614,8 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
               )}
               {cfg.transcript.runningIndicator && running && !awaitingAnswer && !hasBelow && <RunningIndicator agent={agent} agentName={cfg.labels.agent} startedAt={turnStartedAt} lastActivityRef={lastActivityRef} />}
               {!hasBelow && queued.map((m) => <MessageView key={m.id} m={m} initial={false} hideWho={false} handlers={handlers} view={view} />)}
-              {ended && (
-                <div className="session-label"><span className="ln" />{REASON_TEXT[closedReason ?? ""] ?? "对话已结束"}{!finalEnd ? " · 再发消息会开一个新对话接着聊" : ""}<span className="ln" /></div>
+              {ended && cfg.transcript.status && (
+                <div className="session-label"><span className="ln" />{batch ? statusText : <>{REASON_TEXT[closedReason ?? ""] ?? "对话已结束"}{!finalEnd ? " · 再发消息会开一个新对话接着聊" : ""}</>}<span className="ln" /></div>
               )}
               {continuedBy && (
                 <div className="load-older"><button className="btn btn-line btn-sm" onClick={() => go(continuedBy)}>转到接续的新对话</button></div>

package/src/core/client.ts

@@ -2,7 +2,7 @@ import { createSseParser } from "./sse.js";
 import { NEW_TASK, parseConvKey } from "./conversation.js";
 import type {
   BoardInfo, BrowserMessage, BrowserStatus, CenterJob, CenterTask, CenterTurn, DiffResult, DirListing, FileInfo,
-  NewConversationOptions, SendResult, StreamEnd, StreamItem, StreamSnapshot,
+  BatchStreamSnapshot, NewConversationOptions, SendResult, StreamEnd, StreamItem, StreamSnapshot,
 } from "./types.js";
 
 /**
@@ -80,6 +80,11 @@ export interface ConversationBackend {
   createConversation(firstMessage: string, opts?: NewConversationOptions & { businessId?: string }): Promise<{ id: string; job_id: string; status: string; task_ids?: string[]; turn: CenterTurn }>;
   /** taskId：发给对话任务里的哪个对话，不给 = 第一个。 */
   sendMessage(jobId: string, text: string, opts?: { businessId?: string; timeoutSeconds?: number; taskId?: string }): Promise<SendResult>;
+  /**
+   * 一次性任务里的对话式子任务接着聊：续派一条 mode=conversation、continue_from 这个子任务的子任务（接在同一个 Agent 会话里）。
+   * 返回新子任务的 id。
+   */
+  continueTask?(jobId: string, taskId: string, text: string, opts?: { title?: string; businessId?: string }): Promise<{ task_id: string }>;
   /** 在对话任务里新开一个对话（同一节点、同一工作区），text 是它的第一条消息。 */
   openConversation?(jobId: string, text: string, opts?: { title?: string; agent?: string; browser?: boolean; businessId?: string; timeoutSeconds?: number }): Promise<SendResult>;
   cancelTurn(jobId: string, turnId: string): Promise<CenterTurn>;
@@ -197,6 +202,13 @@ export function createCenterClient(options: CenterClientOptions = {}): Conversat
         ...(opts.businessId ? { business_id: opts.businessId } : {}),
         ...(opts.timeoutSeconds ? { timeout_seconds: opts.timeoutSeconds } : {}),
       }),
+    continueTask: async (jobId: string, taskId: string, text: string, opts: { title?: string; businessId?: string } = {}) => {
+      const result = await post<{ task_ids: string[] }>(`/api/jobs`, {
+        job_id: jobId, mode: "conversation",
+        tasks: [{ title: opts.title || firstLine(text, 60), prompt: text, continue_from: taskId, ...(opts.businessId ? { business_id: opts.businessId } : {}) }],
+      });
+      return { task_id: result.task_ids[0] };
+    },
     /** 同一个 business_id 重发只开一个对话。 */
     openConversation: (jobId: string, text: string, opts: { title?: string; agent?: string; browser?: boolean; businessId?: string; timeoutSeconds?: number } = {}) =>
       post<SendResult>(`/api/jobs/${id(jobId)}/conversations`, {
@@ -246,7 +258,7 @@ export function createCenterClient(options: CenterClientOptions = {}): Conversat
           const parser = createSseParser(({ event, data }) => {
             let payload: unknown;
             try { payload = JSON.parse(data); } catch { return; }
-            if (event === "snapshot") handlers.onSnapshot?.(payload as StreamSnapshot);
+            if (event === "snapshot") handlers.onSnapshot?.(payload as StreamSnapshot | BatchStreamSnapshot);
             else if (event === "chunk") handlers.onChunk?.((payload as { events?: StreamItem[] }).events ?? []);
             else if (event === "end") handlers.onEnd?.(payload as StreamEnd);
           });
@@ -278,7 +290,8 @@ export function createCenterClient(options: CenterClientOptions = {}): Conversat
 
 export interface StreamHandlers {
   onOpen?: () => void;
-  onSnapshot?: (snapshot: StreamSnapshot) => void;
+  /** 对话任务是 StreamSnapshot；一次性任务（含续派）是 BatchStreamSnapshot（见 isBatchSnapshot）。 */
+  onSnapshot?: (snapshot: StreamSnapshot | BatchStreamSnapshot) => void;
   onChunk?: (events: StreamItem[]) => void;
   onEnd?: (end: StreamEnd) => void;
   /** 流断了（error 为 null = 服务端正常关闭）。onEnd 之后也会触发一次。 */

package/src/core/config.ts

@@ -1,7 +1,7 @@
 /**
- * 组件的界面配置：哪些模块显示、文案怎么写。全部可选，不给就是缺省（全部显示、默认文案）。
+ * 组件的界面配置：哪些模块显示、文案怎么写。全部可选，不给就是缺省（默认文案；cli-chat 的顶部栏缺省隐藏，其余全部显示）。
  *
- *   <CliChat config={{ header: { export: false, close: false }, composer: { placeholder: "问点什么…", fileUpload: false } }} />
+ *   <CliChat config={{ header: { title: true, status: true }, composer: { placeholder: "问点什么…", fileUpload: false } }} />
  *   <CliMsgList config={{ header: { refresh: false }, card: { turns: false } }} />
  *
  * 开关类的模块写 false 就整块隐藏，写对象就逐项开关；文案里可以用 {title}（对话标题）、{agent}（智能体名）。
@@ -10,7 +10,7 @@
 // ── cli-chat ─────────────────────────────────────────
 
 export interface CliChatConfig {
-  /** 顶部栏。false = 整栏隐藏；对象 = 逐项开关。 */
+  /** 顶部栏。缺省隐藏；true = 每一项都显示；对象 = 只显示写了 true 的项。 */
   header?: boolean | {
     /** 面包屑：色块 + 名称 / 对话。 */
     crumb?: boolean;
@@ -66,6 +66,8 @@ export interface CliChatConfig {
     tools?: boolean;
     /** 「智能体 · 运行中 0:12」那一行。 */
     runningIndicator?: boolean;
+    /** 状态说明行：新对话的「尚未开始」、结束时的「对话已结束」「子任务已完成」等。缺省不显示。 */
+    status?: boolean;
   };
   /** 消息头上的称呼。 */
   labels?: { user?: string; agent?: string };
@@ -79,13 +81,14 @@ export interface ResolvedChatConfig {
     show: boolean; placeholder: string; placeholderNew: string; placeholderRunning: string; placeholderDisabled: string | null;
     hints: boolean; charCount: boolean; fileUpload: boolean; fileButtonText: string; stop: boolean; queue: boolean;
   };
-  transcript: { nav: boolean; sessionLabel: boolean; timestamps: boolean; initialBadge: boolean; tools: boolean; runningIndicator: boolean };
+  transcript: { nav: boolean; sessionLabel: boolean; timestamps: boolean; initialBadge: boolean; tools: boolean; runningIndicator: boolean; status: boolean };
   labels: { user: string; agent: string };
   empty: { show: boolean; title: string; description: string };
 }
 
 export const DEFAULT_CHAT_CONFIG: ResolvedChatConfig = {
-  header: { show: true, crumb: true, export: true, title: true, agent: true, usage: true, model: true, status: true, close: true },
+  // 顶部栏缺省整栏隐藏（模型、状态、用量这些对使用者是干扰），需要的项在 config.header 里打开。
+  header: { show: true, crumb: false, export: false, title: false, agent: false, usage: false, model: false, status: false, close: false },
   composer: {
     show: true,
     placeholder: "在“{title}”中回复 {agent}…（可拖入 TXT / Markdown / Word 文件）",
@@ -94,14 +97,14 @@ export const DEFAULT_CHAT_CONFIG: ResolvedChatConfig = {
     placeholderDisabled: null,
     hints: true, charCount: true, fileUpload: true, fileButtonText: "文件", stop: true, queue: true,
   },
-  transcript: { nav: true, sessionLabel: true, timestamps: true, initialBadge: true, tools: true, runningIndicator: true },
+  transcript: { nav: true, sessionLabel: true, timestamps: true, initialBadge: true, tools: true, runningIndicator: true, status: false },
   labels: { user: "你", agent: "智能体" },
   empty: { show: true, title: "开始一个新对话", description: "在下面输入第一条消息。可以附上 TXT、Markdown 或 Word 文件，内容会转成文字一起发送。" },
 };
 
 export function resolveChatConfig(config: CliChatConfig = {}): ResolvedChatConfig {
   const d = DEFAULT_CHAT_CONFIG;
-  const header = toggle(config.header, d.header);
+  const header = config.header === true ? allOn(d.header) : toggle(config.header, d.header);
   const composer = toggle(config.composer, d.composer);
   const empty = toggle(config.empty, d.empty);
   // 没有文件上传时，缺省文案里的「可拖入文件」提示也去掉。
@@ -138,22 +141,26 @@ export interface CliMsgListConfig {
   /** 搜索框：true 总是显示，false 不显示，"auto"（缺省）对话数 ≥ 6 时显示。 */
   search?: boolean | "auto";
   searchPlaceholder?: string;
+  /**
+   * 按状态分组（需要你处理 / 进行中 / 已结束 / 已取消），配合 groups 改组名。缺省不分组：一个列表，最近活动的在前。
+   */
+  grouped?: boolean;
   /** 卡片上显示哪些内容。 */
   card?: {
-    /** 状态点和状态文字。 */
+    /** 状态点、状态文字，以及底部的「运行中 / 等你处理 / 已完成」等字样。缺省不显示（底部只有时间）。 */
     status?: boolean;
     /** 智能体标签。 */
     agent?: boolean;
     /** 第一条消息摘要。 */
     description?: boolean;
-    /** 底部活动（运行中 · 3 分钟前……）。 */
+    /** 底部活动（3 分钟前；打开 status 时带上运行中、排队等状态）。 */
     activity?: boolean;
     /** 「N 轮对话」。 */
     turns?: boolean;
     /** 「+」按钮：在这个任务（对话任务）里新开一个对话，共用同一个工作区。 */
     newInJob?: boolean;
   };
-  /** 分组标题；写 false 隐藏这一组。 */
+  /** 分组标题（grouped 时）；写 false 隐藏这一组。 */
   groups?: { needs?: string | false; active?: string | false; done?: string | false; cancelled?: string | false };
   /** 没有对话时的提示。 */
   emptyTitle?: string;
@@ -164,6 +171,7 @@ export interface ResolvedMsgListConfig {
   header: { show: boolean; title: boolean; newButton: boolean; newButtonText: string; refresh: boolean; context: boolean };
   search: boolean | "auto";
   searchPlaceholder: string;
+  grouped: boolean;
   card: { status: boolean; agent: boolean; description: boolean; activity: boolean; turns: boolean; newInJob: boolean };
   groups: { needs: string | false; active: string | false; done: string | false; cancelled: string | false };
   emptyTitle: string;
@@ -174,7 +182,9 @@ export const DEFAULT_MSGLIST_CONFIG: ResolvedMsgListConfig = {
   header: { show: true, title: true, newButton: true, newButtonText: "对话", refresh: true, context: true },
   search: "auto",
   searchPlaceholder: "搜索对话…",
-  card: { status: true, agent: true, description: true, activity: true, turns: true, newInJob: true },
+  grouped: false,
+  // 状态缺省不显示（未开始、进行中、已完成……对使用者是干扰），需要时打开 card.status / grouped。
+  card: { status: false, agent: true, description: true, activity: true, turns: true, newInJob: true },
   groups: { needs: "需要你处理", active: "进行中", done: "已结束", cancelled: "已取消" },
   emptyTitle: "还没有对话",
   emptyDescription: "点「对话」开始一个新的对话。",
@@ -186,6 +196,7 @@ export function resolveMsgListConfig(config: CliMsgListConfig = {}): ResolvedMsg
     header: toggle(config.header, d.header),
     search: config.search ?? d.search,
     searchPlaceholder: config.searchPlaceholder ?? d.searchPlaceholder,
+    grouped: config.grouped ?? d.grouped,
     card: { ...d.card, ...defined(config.card) },
     groups: { ...d.groups, ...defined(config.groups) },
     emptyTitle: config.emptyTitle ?? d.emptyTitle,
@@ -211,6 +222,12 @@ function defined<T extends object>(value: T | undefined): Partial<T> {
 /**
  * 开关型模块：false → 全关（show=false 且布尔项全 false，文案保留）；true / 不给 → 缺省；对象 → 合并缺省。
  */
+function allOn<T extends { show: boolean }>(defaults: T): T {
+  const on = { ...defaults } as Record<string, unknown>;
+  for (const key of Object.keys(on)) if (typeof on[key] === "boolean") on[key] = true;
+  return on as T;
+}
+
 function toggle<T extends { show: boolean }>(value: boolean | object | undefined, defaults: T): T {
   if (value === false) {
     const off = { ...defaults, show: false } as Record<string, unknown>;

package/src/core/conversation.ts

@@ -6,13 +6,16 @@
  *   · 节点转录（transcript + node 事件）：Agent 实际的对话过程，规则与 Operator 的 useTaskStream 一致。
  * 界面以节点转录为主；转录还没有（没派发、节点连不上）时用轮次的 input / reply 兜底。
  */
-import type { AskAnswers, AskQuestion, CenterTurn, ConversationClosedCallback, ConversationTurnCallback, JobStatus, Message, Msg, NodeEvent, StreamItem, StreamSnapshot, StreamTask, ToolData, TurnUsage } from "./types.js";
+import { isBatchSnapshot, type AskAnswers, type AskQuestion, type BatchStreamSnapshot, type BatchStreamTask, type CenterTurn, type ConversationClosedCallback, type ConversationTurnCallback, type JobStatus, type Message, type Msg, type NodeEvent, type StreamItem, type StreamSnapshot, type StreamTask, type ToolData, type TurnUsage } from "./types.js";
 import { indexFromEnd, mergeSnapshot, toolDataOf } from "../ui/transcriptModel.js";
 import { formatAnswersText } from "../ui/format.js";
 
 export const TERMINAL_TURN = new Set(["succeeded", "failed", "cancelled", "merged"]);
 export const ACTIVE_TURN = new Set(["queued", "dispatching", "running"]);
 export const TERMINAL_JOB = new Set(["succeeded", "failed", "cancelled"]);
+/** 一次性任务的子任务：结束了的、正在节点上跑的。 */
+export const TERMINAL_TASK = TERMINAL_JOB;
+const ACTIVE_TASK = new Set(["dispatching", "running", "verifying"]);
 
 // ── 对话键 ─────────────────────────────────────────────
 //
@@ -76,11 +79,19 @@ export interface ConvState {
   continuedBy: string | null;
   /** 本页提交过的提问回答（askId → 答案）。节点上那一轮已被中枢结束，不会回 ask_answered，只能本地记。 */
   localAnswers: Record<string, AskAnswers>;
+  /**
+   * 一次性任务（含续派，不是对话任务）：只读查看其中一个子任务。没有轮次，task 是那个子任务，
+   * batchTask 是它的原样（状态、错误、原文），remoteTaskId 是它在节点上的对话（流里只认这个对话的转录）。
+   */
+  batch: boolean;
+  batchTask: BatchStreamTask | null;
+  remoteTaskId: string | null;
 }
 
 export const emptyConv = (key: string): ConvState => ({
   key, ...parseConvKey(key), job: null, task: null, turns: [], msgs: [], hasTranscript: false, nodeRunning: false, resolvedModel: null,
   liveUsage: { fresh: 0, cacheRead: 0 }, stream: "idle", streamError: null, endReason: null, continuedBy: null, localAnswers: {},
+  batch: false, batchTask: null, remoteTaskId: null,
 });
 
 export function upsertTurns(turns: CenterTurn[], incoming: CenterTurn[]): CenterTurn[] {
@@ -101,23 +112,76 @@ export function addTurnsIfAbsent(turns: CenterTurn[], incoming: CenterTurn[]): C
   return fresh.length ? upsertTurns(turns, fresh) : turns;
 }
 
-export function applySnapshot(conv: ConvState, snapshot: StreamSnapshot): ConvState {
+export function applySnapshot(conv: ConvState, snapshot: StreamSnapshot | BatchStreamSnapshot): ConvState {
+  if (isBatchSnapshot(snapshot)) return applyBatchSnapshot(conv, snapshot);
   const { job } = snapshot;
   return {
     ...conv,
     job: { status: job.status, closed_reason: job.closed_reason, node_id: job.node_id, title: job.title },
     task: snapshot.task ?? conv.task,
-    turns: upsertTurns([], snapshot.turns),
+    turns: upsertTurns([], Array.isArray(snapshot.turns) ? snapshot.turns : []),
     resolvedModel: conv.resolvedModel ?? job.conversation?.last_turn?.resolved_model ?? null,
   };
 }
 
+// ── 一次性任务（含续派）：只读查看其中一个子任务 ─────────
+//
+// 指定了子任务就看它；没指定看最近一个派发过的（续派开出新的子任务时跟过去）。
+// 流里可能同时有几个节点对话的事件（带 remote_task_id），只认看的这个子任务所在的那个。
+
+const batchStreamTask = (task: BatchStreamTask): StreamTask => ({
+  // 对话式子任务跑完一条不算结束：还能接着聊。
+  id: task.id, seq: task.seq, title: task.title, status: task.status, closed: !task.conversation && TERMINAL_TASK.has(task.status),
+  remote_task_id: task.remote_task_id, continue_from_task_id: task.continue_from_task_id,
+});
+
+/** 没指定子任务时看哪个：最近一个派发过的，都没派发过就是最后一个。 */
+export const latestBatchTask = (tasks: BatchStreamTask[]) =>
+  [...tasks].sort((a, b) => a.seq - b.seq).reverse().find((task) => task.remote_task_id) ?? tasks.reduce<BatchStreamTask | null>((last, task) => (!last || task.seq > last.seq ? task : last), null);
+
+/** 对话式子任务（续派时 mode=conversation）：可以接着聊，发消息 = 续派一条接着它的对话。 */
+export const isChatTask = (conv: Pick<ConvState, "batch" | "batchTask"> | null | undefined) => !!conv?.batch && !!conv.batchTask?.conversation;
+
+/** 换成看另一个子任务（或同一个子任务换了节点对话，例如重试）：节点转录清掉，等新对话的转录。 */
+function focusBatchTask(conv: ConvState, task: BatchStreamTask | null): ConvState {
+  // 对话式的对话里最新那条可能还没派发：节点对话用它们共用的那个。
+  const remote = task?.conversation_remote_task_id ?? task?.remote_task_id ?? null;
+  const sameRemote = remote === conv.remoteTaskId;
+  // 状态变化事件不一定带原文（没指定子任务时）：沿用已有的。
+  const kept = conv.batchTask && task && conv.batchTask.id === task.id ? { prompt: conv.batchTask.prompt, opener_prompt: conv.batchTask.opener_prompt } : {};
+  const batchTask = task ? { ...kept, ...task } : null;
+  return {
+    ...conv, batch: true, batchTask, task: batchTask ? batchStreamTask(batchTask) : null, remoteTaskId: remote,
+    ...(sameRemote ? {} : { msgs: [], hasTranscript: false, nodeRunning: false }),
+  };
+}
+
+function applyBatchSnapshot(conv: ConvState, snapshot: BatchStreamSnapshot): ConvState {
+  const { job } = snapshot;
+  const tasks = Array.isArray(snapshot.tasks) ? snapshot.tasks : [];
+  // 流给的那个优先：指定了子任务就是它（对话式的是它所在对话里最新的那条）；没指定是最近一个派发过的。旧版中枢不给时自己挑。
+  const shown = snapshot.task ?? (conv.taskId ? tasks.find((task) => task.id === conv.taskId) ?? null : latestBatchTask(tasks));
+  return focusBatchTask({ ...conv, job: { status: job.status, closed_reason: null, node_id: job.node_id, title: job.title }, turns: [] }, shown);
+}
+
+/** 一次性任务里的子任务状态变化。 */
+function applyBatchTask(conv: ConvState, task: BatchStreamTask): ConvState {
+  if (conv.batchTask?.id === task.id) return focusBatchTask(conv, task);
+  // 对话式的对话：接着聊的新消息成了最新那条（流只发这个对话的）。
+  if (conv.taskId && task.conversation) return focusBatchTask(conv, task);
+  // 没指定子任务：续派开出了更新的子任务（已经派发到节点），跟过去。
+  if (!conv.taskId && task.remote_task_id && (!conv.batchTask || task.seq > conv.batchTask.seq)) return focusBatchTask(conv, task);
+  return conv;
+}
+
 // 缺字段时兜底：generation 缺省 1（按它分会话，缺了会把顺序排乱）；时间缺就不显示。
 const toMsg = (m: Message): Msg => ({ id: m.id, role: m.role, content: m.content, generation: typeof m.generation === "number" ? m.generation : 1, ...(typeof m.created_at === "number" ? { ts: m.created_at } : {}) });
 
 export function applyItems(conv: ConvState, items: StreamItem[]): ConvState {
   let next = conv;
   for (const item of items) {
+    // 一次性任务：只认看的这个子任务所在的节点对话。
+    if (next.batch && (item.type === "transcript" || item.type === "node") && item.remote_task_id && item.remote_task_id !== next.remoteTaskId) continue;
     if (item.type === "transcript") {
       // 节点转录全量（连上 / 重连节点时各一次）：整体替换，没变的消息保留对象引用。
       const messages = Array.isArray(item.messages) ? item.messages.map(toMsg) : [];
@@ -131,9 +195,9 @@ export function applyItems(conv: ConvState, items: StreamItem[]): ConvState {
       const settled = TERMINAL_TURN.has(item.turn.status) && !turns.some((turn) => ACTIVE_TURN.has(turn.status));
       next = { ...next, turns, resolvedModel: item.turn.resolved_model ?? next.resolvedModel, ...(settled ? { nodeRunning: false } : {}) };
     } else if (item.type === "job") {
-      next = { ...next, job: { ...next.job, status: item.job.status, closed_reason: item.job.closed_reason, node_id: item.job.node_id } };
+      next = { ...next, job: { ...next.job, status: item.job.status, closed_reason: item.job.closed_reason ?? null, node_id: item.job.node_id } };
     } else if (item.type === "task") {
-      next = { ...next, task: item.task };
+      next = next.batch ? applyBatchTask(next, item.task as BatchStreamTask) : { ...next, task: item.task as StreamTask };
     }
   }
   return next;
@@ -227,7 +291,7 @@ export const convEnded = (conv: Pick<ConvState, "job" | "task">) => !!conv.task?
 /** 正在执行的那一轮（派发中或执行中）。 */
 export const runningTurn = (conv: ConvState) => conv.turns.find((turn) => turn.status === "running" || turn.status === "dispatching") ?? null;
 
-export const isRunning = (conv: ConvState) => conv.nodeRunning || !!runningTurn(conv);
+export const isRunning = (conv: ConvState) => conv.nodeRunning || !!runningTurn(conv) || (conv.batch && ACTIVE_TASK.has(conv.batchTask?.status ?? ""));
 
 /**
  * 界面上的转录：
@@ -236,6 +300,7 @@ export const isRunning = (conv: ConvState) => conv.nodeRunning || !!runningTurn(
  *   3. 还在中枢排队的消息，作为「排队中」气泡（可撤回），由界面钉在最下面。
  */
 export function viewMessages(conv: ConvState): Msg[] {
+  if (conv.batch) return batchViewMessages(conv);
   let out: Msg[] = [];
   // 有节点消息就以节点为准：通常先收到全量转录，但新对话可能先来增量事件（user / assistant / tool），也算。
   if (conv.msgs.length) {
@@ -296,6 +361,55 @@ export function viewMessages(conv: ConvState): Msg[] {
   return out;
 }
 
+// 中枢派发一次性任务时加在正文前的标记行，和完成后的自动核对（见 center scheduler.ts）。
+const CENTER_MARKER_LINES = /^(?:\[CENTER-(?:ATTEMPT|TERMINAL-REVISION):[^\]\n]*\][ \t]*(?:\r?\n|$))+/;
+const CONFIRM_MARK = "[CENTER-CONFIRM]";
+const BATCH_TASK_ERROR: Record<string, string> = { failed: "子任务失败", cancelled: "子任务已取消" };
+const CHAT_TASK_ERROR: Record<string, string> = { failed: "这一轮没有完成", cancelled: "这条消息已取消" };
+
+/**
+ * 一次性任务（含续派）的转录，只读：
+ *   1. 第一条用户消息是 Operator 固定的启动语句，换成开出这个节点对话的子任务原文（流里给了才换）；
+ *   2. 去掉中枢加在正文前的标记行（[CENTER-ATTEMPT:…]、[CENTER-TERMINAL-REVISION:…]）；
+ *   3. 中枢的完成核对（[CENTER-CONFIRM] 追问 + Agent 回的 TASK_COMPLETE / TASK_INCOMPLETE）合成一行说明；
+ *   4. 还没派发、拿不到执行记录、失败 / 取消时补一行说明。
+ */
+function batchViewMessages(conv: ConvState): Msg[] {
+  const out: Msg[] = [];
+  const task = conv.batchTask;
+  const opener = task?.opener_prompt ?? null;
+  const firstUserId = conv.msgs.find((m) => m.role === "user")?.id;
+  for (let i = 0; i < conv.msgs.length; i++) {
+    const m = conv.msgs[i];
+    if (m.role === "user" && m.content.includes(CONFIRM_MARK)) {
+      const reply = conv.msgs[i + 1]?.role === "assistant" ? conv.msgs[++i] : null;
+      const content = !reply ? "中枢正在核对任务是否完成…" : /^\s*TASK_COMPLETE\b/.test(reply.content) ? "✓ 中枢核对：任务已完成" : "⚠ 中枢核对：任务没有完成";
+      out.push({ id: `confirm-${m.id}`, role: "system", content, generation: m.generation, ...(m.ts !== undefined ? { ts: m.ts } : {}) });
+      continue;
+    }
+    if (m.role !== "user") { out.push(m); continue; }
+    const content = m.id === firstUserId && opener ? opener : m.content.replace(CENTER_MARKER_LINES, "");
+    out.push(content === m.content ? m : { ...m, content });
+  }
+  const generation = out.length ? out[out.length - 1].generation : 1;
+  const note = (id: string, content: string) => out.push({ id: `batch-${id}`, role: "system", content, generation });
+  if (task?.conversation) {
+    // 对话式：像对话一样显示——还没派发的消息是「排队中」气泡，没有「子任务」字样。
+    if (CHAT_TASK_ERROR[task.status]) note(`err-${task.id}-${task.attempt}`, `⚠ ${CHAT_TASK_ERROR[task.status]}${task.last_error ? `：${describeTurnError(task.last_error)}` : ""}`);
+    for (const q of task.queued ?? []) out.push({ id: `batch-q-${q.id}`, role: "queued", content: q.prompt, generation, ...(q.created_at ? { ts: new Date(q.created_at).getTime() } : {}) });
+    return out;
+  }
+  if (!task) {
+    if (conv.job) note("none", "这个任务里还没有子任务");
+  } else if (!conv.msgs.length && !task.remote_task_id && !TERMINAL_TASK.has(task.status)) {
+    note("waiting", "子任务还没派发到执行节点，派发后这里会实时显示执行过程");
+  } else if (!conv.msgs.length && conv.stream === "ended") {
+    note("empty", "没有拿到这个子任务的执行记录（执行节点上的会话可能已经清理）");
+  }
+  if (task && BATCH_TASK_ERROR[task.status]) note(`err-${task.id}-${task.attempt}`, `⚠ ${BATCH_TASK_ERROR[task.status]}${task.last_error ? `：${describeTurnError(task.last_error)}` : ""}`);
+  return out;
+}
+
 /** 把说明行按时间插进转录：放在时间不晚于它的最后一条消息之后（没有时间的消息沿用前一条的时间）。 */
 function insertByTime(msgs: Msg[], notices: Msg[]): Msg[] {
   if (!notices.length) return msgs;

package/src/core/provider.tsx

@@ -1,16 +1,20 @@
-import { createContext, useContext, useEffect, useMemo, useRef, useSyncExternalStore, type ReactNode } from "react";
+import { createContext, useContext, useEffect, useLayoutEffect, useMemo, useRef, useSyncExternalStore, type ReactNode } from "react";
 import { createCliStore, type CliEvent, type CliState, type CliStore, type CliStoreOptions } from "./store.js";
 import type { ConversationCallback, ConversationEndPayload, TurnEndPayload } from "./types.js";
 
 /**
- * 积木的拼接点。放在同一个 <CliCenterProvider> 里的组件共享一个仓库：
- * 列表点哪个对话，对话组件就显示哪个；同一个对话只连一条实时流。
+ * 积木的拼接点。放在同一个 <CliCenterProvider> 里的组件共享一个仓库，切换时一起变：
+ * 列表点哪个对话，对话和看板就显示哪个；对话里新建 / 接续出新对话，列表跟着选中、看板跟着切；
+ * 对话里点文件在看板里打开。同一个对话只连一条实时流。
  *
- *   <CliCenterProvider baseUrl="/api/center">
+ *   <CliCenterProvider baseUrl="/api/center" selectedId={key} onEvent={(e) => e.type === "select" && setKey(e.jobId)}>
  *     <CliMsgList />
  *     <CliChat />
+ *     <CliBoard />
  *   </CliCenterProvider>
  *
+ * 要一起切换，里面的组件就不要再传 jobId（传了的组件只看自己那个，不跟着切）；从外面打开某个对话用 selectedId。
+ *
  * 组件单独使用时不需要它：组件发现外面没有 Provider，会用自己的 props 建一个。
  */
 const StoreContext = createContext<CliStore | null>(null);
@@ -18,6 +22,11 @@ const StoreContext = createContext<CliStore | null>(null);
 export interface CliCenterProviderProps extends CliStoreOptions, ResultHandlers {
   /** 外部建好的仓库（例如 Web Component 按 group 共享的）；给了就不再自己建。 */
   store?: CliStore;
+  /**
+   * 里面这几个组件一起看哪个对话（对话键："job_x" 或 "job_x#task_y"；null = 新对话）。不给就由列表的点击决定。
+   * 给了之后改它，列表、对话、看板一起切过去；列表点击、对话里新建出的对话照样会切，并发 select / job_change 事件。
+   */
+  selectedId?: string | null;
   /** 监听仓库事件：选中、一轮结束、对话结束、job 变化、错误。 */
   onEvent?: (event: CliEvent) => void;
   children: ReactNode;
@@ -41,10 +50,22 @@ export function dispatchResult(event: CliEvent, handlers: ResultHandlers) {
   else if (event.type === "conversation_closed") { handlers.onConversationEnd?.(event.payload); handlers.onCallback?.(event.payload); }
 }
 
-export function CliCenterProvider({ store: external, onEvent, onTurnEnd, onConversationEnd, onCallback, children, ...options }: CliCenterProviderProps) {
+export function CliCenterProvider({ store: external, selectedId, onEvent, onTurnEnd, onConversationEnd, onCallback, children, ...options }: CliCenterProviderProps) {
   // 连接参数只在建仓库时用一次：中途换 baseUrl / token 请换 key 重建。
   const optionsRef = useRef(options);
-  const store = useMemo(() => external ?? createCliStore(optionsRef.current), [external]);
+  const applied = useRef<string | null | undefined>(undefined);
+  const store = useMemo(() => {
+    const created = external ?? createCliStore(optionsRef.current);
+    // 第一次渲染前就选好：里面的组件一上来就看这个对话，不会先打开别的。
+    if (selectedId !== undefined) { created.select(selectedId); applied.current = selectedId; }
+    return created;
+  }, [external]); // eslint-disable-line react-hooks/exhaustive-deps
+  // 之后宿主改了 selectedId：一起切过去（在绘制前，免得闪一下旧的）。
+  useLayoutEffect(() => {
+    if (selectedId === undefined || selectedId === applied.current) return;
+    applied.current = selectedId;
+    store.select(selectedId);
+  }, [store, selectedId]);
   const onEventRef = useRef(onEvent);
   onEventRef.current = onEvent;
   const resultRef = useRef<ResultHandlers>({});