@spzxg/cli-ui 0.3.0 → 0.3.1

package/dist/{cli-ui-index-C8TOk7M3.js → cli-ui-index--RVPCGIc.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-C0F64Ln7.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-C0F64Ln7.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.3.1",
   "type": "module",
   "description": "任务中心（cli-task-center）对话任务的前端积木：cli-msglist 消息对话列表、cli-chat 对话，数据全部来自 center 服务。",
   "main": "src/index.ts",

package/src/chat/CliChat.tsx

@@ -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,8 +169,13 @@ 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]);
+  // 一次性任务（含续派，不是对话任务）：只读查看其中一个子任务——没有轮次，不能发消息、结束、回答。
+  const batch = !!conv?.batch || (!!job && job.mode !== "conversation");
+  const readOnly = !!readOnlyProp || !cfg.composer.show || batch;
+  // 这个对话对应的子任务：指定了就是它，否则对话任务的第一个（「新开」时借用第一个的智能体显示）；
+  // 一次性任务没指定时是实时流挑的那个（最近一个派发过的）。
+  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);
@@ -176,15 +193,17 @@ 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 manyConvs = (batch ? job?.tasks?.length ?? 0 : job?.conversation?.conversations?.length ?? 0) > 1;
   const convName = 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 +213,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) 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, batchStatus, jobStatus, ended, status, closedReason, awaiting, running]);
 
   // ── 处理器（引用稳定，MessageView 的 memo 才有效） ──
   // 输入框之外的操作（回答提问、撤回排队、结束对话、停止）失败时在顶部提示，不静默吞掉。
@@ -591,7 +611,7 @@ 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>
+                <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";
 
 /**
@@ -246,7 +246,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 +278,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/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,70 @@ 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: 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);
+
+/** 换成看另一个子任务（或同一个子任务换了节点对话，例如重试）：节点转录清掉，等新对话的转录。 */
+function focusBatchTask(conv: ConvState, task: BatchStreamTask | null): ConvState {
+  const remote = 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 wanted = conv.taskId ? tasks.find((task) => task.id === conv.taskId) ?? null : snapshot.task ?? latestBatchTask(tasks);
+  const shown = wanted && snapshot.task?.id === wanted.id ? { ...wanted, ...snapshot.task } : wanted;
+  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.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 +189,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 +285,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 +294,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 +355,48 @@ 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: "子任务已取消" };
+
+/**
+ * 一次性任务（含续派）的转录，只读：
+ *   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) {
+    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/store.ts

@@ -149,7 +149,8 @@ export function createCliStore(options: CliStoreOptions = {}) {
     // 对话结束（整个对话任务结束，或只关掉了这一个对话）：只对本页看着还开着的对话发（打开时就已结束的不算）；
     // 而且要等所有轮次都收尾之后再发，保证 conversation_closed 排在这个对话最后一个 conversation_turn 之后（与 center 的 callback_seq 一致）。
     if (next.job && !convEnded(next)) seenOpen.add(key);
-    if (next.job && convEnded(next) && seenOpen.has(key) && !closedJobs.has(key)) {
+    // 一次性任务（只读查看）没有对话的结果通知。
+    if (next.job && convEnded(next) && seenOpen.has(key) && !closedJobs.has(key) && !next.batch) {
       const settled = next.turns.every((turn) => TERMINAL_TURN.has(turn.status));
       if (settled || next.stream === "ended") {
         closedJobs.add(key);

package/src/core/types.ts

@@ -223,12 +223,13 @@ export type NodeEvent =
 
 /** center 实时流 chunk.events 里的一项。 */
 export type StreamItem =
-  | { type: "transcript"; messages: Message[] | null; pending: PendingMessage[] | null; running: boolean | null }
-  | { type: "node"; event: NodeEvent }
+  /** remote_task_id：一次性任务的流里才有（大任务里可能同时有几个节点对话）。 */
+  | { type: "transcript"; remote_task_id?: string; messages: Message[] | null; pending: PendingMessage[] | null; running: boolean | null }
+  | { type: "node"; remote_task_id?: string; event: NodeEvent }
   | { type: "turn"; turn: CenterTurn }
-  | { type: "job"; job: { id: string; status: JobStatus; closed_reason: string | null; node_id: string | null } }
-  /** 正在看的这个对话的状态变化（关闭了：closed=true）。 */
-  | { type: "task"; task: StreamTask };
+  | { type: "job"; job: { id: string; status: JobStatus; closed_reason?: string | null; node_id: string | null } }
+  /** 正在看的这个对话的状态变化（关闭了：closed=true）；一次性任务的流里是子任务（BatchStreamTask）。 */
+  | { type: "task"; task: StreamTask | BatchStreamTask };
 
 /** 实时流看的那个对话（GET /api/jobs/:id/stream?task=）。 */
 export interface StreamTask { id: string; seq: number; title: string; status: string; closed: boolean; remote_task_id: string | null; continue_from_task_id: string | null }
@@ -240,6 +241,36 @@ export interface StreamSnapshot {
   turns: CenterTurn[];
 }
 
+/**
+ * 一次性任务（含续派）的子任务，实时流里的样子。cli-chat 只读查看这类任务时用。
+ * prompt / opener_prompt：指定了 ?task= 时看的那个子任务才有（opener_prompt = 开出它所在节点对话的那个子任务的原文）。
+ */
+export interface BatchStreamTask {
+  id: string;
+  seq: number;
+  task_key: string | null;
+  title: string;
+  status: string;
+  round: number;
+  attempt: number;
+  remote_task_id: string | null;
+  continue_from_task_id: string | null;
+  last_error: string | null;
+  prompt?: string;
+  opener_prompt?: string;
+}
+
+/** 一次性任务（含续派，mode 不是 conversation）的实时流首个事件：没有轮次，只有子任务。 */
+export interface BatchStreamSnapshot {
+  job: { id: string; status: JobStatus; node_id: string | null; round: number; terminal_revision: number; mode: string; title: string };
+  tasks: BatchStreamTask[];
+  /** 指定了 ?task= 时：看的那个子任务。 */
+  task?: BatchStreamTask;
+}
+
+export const isBatchSnapshot = (snapshot: StreamSnapshot | BatchStreamSnapshot): snapshot is BatchStreamSnapshot =>
+  !Array.isArray((snapshot as StreamSnapshot).turns) && Array.isArray((snapshot as BatchStreamSnapshot).tasks);
+
 export interface StreamEnd {
   /** 对话任务的结束原因；只是这个对话被关闭时为 conversation_closed。 */
   reason: string;

package/src/msglist/CliMsgList.tsx

@@ -53,6 +53,7 @@ export function CliMsgList(props: CliMsgListProps) {
 }
 
 const SEARCH_MIN = 6;
+const BATCH_ACTIVE = new Set(["dispatching", "running", "verifying"]);
 
 interface CardView {
   id: string;
@@ -67,6 +68,8 @@ interface CardView {
   agent: string | null;
   turns: number;
   updatedAt: number;
+  /** 一次性任务（含续派，宿主把它的 job_id 放进了列表）：只能查看，不能在里面新开对话。 */
+  batch: boolean;
   loading: boolean;
   error: string | null;
 }
@@ -75,7 +78,8 @@ export function cardView(id: string, entry: JobEntry | undefined): CardView {
   const job = entry?.job;
   const conv = job?.conversation;
   const updatedAt = toMs(conv?.last_activity_at) ?? 0;
-  const base = { id, title: job?.title ?? id, desc: entry?.firstInput ?? "", agent: job?.tasks?.[0]?.agent ?? conv?.last_turn?.agent ?? null, turns: conv?.turns ?? 0, updatedAt, loading: !job && !entry?.error, error: entry?.error ?? null };
+  const batch = !!job && job.mode !== "conversation";
+  const base = { id, title: job?.title ?? id, desc: entry?.firstInput ?? "", agent: job?.tasks?.[0]?.agent ?? conv?.last_turn?.agent ?? null, turns: conv?.turns ?? 0, updatedAt, batch, loading: !job && !entry?.error, error: entry?.error ?? null };
   const status = job?.status ?? "queued";
   if (TERMINAL_JOB.has(status)) {
     const cancelled = status === "cancelled";
@@ -83,6 +87,11 @@ export function cardView(id: string, entry: JobEntry | undefined): CardView {
     const label = cancelled ? "已取消" : failed ? "已失败" : "已完成";
     return { ...base, cls: cancelled || failed ? "x" : "g", label, running: false, awaiting: false, group: cancelled ? "cancelled" : "done", activity: updatedAt ? `${label} · ${relTime(updatedAt)}` : label };
   }
+  // 一次性任务：有子任务在节点上跑就是运行中，没有轮次、不会停在提问上。
+  if (batch) {
+    const running = (job?.tasks ?? []).some((task) => BATCH_ACTIVE.has(task.status));
+    return { ...base, cls: "a", label: "进行中", running, awaiting: false, group: "active", activity: running ? "运行中 · 工作中" : status === "queued" ? "等待执行节点" : "进行中" };
+  }
   // 开了几个对话：任何一个在跑就算在跑，任何一个停在提问上就要你处理（关掉的对话不算）。
   const open = (conv?.conversations ?? []).filter((c) => !c.closed);
   const many = (conv?.conversations?.length ?? 0) > 1;
@@ -194,7 +203,7 @@ function Group({ label, cards, selected, onSelect, show, rows, firstTask, onNewI
         // 只有一个对话：整张卡片就是它；有几个对话：卡片是标题，选中落在下面的行上。
         selected={!convs.length && !newing && sel?.jobId === v.id}
         onSelect={() => onSelect(convs.length ? convs.find((c) => c.key === selectedKey)?.key ?? convs[0].key : v.id)}
-        onNewInJob={onNewInJob && v.group !== "done" && v.group !== "cancelled" ? () => onNewInJob(v.id) : undefined}
+        onNewInJob={onNewInJob && !v.batch && v.group !== "done" && v.group !== "cancelled" ? () => onNewInJob(v.id) : undefined}
       />
     );
     if (!convs.length && !newing) return card;