@tfdesign/b-end 1.0.14 → 1.0.15

package/src/_b_end_runtime/page-patterns/ChatConversationPattern.jsx

@@ -10,6 +10,7 @@ import ChatMessage, {
   DEFAULT_CHAT_TASK_GROUPS,
   DEFAULT_CHAT_PLAN,
   DEFAULT_CHAT_THINKING,
+  DEFAULT_CHAT_FORM_CONFIRM,
   useStreamingTaskGroups,
 } from '../components/ChatMessage';
 
@@ -41,64 +42,20 @@ import ChatMessage, {
  */
 
 const STREAM_INTERVAL = 600;
+const AUTO_FLOW_TIMINGS = {
+  thinkingDone: 900,
+  confirmShow: 1400,
+  confirmDone: 2400,
+  flowStart: 3000,
+};
 
-/* ── 端到端 mock 对话 ── */
-function buildInitMessages() {
-  return [
-    /* m1 用户：富文本 + tag + 附件 */
-    {
-      id: 'm1',
-      kind: 'user',
-      timestamp: '14:02',
-      userContent: [
-        { type: 'text', value: '帮我整理 ' },
-        {
-          type: 'entity',
-          icon: 'message-chat-square-stroked',
-          label: '智能会话:社交私信',
-          showChevron: true,
-        },
-        { type: 'text', value: ' 场景近 7 天的人工解决率，做一份分析报告' },
-      ],
-      userAttachments: [
-        { id: 'att-1', name: '抖音电商售后政策汇编.pdf', size: 327680 },
-      ],
-    },
-
-    /* m2 AI（合并：深度思考 + 引导文本 + 任务规划卡，已被用户处理 → 禁用置灰态） */
-    {
-      id: 'm2',
-      kind: 'ai-task-plan',
-      timestamp: '14:02',
-      thinking: {
-        ...DEFAULT_CHAT_THINKING,
-        state: 'completed',
-        defaultExpanded: false,
-      },
-      leadText: '好的，我先做一份任务规划，请稍后...',
-      planConfirmed: true,
-    },
-
-    /* m3 用户：开始执行任务 */
-    {
-      id: 'm3',
-      kind: 'user',
-      timestamp: '14:03',
-      userContent: [{ type: 'text', value: '开始执行任务' }],
-    },
-
-    /* m4 AI：完整执行流消息（执行流 + 总结文本 + 产物组 + 追问） */
-    {
-      id: 'm4',
-      kind: 'ai-flow',
-      timestamp: '14:08',
-      taskGroups: DEFAULT_CHAT_TASK_GROUPS.map((g) => ({ ...g, status: 'completed' })),
-      resultText: DEFAULT_CHAT_RESULT,
-      resultArtifacts: DEFAULT_CHAT_RESULT_ARTIFACTS,
-      followUps: DEFAULT_CHAT_FOLLOW_UPS,
-    },
-  ];
-}
+const DEFAULT_CONVERSATION_CONTEXT = {
+  account: '抖音电商客服账号 · after_sales_prod',
+  environment: '生产环境 / OLA Workflow v13',
+  mock: '近 7 天售后会话样本 240 条',
+  conclusion: '上一轮已完成售后政策口径梳理，并沉淀可继续追问的结论摘要。',
+  artifacts: DEFAULT_CHAT_RESULT_ARTIFACTS.map((item) => item.title),
+};
 
 /* ── 关键词 → 回复路由 ── */
 const TASK_KEYWORDS = ['整理', '分析', '生成', '梳理', '输出', '汇总'];
@@ -194,6 +151,108 @@ function routeReply(text) {
   return { type: 'short', text: GENERIC_REPLIES[Math.floor(Math.random() * GENERIC_REPLIES.length)] };
 }
 
+function buildThinkingContent(text, context) {
+  const artifacts = context.artifacts?.length ? context.artifacts.join('、') : '暂无历史产物';
+  return [
+    `用户本轮输入：${text}`,
+    `系统自动带入上一轮账号：${context.account}`,
+    `系统自动带入上一轮环境：${context.environment}`,
+    `系统自动带入上一轮 Mock：${context.mock}`,
+    `系统自动带入上一轮结论：${context.conclusion || '暂无历史结论'}`,
+    `系统自动带入上一轮产物：${artifacts}`,
+    '基于上述连续会话上下文，先确认关键执行口径，再进入自动执行流。',
+  ].join('\n');
+}
+
+function buildClarificationConfirms(context) {
+  return DEFAULT_CHAT_FORM_CONFIRM.map((confirm) => ({
+    ...confirm,
+    id: 'auto-clarify-confirm',
+    title: '人工澄清确认',
+    primaryActionLabel: '确认并继续',
+    secondaryActionLabel: '',
+    formItems: [
+      {
+        id: 'scene',
+        label: '业务场景',
+        type: 'select',
+        placeholder: '请选择业务场景',
+        defaultValue: 'after-sales-policy',
+        options: [
+          { value: 'after-sales-policy', label: '售后政策整理' },
+          { value: 'conversation-analysis', label: '会话场景分析' },
+          { value: 'ab-experiment', label: 'AB 实验方案' },
+        ],
+        fullWidth: true,
+      },
+      {
+        id: 'channel',
+        label: '处理渠道',
+        type: 'select',
+        placeholder: '请选择处理渠道',
+        defaultValue: 'current-context',
+        options: [
+          {
+            value: 'current-context',
+            label: `使用当前账号、${context.environment} 与 ${context.mock}`,
+          },
+          { value: 'refresh-mock', label: '刷新 Mock 数据后再执行' },
+          { value: 'manual-review', label: '先转人工复核上下文再执行' },
+        ],
+        fullWidth: true,
+      },
+      {
+        id: 'remark',
+        label: '补充说明',
+        type: 'input',
+        placeholder: '请输入补充说明（可选）',
+        fullWidth: true,
+      },
+    ],
+  }));
+}
+
+function buildAutoFlowPayload(text, reply, context) {
+  if (reply.type === 'follow-up-result') {
+    return {
+      resultText: `${reply.resultText}\n\n本轮追问已自动继承上一轮账号、环境、Mock、结论和产物上下文，未新开会话。`,
+      resultArtifacts: reply.resultArtifacts,
+      followUps: reply.followUps,
+    };
+  }
+
+  if (reply.type === 'task') {
+    return {
+      resultText: DEFAULT_CHAT_RESULT,
+      resultArtifacts: DEFAULT_CHAT_RESULT_ARTIFACTS,
+      followUps: DEFAULT_CHAT_FOLLOW_UPS,
+    };
+  }
+
+  return {
+    resultText:
+      `${reply.text} 已结合当前会话上下文继续处理「${text}」：账号为 ${context.account}，环境为 ${context.environment}，Mock 使用 ${context.mock}。如需深入推进，可继续选择下方追问或直接在底部输入补充要求。`,
+    resultArtifacts: DEFAULT_CHAT_RESULT_ARTIFACTS.slice(0, 2),
+    followUps: ['继续细化结论', '补充一轮 Mock 验证', '生成可交付文档'],
+  };
+}
+
+function getFlowTotalMs() {
+  const totalSteps = DEFAULT_CHAT_TASK_GROUPS.reduce(
+    (sum, group) => sum + (group.steps?.length ?? 0),
+    0,
+  );
+  return (totalSteps + 1) * STREAM_INTERVAL;
+}
+
+function hasActionablePrimaryButton(label) {
+  return typeof label === 'string' && label.trim().length > 0;
+}
+
+function confirmsRequireHumanGate(confirms) {
+  return Array.isArray(confirms) && confirms.some((confirm) => hasActionablePrimaryButton(confirm?.primaryActionLabel));
+}
+
 /* ── 单条消息 → ChatMessage props 映射 ──
  *  isLatest：是否为列表中最后一条（决定 historyMode 是否启用）
  *  handlers：所有交互回调集合
@@ -202,7 +261,15 @@ function routeReply(text) {
  *    · onFollowUpSelect(text) — 追问 chip 点击（默认作为新一轮对话发出）
  */
 function messageToChatProps(msg, isLatest, handlers = {}) {
-  const { onPlanConfirm, onPlanCancel, onFollowUpSelect } = handlers;
+  const {
+    onPlanConfirm,
+    onPlanCancel,
+    onFollowUpSelect,
+    onConfirmPrimary,
+    onConfirmSecondary,
+    onConfirmOptionChange,
+    onConfirmFormChange,
+  } = handlers;
   const baseProps = {
     className: msg.className || '',
   };
@@ -262,6 +329,41 @@ function messageToChatProps(msg, isLatest, handlers = {}) {
       thinking: msg.thinking,
       resultText: msg.resultText,
       timestamp: msg.timestamp,
+      actions: msg.thinking?.state === 'thinking' ? null : baseActions,
+    };
+  }
+
+  if (msg.kind === 'ai-confirm') {
+    return {
+      ...baseProps,
+      role: 'ai',
+      header: true,
+      title: '',
+      steps: null,
+      leadText: msg.leadText,
+      confirms: Array.isArray(msg.confirms)
+        ? msg.confirms.map((confirm) => ({
+            ...confirm,
+            onOptionChange: (value, option) => onConfirmOptionChange && onConfirmOptionChange(
+              msg.id,
+              confirm.id,
+              value,
+              option,
+            ),
+            onFormChange: (formValues, meta) => onConfirmFormChange && onConfirmFormChange(
+              msg.id,
+              confirm.id,
+              formValues,
+              meta,
+            ),
+            onPrimaryAction: (payload) => onConfirmPrimary && onConfirmPrimary(msg.id, confirm.id, {
+              ...payload,
+              primaryActionLabel: confirm.primaryActionLabel,
+            }),
+            onSecondaryAction: () => onConfirmSecondary && onConfirmSecondary(msg.id, confirm.id),
+          }))
+        : msg.confirms,
+      timestamp: msg.timestamp,
       actions: baseActions,
     };
   }
@@ -329,7 +431,7 @@ export default function ChatConversationPattern({
   initialMessages,
 }) {
   const resolvedInitialMessagesRef = useRef(
-    Array.isArray(initialMessages) ? initialMessages : buildInitMessages(),
+    Array.isArray(initialMessages) ? initialMessages : [],
   );
   const [messages, setMessages] = useState(() => resolvedInitialMessagesRef.current);
   const [phase, setPhase] = useState(() => (
@@ -346,10 +448,62 @@ export default function ChatConversationPattern({
   const [prefillSeed, setPrefillSeed] = useState(0);
   const replyTimerRef = useRef(null);
   const busyTimerRef = useRef(null);
+  const flowTimersRef = useRef([]);
+  const pendingFlowResumeRef = useRef(null);
   const scrollRef = useRef(null);
+  const latestAnchorRef = useRef(null);
+  const conversationContextRef = useRef({ ...DEFAULT_CONVERSATION_CONTEXT });
   const idSeedRef = useRef(100);
   const nextId = useCallback((prefix = 'm') => `${prefix}${++idSeedRef.current}`, []);
 
+  const scrollToLatest = useCallback((behavior = 'smooth') => {
+    if (latestAnchorRef.current?.scrollIntoView) {
+      latestAnchorRef.current.scrollIntoView({ block: 'end', behavior });
+      return;
+    }
+    const el = scrollRef.current;
+    if (el) el.scrollTo({ top: el.scrollHeight, behavior });
+  }, []);
+
+  const scheduleScrollToLatest = useCallback((behavior = 'smooth') => {
+    if (typeof window === 'undefined') return;
+    window.requestAnimationFrame(() => scrollToLatest(behavior));
+  }, [scrollToLatest]);
+
+  const clearFlowTimers = useCallback(() => {
+    flowTimersRef.current.forEach((timer) => clearTimeout(timer));
+    flowTimersRef.current = [];
+  }, []);
+
+  const clearPendingFlowResume = useCallback(() => {
+    pendingFlowResumeRef.current = null;
+  }, []);
+
+  const pauseForHumanGate = useCallback((resume) => {
+    pendingFlowResumeRef.current = resume;
+    setInputView('default');
+    scheduleScrollToLatest();
+  }, [scheduleScrollToLatest]);
+
+  const scheduleFlowTimer = useCallback((callback, delay) => {
+    const timer = setTimeout(() => {
+      flowTimersRef.current = flowTimersRef.current.filter((item) => item !== timer);
+      callback();
+      scheduleScrollToLatest();
+    }, delay);
+    flowTimersRef.current.push(timer);
+    return timer;
+  }, [scheduleScrollToLatest]);
+
+  const resumePendingFlow = useCallback((delay = 240) => {
+    const resume = pendingFlowResumeRef.current;
+    pendingFlowResumeRef.current = null;
+    if (typeof resume !== 'function') return;
+    scheduleFlowTimer(() => {
+      resume();
+    }, delay);
+  }, [scheduleFlowTimer]);
+
   /* chip 回填到输入框（覆盖当前草稿 + 自动聚焦） */
   const prefillInput = useCallback((text) => {
     setPrefillText(text || '');
@@ -361,8 +515,10 @@ export default function ChatConversationPattern({
     () => () => {
       if (replyTimerRef.current) clearTimeout(replyTimerRef.current);
       if (busyTimerRef.current) clearTimeout(busyTimerRef.current);
+      clearFlowTimers();
+      clearPendingFlowResume();
     },
-    [],
+    [clearFlowTimers, clearPendingFlowResume],
   );
 
   /* 自动滚到底：用 ResizeObserver 监听消息容器内容高度变化
@@ -374,11 +530,11 @@ export default function ChatConversationPattern({
     const inner = el.firstElementChild;
     if (!inner) return undefined;
     const ro = new ResizeObserver(() => {
-      el.scrollTo({ top: el.scrollHeight, behavior: 'smooth' });
+      scrollToLatest();
     });
     ro.observe(inner);
     return () => ro.disconnect();
-  }, [phase, messages.length]);
+  }, [phase, messages.length, scrollToLatest]);
 
   /* 重置回欢迎状态 */
   const handleNewSession = useCallback(() => {
@@ -388,12 +544,11 @@ export default function ChatConversationPattern({
     setPrefillSeed((s) => s + 1);
   }, []);
 
-  /* ── 取消链路：用户在任务规划卡里点「取消」 ──
-   *   1. 标记该任务规划卡为「已确认」（卡片置灰）
-   *   2. 追加用户消息「取消」
-   *   3. ChatInput 进 replying（短答态）+ 600ms 后追加 AI 寒暄 + 回 default */
+  /* ── 取消链路：任务规划卡次按钮 ──
+   * 在自动编排有人为闸门等待时，取消会清空 pending resume 并暂停后续链路。 */
   const handlePlanCancel = useCallback(
     (planMsgId) => {
+      clearPendingFlowResume();
       setMessages((prev) =>
         prev.map((m) => (m.id === planMsgId ? { ...m, planConfirmed: true } : m)),
       );
@@ -421,17 +576,137 @@ export default function ChatConversationPattern({
         setInputView('default');
       }, 600);
     },
-    [nextId],
+    [nextId, clearPendingFlowResume],
+  );
+
+  const handleConfirmPrimary = useCallback(
+    (messageId, confirmId, payload = {}) => {
+      const isActionable = hasActionablePrimaryButton(payload.primaryActionLabel);
+      const selectedLabel = payload.option?.label ?? '';
+      setMessages((prev) =>
+        prev.map((message) =>
+          message.id === messageId
+            ? {
+                ...message,
+                confirms: Array.isArray(message.confirms)
+                  ? message.confirms.map((confirm) => (
+                    confirm.id === confirmId
+                      ? {
+                          ...confirm,
+                          defaultConfirmed: true,
+                          selectedValue: payload.value ?? confirm.selectedValue,
+                          defaultSelectedValue: payload.value ?? confirm.defaultSelectedValue,
+                          selectedLabel: selectedLabel || confirm.selectedLabel,
+                          formValues: payload.formValues ?? confirm.formValues,
+                        }
+                      : confirm
+                  ))
+                  : message.confirms,
+                leadText: isActionable ? '已确认，继续执行后续流程。' : message.leadText,
+                timestamp: nowHHmm(),
+              }
+            : message,
+        ),
+      );
+      if (isActionable) resumePendingFlow();
+    },
+    [resumePendingFlow],
   );
 
-  /* ── 任务规划链路：用户在任务规划卡里点「开始执行任务」 ── */
+  const handleConfirmOptionChange = useCallback((messageId, confirmId, value, option) => {
+    setMessages((prev) =>
+      prev.map((message) =>
+        message.id === messageId
+          ? {
+              ...message,
+              confirms: Array.isArray(message.confirms)
+                ? message.confirms.map((confirm) => (
+                  confirm.id === confirmId
+                    ? {
+                        ...confirm,
+                        selectedValue: value,
+                        defaultSelectedValue: value,
+                        selectedLabel: option?.label ?? confirm.selectedLabel,
+                      }
+                    : confirm
+                ))
+                : message.confirms,
+            }
+          : message,
+      ),
+    );
+  }, []);
+
+  const handleConfirmFormChange = useCallback((messageId, confirmId, formValues, meta = {}) => {
+    setMessages((prev) =>
+      prev.map((message) =>
+        message.id === messageId
+          ? {
+              ...message,
+              confirms: Array.isArray(message.confirms)
+                ? message.confirms.map((confirm) => (
+                  confirm.id === confirmId
+                    ? {
+                        ...confirm,
+                        formValues,
+                        lastChangedFieldId: meta.fieldId,
+                      }
+                    : confirm
+                ))
+                : message.confirms,
+            }
+          : message,
+      ),
+    );
+  }, []);
+
+  const handleConfirmSecondary = useCallback(
+    (messageId, confirmId) => {
+      setMessages((prev) =>
+        prev.map((message) =>
+          message.id === messageId
+            ? {
+                ...message,
+                confirms: Array.isArray(message.confirms)
+                  ? message.confirms.map((confirm) => (
+                    confirm.id === confirmId ? { ...confirm, defaultConfirmed: true } : confirm
+                  ))
+                  : message.confirms,
+                leadText: '已取消当前确认，流程暂停。',
+                timestamp: nowHHmm(),
+              }
+            : message,
+        ),
+      );
+      clearPendingFlowResume();
+      setInputView('default');
+    },
+    [clearPendingFlowResume],
+  );
+
+  /* ── 任务规划卡主按钮：有人为闸门时用于恢复自动链路；无闸门时保留旧兜底链路 ── */
   const handlePlanConfirm = useCallback(
     (planMsgId) => {
+      const hasPendingResume = typeof pendingFlowResumeRef.current === 'function';
       /* 1) 标记该任务规划卡为「已确认」（持久化到消息数据，重渲染时也是禁用态） */
       setMessages((prev) =>
         prev.map((m) => (m.id === planMsgId ? { ...m, planConfirmed: true } : m)),
       );
 
+      if (hasPendingResume) {
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: nextId('u'),
+            kind: 'user',
+            timestamp: nowHHmm(),
+            userContent: [{ type: 'text', value: '开始执行任务' }],
+          },
+        ]);
+        resumePendingFlow();
+        return;
+      }
+
       const flowMsgId = nextId('flow');
 
       /* 2) 立即追加：用户消息「开始执行任务」+ AI 流式执行流（带 stream 标记，由 StreamingChatMessage 接管） */
@@ -486,12 +761,145 @@ export default function ChatConversationPattern({
         setInputView('default');
       }, totalMs);
     },
-    [nextId],
+    [nextId, resumePendingFlow],
+  );
+
+  const startAutoOrchestratedFlow = useCallback(
+    (text, reply, ctx = {}) => {
+      const contextSnapshot = { ...conversationContextRef.current };
+      const thinkingMsgId = nextId('think');
+      const confirmMsgId = nextId('confirm');
+      const flowMsgId = nextId('flow');
+      const payload = buildAutoFlowPayload(text, reply, contextSnapshot);
+      const clarificationConfirms = buildClarificationConfirms(contextSnapshot);
+
+      const finishExecutionFlow = () => {
+        setMessages((prev) =>
+          prev.map((message) =>
+            message.id === flowMsgId
+              ? {
+                  ...message,
+                  stream: false,
+                  taskGroups: DEFAULT_CHAT_TASK_GROUPS.map((group) => ({
+                    ...group,
+                    status: 'completed',
+                  })),
+                  resultText: payload.resultText,
+                  resultArtifacts: payload.resultArtifacts,
+                  followUps: payload.followUps,
+                  timestamp: nowHHmm(),
+                }
+              : message,
+          ),
+        );
+        conversationContextRef.current = {
+          ...contextSnapshot,
+          conclusion: payload.resultText,
+          artifacts: payload.resultArtifacts.map((artifact) => artifact.title),
+          lastUserIntent: text,
+        };
+        setInputView('default');
+      };
+
+      const startExecutionFlow = () => {
+        setInputView('busy');
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: flowMsgId,
+            kind: 'ai-flow',
+            timestamp: nowHHmm(),
+            taskGroups: DEFAULT_CHAT_TASK_GROUPS,
+            stream: true,
+          },
+        ]);
+        scheduleFlowTimer(finishExecutionFlow, getFlowTotalMs());
+      };
+
+      const continueAfterConfirm = () => {
+        setMessages((prev) =>
+          prev.map((message) =>
+            message.id === confirmMsgId
+              ? {
+                  ...message,
+                  confirms: Array.isArray(message.confirms)
+                    ? message.confirms.map((confirm) => ({
+                        ...confirm,
+                        defaultConfirmed: true,
+                      }))
+                    : message.confirms,
+                  leadText: '已确认澄清信息，开始自动执行。',
+                  timestamp: nowHHmm(),
+                }
+              : message,
+          ),
+        );
+        scheduleFlowTimer(startExecutionFlow, 320);
+      };
+
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: thinkingMsgId,
+          kind: 'ai-thinking',
+          timestamp: nowHHmm(),
+          thinking: {
+            ...DEFAULT_CHAT_THINKING,
+            state: 'thinking',
+            inProgressLabel: '深度思考中 ...',
+            defaultExpanded: false,
+          },
+          className: ctx.source === 'follow-up' ? 'tfds-followup-ai-pop' : '',
+        },
+      ]);
+
+      scheduleFlowTimer(() => {
+        setMessages((prev) =>
+          prev.map((message) =>
+            message.id === thinkingMsgId
+              ? {
+                  ...message,
+                  thinking: {
+                    ...DEFAULT_CHAT_THINKING,
+                    state: 'completed',
+                    durationLabel: '深度思考（用时 3.20 秒）',
+                    content: buildThinkingContent(text, contextSnapshot),
+                    defaultExpanded: false,
+                  },
+                  resultText: '已完成上下文理解，接下来需要先确认本轮执行口径。',
+                  timestamp: nowHHmm(),
+                }
+              : message,
+          ),
+        );
+      }, AUTO_FLOW_TIMINGS.thinkingDone);
+
+      scheduleFlowTimer(() => {
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: confirmMsgId,
+            kind: 'ai-confirm',
+            timestamp: nowHHmm(),
+            leadText: '请确认以下人工澄清信息；若卡片右下角存在可操作主按钮，则点击后再继续执行。',
+            confirms: clarificationConfirms,
+          },
+        ]);
+
+        if (confirmsRequireHumanGate(clarificationConfirms)) {
+          pauseForHumanGate(continueAfterConfirm);
+          return;
+        }
+
+        scheduleFlowTimer(continueAfterConfirm, 320);
+      }, AUTO_FLOW_TIMINGS.confirmShow);
+    },
+    [nextId, pauseForHumanGate, scheduleFlowTimer],
   );
 
   /* ── 用户输入框发送 ──
-   * 状态机：default → replying → 600ms 后追加 AI 回复 → default
-   * 任务关键词分支也走 replying 态（正在规划中），规划卡推出后回 default 等用户处理卡片 */
+   * 状态机：default → replying → AI 深度思考 → 人工澄清确认 → busy 执行流 → 结论/产物/追问 → default
+   * 底部输入与 followUps 点击都进入同一条会话流，并自动继承上一轮上下文。 */
   const handleSend = useCallback(
     (text, ctx = {}) => {
       const trimmed = (text || '').trim();
@@ -520,64 +928,35 @@ export default function ChatConversationPattern({
         },
       ]);
       setInputView('replying');
+      scheduleScrollToLatest();
 
       const reply = routeReply(trimmed);
       if (replyTimerRef.current) clearTimeout(replyTimerRef.current);
+      if (busyTimerRef.current) clearTimeout(busyTimerRef.current);
+      clearFlowTimers();
+      clearPendingFlowResume();
 
-      /* 2) 追问结果：点击 follow-up chip 等价于立即发送，并模拟生成对应的新答案 */
-      if (reply.type === 'follow-up-result') {
+      if (reply.type === 'short' && STOP_KEYWORDS.some((keyword) => trimmed.includes(keyword))) {
         replyTimerRef.current = setTimeout(() => {
           setMessages((prev) => [
             ...prev,
             {
               id: nextId('a'),
-              kind: 'ai-result',
+              kind: 'ai-text',
               timestamp: nowHHmm(),
-              resultText: reply.resultText,
-              resultArtifacts: reply.resultArtifacts,
-              followUps: reply.followUps,
+              resultText: reply.text,
               className: ctx.source === 'follow-up' ? 'tfds-followup-ai-pop' : '',
             },
           ]);
           setInputView('default');
+          scheduleScrollToLatest();
         }, 600);
         return;
       }
 
-      /* 3) 任务流：AI 推规划卡（待用户处理）；规划卡出现后输入框回 default 让用户操作卡片 */
-      if (reply.type === 'task') {
-        replyTimerRef.current = setTimeout(() => {
-          setMessages((prev) => [
-            ...prev,
-            {
-              id: nextId('plan'),
-              kind: 'ai-task-plan',
-              timestamp: nowHHmm(),
-              leadText: '我开始规划啦，请稍后...',
-              planConfirmed: false,
-            },
-          ]);
-          setInputView('default');
-        }, 600);
-        return;
-      }
-
-      /* 4) 短答：600ms 后追加 AI 短答 + 输入框回 default */
-      replyTimerRef.current = setTimeout(() => {
-        setMessages((prev) => [
-          ...prev,
-          {
-            id: nextId('a'),
-            kind: 'ai-text',
-            timestamp: nowHHmm(),
-            resultText: reply.text,
-            className: ctx.source === 'follow-up' ? 'tfds-followup-ai-pop' : '',
-          },
-        ]);
-        setInputView('default');
-      }, 600);
+      startAutoOrchestratedFlow(trimmed, reply, ctx);
     },
-    [phase, nextId],
+    [phase, nextId, clearFlowTimers, clearPendingFlowResume, scheduleScrollToLatest, startAutoOrchestratedFlow],
   );
 
   const handleFollowUpSend = useCallback(
@@ -598,6 +977,8 @@ export default function ChatConversationPattern({
       clearTimeout(busyTimerRef.current);
       busyTimerRef.current = null;
     }
+    clearFlowTimers();
+    clearPendingFlowResume();
     setInputView('default');
     setMessages((prev) => [
       ...prev,
@@ -608,15 +989,18 @@ export default function ChatConversationPattern({
         resultText: '已停止当前任务，需要时再叫我。',
       },
     ]);
-  }, [nextId]);
+  }, [nextId, clearFlowTimers, clearPendingFlowResume]);
 
   /* 新会话：清空消息 + 切欢迎屏 + 重置输入框状态 */
   const handleNewSessionFull = useCallback(() => {
     if (replyTimerRef.current) clearTimeout(replyTimerRef.current);
     if (busyTimerRef.current) clearTimeout(busyTimerRef.current);
+    clearFlowTimers();
+    clearPendingFlowResume();
+    conversationContextRef.current = { ...DEFAULT_CONVERSATION_CONTEXT };
     setInputView('default');
     handleNewSession();
-  }, [handleNewSession]);
+  }, [handleNewSession, clearFlowTimers, clearPendingFlowResume]);
 
   const lastIdx = messages.length - 1;
   const isNewConversationState = phase === 'welcome' || messages.length === 0;
@@ -649,11 +1033,16 @@ export default function ChatConversationPattern({
       ) : (
         <ChatPhase
           scrollRef={scrollRef}
+          latestAnchorRef={latestAnchorRef}
           messages={messages}
           lastIdx={lastIdx}
           handlers={{
             onPlanConfirm: handlePlanConfirm,
             onPlanCancel: handlePlanCancel,
+            onConfirmPrimary: handleConfirmPrimary,
+            onConfirmSecondary: handleConfirmSecondary,
+            onConfirmOptionChange: handleConfirmOptionChange,
+            onConfirmFormChange: handleConfirmFormChange,
             onFollowUpSelect: handleFollowUpSend,
           }}
           onSend={handleSend}
@@ -670,7 +1059,18 @@ export default function ChatConversationPattern({
 /* ============================================================
  * ChatPhase — 对话阶段：消息流 + 底部 ChatInput
  * ============================================================ */
-function ChatPhase({ scrollRef, messages, lastIdx, handlers, onSend, onStop, inputView, prefillText, prefillSeed }) {
+function ChatPhase({
+  scrollRef,
+  latestAnchorRef,
+  messages,
+  lastIdx,
+  handlers,
+  onSend,
+  onStop,
+  inputView,
+  prefillText,
+  prefillSeed,
+}) {
   /* 上下 40px 渐隐遮罩：让消息进入 / 离开滚动视口时柔和过渡，不硬切
    * 顶部渐隐仅在「可向上滚」时启用，回到第一条时取消，避免首条被遮淡 */
   const [atTop, setAtTop] = useState(true);
@@ -725,8 +1125,8 @@ function ChatPhase({ scrollRef, messages, lastIdx, handlers, onSend, onStop, inp
       >
         <div
           className="mx-auto flex w-full flex-col gap-2"
-          /* 底部 60px padding：避免最后一条消息贴住底部 ChatInput */
-          style={{ width: '800px', maxWidth: '100%', padding: '0 20px 60px' }}
+          /* 底部 80px padding：让最后一条会话卡片再上移 20px，避免被底部渐隐遮挡 */
+          style={{ width: '800px', maxWidth: '100%', padding: '0 20px 80px' }}
         >
           {messages.map((m, idx) => {
             const isLatest = idx === lastIdx;
@@ -737,6 +1137,7 @@ function ChatPhase({ scrollRef, messages, lastIdx, handlers, onSend, onStop, inp
             }
             return <ChatMessage key={m.id} {...props} />;
           })}
+          <div ref={latestAnchorRef} aria-hidden="true" style={{ height: '1px' }} />
         </div>
       </div>