minimal-agent 0.13.0 → 0.14.0

package/src/ui/ModelPicker.tsx

@@ -1,11 +1,33 @@
-import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
+import React, { useState } from 'react';
 
 import type { ModelConfig } from '../config/configFile.js';
+import type { OnlineModelAvailability } from '../team/onlineToolContract.js';
 import { theme } from './theme.js';
 
+export interface GatewayPickerModel {
+  id: string;
+  source: 'gateway';
+  apiFormat: 'openai' | 'anthropic';
+  displayName: string;
+  model: string;
+  contextWindow: number;
+  maxTokens: number;
+  supportsVision: boolean;
+  enabled: true;
+  isDefault?: boolean;
+  availability?: OnlineModelAvailability;
+}
+export type PickerModel =
+  | (ModelConfig & {
+      source?: 'local';
+      isDefault?: boolean;
+      availability?: never;
+    })
+  | GatewayPickerModel;
+
 interface ModelPickerProps {
-  models: ModelConfig[];
+  models: PickerModel[];
   currentModelId: string | null;
   title: string;
   /** null 选项标签（用于顾问模型"不使用"）；不传则不显示 null 选项 */
@@ -22,7 +44,9 @@ export function ModelPicker({
   onSelect,
   onCancel,
 }: ModelPickerProps): JSX.Element {
-  const enabledModels = models.filter((m) => m.enabled && m.apiKey);
+  const enabledModels = models.filter(
+    (m) => m.enabled && (m.source === 'gateway' || m.apiKey),
+  );
   const hasNullOption = Boolean(nullOptionLabel);
   const nullIndex = hasNullOption ? enabledModels.length : -1;
   const listLength = enabledModels.length + (hasNullOption ? 1 : 0);
@@ -34,7 +58,9 @@ export function ModelPicker({
     return 0;
   })();
 
-  const [idx, setIdx] = useState(Math.max(0, Math.min(initialIdx, listLength - 1)));
+  const [idx, setIdx] = useState(
+    Math.max(0, Math.min(initialIdx, listLength - 1)),
+  );
 
   useInput((input, key) => {
     if (key.escape || (key.ctrl && input === 'c')) {
@@ -54,7 +80,13 @@ export function ModelPicker({
         onSelect(null);
       } else {
         const target = enabledModels[idx];
-        if (target) onSelect(target.id);
+        if (
+          target &&
+          (target.source !== 'gateway' ||
+            !target.availability ||
+            target.availability.state === 'available')
+        )
+          onSelect(target.id);
       }
     }
   });
@@ -62,9 +94,13 @@ export function ModelPicker({
   return (
     <Box flexDirection="column" paddingX={1}>
       <Box marginBottom={1}>
-        <Text color={theme.user} bold>{title}</Text>
+        <Text color={theme.user} bold>
+          {title}
+        </Text>
       </Box>
-      <Text color={theme.subtle}>在已配置的模型中选择；选择后立即生效，后续请求使用新模型。</Text>
+      <Text color={theme.subtle}>
+        在已配置的模型中选择；选择后立即生效，后续请求使用新模型。
+      </Text>
       <Box flexDirection="column" marginTop={1}>
         {enabledModels.map((m, i) => {
           const active = i === idx;
@@ -72,10 +108,21 @@ export function ModelPicker({
           const displayName = m.displayName || m.model;
           return (
             <Box key={m.id} flexDirection="column">
+              {i > 0 && enabledModels[i - 1]?.source !== m.source ? (
+                <Text color={theme.subtle}>
+                  {' '}
+                  ── {m.source === 'gateway' ? '团队在线模型' : '本机模型'} ──
+                </Text>
+              ) : null}
               <Text color={active ? theme.user : undefined}>
                 {active ? '> ' : '  '}
                 {isCurrent ? '✓ ' : '  '}
-                <Text color={active ? theme.user : undefined} bold={isCurrent}>{displayName}</Text>
+                <Text color={active ? theme.user : undefined} bold={isCurrent}>
+                  {m.source === 'gateway' ? '🌐 ' : ''}
+                  {displayName}
+                  {m.isDefault ? ' · 默认' : ''}
+                  {m.availability?.reason ? ` · ${m.availability.reason}` : ''}
+                </Text>
                 {isCurrent ? <Text color={theme.subtle}> （当前）</Text> : null}
               </Text>
               <Text color={theme.subtle}>

package/src/ui/hooks/useChat.js

@@ -14,35 +14,37 @@
  *    用 version 计数器驱动 setState 触发 re-render 是更顺手的写法。
  * ============================================================
  */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { stat } from 'node:fs/promises';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { createAskCoordinator, setAskHandler, } from '../../askBridge.js';
 import { getWorkingDir, setWorkingDir } from '../../bootstrap/workingDir.js';
+import { createCliComputerRun, createComputerUseHostGate, } from '../../cli/computerUse.js';
 import { forceCompact } from '../../context/compact.js';
+import { acquireContextLock } from '../../context/contextLock.js';
 import { clearContext, loadContext, saveContext, } from '../../context/persistContext.js';
 import { resetReactiveCompactState } from '../../context/reactiveCompact.js';
-import { acquireContextLock } from '../../context/contextLock.js';
-import { workspaceIndexService } from '../../context/workspaceIndex.js';
-import { getActiveSession, setActiveSession, updateSessionMetadata, } from '../../context/sessionRegistry.js';
 import { resolveSessionFile, sessionFileFor, } from '../../context/sessionPath.js';
-import { buildBaseSystemPrompt, buildTransientPromptBundle } from '../../prompts/system.js';
+import { getActiveSession, listSessionSummaries, setActiveSession, updateSessionMetadata, } from '../../context/sessionRegistry.js';
+import { workspaceIndexService } from '../../context/workspaceIndex.js';
+import { HumanInterventionCoordinator, } from '../../humanIntervention.js';
 import { createPromptCacheContext } from '../../llm/promptCache.js';
+import { startTurnJournal, } from '../../memory/turnJournal.js';
+import { createInputQueue } from '../../messageQueue.js';
+import { runWithPlugins } from '../../plugins/pluginRunner.js';
+import { buildBaseSystemPrompt, buildTransientPromptBundle, } from '../../prompts/system.js';
+import { refreshStableSystemPrompt, upsertStableSystemMessage, } from '../../prompts/stableSystemPrompt.js';
 import { createAgentRuntimeContext, filterToolsForRuntime, memoryContextFromRuntime, } from '../../runtime/agentRuntimeContext.js';
-import { startTurnJournal } from '../../memory/turnJournal.js';
+import { getOrCreateSessionState, sessionStateKey, } from '../../session/sessionState.js';
+import { filterToolsForCategories } from '../../team/toolPolicy.js';
+import { runAdvisor } from '../../tools/advisor/advisor.js';
+import { classifyComputerAutomationIntent } from '../../tools/computeruse/computerIntent.js';
+import { computerUseService } from '../../tools/computeruse/computerUseService.js';
+import { createComputerInterventionAdapter } from '../../tools/computeruse/intervention.js';
 import { ALL_TOOLS, getToolByName } from '../../tools/index.js';
-import { createInputQueue } from '../../messageQueue.js';
-import { createAskCoordinator, setAskHandler, } from '../../askBridge.js';
-import { createAskSlot } from './askSlot.js';
-import { figures } from '../figures.js';
 import { clearFileState } from '../../tools/shared/fileState.js';
-import { getOrCreateSessionState, sessionStateKey } from '../../session/sessionState.js';
 import { hydrateSessionWorktree } from '../../tools/worktree/sessionWorktree.js';
-import { runAdvisor } from '../../tools/advisor/advisor.js';
-import { runWithPlugins } from '../../plugins/pluginRunner.js';
 import { dlog } from '../../utils/debugLog.js';
-import { createCliComputerRun, createComputerUseHostGate } from '../../cli/computerUse.js';
-import { computerUseService, } from '../../tools/computeruse/computerUseService.js';
-import { HumanInterventionCoordinator, } from '../../humanIntervention.js';
-import { createComputerInterventionAdapter } from '../../tools/computeruse/intervention.js';
+import { createAskSlot } from './askSlot.js';
 /**
  * reasoningPreview 环形 buffer 容量（字符）。
  * LiveArea 现在多行显示思维链尾部（最近 N 行），需要喂饱足够文本；
@@ -111,7 +113,8 @@ function useThrottledFlush({ delayMs, maxChars, flushEmpty, onFlush, }) {
     }, [delayMs, flush]);
     const append = useCallback((delta) => {
         bufferRef.current += delta;
-        if (typeof maxChars === 'number' && bufferRef.current.length >= maxChars) {
+        if (typeof maxChars === 'number' &&
+            bufferRef.current.length >= maxChars) {
             flush();
             return;
         }
@@ -131,18 +134,11 @@ export function useChat(args) {
     const [error, setError] = useState(null);
     const [transientError, setTransientError] = useState(null);
     const [interrupted, setInterrupted] = useState(false);
-    /**
-     * 暂态错误状态机的跨事件可变上下文（用 ref，不需要为它单独重渲染）。
-     *   - activeStepId：当前正在执行的 workflow step id（workflow_step_start 记下，
-     *     该 step 的 workflow_step_end 清除）；null = 不在任何 step 内。
-     *   - pendingLlmError：该 step 执行中捕获到的最近一次 llm_error 文案（暂存，
-     *     等 step 结束才决定丢弃 or 提升为永久红字）。
-     * handleEvent 通过 setters.workflowCtx 同步读写这个对象（pure 逻辑，测试可注入 stub）。
-     */
-    const workflowCtxRef = useRef({ activeStepId: null, pendingLlmError: null });
-    // 工作流步骤 id → 人话进度名（title）映射：start 记入、end/skipped 回查，
-    // 让 scrollback 三种进度行（▶/✓/⊘）都显示同一人话名而非 id。跨事件持 ref。
-    const stepTitlesRef = useRef(new Map());
+    // 注：这里曾有 workflowCtxRef（activeStepId / pendingLlmError）与 stepTitlesRef，
+    // 服务于 yaml DSL 的 workflow_step_* 事件。那些事件随引擎删除后没有任何发送方，
+    // 于是 activeStepId 恒为 null、两条依赖它的暂态错误分支永远走不到 —— 一并删掉。
+    // 代码编排引擎把 llm_error / max_turns 在 api.ts 内部消化（不外泄给顶层），
+    // 不需要宿主再做这层「暂态还是永久」的裁决。
     const [pluginProgress, setPluginProgress] = useState(null);
     // ---- 工作过程显示相关 state ----
     const [compactGeneration, setCompactGeneration] = useState(0);
@@ -196,7 +192,7 @@ export function useChat(args) {
     const [pendingAskQueueCount, setPendingAskQueueCount] = useState(0);
     const [askSlot] = useState(() => createAskSlot((questions, source) => {
         setPendingAsk(questions);
-        setPendingAskSource(questions ? source ?? null : null);
+        setPendingAskSource(questions ? (source ?? null) : null);
     }));
     const streamingFlush = useThrottledFlush({
         delayMs: STREAM_FLUSH_MS,
@@ -240,7 +236,6 @@ export function useChat(args) {
         setRunningToolsMap(new Map());
         // 暂态错误是"过程级"提示，turn 结束 / 切换时一并清掉，不残留到下一轮
         setTransientError(null);
-        workflowCtxRef.current = { activeStepId: null, pendingLlmError: null };
     }, []);
     /** turn 结束 / 中断 / 切换时一并取消所有节流 buffer 的 pending timer。 */
     const cancelAllThrottles = useCallback(() => {
@@ -323,19 +318,27 @@ export function useChat(args) {
      */
     const runManualAdvisor = useCallback(async (note) => {
         if (isLoading) {
-            return { ok: false, error: '当前有任务在执行；等它结束或按 ESC 中断后再咨询顾问。' };
+            return {
+                ok: false,
+                error: '当前有任务在执行；等它结束或按 ESC 中断后再咨询顾问。',
+            };
         }
         const callId = 'manual-advisor';
         const ac = new AbortController();
         abortRef.current = ac;
         setIsLoading(true);
         setProgressStage('tool_executing');
-        setRunningToolsMap(new Map([[callId, {
+        setRunningToolsMap(new Map([
+            [
+                callId,
+                {
                     toolName: 'Advisor',
                     argsPreview: note ?? '',
                     status: 'running',
                     argsFriendly: '正在咨询顾问模型',
-                }]]));
+                },
+            ],
+        ]));
         try {
             return await runAdvisor(note ? { note } : {}, ac.signal, {
                 history: historyRef.current,
@@ -347,7 +350,10 @@ export function useChat(args) {
                         const current = prev.get(callId);
                         if (!current)
                             return prev;
-                        return new Map(prev).set(callId, { ...current, progress: message });
+                        return new Map(prev).set(callId, {
+                            ...current,
+                            progress: message,
+                        });
                     });
                 },
             });
@@ -363,7 +369,9 @@ export function useChat(args) {
             // 用户看到「排队 1 条」却永远不执行，直到下次提交才错序跑掉。
             const queued = inputQueue.dequeue();
             if (queued)
-                queueMicrotask(() => { void submitRef.current?.(queued.value); });
+                queueMicrotask(() => {
+                    void submitRef.current?.(queued.value);
+                });
         }
     }, [isLoading, inputQueue]);
     const submit = useCallback(async (input) => {
@@ -373,7 +381,7 @@ export function useChat(args) {
         if (isLoading) {
             inputQueue.enqueue(trimmed, 'next');
             const running = Array.from(runningToolsRef.current.values());
-            const allCancelable = running.length > 0 && running.every(t => t.isCancelable);
+            const allCancelable = running.length > 0 && running.every((t) => t.isCancelable);
             if (allCancelable) {
                 abortRef.current?.abort('interrupt');
             }
@@ -391,8 +399,6 @@ export function useChat(args) {
         setProgressStage('idle');
         setReasoningPreview('');
         setRunningToolsMap(new Map());
-        // 重置暂态错误状态机（防上一轮工作流残留）
-        workflowCtxRef.current = { activeStepId: null, pendingLlmError: null };
         const ac = new AbortController();
         abortRef.current = ac;
         let releaseContextLock = null;
@@ -419,7 +425,9 @@ export function useChat(args) {
                 historyRef.current.length = 0;
                 historyRef.current.push(...latest, ...ephemeral);
             }
-            const workspace = await workspaceIndexService.findByPath(getWorkingDir()).catch(() => null);
+            const workspace = await workspaceIndexService
+                .findByPath(getWorkingDir())
+                .catch(() => null);
             const computerRun = computerUseMode !== 'disabled'
                 ? createCliComputerRun({
                     mode: computerUseMode,
@@ -444,15 +452,20 @@ export function useChat(args) {
                     },
                 })
                 : undefined;
-            const toolGate = computerRun ? createComputerUseHostGate(computerRun) : undefined;
+            const toolGate = computerRun
+                ? createComputerUseHostGate(computerRun)
+                : undefined;
             const turnSessionState = getOrCreateSessionState(sessionStateKey({
-                surface: 'tui', workspaceId: workspace?.id,
+                surface: 'tui',
+                workspaceId: workspace?.id,
                 cwd: workspace?.id ? undefined : getWorkingDir(),
                 sessionId: activeSessionIdRef.current,
             }));
             await hydrateSessionWorktree({
-                sessionState: turnSessionState, workspaceId: workspace?.id,
-                sessionId: activeSessionIdRef.current, cwd: getWorkingDir(),
+                sessionState: turnSessionState,
+                workspaceId: workspace?.id,
+                sessionId: activeSessionIdRef.current,
+                cwd: getWorkingDir(),
             });
             const effectiveCwd = turnSessionState.activeWorktree?.path ?? getWorkingDir();
             const runtimeContext = createAgentRuntimeContext({
@@ -465,18 +478,33 @@ export function useChat(args) {
                 memoryAccess: 'read-write',
                 interactiveAsk: true,
                 computer: computerRun,
+                computerIntent: classifyComputerAutomationIntent(trimmed, turnSessionState.computerAutomation),
                 computerIntervention,
                 toolGate,
             });
-            const turnTools = filterToolsForRuntime(ALL_TOOLS, runtimeContext);
+            const runtimeTools = filterToolsForRuntime(ALL_TOOLS, runtimeContext);
+            const sessionSummary = (await listSessionSummaries(getWorkingDir())).find((session) => session.id === activeSessionIdRef.current);
+            const currentProvider = providerRef.current;
+            const effectiveGatewayCategories = currentProvider.source === 'gateway'
+                ? [
+                    ...new Set((sessionSummary?.onlineToolCategories ??
+                        currentProvider.gatewayDefaultToolCategories ??
+                        currentProvider.gatewayMaxToolCategories ??
+                        []).filter((category) => currentProvider.gatewayMaxToolCategories?.includes(category) ?? true)),
+                ]
+                : undefined;
+            const turnProvider = currentProvider.source === 'gateway'
+                ? {
+                    ...currentProvider,
+                    gatewayToolCategories: effectiveGatewayCategories,
+                }
+                : currentProvider;
+            const turnTools = currentProvider.source === 'gateway'
+                ? filterToolsForCategories(runtimeTools, effectiveGatewayCategories)
+                : runtimeTools;
             const toolSignature = `${effectiveCwd}\0${turnTools.map((tool) => tool.name).join(',')}`;
             if (promptToolSignatureRef.current !== toolSignature) {
-                const stablePrompt = await buildBaseSystemPrompt(effectiveCwd, turnTools);
-                const rest = historyRef.current[0]?.role === 'system'
-                    ? historyRef.current.slice(1)
-                    : [...historyRef.current];
-                historyRef.current.length = 0;
-                historyRef.current.push({ role: 'system', content: stablePrompt }, ...rest);
+                await refreshStableSystemPrompt(historyRef.current, effectiveCwd, turnTools);
                 promptToolSignatureRef.current = toolSignature;
             }
             // 每回合只刷新易变层；稳定层仅在实际能力目录变化时重建。
@@ -502,11 +530,12 @@ export function useChat(args) {
                 userInput: trimmed,
             }).catch(() => null);
             for await (const ev of runWithPlugins(trimmed, {
-                provider: providerRef.current,
+                provider: turnProvider,
                 history: historyRef.current,
                 signal: ac.signal,
                 runtimeContext,
                 allowedTools: turnTools.map((tool) => tool.name),
+                availableTools: turnTools,
                 sessionState: turnSessionState,
                 parseInlineImages: true,
                 ...(turnTransient ? { transientBundle: turnTransient } : {}),
@@ -539,9 +568,6 @@ export function useChat(args) {
                     setContextUsage,
                     // 暂态错误（工作流步内 llm_error / 重试进度）→ LiveArea 黄字
                     setTransientError,
-                    workflowCtx: workflowCtxRef.current,
-                    // 步骤 id→人话名映射：scrollback 进度行三态（▶/✓/⊘）统一显示 title
-                    stepTitles: stepTitlesRef.current,
                     // 节流相关 —— buffer 累积 + 100ms timer flush
                     appendStreamingDelta: streamingFlush.append,
                     flushStreamingBuffer: streamingFlush.flush,
@@ -576,7 +602,9 @@ export function useChat(args) {
             activeComputerRunRef.current = null;
             runningToolsRef.current.clear();
             // 记账失败不影响落盘与解锁（它是附加能力，不是功能）。
-            await turnJournal?.finish(historyRef.current, turnJournalStart).catch(() => undefined);
+            await turnJournal
+                ?.finish(historyRef.current, turnJournalStart)
+                .catch(() => undefined);
             turnJournal = null;
             // v2 multi-session：持久化到当前 active session 文件。
             try {
@@ -598,7 +626,6 @@ export function useChat(args) {
     }, [
         bump,
         isLoading,
-        sessionFile,
         streamingFlush,
         cancelAllThrottles,
         reasoningFlush,
@@ -626,7 +653,9 @@ export function useChat(args) {
         if (!context)
             return '已撤销后续回合授权；当前没有正在运行的 Computer Use。';
         computerInterventions.abort(context);
-        const response = await computerUseService.request(context, { action: 'stop' });
+        const response = await computerUseService.request(context, {
+            action: 'stop',
+        });
         return response.ok
             ? '已停止当前回合的 Computer Use，并撤销后续回合授权。'
             : `已撤销后续回合授权；原生停止失败：${response.error?.message ?? '未知错误'}`;
@@ -713,7 +742,9 @@ export function useChat(args) {
         // 清空磁盘上的持久化文件（防止下次启动又加载损坏数据）
         await clearContext();
         // 清空 pre-read guard 状态表（防止跨 session 的 Read 记录污染新会话）
-        const workspace = await workspaceIndexService.findByPath(getWorkingDir()).catch(() => null);
+        const workspace = await workspaceIndexService
+            .findByPath(getWorkingDir())
+            .catch(() => null);
         clearFileState(getOrCreateSessionState(sessionStateKey({
             surface: 'tui',
             workspaceId: workspace?.id,
@@ -740,7 +771,9 @@ export function useChat(args) {
         let success = false;
         try {
             const cwd = getWorkingDir();
-            const workspace = await workspaceIndexService.findByPath(cwd).catch(() => null);
+            const workspace = await workspaceIndexService
+                .findByPath(cwd)
+                .catch(() => null);
             const r = await forceCompact(historyRef.current, args.provider, undefined, undefined, createPromptCacheContext(`workspace:${workspace?.id ?? cwd}:session:${activeSessionIdRef.current}`));
             historyRef.current.length = 0;
             historyRef.current.push(...r.messages);
@@ -892,12 +925,12 @@ export function useChat(args) {
         activeSessionIdRef.current = targetSessionId;
         setActiveSessionId(targetSessionId);
         historyRef.current.length = 0;
-        historyRef.current.push({ role: 'system', content: systemPrompt });
+        historyRef.current.push(...(loaded ?? []));
+        upsertStableSystemMessage(historyRef.current, systemPrompt);
         promptToolSignatureRef.current = '';
-        if (loaded?.length) {
-            historyRef.current.push(...(loaded[0]?.role === 'system' ? loaded.slice(1) : loaded));
-        }
-        const targetWorkspace = await workspaceIndexService.findByPath(targetCwd).catch(() => null);
+        const targetWorkspace = await workspaceIndexService
+            .findByPath(targetCwd)
+            .catch(() => null);
         clearFileState(getOrCreateSessionState(sessionStateKey({
             surface: 'tui',
             workspaceId: targetWorkspace?.id,
@@ -919,6 +952,9 @@ export function useChat(args) {
     // 返回同一引用，Ink <Static items={history}> 浅比较看不到 prop 变化 → 不 commit
     // 新增 message → turn 结束 LiveArea 消失后屏幕空白，看起来像"输出被吃掉"。
     // slice 后元素引用不变，只是数组容器是新的，足够让 Static 检测到 length 增长并 commit。
+    // version is an explicit invalidation counter; the callback intentionally
+    // reads the ref-backed history rather than the counter itself.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: version intentionally invalidates the ref-backed history snapshot
     const history = useMemo(() => historyRef.current.slice(), [version]);
     return {
         history,
@@ -960,79 +996,12 @@ export function useChat(args) {
     };
 }
 export function handleEvent(ev, setters) {
-    // ---- 工作流进度事件（WorkflowEvent，不在 LoopEvent union 里）----
-    // 渲染成持久的暗色行落进 scrollback：跑到哪一步、成功/失败/跳过都看得见，
-    // 且出错后仍停留在屏幕上 —— 解决"工作流执行过程不可见、不知道停在哪"。
-    const wf = ev;
-    // 据 id 回查人话进度名：声明了 title 的步走 title，否则回落 id（end/skipped 用）。
-    const titleOrId = (id) => (id && setters.stepTitles?.get(id)) || id || '?';
-    switch (wf.type) {
-        case 'workflow_start':
-            setters.emitProgressLine?.(`${figures.step} 工作流 ${wf.name} 开始（共 ${wf.totalSteps} 步）`);
-            // 新工作流开始：清空上一条工作流残留的 title 映射，避免同名步串味。
-            setters.stepTitles?.clear();
-            // 工作流开始：立即刷新 token（可能已积累大量前置对话上下文）
-            setters.bump();
-            return;
-        case 'workflow_step_start':
-            // 声明了 title 的步显示人话名（与状态行一致、不显示块内相对序号——嵌套块
-            // 的 i/total 拼在一起会被误读成"跳步"）；未声明 title 的步保持 legacy 格式。
-            // ⎿ 前缀：step 行挂在「▶ 工作流 x 开始」下的层次连接符（figures.elbow 语汇，
-            // 与工具结果/蜂群树统一）。ephemeral 是尾部追加消息，不触任何既有前缀字节。
-            if (wf.title) {
-                if (wf.id)
-                    setters.stepTitles?.set(wf.id, wf.title);
-                setters.emitProgressLine?.(`  ${figures.elbow} ${figures.step} ${wf.title}`);
-            }
-            else {
-                setters.emitProgressLine?.(`  ${figures.elbow} ${figures.step} ${(wf.index ?? 0) + 1}/${wf.total ?? '?'} ${wf.id} (${wf.kind})`);
-            }
-            // 暂态错误状态机：记下当前正在执行的 step id，进入"该步内的 llm_error 暂态化"窗口。
-            // 进新步先清掉上一步可能残留的暂态错误（上一步已 end、不应跨步显示）。
-            if (setters.workflowCtx) {
-                setters.workflowCtx.activeStepId = wf.id ?? null;
-                setters.workflowCtx.pendingLlmError = null;
-            }
-            setters.setTransientError?.(null);
-            return;
-        case 'workflow_step_end':
-            setters.emitProgressLine?.(`  ${figures.elbow} ${wf.ok ? figures.ok : figures.fail} ${titleOrId(wf.id)}${wf.error ? `：${wf.error}` : ''}`);
-            // 暂态错误裁决（仅当 end 的是当前活跃步）：
-            //   ok:true  → 重试/恢复成功 → 丢弃 pending llm_error，短暂显示"已恢复"后随刷新消失。
-            //   ok:false → 该步彻底失败 → 把暂态错误提升为永久红字（chat.error，进 scrollback 上方）。
-            if (setters.workflowCtx && setters.workflowCtx.activeStepId === wf.id) {
-                const pending = setters.workflowCtx.pendingLlmError;
-                if (wf.ok) {
-                    if (pending) {
-                        // 成功收回：留一条灰底"已恢复"提示，下一次状态行刷新自然覆盖消失
-                        setters.setTransientError?.(`${figures.ok} ${wf.id} 已恢复（此前 LLM 调用失败已重试成功）`);
-                    }
-                    else {
-                        setters.setTransientError?.(null);
-                    }
-                }
-                else {
-                    // 彻底失败：暂态升永久红字。优先用 step.error，回落到 pending llm_error。
-                    const finalMsg = wf.error ?? pending;
-                    if (finalMsg)
-                        setters.setError(finalMsg);
-                    setters.setTransientError?.(null);
-                }
-                setters.workflowCtx.activeStepId = null;
-                setters.workflowCtx.pendingLlmError = null;
-            }
-            // 步骤完成：强制刷新 token（agent/llm 步骤可能写入大量上下文）
-            setters.bump();
-            return;
-        case 'workflow_step_skipped':
-            setters.emitProgressLine?.(`  ${figures.elbow} ${figures.skip} ${titleOrId(wf.id)}：${wf.reason ?? ''}`);
-            return;
-        case 'workflow_done':
-            setters.emitProgressLine?.(`${figures.ok} 工作流 ${wf.name} 完成`);
-            // 工作流结束：最终刷新（反映完整执行后的上下文量）
-            setters.bump();
-            return;
-    }
+    // ⚠️ 这里曾有一整块 `workflow_start` / `workflow_step_start` / `workflow_step_end` /
+    // `workflow_step_skipped` / `workflow_done` 的渲染逻辑（外加一个 activeStepId
+    // 状态机）。那是 yaml DSL 引擎的事件，随引擎一起删除后**一个发送方都不剩**，
+    // 只有测试自己合成它们 —— 纯死代码。
+    //
+    // V2 工作流发结构化 `workflow_progress`；旧插件仍可发 `plugin_progress`。
     // 收口到 LoopEvent：未识别的 PluginEvent type 走 default no-op
     const e = ev;
     switch (e.type) {
@@ -1060,6 +1029,13 @@ export function handleEvent(ev, setters) {
             setters.setRunningToolsMap(() => new Map());
             setters.bump();
             break;
+        case 'assistant_draft_discarded':
+            setters.flushStreamingBuffer();
+            setters.setStreamingText(() => '');
+            setters.cancelReasoningFlush();
+            setters.setReasoningPreview(() => '');
+            setters.setProgressStage('thinking');
+            break;
         case 'tool_start':
             // 把工具加入运行集合；并行多个工具时这里会累积。
             // v2: argsFriendly 是 loop.ts 通过 LoopEvent 扩展字段传过来的人话描述
@@ -1085,7 +1061,11 @@ export function handleEvent(ev, setters) {
                 if (!current)
                     return prev;
                 const next = new Map(prev);
-                next.set(e.toolCallId, { ...current, progress: e.message, progressDetail: e.detail });
+                next.set(e.toolCallId, {
+                    ...current,
+                    progress: e.message,
+                    progressDetail: e.detail,
+                });
                 return next;
             });
             setters.scheduleToolBump();
@@ -1145,29 +1125,12 @@ export function handleEvent(ev, setters) {
                 setters.bump();
                 break;
             }
-            // 工作流步执行中的 max_turns 是可恢复截断信号：runner 会在共享 history 上续跑。
-            // 这里不要落入永久红字错误区；顶层非工作流 max_turns 仍保持原有错误展示。
-            if (code === 'max_turns' &&
-                setters.workflowCtx &&
-                setters.workflowCtx.activeStepId !== null &&
-                setters.setTransientError) {
-                setters.setTransientError('↻ 当前步骤达到轮数预算，正在续跑…');
-                setters.bump();
-                break;
-            }
-            // 工作流步执行中的 llm_error：暂态而非永久红字 ——
-            // 该步通常会被重试，这里只暂存 + 喂 LiveArea 黄字，等 step_end 裁决去留。
-            // 非工作流场景（无活跃 step，或缺 setTransientError 降级）走原有永久红字路径。
-            if (code === 'llm_error' &&
-                setters.workflowCtx &&
-                setters.workflowCtx.activeStepId !== null &&
-                setters.setTransientError) {
-                setters.workflowCtx.pendingLlmError = e.error;
-                setters.setTransientError(`⚠ LLM 调用失败（重试中）：${e.error}`);
-                setters.bump();
-                break;
-            }
-            // 其余：顶层 halt（无 code）、非工作流 llm_error、aborted 等 → 永久红字。
+            // 注：这里曾有两条「工作流步内的 max_turns / llm_error 降级成暂态黄字」分支，
+            // 都以 `workflowCtx.activeStepId !== null` 为前提。那个 id 由 yaml DSL 的
+            // workflow_step_start 事件写入，事件删除后恒为 null，两条分支永远走不到。
+            // 代码编排引擎把这两种错误在 `api.ts` 内部就地消化（`continue`，不外泄给顶层），
+            // 顶层根本收不到 —— 所以不是「少了个降级」，而是这层判断已无对象。
+            // 其余：顶层 halt（无 code）、llm_error、aborted 等 → 永久红字。
             setters.setError(e.error);
             setters.bump();
             break;
@@ -1192,6 +1155,14 @@ export function handleEvent(ev, setters) {
                 max: e.max,
                 message: e.message,
             });
+            // 同时落一行进 scrollback。状态行是**覆盖刷新**的：一条二十步的工作流跑完，
+            // 状态行只剩最后一步，前面十九步去哪了、在哪一步失败的全查不到 —— 而排障
+            // 恰恰总发生在跑完之后。legacy 靠 workflow_step_* 事件做这件事，那套事件随
+            // yaml 引擎删了，这里由 plugin_progress 承担同一职责。
+            // 走 ephemeral 行：只进展示，不进 history、不被 saveContext 持久化。
+            if (typeof e.message === 'string' && e.message.length > 0) {
+                setters.emitProgressLine?.(e.message);
+            }
             // 重试进度也镜像到暂态行（覆盖刷新）：runner 在重试时发 "↻ 重试 x N/M…"。
             // 与 warning 分支互为补充（plugin_progress 文案更短，适合状态行下方一行）。
             if (setters.setTransientError &&
@@ -1201,6 +1172,24 @@ export function handleEvent(ev, setters) {
             }
             setters.bump();
             break;
+        case 'workflow_progress': {
+            const indent = '  '.repeat(e.depth ?? 0);
+            const count = e.current !== undefined && e.total !== undefined
+                ? `${e.current}/${e.total} `
+                : '';
+            const message = `${indent}${count}${e.message ?? e.phase}`;
+            setters.setPluginProgress({
+                pluginId: e.workflow,
+                current: e.current,
+                max: e.total,
+                message,
+            });
+            setters.emitProgressLine?.(message);
+            if (e.status === 'warning')
+                setters.setTransientError?.(message);
+            setters.bump();
+            break;
+        }
         case 'reasoning':
             // reasoning delta 频率跟 text delta 一样高（60+/秒），不节流的话每个 delta 立即
             // setReasoningPreview → LiveArea rerender → Ink 重绘扛不住。