minimal-agent 0.7.1 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimal-agent",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "description": "最小化 Agent 系统 —— 10 工具 + 插件系统 + workflow DSL + 自动压缩 + OpenAI 兼容 + Ink TUI；NodeNext + tsc 原地编译，dev 用 Bun .ts、install 用 Node .js（学习/教学用）",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Bill Wang <leiwang0359@gmail.com>",

package/plugins/ralph-wiggum/plugin.js

@@ -22,8 +22,8 @@
 import { fileURLToPath } from 'node:url';
 import { dirname } from 'node:path';
 import { runQuery, getWorkingDir, } from '../../src/plugin-sdk.js';
+import { parseVerifyArgs, runVerification } from '../../src/infra/verification.js';
 import { GoalState, Phase } from './src/goalState.js';
-import { parseVerifyArgs, runVerification } from './src/verificationGate.js';
 import { makeCompletionMatcher, hasNeedReplanSentinel, hasNeedGoalRevisionSentinel, extractLearnings, } from './src/sentinels.js';
 import { executeStopHook } from './src/stopHookRunner.js';
 const PLUGIN_NAME = 'ralph-wiggum';

package/plugins/workflow-runner/plugin.js

@@ -12,6 +12,7 @@
  *  缓存这次 import，所以 cold start 后 dynamic import 只跑一次。
  * ============================================================
  */
+import { ALL_TOOLS, getWorkingDir } from '../../src/plugin-sdk.js';
 import { runWorkflowFromCommand, runWorkflowsList } from './src/index.js';
 const api = {
     async *runCommand(commandName, args, ctx) {
@@ -24,6 +25,8 @@ const api = {
                 provider: ctx.provider,
                 history: ctx.history,
                 signal: ctx.signal,
+                cwd: getWorkingDir(),
+                tools: ALL_TOOLS,
             });
             return;
         }

package/plugins/workflow-runner/src/agentCommon.js

@@ -7,14 +7,18 @@
  *    - agent: 节点（stepExecutors/agent.ts）—— 作者显式声明的开放任务
  *  二者本质同构：受工作流目标/上下文指导、用工具随机应变、产出经验证后回灌 capture。
  *  为避免「同一个脑子写两份提示词、行为漂移」，这里收敛它们的**共享件**：
- *    1. 统一系统提示词纪律（DISCIPLINE）—— 诊断→动手→自我验证→诚实失败(不伪造)→输出纪律；
- *       两处只在前面各加一句**角色开场白**（recover=救火 / agent=自主完成一步）。
+ *    1. 统一系统提示词基础内核（来自 promptAssembly.ts）—— 含工具/skill/plugin 完整列表；
+ *       两处只在前面各加一句**角色开场白**（recover=救火 / agent=自主完成一步），
+ *       后面追加共享纪律块。
  *    2. 统一验证闸门（interpretMiniReActResult）—— miniReAct 跑完后，判定「真交付」还是
  *       「放弃/不可信」，**永不把没验证过的产出当成功**。这是 Phase 2 验证闸门的提取。
  * ============================================================
  */
+import { assembleBasePrompt } from '../../../src/prompts/promptAssembly.js';
 /** agent 显式放弃的唯一标记；与 DISCIPLINE 收尾约束严格对应。recover 与 agent 节点共用。 */
 export const GIVEUP_MARKER = '__AGENT_GIVEUP__';
+/** agent 步骤的角色开场白（与 recovery 的 RECOVER_OPENING 对称） */
+export const AGENT_OPENING = '你是一名资深工程师，被一个确定性工作流临时调来「自主完成一步开放任务」。';
 /** 共享纪律块：所有 workflow 内 agent 的通用行为约束（角色开场白由各调用方拼在前面）。 */
 const DISCIPLINE = `按这个纪律干活：
 1. 先想清楚「这一步要产出什么」，必要时用只读工具（Read / Grep / Glob）做最小探查，别凭空猜、别凭空编。
@@ -29,9 +33,22 @@ const DISCIPLINE = `按这个纪律干活：
 收尾（二选一，硬约束）：
 - 真的达成了 → 最终消息**只输出这一步要的结果本身**，不要寒暄、不要复述要求、不要解释推理过程。若要求结构化输出，严格按 JSON Schema、**不要**用 markdown 代码块包裹。
 - 确实做不成 → 最终消息**只输出一行**：\`${GIVEUP_MARKER}: <一句话说明为什么>\`，让工作流诚实地停下。绝不要为了「交差」而编一个假结果。`;
-/** 拼一个 workflow agent 的 system prompt：角色开场白 + 共享纪律。 */
-export function buildWorkflowAgentSystem(opening) {
-    return `${opening}\n\n${DISCIPLINE}`;
+/**
+ * 拼一个 workflow agent 的完整 system prompt：
+ *
+ *   角色开场白 + 基础内核（含 skill/plugin/工具完整列表） + 共享纪律
+ *
+ * 基础内核来自 assembleBasePrompt()，确保 workflow agent 与 TUI 普通对话
+ * 看到完全相同的 skill 列表和插件信息。
+ */
+export async function buildWorkflowAgentSystem(cwd, opening, tools) {
+    const baseKernel = await assembleBasePrompt({
+        cwd,
+        tools,
+        includeProjectInstructions: false, // workflow 子步骤不需要项目指令
+        includePlugins: true, // 插件列表对 agent 也有参考价值
+    });
+    return `${opening}\n\n${baseKernel}\n\n${DISCIPLINE}`;
 }
 /** 把 step.capture 翻成「下游会把你的结果存成哪些变量」，让 agent 产出对得上形状。 */
 export function describeCaptureContract(step) {

package/plugins/workflow-runner/src/index.js

@@ -188,6 +188,8 @@ export async function* runWorkflowFromCommand(rawArgs, opts) {
         provider: opts.provider,
         signal: opts.signal,
         history: opts.history,
+        cwd: opts.cwd ?? process.cwd(),
+        tools: opts.tools ?? [],
     };
     // 透传 runWorkflow 的事件，并观察是否出现终结事件（error / interrupted = 失败或中断，
     // 与 gateway broker 的 TERMINAL 判定同一套逻辑）。成功（没见到终结事件）则在末尾补一条

package/plugins/workflow-runner/src/loader.js

@@ -130,6 +130,7 @@ function validate(obj, file) {
 // editor 因 D2 红线禁止 import 后端、手抄了同一份；后端在此演进时该测试会红，提示同步 editor。
 export const CONTROL_FLOW_TYPES = new Set([
     'assert',
+    'verify',
     'branch',
     'loop',
     'pause',
@@ -138,6 +139,7 @@ export const CONTROL_FLOW_TYPES = new Set([
 ]);
 export const VALID_STEP_TYPES = new Set([
     'assert',
+    'verify',
     'branch',
     'loop',
     'pause',
@@ -207,6 +209,16 @@ function validateSteps(steps, file, pathPrefix) {
         if (s.type === 'assert' && s.condition === undefined) {
             throw new WorkflowLoadError(`${p} type=assert 必须带 'condition'`, file);
         }
+        if (s.type === 'verify') {
+            if (!Array.isArray(s.checks) || s.checks.length === 0) {
+                throw new WorkflowLoadError(`${p} type=verify 必须带非空 'checks' 数组`, file);
+            }
+            for (const [ci, c] of s.checks.entries()) {
+                if (typeof c !== 'string' || !c.includes(':')) {
+                    throw new WorkflowLoadError(`${p}.checks[${ci}] 格式错误，应为 "type:value"（如 "file_exists:./x"）`, file);
+                }
+            }
+        }
         if (s.type === 'branch') {
             if (s.then !== undefined && !Array.isArray(s.then)) {
                 throw new WorkflowLoadError(`${p}.then 必须是数组`, file);

package/plugins/workflow-runner/src/recovery.js

@@ -29,9 +29,9 @@ import { ALL_TOOLS } from '../../../src/plugin-sdk.js';
 import { buildWorkflowAgentSystem, describeCaptureContract, interpretMiniReActResult, truncate, } from './agentCommon.js';
 import { interpolate, interpolateDeep } from './expressions.js';
 import { runMiniReAct } from './miniReAct.js';
+// RECOVERY_SYSTEM 现在是 async（需要扫描 skill/plugin），在 runRecovery 内部构建
 const RECOVER_OPENING = `你是一名资深的自动化工程师 / SRE，被一个确定性工作流临时调来「救火」。
 工作流里一个原本写死的步骤刚刚执行失败了，现在交给你随机应变——先看错误信息诊断根因，再想办法真正达成这个步骤**本来要的结果**（关注它要的结果，别拘泥它原先怎么写）。`;
-const RECOVERY_SYSTEM = buildWorkflowAgentSystem(RECOVER_OPENING);
 /** 描述失败节点「本来要干什么」，喂给恢复 agent 作为意图说明。 */
 function describeStepIntent(step, vars) {
     if (step.tool) {
@@ -78,8 +78,10 @@ export async function* runRecovery(step, vars, ctx, errorMsg) {
     const tools = allowed && allowed.length > 0
         ? ALL_TOOLS.filter((t) => allowed.includes(t.name))
         : ALL_TOOLS;
+    // ✅ Phase 2: 异步构建完整 system prompt（含 skill/plugin 列表）
+    const systemContent = await buildWorkflowAgentSystem(ctx.cwd, RECOVER_OPENING, tools);
     const messages = [
-        { role: 'system', content: RECOVERY_SYSTEM },
+        { role: 'system', content: systemContent },
         { role: 'user', content: userMsg },
     ];
     try {

package/plugins/workflow-runner/src/runner.js

@@ -27,6 +27,7 @@ import { evalExpr, interpolate } from './expressions.js';
 import { runRecovery } from './recovery.js';
 import { execAgentStep } from './stepExecutors/agent.js';
 import { execAssertStep } from './stepExecutors/assert.js';
+import { execVerifyStep } from './stepExecutors/verify.js';
 import { execLlmStep } from './stepExecutors/llm.js';
 import { execSkillStep } from './stepExecutors/skill.js';
 import { execToolStep } from './stepExecutors/tool.js';
@@ -78,6 +79,8 @@ function bindCapture(captureMap, result, vars) {
 async function* dispatchActionStep(step, vars, ctx) {
     if (step.type === 'assert')
         return execAssertStep(step, vars);
+    if (step.type === 'verify')
+        return await execVerifyStep(step, vars);
     if (step.tool)
         return yield* execToolStep(step, vars, ctx);
     if (step.agent)
@@ -86,7 +89,7 @@ async function* dispatchActionStep(step, vars, ctx) {
         return yield* execLlmStep(step, vars, ctx);
     if (step.skill)
         return yield* execSkillStep(step, vars, ctx);
-    throw new Error(`step ${step.id}: 无可执行字段（tool/agent/llm/skill/assert）`);
+    throw new Error(`step ${step.id}: 无可执行字段（tool/agent/llm/skill/assert/verify）`);
 }
 /**
  * 递归执行 steps[]。返回 true 表示该 block 已 halt（上游应中止）。
@@ -527,14 +530,41 @@ export async function* runWorkflow(def, inputs, ctx) {
         };
         yield { type: 'workflow_done', name: def.name, vars: vars.snapshot() };
         succeeded = true;
+        // ---- 层1：写入摘要到对话历史（让后续对话记住这次 workflow 做了什么）----
+        const snapshot = vars.snapshot();
+        const summaryText = typeof snapshot.summary_text === 'string'
+            ? snapshot.summary_text
+            : '';
+        // 收集关键产出物（从 vars 中提取文件路径）
+        const artifacts = [];
+        if (typeof snapshot.plan_text === 'string')
+            artifacts.push('./PLAN.md');
+        // 检查是否有执行结果（execute_plan 步的产出）
+        if (typeof snapshot.execution_result === 'string') {
+            // 尝试从执行结果中提取文件路径（常见模式：产出物路径）
+            const fileMatches = snapshot.execution_result.match(/`[^`]*\.(pptx|docx|pdf|xlsx|md|ts|js|py)[^`]*`/g);
+            if (fileMatches)
+                artifacts.push(...fileMatches.map((f) => f.replace(/`/g, '')));
+        }
+        const summaryLines = [
+            `**工作流「${def.name}」执行完成**`,
+            ``,
+            `- 步骤: ${def.steps.length}/${def.steps.length} 全部完成`,
+            ...(artifacts.length > 0 ? [`- 产出物: ${artifacts.join(', ')}`] : []),
+            ...(summaryText ? [`- 摘要: ${summaryText}`] : []),
+        ];
+        yield {
+            type: 'assistant_message',
+            message: {
+                role: 'assistant',
+                content: summaryLines.join('\n'),
+            },
+        };
     }
     finally {
-        // 只在「干净跑完」时清现场；halt / 中断 / 抛错都**保留** .minimal-agent-workflow/
-        // （current.json / inputs.json / vars.json / progress.md，含失败那步的 ✗ 行）供事后排查
-        // ——这正是这些文件的设计目的（workflowState.ts 头注）；失败时删掉等于自废武功。
-        // 残留不会永久堆积：下次同名 workflow 的 init() 会先 rm，/new 也按 .minimal-agent-* 前缀统一清。
+        // 成功时归档（保留 vars.json/progress.md 供后续回溯）；失败/中断时保留原状供排查
         if (succeeded)
-            await state.cleanup();
+            await state.archive();
     }
 }
 /**

package/plugins/workflow-runner/src/stepExecutors/agent.js

@@ -1,72 +1,55 @@
 /**
  * ============================================================
- *  plugins/workflow-runner/src/stepExecutors/agent.ts —— agent step 执行
+ *  plugins/workflow-runner/src/stepExecutors/agent.ts —— agent 步骤执行器
  * ------------------------------------------------------------
- *  「受工作流指导的 TAOR」一等公民。作者在 yaml 里 inline 描述一步开放任务
- *  （agent: "..."），本执行器起一个**有界 TAOR agent**（miniReAct）随机应变完成：
- *  思考 → 用工具 → 观察 → 反思 → 再来，直到把这一步要的结果做出来。
+ *  执行 workflow 中 type: agent 的步骤：启动一个 miniReAct 子循环，
+ *  用工具随机应变地完成开放性任务。
  *
- *  与 skill: 节点的分工：
- *    - skill: 跑一个**外部 SKILL.md 定义的、可复用的**完整 agent（runQuery，maxTurns 50，流式）
- *    - agent: 跑一个**inline 描述的、一次性的**有界 agent（miniReAct，白名单工具 + output_schema
- *             + 验证闸门），轻、收敛快、产出受验证
- *
- *  与 onError:'recover' 共享 agentCommon 的系统提示词纪律与验证闸门——同一个脑子。
- *
- *  失败语义：agent 放弃 / 空产出 → interpretMiniReActResult 判 ok:false → 本执行器 throw，
- *  走 dispatchActionStep 的正常失败路径，由 step.onError 接管（halt/continue/recover）。
- *  —— 与其它动作 step 完全一致：agent 节点自己也能声明 onError:'recover' 被再救一次。
- *
- *  流式：execAgentStep 是 AsyncGenerator，`yield* runMiniReAct(...)` 把子 agent 的
- *  text / reasoning / tool_start / tool_end 事件透传到 runWorkflow → UI，内层思考实时可见。
+ *  与 llm 步骤的区别：
+ *    - agent 有工具白名单（allowed_tools 过滤），可以 Read/Write/Grep/...
+ *    - agent 跑多轮 miniReAct（maxTurns 上限），llm 只跑单轮 chat
+ *    - agent 的产出经过验证闸门（interpretMiniReActResult），llm 直接透传
  * ============================================================
  */
-import { ALL_TOOLS } from '../../../../src/plugin-sdk.js';
-import { buildWorkflowAgentSystem, describeCaptureContract, interpretMiniReActResult, } from '../agentCommon.js';
 import { interpolate } from '../expressions.js';
 import { runMiniReAct } from '../miniReAct.js';
-const AGENT_OPENING = `你是一名资深工程师。一个工作流把其中**一步开放任务**交给你自主完成。
-你受工作流的总目标与已知上下文指导，但具体怎么做由你用工具随机应变决定——把这一步要的结果真正做出来。`;
-const AGENT_NODE_SYSTEM = buildWorkflowAgentSystem(AGENT_OPENING);
+import { AGENT_OPENING, buildWorkflowAgentSystem, describeCaptureContract, interpretMiniReActResult, } from '../agentCommon.js';
+/**
+ * 执行一个 agent 步骤。
+ *
+ * 关键变化（Phase 2 重构）：
+ *   buildWorkflowAgentSystem 现在是 async（因为需要扫描 skill/plugin 目录），
+ *   agent 步骤的 system prompt 现在包含完整的：
+ *     - 工具列表 + 使用规范
+ *     - Skill 列表（含触发词）
+ *     - Plugin 列表（含命令和描述）
+ *   这解决了之前 workflow 模式下模型不知道有 pptx/pdf 等 skill 的问题。
+ */
 export async function* execAgentStep(step, vars, ctx) {
-    if (typeof step.agent !== 'string') {
-        throw new Error(`step ${step.id}: 缺少 agent 字段`);
-    }
-    const task = interpolate(step.agent, vars);
-    const goalLine = ctx.goal ? `工作流总目标：${ctx.goal}\n\n` : '';
-    const captureLine = describeCaptureContract(step);
-    // 可选 context_files：列出 path + hint，让 agent 用 Read 按需取（不 inline 内容）。
-    let filesLine = '';
-    if (step.context_files && step.context_files.length > 0) {
-        const list = step.context_files
-            .map((f) => `- ${interpolate(f.path, vars)}${f.hint ? ` — ${f.hint}` : ''}`)
-            .join('\n');
-        filesLine = `\n\n以下文件可用，按需用 Read 读取：\n${list}`;
-    }
-    const userMsg = `${goalLine}` +
-        `你这一步要完成的任务：\n${task}` +
-        `${filesLine}${captureLine}\n\n` +
-        `请用工具把它做出来；确实做不成就按约定输出放弃标记。`;
-    // 工具集：默认全量 ALL_TOOLS（真 agency）；step.allowed_tools 收窄。
-    const allowed = step.allowed_tools;
-    const tools = allowed && allowed.length > 0
-        ? ALL_TOOLS.filter((t) => allowed.includes(t.name))
-        : ALL_TOOLS;
+    // 工具白名单：allowed_tools 声明时按白名单过滤；未声明时默认全量（不限制）
+    const allTools = ctx.tools ?? [];
+    const tools = step.allowed_tools
+        ? allTools.filter((t) => step.allowed_tools.includes(t.name))
+        : allTools;
+    // ✅ Phase 2: 异步构建完整 system prompt（含 skill/plugin 列表）
+    const systemContent = await buildWorkflowAgentSystem(ctx.cwd, // 新增：传入 cwd 用于 skill/plugin 扫描
+    AGENT_OPENING, tools);
+    const userMsg = interpolate(step.agent ?? '', vars) +
+        describeCaptureContract(step) +
+        (step.input ? `\n\n上下文变量：${interpolate(step.input, vars)}` : '');
+    const messages = [
+        { role: 'system', content: systemContent },
+        { role: 'user', content: userMsg },
+    ];
     const result = yield* runMiniReAct({
-        messages: [
-            { role: 'system', content: AGENT_NODE_SYSTEM },
-            { role: 'user', content: userMsg },
-        ],
+        messages,
         tools,
-        output_schema: step.output_schema,
+        maxTurns: step.maxTurns ?? 12,
         provider: ctx.provider,
         signal: ctx.signal,
-        maxTurns: step.maxTurns ?? 12,
     });
-    const outcome = interpretMiniReActResult(result, step.output_schema !== undefined);
-    if (!outcome.ok) {
-        // 放弃 / 空产出 → 抛错，交给 dispatchActionStep 的失败路径 + step.onError 处置。
-        throw new Error(`agent 未完成任务：${outcome.reason}`);
-    }
+    const outcome = interpretMiniReActResult(result, !!step.output_schema);
+    if (!outcome.ok)
+        throw new Error(`agent 步骤放弃: ${outcome.reason}`);
     return outcome.value;
 }

package/plugins/workflow-runner/src/stepExecutors/llm.js

@@ -9,6 +9,11 @@
  *      消除 TUI"无声"），最终仍 return StepResult；schema 模式静默累积 JSON 不回显。
  *      reasoning 字段在这里忽略；只关心最终文本
  *
+ *  Phase 2 重构：
+ *    - system prompt 现在追加 CapabilityHint（skill + plugin 轻量列表）
+ *    - 即使 tools=[] 的 llm 步骤也知道有哪些 skill/plugin 可用，
+ *      可以在输出文本中引用或建议用户后续使用（如 draft_plan 提到"建议用 /pptx 执行"）
+ *
  *  capture：
  *    - `{ text: var_name }` 绑生成文本（无 output_schema 时）
  *    - `{ result: var_name }` 同义
@@ -24,6 +29,7 @@ import { ALL_TOOLS, chat, } from '../../../../src/plugin-sdk.js';
 import { interpolate } from '../expressions.js';
 import { extractJsonPayload } from '../jsonPayload.js';
 import { runMiniReAct } from '../miniReAct.js';
+import { assembleCapabilityHint } from '../../../../src/prompts/promptAssembly.js';
 const LLM_STEP_SYSTEM_PLAIN = '你正在被一个 workflow 调用。只输出本步骤要求的内容本身，不要寒暄、不要列要求复述、不要工具调用语法。';
 const LLM_STEP_SYSTEM_SCHEMA = `你正在被一个 workflow 调用。
 要求：
@@ -75,10 +81,14 @@ export async function* execLlmStep(step, vars, ctx) {
     const schemaHint = useSchema
         ? `\n\n最终只输出匹配以下 JSON Schema 的 JSON 对象本身（不要解释、不要 markdown 代码块）：\n${JSON.stringify(step.output_schema)}`
         : '';
+    // ✅ Phase 2: 追加 CapabilityHint —— 让 llm 步骤知道有哪些 skill/plugin 可用
+    // 即使 tools=[] 不能执行工具，模型也能在输出中引用或建议用户后续使用
+    const capabilityHint = await assembleCapabilityHint(ctx.cwd);
+    const baseSystem = (useSchema ? LLM_STEP_SYSTEM_SCHEMA : LLM_STEP_SYSTEM_PLAIN) + schemaHint;
     const messages = [
         {
             role: 'system',
-            content: (useSchema ? LLM_STEP_SYSTEM_SCHEMA : LLM_STEP_SYSTEM_PLAIN) + schemaHint,
+            content: baseSystem + capabilityHint,
         },
         { role: 'user', content: prompt },
     ];
@@ -114,7 +124,7 @@ export async function* execLlmStep(step, vars, ctx) {
     const trimmed = text.trim();
     if (useSchema) {
         // strict structured output：解析 JSON 后整个对象作为 raw。
-        // 思考型模型即便在 strict 下仍会把 <think>…</think> 写进 content（见 jsonPayload.ts
+        // 思考型模型即便在 strict 下仍会把 think…</think 写进 content（见 jsonPayload.ts
         // 头注与 src/llm/client.ts:200），故先剥思维链/前后散文再 parse；报错仍带原文便于排查。
         const payload = extractJsonPayload(text);
         let parsed;

package/plugins/workflow-runner/src/stepExecutors/verify.js

@@ -0,0 +1,41 @@
+/**
+ * ============================================================
+ *  stepExecutors/verify.ts —— verify step 执行
+ * ------------------------------------------------------------
+ *  复用 src/infra/verification.ts 共享验证基础设施，
+ *  支持 shell / file_exists / file_contains / test_count 四种检查。
+ *
+ *  与 assert 的区别：
+ *    - assert: evalExpr 表达式（轻量，适合简单文件存在判断）
+ *    - verify: 完整检查器（重量，支持命令执行/正则匹配/测试计数）
+ * ============================================================
+ */
+import { parseCheckString, runVerification } from '../../../../src/infra/verification.js';
+import { interpolate } from '../expressions.js';
+export async function execVerifyStep(step, vars) {
+    if (!Array.isArray(step.checks) || step.checks.length === 0) {
+        throw new Error(`step ${step.id}: verify 缺少 checks 数组`);
+    }
+    // 解析并插值每条 check 字符串
+    const checks = [];
+    for (const raw of step.checks) {
+        const interpolated = interpolate(raw, vars);
+        const check = parseCheckString(interpolated);
+        if (!check) {
+            throw new Error(`step ${step.id}: 无法解析 check "${interpolated}"，格式应为 "type:value"`);
+        }
+        checks.push(check);
+    }
+    // 执行所有检查
+    const result = await runVerification(checks);
+    if (!result.passed) {
+        const msg = step.onFail
+            ? interpolate(step.onFail, vars)
+            : `verify 失败: ${result.summary}`;
+        throw new Error(msg);
+    }
+    return {
+        raw: { passed: true, summary: result.summary, details: result.details },
+        preview: result.summary,
+    };
+}

package/plugins/workflow-runner/src/workflowState.js

@@ -18,16 +18,19 @@
  *  因为执行流程是确定性的，没有 LLM 自规划过程。
  * ============================================================
  */
-import { mkdir, writeFile, appendFile, rm } from 'node:fs/promises';
+import { mkdir, writeFile, appendFile, rm, rename } from 'node:fs/promises';
 import { join } from 'node:path';
 const STATE_DIR = '.minimal-agent-workflow';
+const DONE_SUFFIX = '.done';
 export class WorkflowState {
     dir;
     constructor(workingDir) {
         this.dir = join(workingDir, STATE_DIR);
     }
     async init(name, inputs) {
-        await rm(this.dir, { recursive: true, force: true });
+        // 启动新 workflow 时清理旧状态（含之前的归档）
+        await rm(this.dir, { recursive: true, force: true }).catch(() => { });
+        await rm(this.dir + DONE_SUFFIX, { recursive: true, force: true }).catch(() => { });
         await mkdir(this.dir, { recursive: true });
         await writeFile(join(this.dir, 'current.json'), JSON.stringify({ name, startedAt: new Date().toISOString() }, null, 2), 'utf8');
         await writeFile(join(this.dir, 'inputs.json'), JSON.stringify(inputs, null, 2), 'utf8');
@@ -40,7 +43,32 @@ export class WorkflowState {
     async writeVars(snapshot) {
         await writeFile(join(this.dir, 'vars.json'), JSON.stringify(snapshot, null, 2), 'utf8').catch(() => { });
     }
+    /**
+     * 归档（成功完成时调用）：重命名状态目录为 .done 后缀，保留所有中间产物。
+     * vars.json / progress.md / inputs.json 全部保留——供后续对话 Read 回溯。
+     */
+    async archive() {
+        const doneDir = this.dir + DONE_SUFFIX;
+        try {
+            // 先清理旧的归档（如果存在）
+            await rm(doneDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+        try {
+            await rename(this.dir, doneDir);
+        }
+        catch {
+            // rename 失败时静默（某些文件系统/权限问题），保留原目录
+        }
+    }
+    /**
+     * 强制清理（/new 或新 workflow init 时调用）：删除状态目录（含 .done 归档）。
+     */
     async cleanup() {
         await rm(this.dir, { recursive: true, force: true }).catch(() => { });
+        // 同时清理可能的归档目录
+        await rm(this.dir + DONE_SUFFIX, { recursive: true, force: true }).catch(() => { });
     }
 }