@spzxg/cli-ui 0.3.1 → 0.4.0

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

@@ -1,4 +1,4 @@
-import { g as yu, c as ft, a as xu } from "./cli-ui-embed-C0F64Ln7.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-C0F64Ln7.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.1",
+  "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";
@@ -170,8 +170,10 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
   const running = conv ? isRunning(conv) : false;
   const job = entry?.job;
   // 一次性任务（含续派，不是对话任务）：只读查看其中一个子任务——没有轮次，不能发消息、结束、回答。
+  // 例外是对话式子任务（续派时 mode=conversation）：当对话用，随时能接着发（= 续派一条接着它），不显示子任务状态。
   const batch = !!conv?.batch || (!!job && job.mode !== "conversation");
-  const readOnly = !!readOnlyProp || !cfg.composer.show || batch;
+  const chat = !!taskId && isChatTask(conv);
+  const readOnly = !!readOnlyProp || !cfg.composer.show || (batch && !chat);
   // 这个对话对应的子任务：指定了就是它，否则对话任务的第一个（「新开」时借用第一个的智能体显示）；
   // 一次性任务没指定时是实时流挑的那个（最近一个派发过的）。
   const shownTaskId = taskId ?? (batch ? conv?.task?.id : undefined);
@@ -180,7 +182,8 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
   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;
@@ -194,7 +197,8 @@ function ChatInner({ jobId: jobIdProp, taskId: taskIdProp, title = "对话", col
   const jobTitle = job?.title ?? conv?.job?.title;
   // 对话任务里有几个对话时，标题是「对话任务 / 这个对话」。
   const manyConvs = (batch ? job?.tasks?.length ?? 0 : job?.conversation?.conversations?.length ?? 0) > 1;
-  const convName = conv?.task?.title ?? info?.title ?? task?.title;
+  // 对话式子任务：流里的是这个对话最新的那条消息，名称取打开的那个子任务。
+  const convName = chat ? task?.title ?? conv?.task?.title : conv?.task?.title ?? info?.title ?? task?.title;
   const convTitle = isNew ? `${jobTitle ? `${jobTitle} / ` : ""}新对话`
     : (taskId || batch) && manyConvs && convName && convName !== jobTitle ? `${jobTitle ?? "对话"} / ${convName}`
       : jobTitle ?? (key ? "对话" : "新对话");
@@ -213,13 +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) return batchStatusView(batchStatus, jobStatus);
+    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, batch, batchStatus, jobStatus, ended, status, closedReason, awaiting, running]);
+  }, [key, isNew, batch, chat, batchStatus, jobStatus, ended, status, closedReason, awaiting, running]);
 
   // ── 处理器（引用稳定，MessageView 的 memo 才有效） ──
   // 输入框之外的操作（回答提问、撤回排队、结束对话、停止）失败时在顶部提示，不静默吞掉。
@@ -279,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;
@@ -307,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;
@@ -537,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>
@@ -561,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>}
@@ -610,7 +614,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 && (
+              {ended && cfg.transcript.status && (
                 <div className="session-label"><span className="ln" />{batch ? statusText : <>{REASON_TEXT[closedReason ?? ""] ?? "对话已结束"}{!finalEnd ? " · 再发消息会开一个新对话接着聊" : ""}</>}<span className="ln" /></div>
               )}
               {continuedBy && (

package/src/core/client.ts

@@ -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`, {

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

@@ -130,7 +130,8 @@ export function applySnapshot(conv: ConvState, snapshot: StreamSnapshot | BatchS
 // 流里可能同时有几个节点对话的事件（带 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),
+  // 对话式子任务跑完一条不算结束：还能接着聊。
+  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,
 });
 
@@ -138,9 +139,13 @@ const batchStreamTask = (task: BatchStreamTask): StreamTask => ({
 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?.remote_task_id ?? null;
+  // 对话式的对话里最新那条可能还没派发：节点对话用它们共用的那个。
+  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 } : {};
@@ -154,15 +159,16 @@ function focusBatchTask(conv: ConvState, task: BatchStreamTask | null): ConvStat
 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;
+  // 流给的那个优先：指定了子任务就是它（对话式的是它所在对话里最新的那条）；没指定是最近一个派发过的。旧版中枢不给时自己挑。
+  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;
@@ -359,6 +365,7 @@ export function viewMessages(conv: ConvState): Msg[] {
 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: "这条消息已取消" };
 
 /**
  * 一次性任务（含续派）的转录，只读：
@@ -386,6 +393,12 @@ function batchViewMessages(conv: ConvState): Msg[] {
   }
   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)) {

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>({});

package/src/core/store.ts

@@ -11,7 +11,7 @@
  * 单独用某个组件时它会自己建一个仓库；放进同一个 <CliCenterProvider>（或同一个 group 的 Web Component）就共享一个。
  */
 import { CenterError, createCenterClient, firstLine, type CenterClient, type CenterClientOptions } from "./client.js";
-import { addTurnsIfAbsent, applyItems, applySnapshot, closedCallback, convEnded, convKey, emptyConv, NEW_TASK, parseConvKey, TERMINAL_JOB, TERMINAL_TURN, turnCallback, upsertTurns, type ConvState } from "./conversation.js";
+import { addTurnsIfAbsent, applyItems, applySnapshot, closedCallback, convEnded, convKey, emptyConv, isChatTask, NEW_TASK, parseConvKey, TERMINAL_JOB, TERMINAL_TURN, turnCallback, upsertTurns, type ConvState } from "./conversation.js";
 import { formatAnswersText } from "../ui/format.js";
 import type { AskAnswers, AskQuestion, CenterJob, CenterTurn, ConversationClosedCallback, ConversationTurnCallback, NewConversationOptions } from "./types.js";
 
@@ -430,6 +430,22 @@ export function createCliStore(options: CliStoreOptions = {}) {
         void refreshJob(newId, true);
         return newId;
       }
+      const shown = state.convs[key];
+      if (ref.taskId && isChatTask(shown)) {
+        // 一次性任务里的对话式子任务：续派一条接着它的对话（中枢接到这个对话最新的那条后面），对话键不变。
+        // 续派没有按 business_id 去重，不重发。
+        if (!client.continueTask) throw new CenterError("当前后端不支持接着对话式子任务聊", "UNSUPPORTED", 0);
+        const { task_id } = await client.continueTask(ref.jobId, ref.taskId, text, { businessId });
+        // 先显示成排队中，不用等实时流的下一次轮询。
+        patchConv(key, (conv) => conv.batchTask && !conv.batchTask.queued?.some((q) => q.id === task_id)
+          ? { ...conv, batchTask: { ...conv.batchTask, queued: [...(conv.batchTask.queued ?? []), { id: task_id, prompt: text, created_at: new Date().toISOString() }] } }
+          : conv);
+        // 大任务结束时旧版中枢会关流：重新连上，接着看这一条。
+        const entry = streams.get(key);
+        if (entry && entry.refs > 0 && !entry.stop && !entry.timer) { entry.attempt = 0; connect(key); }
+        void refreshJob(ref.jobId, true);
+        return key;
+      }
       const result = await retryOnce(() => client.sendMessage(ref.jobId, text, { businessId, ...(ref.taskId ? { taskId: ref.taskId } : {}) }));
       const jobTarget = result.job_id || ref.jobId;
       // 指定了对话的：接续后跟到新对话任务里对应的那个对话；只有 job_id 的照旧只换 job。

package/src/core/types.ts

@@ -258,6 +258,13 @@ export interface BatchStreamTask {
   last_error: string | null;
   prompt?: string;
   opener_prompt?: string;
+  /**
+   * 对话式子任务（续派时 mode=conversation）：指定 ?task= 看它时，它和续派接着它聊的子任务算一个对话——
+   * 这条是其中最新的；conversation_remote_task_id 是它们共用的节点对话，queued 是还没派发的消息。旧版中枢没有。
+   */
+  conversation?: boolean;
+  conversation_remote_task_id?: string | null;
+  queued?: Array<{ id: string; prompt: string; created_at?: string }>;
 }
 
 /** 一次性任务（含续派，mode 不是 conversation）的实时流首个事件：没有轮次，只有子任务。 */

package/src/elements.tsx

@@ -11,7 +11,9 @@
  *   <cli-file-preview job-id="job_x" path="outputs/报告.md"></cli-file-preview>   （单独的文件预览 + 下载）
  *   <cli-browser job-id="job_x"></cli-browser>                                  （单独的浏览器实时画面）
  *
- * 同一个 group 的元素共享一个仓库：列表点哪个，对话就显示哪个；不写 group 各自独立。
+ * 同一个 group 的元素共享一个仓库，切换时一起变：列表点哪个，对话和看板就显示哪个；不写 group 各自独立。
+ * 要一起切换，group 里的元素就不要写 job-id（写了的只看自己那个）；从外面打开某个对话，给任意一个元素写
+ * selected-id="job_x" 或 "job_x#task_y"（改它就一起切过去），选中变化在 cli-event 的 select 事件里。
  * 属性：base-url、token、line、namespace、group、job-id、task-id（对话任务里的哪个对话，"new" = 新开一个；对话 / 看板）、
  *       title、color、theme、context、read-only、
  *       tabs（看板页签，逗号分隔：files,changes,browser）、default-tab、file-open（对话：auto / board / modal / link）、
@@ -45,7 +47,7 @@ function storeFor(el: HTMLElement): CliStore | undefined {
   return store;
 }
 
-const ATTRS = ["base-url", "token", "line", "namespace", "group", "job-id", "task-id", "title", "color", "theme", "context", "read-only", "config", "new-conversation", "tabs", "default-tab", "file-open", "path"];
+const ATTRS = ["base-url", "token", "line", "namespace", "group", "selected-id", "job-id", "task-id", "title", "color", "theme", "context", "read-only", "config", "new-conversation", "tabs", "default-tab", "file-open", "path"];
 
 function jsonAttr(el: HTMLElement, name: string): object | undefined {
   const raw = el.getAttribute(name);
@@ -92,8 +94,15 @@ abstract class CliElement extends HTMLElement {
   }
   attributeChangedCallback() { if (this.root) this.render(); }
 
+  private appliedSelection: string | null = null;
   protected common() {
     const store = storeFor(this) ?? (this.ownStore ??= createCliStore(storeOptions(this)));
+    // selected-id：这一组一起看哪个对话。属性变了才切（列表点击换了选中，不会被属性拉回去）。
+    const selection = this.getAttribute("selected-id");
+    if (selection !== null && selection !== this.appliedSelection) {
+      this.appliedSelection = selection;
+      store.select(selection || null);
+    }
     return {
       store,
       title: this.getAttribute("title") ?? undefined,

package/src/msglist/CliMsgList.tsx

@@ -64,7 +64,10 @@ interface CardView {
   running: boolean;
   awaiting: boolean;
   group: "needs" | "active" | "done" | "cancelled";
+  /** 带状态的活动（打开 card.status 时显示）。 */
   activity: string;
+  /** 只有时间（缺省显示这个）。 */
+  when: string;
   agent: string | null;
   turns: number;
   updatedAt: number;
@@ -79,7 +82,7 @@ export function cardView(id: string, entry: JobEntry | undefined): CardView {
   const conv = job?.conversation;
   const updatedAt = toMs(conv?.last_activity_at) ?? 0;
   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 base = { id, title: job?.title ?? id, desc: entry?.firstInput ?? "", when: updatedAt ? relTime(updatedAt) : "", 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";
@@ -134,7 +137,8 @@ export function convRows(jobId: string, entry: JobEntry | undefined): ConvRowVie
 
 function MsgCard({ v, selected, onSelect, show, onNewInJob }: { v: CardView; selected: boolean; onSelect: () => void; show: ResolvedMsgListConfig["card"]; onNewInJob?: () => void }) {
   if (v.loading) return <CardSkeleton i={v.id.length} />;
-  const foot = show.activity || (show.turns && v.turns > 0);
+  const activity = show.status ? v.activity : v.when;
+  const foot = (show.activity && !!activity) || (show.turns && v.turns > 0);
   const card = (
     <button className={`task ${selected ? "sel" : ""} ${v.awaiting && show.status ? "awaiting" : ""}`} onClick={onSelect} title={v.error ?? undefined}>
       <div className="task-top">
@@ -146,7 +150,7 @@ function MsgCard({ v, selected, onSelect, show, onNewInJob }: { v: CardView; sel
       {show.description && v.desc && <div className="tdesc">{v.desc}</div>}
       {v.error && <div className="blocked-chip">{Icon.x()} {v.error}</div>}
       {foot && <div className="task-foot">
-        {show.activity && <span className="activity">{v.awaiting ? <span style={{ color: "var(--blue)" }}>●</span> : v.running ? <span style={{ color: "var(--amber)" }}>●</span> : null}{v.activity}</span>}
+        {show.activity && activity && <span className="activity">{show.status && (v.awaiting ? <span style={{ color: "var(--blue)" }}>●</span> : v.running ? <span style={{ color: "var(--amber)" }}>●</span> : null)}{activity}</span>}
         <span className="spacer" />
         {show.turns && v.turns > 0 && <span className="activity">{v.turns} 条消息</span>}
       </div>}
@@ -167,7 +171,7 @@ function ConvRow({ v, selected, onSelect, show }: { v: ConvRowView; selected: bo
     <button className={`cli-conv-row ${selected ? "sel" : ""} ${v.awaiting && show.status ? "awaiting" : ""}`} onClick={onSelect}>
       {show.status && <StatusDot cls={v.cls} running={v.running} awaiting={v.awaiting} title={v.label} />}
       <span className="cli-conv-title">{v.title}</span>
-      {show.activity && <span className="cli-conv-act">{v.activity}</span>}
+      {show.activity && show.status && <span className="cli-conv-act">{v.activity}</span>}
       {show.turns && v.turns > 0 && <span className="cli-conv-act">{v.turns} 条</span>}
     </button>
   );
@@ -187,9 +191,11 @@ type GroupProps = {
   label: string | false; cards: CardView[]; selected: string | null; onSelect: (id: string) => void; show: ResolvedMsgListConfig["card"];
   rows: Record<string, ConvRowView[]>; firstTask: Record<string, string | undefined>; onNewInJob?: (jobId: string) => void;
   accent?: boolean; collapsible?: boolean; collapsed?: boolean; onToggle?: () => void;
+  /** 不分组：只有卡片，没有组标题。 */
+  plain?: boolean;
 };
 
-function Group({ label, cards, selected, onSelect, show, rows, firstTask, onNewInJob, accent, collapsible, collapsed, onToggle }: GroupProps) {
+function Group({ label, cards, selected, onSelect, show, rows, firstTask, onNewInJob, accent, collapsible, collapsed, onToggle, plain }: GroupProps) {
   if (!cards.length || label === false) return null;
   const sel = selected ? parseConvKey(selected) : null;
   const list = cards.map((v) => {
@@ -217,6 +223,7 @@ function Group({ label, cards, selected, onSelect, show, rows, firstTask, onNewI
       </div>
     );
   });
+  if (plain) return <>{list}</>;
   if (collapsible) {
     return (
       <>
@@ -337,10 +344,13 @@ function MsgListInner({ jobIds, discover = true, selectedId, onSelect, onNew, ti
               <>
                 {cards.length === 0 && <div className="empty" style={{ padding: "30px 16px" }}><div className="e-t">{cfg.emptyTitle}</div>{cfg.emptyDescription && <div className="e-s">{cfg.emptyDescription}</div>}</div>}
                 {q && shown.length === 0 && <div className="search-empty">没有匹配“{query.trim()}”的对话。</div>}
+                {!cfg.grouped && <Group label="" cards={[...shown].sort(byRecent)} {...groupProps} plain />}
+                {cfg.grouped && <>
                 <Group label={cfg.groups.needs} cards={groups.needs} {...groupProps} accent />
                 <Group label={cfg.groups.active} cards={groups.active} {...groupProps} />
                 <Group label={cfg.groups.done} cards={groups.done} {...groupProps} collapsible collapsed={doneCollapsed && !q} onToggle={() => setDoneCollapsed((c) => !c)} />
                 <Group label={cfg.groups.cancelled} cards={groups.cancelled} {...groupProps} collapsible collapsed={cancelledCollapsed && !q} onToggle={() => setCancelledCollapsed((c) => !c)} />
+                </>}
               </>
             )}
           </div>