minimal-agent 0.11.0 → 0.13.0

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

@@ -11,16 +11,17 @@
  * ============================================================
  */
 
-import { findWorkflowByName, listWorkflows } from './loader.js';
-import { runWorkflow } from './runner.js';
-import type { InputDef, RunContext, WorkflowEvent } from './types.js';
 import {
-  buildBaseSystemPrompt,
   type LoopEvent,
   type Message,
+  type PluginContext,
   type Provider,
   type Tool,
+  buildBaseSystemPrompt,
 } from '../../../src/plugin-sdk.js';
+import { findWorkflowByName, listWorkflows } from './loader.js';
+import { runWorkflow } from './runner.js';
+import type { InputDef, RunContext, WorkflowEvent } from './types.js';
 
 export interface RunWorkflowFromCommandOptions {
   provider: Provider;
@@ -31,11 +32,13 @@ export interface RunWorkflowFromCommandOptions {
   sessionState?: import('../../../src/plugin-sdk.js').SessionState;
   /** 当前工作目录（默认 process.cwd()） */
   cwd?: string;
-  /** 可用工具列表（默认空数组，由 runner 注入 ALL_TOOLS） */
+  /** 宿主过滤后的可用工具列表；缺省为空，绝不在 runner 内恢复全量工具。 */
   tools?: Tool[];
   transientContext?: string;
   transientBundle?: import('../../../src/plugin-sdk.js').ContextBundle;
   promptCache?: import('../../../src/plugin-sdk.js').PromptCacheContext;
+  executeTool?: PluginContext['executeTool'];
+  toolContext?: RunContext['toolContext'];
   /**
    * 宿主授权上下文（浏览器 / 电脑操控）。
    *
@@ -88,29 +91,43 @@ export function parseWorkflowArgs(rawArgs: string): {
   return { name, inputs, positional };
 }
 
-/** 简单 token 化：双引号包裹的整体当一个 token；其它按空白切。 */
+/**
+ * shell 风格 token 化：空白切分 token；引号（' 或 "）在 token **任意位置**（不只开头）
+ * 出现即进入引号模式——引号内的空白不切分、引号字符本身被剥离。
+ *
+ * 修复：`--input topic="带空格的值"`（引号在 `=` 后，token 开头是 `t`）曾被按空白
+ * 硬切 → 值截断 + 引号残留（实测 inputs.topic 带 `"` 尾，positional 里散落被拆的字）。
+ * 现在 token 内任意位置的引号都正确分组。
+ *
+ * 边界语义（被 parseWorkflowArgs.test.ts 冻结）：
+ *   - 未闭合引号：剩余部分并入当前 token（不报错）
+ *   - 双引号内的单引号是字面量（不触发嵌套）
+ *   - 反斜杠不转义（`a\"b` 中 `"` 仍开启引号模式，行为变化但测试用 toBeDefined 容错）
+ *   - 连续空白合并、`""` 产生空 token
+ */
 function tokenizeArgs(s: string): string[] {
   const out: string[] = [];
   let i = 0;
   while (i < s.length) {
     while (i < s.length && /\s/.test(s[i])) i++;
     if (i >= s.length) break;
-    if (s[i] === '"' || s[i] === "'") {
-      const q = s[i];
-      i++;
-      let acc = '';
-      while (i < s.length && s[i] !== q) {
-        acc += s[i++];
-      }
-      if (i < s.length) i++;
-      out.push(acc);
-    } else {
-      let acc = '';
-      while (i < s.length && !/\s/.test(s[i])) {
-        acc += s[i++];
+    let acc = '';
+    while (i < s.length) {
+      const c = s[i];
+      if (c === '"' || c === "'") {
+        // 引号模式：收集到闭合引号，引号内空白保留
+        const q = c;
+        i++;
+        while (i < s.length && s[i] !== q) acc += s[i++];
+        if (i < s.length) i++; // 跳过闭合引号
+      } else if (/\s/.test(c)) {
+        break;
+      } else {
+        acc += c;
+        i++;
       }
-      out.push(acc);
     }
+    out.push(acc);
   }
   return out;
 }
@@ -138,8 +155,9 @@ function coerceInputs(
       continue;
     }
     if (def.type === 'number') {
-      const n = parseFloat(rawVal);
-      if (Number.isNaN(n)) throw new Error(`input ${def.name} 必须是数字，收到 "${rawVal}"`);
+      const n = Number.parseFloat(rawVal);
+      if (Number.isNaN(n))
+        throw new Error(`input ${def.name} 必须是数字，收到 "${rawVal}"`);
       out[def.name] = n;
     } else if (def.type === 'enum') {
       if (!def.values?.includes(rawVal)) {
@@ -167,7 +185,9 @@ async function refreshWorkflowSystemPrompt(
   // 只刷稳定层：workflow 一跑就是几十步，system 消息若含日期/记忆等易变内容，
   // 每步都会重写 history[0]、把 provider 前缀缓存打散（见 prompts/system.ts）。
   const content = await buildBaseSystemPrompt(cwd, tools);
-  const systemIndex = history.findIndex((m) => m.role === 'system' && !m._ephemeral);
+  const systemIndex = history.findIndex(
+    (m) => m.role === 'system' && !m._ephemeral,
+  );
   const fresh: Message = { role: 'system', content };
 
   if (systemIndex === 0) {
@@ -213,13 +233,18 @@ export async function* runWorkflowFromCommand(
   //   - 默认：严格按"第 i 个位置参数 ↔ def.inputs[i]"对应。
   // --input k=v 显式优先：已显式的 input 不被位置参数覆盖（对应位置参数被丢弃，会 warn）。
   const overriddenByKV: string[] = [];
+  const greedyNotes: string[] = [];
   const greedyFirst = def.inputs?.[0]?.greedy === true;
   if (greedyFirst && def.inputs && positional.length > 0) {
     const greedyName = def.inputs[0].name;
     if (greedyName in rawInputs) {
-      // 首参已被 --input 占位 → 整串位置参数被忽略
-      overriddenByKV.push(
-        `${greedyName}=${JSON.stringify(rawInputs[greedyName])} (位置参数 ${JSON.stringify(positional.join(' '))} 被忽略)`,
+      // 首参已由 --input 提供时，位置参数仍按贪婪语义【拼回】首参末尾--
+      // 含空格的值未加引号时会被 shell 拆开（--input topic=A B C 只有 A 进 KV，
+      // B C 散落成位置参数），静默丢弃曾把整段中文调研主题截成半句、
+      // 连锁触发任务仲裁误判 new-task 清空全部产物。
+      rawInputs[greedyName] = [rawInputs[greedyName], ...positional].join(' ');
+      greedyNotes.push(
+        `${greedyName}：--input 值未加引号被拆成 ${positional.length} 段位置参数，已自动拼回（下次请写 --input "${greedyName}=完整值"）`,
       );
     } else {
       // 贪婪吸收：整句进首参（空格 join 还原用户原话，不逐位拆映射）
@@ -250,6 +275,13 @@ export async function* runWorkflowFromCommand(
       message: `⚠ 忽略了 ${dropped.length} 个多余位置参数: ${dropped.map((d) => JSON.stringify(d)).join(' ')}（workflow "${name}" 只声明了 ${def.inputs.length} 个 input）`,
     };
   }
+  // warn：贪婪首参的 --input 值被 shell 拆开后自动拼回
+  if (greedyNotes.length > 0) {
+    yield {
+      type: 'warning',
+      message: `⚠ ${greedyNotes.join('；')}`,
+    };
+  }
   // warn：位置参数被 --input 覆盖
   if (overriddenByKV.length > 0) {
     yield {
@@ -278,6 +310,8 @@ export async function* runWorkflowFromCommand(
     transientContext: opts.transientContext,
     transientBundle: opts.transientBundle,
     promptCache: opts.promptCache,
+    executeTool: opts.executeTool,
+    toolContext: opts.toolContext,
   };
 
   // 透传 runWorkflow 的事件，并观察是否出现终结事件（error / interrupted = 失败或中断，
@@ -295,7 +329,11 @@ export async function* runWorkflowFromCommand(
 }
 
 /** /workflows —— 列出可用 workflow。yield 一条 text 事件让 UI 显示。 */
-export async function* runWorkflowsList(): AsyncGenerator<LoopEvent, void, void> {
+export async function* runWorkflowsList(): AsyncGenerator<
+  LoopEvent,
+  void,
+  void
+> {
   const list = await listWorkflows();
   if (list.length === 0) {
     yield {
@@ -308,13 +346,19 @@ export async function* runWorkflowsList(): AsyncGenerator<LoopEvent, void, void>
   }
   const lines = ['可用工作流：'];
   for (const w of list) {
-    lines.push(`  /workflow ${w.name}  —  ${w.description.split('\n')[0].trim()}`);
+    lines.push(
+      `  /workflow ${w.name}  —  ${w.description.split('\n')[0].trim()}`,
+    );
   }
   lines.push('');
   lines.push('运行示例:');
-  lines.push('  /workflow <name> <val>            位置参数（按 inputs 声明顺序，第一个 input 直接写值）');
+  lines.push(
+    '  /workflow <name> <val>            位置参数（按 inputs 声明顺序，第一个 input 直接写值）',
+  );
   lines.push('  /workflow <name>.yaml <val>       .yaml 后缀可省');
-  lines.push('  /workflow <name> --input k=v      显式 KV（多 input 或想跳过中间 input 时用）');
-  yield { type: 'text', delta: lines.join('\n') + '\n' };
+  lines.push(
+    '  /workflow <name> --input k=v      显式 KV（多 input 或想跳过中间 input 时用）',
+  );
+  yield { type: 'text', delta: `${lines.join('\n')}\n` };
   yield { type: 'turn_done' };
 }

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

@@ -1,5 +1,6 @@
 import { isAbsolute, resolve } from 'node:path';
 import { interpolate } from './expressions.js';
+import { effectiveWorkflowCwd } from './toolRuntime.js';
 export function resolveWorkflowMultimodalOptions(step, vars, ctx, onMissing) {
     const imageDetail = step.image_detail;
     const imageMaxLongSidePixel = step.image_max_long_side_pixel;
@@ -33,5 +34,5 @@ function resolveWorkflowImageSource(source, ctx) {
         isAbsolute(clean)) {
         return clean;
     }
-    return resolve(ctx.cwd, clean);
+    return resolve(effectiveWorkflowCwd(ctx), clean);
 }

package/plugins/workflow-runner/src/multimodal.ts

@@ -2,6 +2,7 @@ import { isAbsolute, resolve } from 'node:path';
 
 import type { ImageDetail, ImageInputSpec } from '../../../src/plugin-sdk.js';
 import { interpolate } from './expressions.js';
+import { effectiveWorkflowCwd } from './toolRuntime.js';
 import type { RunContext, StepDef, VarStack } from './types.js';
 
 export interface WorkflowMultimodalOptions {
@@ -59,5 +60,5 @@ function resolveWorkflowImageSource(source: string, ctx: RunContext): string {
   ) {
     return clean;
   }
-  return resolve(ctx.cwd, clean);
+  return resolve(effectiveWorkflowCwd(ctx), clean);
 }

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

@@ -81,8 +81,15 @@ export async function* runRecovery(step, vars, ctx, errorMsg) {
         : recoverPrompt + schemaHint;
     try {
         // 委托 TAOR 引擎执行（共享消费层 runStepQuery）——事件透传给 UI（显示恢复进度）。
-        // 注意剥掉 step 的 allowed_tools 白名单：原步收敛工具是为弱模型聚焦，
-        // 恢复 agent 的职责正是「随机应变换路径」，要全工具箱（保持 v0.9 行为）。
+        // 注意剥掉 step 的 allowed_tools 白名单：【allowed_tools 本身不是安全边界，是弱模型聚焦优化】
+        // （原步限定一小撮工具给能力弱的模型，避免它瞎试跑遍所有工具）。
+        // 恢复 agent 的职责正是「随机应变换路径」，需要它能调用原步没考虑过的替代工具，
+        // 所以这里解除聚焦限制。真正的安全边界在**另外两层**，此处没有动：
+        //   1. `StepDef.uses: [browser|computer]` —— 宿主能力切片（buildWorkflowToolContext 仍生效），
+        //      原步没声明 computer 的话，恢复 agent 也调不通 ComputerUse。
+        //   2. `ctx.tools` —— 插件层按 runtime + 宿主白名单裁剪后的有效工具集合，
+        //      无论 allowed_tools 写什么都不能超出它。
+        // 保持 v0.9 行为（放开 allowed_tools），但明确安全层次不发生变化。
         const { rawText, sawLlmError, sawMaxTurns, llmErrorDetail } = yield* runStepQuery(fullPrompt, { ...step, allowed_tools: undefined }, ctx, { maxTurns: step.maxTurns ?? 25 });
         // 恢复是兜底路径：无论 provider 失败还是模型空答，都按「没救回」返回
         // ok:false（不抛重试——retry 在进入 recover 前已用尽）；只是归因更诚实。

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

@@ -104,8 +104,15 @@ export async function* runRecovery(
 
   try {
     // 委托 TAOR 引擎执行（共享消费层 runStepQuery）——事件透传给 UI（显示恢复进度）。
-    // 注意剥掉 step 的 allowed_tools 白名单：原步收敛工具是为弱模型聚焦，
-    // 恢复 agent 的职责正是「随机应变换路径」，要全工具箱（保持 v0.9 行为）。
+    // 注意剥掉 step 的 allowed_tools 白名单：【allowed_tools 本身不是安全边界，是弱模型聚焦优化】
+    // （原步限定一小撮工具给能力弱的模型，避免它瞎试跑遍所有工具）。
+    // 恢复 agent 的职责正是「随机应变换路径」，需要它能调用原步没考虑过的替代工具，
+    // 所以这里解除聚焦限制。真正的安全边界在**另外两层**，此处没有动：
+    //   1. `StepDef.uses: [browser|computer]` —— 宿主能力切片（buildWorkflowToolContext 仍生效），
+    //      原步没声明 computer 的话，恢复 agent 也调不通 ComputerUse。
+    //   2. `ctx.tools` —— 插件层按 runtime + 宿主白名单裁剪后的有效工具集合，
+    //      无论 allowed_tools 写什么都不能超出它。
+    // 保持 v0.9 行为（放开 allowed_tools），但明确安全层次不发生变化。
     const { rawText, sawLlmError, sawMaxTurns, llmErrorDetail } =
       yield* runStepQuery(
         fullPrompt,

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

@@ -25,7 +25,8 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { dlog, getWorkingDir } from '../../../src/plugin-sdk.js';
 import { evalExpr, interpolate } from './expressions.js';
-import { buildTaskArbitrator, isContinuationPhrase } from './taskIdentity.js';
+import { effectiveWorkflowCwd } from './toolRuntime.js';
+import { buildTaskArbitrator, DEFAULT_SESSION_ID, generateDefaultSessionId, isContinuationPhrase, sanitizeWorkflowDirName } from './taskIdentity.js';
 import { execAgentStep } from './stepExecutors/agent.js';
 import { execAssertStep } from './stepExecutors/assert.js';
 import { execVerifyStep } from './stepExecutors/verify.js';
@@ -153,7 +154,7 @@ async function* dispatchActionStep(step, vars, ctx) {
     if (step.type === 'assert')
         return execAssertStep(step, vars, ctx);
     if (step.type === 'verify')
-        return await execVerifyStep(step, vars);
+        return await execVerifyStep(step, vars, ctx);
     // set / echo 从 runSteps 的内联块搬进执行器体系：它们不影响迭代、只产出 StepResult。
     // 搬过来的直接收益是 `capture:` 自然生效（此前它们从不调 bindCapture —— 静默失效）。
     if (step.type === 'set')
@@ -340,6 +341,20 @@ function collectDeclaredArtifacts(def) {
 export async function* runWorkflow(def, inputs, ctx) {
     const vars = new VarStack();
     vars.setGlobal('inputs', inputs);
+    // 让 fileExists / readJson（done_when、when、over 都靠它们）与写入侧锚同一个目录。
+    // 传函数而非当前值：worktree 是运行途中才可能进入的，锚点必须每次求值时重算。
+    vars.resolveCwd = () => effectiveWorkflowCwd(ctx);
+    // Phase 3：session 即任务实例。优先用宿主显式提供的 sessionId（TUI 当前会话 /
+    // -p 的 --session）；缺失或为缺省 'default' 时，由工作流引擎自动命名一个唯一
+    // session（generateDefaultSessionId，见 taskIdentity.ts）——保证每次工作流运行都
+    // 有独立目录，多 session 并行互不覆盖；宿主显式指定时仍可复用/续跑该 session。
+    // 注入全局变量 `session`（sanitize 后的目录安全名），供 yaml 产物路径用
+    // ${session} 占位符（如 out/research/${session}/01-goal.md）。
+    const explicitSessionId = ctx.runtimeContext?.sessionId;
+    const sessionId = explicitSessionId && explicitSessionId !== DEFAULT_SESSION_ID
+        ? explicitSessionId
+        : generateDefaultSessionId();
+    vars.setGlobal('session', sanitizeWorkflowDirName(sessionId));
     // onError:'recover' 用：把工作流总目标（description）透传给恢复 agent，
     // 让它知道「这条工作流到底想干什么」。已有 goal 则不覆盖。
     const runCtx = { ...ctx, goal: ctx.goal ?? def.description };
@@ -353,13 +368,17 @@ export async function* runWorkflow(def, inputs, ctx) {
     runCtx.maxTurnsRetryDelayMs = def.self_heal?.max_turns_retry_delay_ms;
     // 声明产物清单：state.init 用于 new-task 清理/completed 报产物；
     // 挂到 runCtx 供 tool 步覆盖判定（声明产物自动 pre-Read 解 Write 守卫）。
-    const declaredArtifacts = collectDeclaredArtifacts(def);
+    // Phase 3：产物路径可能含 ${session} 占位符，收集后按 vars 展开为实际路径
+    //（new-task 清理 / completed 报告都以展开后的真实路径为准）。
+    const declaredArtifacts = collectDeclaredArtifacts(def)
+        .map((a) => interpolate(a, vars))
+        .filter((a) => a.length > 0);
     runCtx.declaredArtifacts = declaredArtifacts;
     // 任务身份语义仲裁器（hash 不等 + 旧任务未完成时的二审，见 taskIdentity.ts）：
     // 短语快路径 → LLM 单轮仲裁 → AskUserQuestion → 兜底 new-task。
     // init 非 generator，仲裁过程的人话记录收进 notes，init 返回后统一 yield。
     const arbitrationNotes = [];
-    const state = new WorkflowState(getWorkingDir(), def.name);
+    const state = new WorkflowState(getWorkingDir(), def.name, sessionId);
     const resume = await state.init(def.name, inputs, def.steps, def.self_heal?.backoff, declaredArtifacts, buildTaskArbitrator({
         provider: runCtx.provider,
         chat: runCtx.chat,
@@ -396,9 +415,16 @@ export async function* runWorkflow(def, inputs, ctx) {
             message: '♻ 工作流定义已变更（步骤结构与旧断点不再匹配），旧执行现场已作废，本次从头开始执行。',
         };
     }
-    // fresh/new-task 启动清理可见化：全新任务开始前已删掉的残留产物（上次任务
+    // fresh/new-task 启动清理可见化：全新任务开始前清理的残留产物（上次任务
     // 的声明产物 + /new 后无主孤儿）。用户约定：全新 plan 一律从干净状态开始；
     // 删除范围仅限本工作流声明的产物，同任务 resume 不清理。
+    // 清理一律先归档到 .trash 回收目录再删残留：仲裁误判 new-task 时成果可找回。
+    if (resume.archivedTo) {
+        yield {
+            type: 'warning',
+            message: `全新任务：上次残留的旧产物已归档到 ${resume.archivedTo}/（确认不需要后可删除该目录），从干净状态开始。`,
+        };
+    }
     if (resume.cleanedArtifacts?.length) {
         yield {
             type: 'warning',

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

@@ -28,7 +28,8 @@ import { dlog, executeTool, getWorkingDir, type LoopEvent } from '../../../src/p
 import { isMaxTurnsCutoff, truncate } from './agentCommon.js';
 import { evalExpr, interpolate, interpolateDeep, interpolateTyped } from './expressions.js';
 import { runRecovery } from './recovery.js';
-import { buildTaskArbitrator, isContinuationPhrase } from './taskIdentity.js';
+import { effectiveWorkflowCwd } from './toolRuntime.js';
+import { buildTaskArbitrator, DEFAULT_SESSION_ID, generateDefaultSessionId, isContinuationPhrase, sanitizeWorkflowDirName } from './taskIdentity.js';
 import { execAgentStep } from './stepExecutors/agent.js';
 import { execAssertStep } from './stepExecutors/assert.js';
 import { execVerifyStep } from './stepExecutors/verify.js';
@@ -206,7 +207,7 @@ async function* dispatchActionStep(
   ctx: RunContext,
 ): AsyncGenerator<LoopEvent, StepResult, void> {
   if (step.type === 'assert') return execAssertStep(step, vars, ctx);
-  if (step.type === 'verify') return await execVerifyStep(step, vars);
+  if (step.type === 'verify') return await execVerifyStep(step, vars, ctx);
   // set / echo 从 runSteps 的内联块搬进执行器体系：它们不影响迭代、只产出 StepResult。
   // 搬过来的直接收益是 `capture:` 自然生效（此前它们从不调 bindCapture —— 静默失效）。
   if (step.type === 'set') return yield* execSetStep(step, vars);
@@ -395,6 +396,22 @@ export async function* runWorkflow(
 ): AsyncGenerator<WorkflowEvent | LoopEvent, void, void> {
   const vars = new VarStack();
   vars.setGlobal('inputs', inputs);
+  // 让 fileExists / readJson（done_when、when、over 都靠它们）与写入侧锚同一个目录。
+  // 传函数而非当前值：worktree 是运行途中才可能进入的，锚点必须每次求值时重算。
+  vars.resolveCwd = () => effectiveWorkflowCwd(ctx);
+
+  // Phase 3：session 即任务实例。优先用宿主显式提供的 sessionId（TUI 当前会话 /
+  // -p 的 --session）；缺失或为缺省 'default' 时，由工作流引擎自动命名一个唯一
+  // session（generateDefaultSessionId，见 taskIdentity.ts）——保证每次工作流运行都
+  // 有独立目录，多 session 并行互不覆盖；宿主显式指定时仍可复用/续跑该 session。
+  // 注入全局变量 `session`（sanitize 后的目录安全名），供 yaml 产物路径用
+  // ${session} 占位符（如 out/research/${session}/01-goal.md）。
+  const explicitSessionId = ctx.runtimeContext?.sessionId;
+  const sessionId =
+    explicitSessionId && explicitSessionId !== DEFAULT_SESSION_ID
+      ? explicitSessionId
+      : generateDefaultSessionId();
+  vars.setGlobal('session', sanitizeWorkflowDirName(sessionId));
 
   // onError:'recover' 用：把工作流总目标（description）透传给恢复 agent，
   // 让它知道「这条工作流到底想干什么」。已有 goal 则不覆盖。
@@ -412,14 +429,18 @@ export async function* runWorkflow(
 
   // 声明产物清单：state.init 用于 new-task 清理/completed 报产物；
   // 挂到 runCtx 供 tool 步覆盖判定（声明产物自动 pre-Read 解 Write 守卫）。
-  const declaredArtifacts = collectDeclaredArtifacts(def);
+  // Phase 3：产物路径可能含 ${session} 占位符，收集后按 vars 展开为实际路径
+  //（new-task 清理 / completed 报告都以展开后的真实路径为准）。
+  const declaredArtifacts = collectDeclaredArtifacts(def)
+    .map((a) => interpolate(a, vars))
+    .filter((a) => a.length > 0);
   runCtx.declaredArtifacts = declaredArtifacts;
 
   // 任务身份语义仲裁器（hash 不等 + 旧任务未完成时的二审，见 taskIdentity.ts）：
   // 短语快路径 → LLM 单轮仲裁 → AskUserQuestion → 兜底 new-task。
   // init 非 generator，仲裁过程的人话记录收进 notes，init 返回后统一 yield。
   const arbitrationNotes: string[] = [];
-  const state = new WorkflowState(getWorkingDir(), def.name);
+  const state = new WorkflowState(getWorkingDir(), def.name, sessionId);
   const resume = await state.init(
     def.name,
     inputs,
@@ -469,9 +490,16 @@ export async function* runWorkflow(
     };
   }
 
-  // fresh/new-task 启动清理可见化：全新任务开始前已删掉的残留产物（上次任务
+  // fresh/new-task 启动清理可见化：全新任务开始前清理的残留产物（上次任务
   // 的声明产物 + /new 后无主孤儿）。用户约定：全新 plan 一律从干净状态开始；
   // 删除范围仅限本工作流声明的产物，同任务 resume 不清理。
+  // 清理一律先归档到 .trash 回收目录再删残留：仲裁误判 new-task 时成果可找回。
+  if (resume.archivedTo) {
+    yield {
+      type: 'warning',
+      message: `全新任务：上次残留的旧产物已归档到 ${resume.archivedTo}/（确认不需要后可删除该目录），从干净状态开始。`,
+    };
+  }
   if (resume.cleanedArtifacts?.length) {
     yield {
       type: 'warning',

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

@@ -8,6 +8,7 @@
  *  让后续 LLM 步骤能看到验证通过的信息（如"文件已存在""变量值符合预期"等）。
  * ============================================================
  */
+import { randomUUID } from 'node:crypto';
 import { evalExpr, interpolate } from '../expressions.js';
 export function execAssertStep(step, vars, ctx) {
     if (typeof step.condition !== 'string') {
@@ -34,7 +35,7 @@ export function execAssertStep(step, vars, ctx) {
             role: 'assistant',
             content: `[workflow:${step.id}] ✅ 断言通过：${step.condition}`,
             timestamp: Date.now(),
-            id: crypto.randomUUID(),
+            id: randomUUID(),
         });
     }
     return { raw: { ok: true }, preview: 'assert passed' };

package/plugins/workflow-runner/src/stepExecutors/assert.ts

@@ -9,6 +9,8 @@
  * ============================================================
  */
 
+import { randomUUID } from 'node:crypto';
+
 import { evalExpr, interpolate } from '../expressions.js';
 import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
 
@@ -42,7 +44,7 @@ export function execAssertStep(
       role: 'assistant',
       content: `[workflow:${step.id}] ✅ 断言通过：${step.condition}`,
       timestamp: Date.now(),
-      id: crypto.randomUUID(),
+      id: randomUUID(),
     });
   }
 

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

@@ -15,11 +15,12 @@
  *  capture：{ text: var_name } / { result: var_name }
  * ============================================================
  */
-import { readdir, readFile } from 'node:fs/promises';
+import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { getResourceSearchPaths } from '../../../../src/plugin-sdk.js';
+import { getResourceSearchPaths, } from '../../../../src/plugin-sdk.js';
 import { describeLlmFailure, describeMaxTurnsCutoff, effectiveGoalAnchor, runStepQuery, } from '../agentCommon.js';
 import { interpolate } from '../expressions.js';
+import { effectiveWorkflowCwd } from '../toolRuntime.js';
 function stripFrontmatter(content) {
     return content.replace(/^---\n[\s\S]*?\n---\n?/, '');
 }
@@ -53,9 +54,7 @@ async function findSkillFile(skillName, cwd) {
                 if (parseFrontmatterName(md) === skillName)
                     return skillFile;
             }
-            catch {
-                continue;
-            }
+            catch { }
         }
     }
     return null;
@@ -64,7 +63,7 @@ export async function* execSkillStep(step, vars, ctx) {
     if (!step.skill)
         throw new Error(`step ${step.id}: 缺少 skill 字段`);
     const skillName = interpolate(step.skill, vars);
-    const skillFile = await findSkillFile(skillName, ctx.cwd);
+    const skillFile = await findSkillFile(skillName, effectiveWorkflowCwd(ctx));
     if (!skillFile) {
         throw new Error(`step ${step.id}: 未找到 skill "${skillName}"（cwd/skills/ 与 packageRoot/skills/ 双源均未命中）`);
     }

package/plugins/workflow-runner/src/stepExecutors/skill.ts

@@ -16,10 +16,13 @@
  * ============================================================
  */
 
-import { readdir, readFile } from 'node:fs/promises';
+import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 
-import { getResourceSearchPaths, type LoopEvent } from '../../../../src/plugin-sdk.js';
+import {
+  type LoopEvent,
+  getResourceSearchPaths,
+} from '../../../../src/plugin-sdk.js';
 import {
   describeLlmFailure,
   describeMaxTurnsCutoff,
@@ -27,6 +30,7 @@ import {
   runStepQuery,
 } from '../agentCommon.js';
 import { interpolate } from '../expressions.js';
+import { effectiveWorkflowCwd } from '../toolRuntime.js';
 import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
 
 function stripFrontmatter(content: string): string {
@@ -41,7 +45,10 @@ function parseFrontmatterName(content: string): string | null {
   return nm[1].trim().replace(/^["']|["']$/g, '');
 }
 
-async function findSkillFile(skillName: string, cwd: string): Promise<string | null> {
+async function findSkillFile(
+  skillName: string,
+  cwd: string,
+): Promise<string | null> {
   const roots = getResourceSearchPaths('skills', import.meta.url, cwd);
 
   for (const root of roots) {
@@ -58,9 +65,7 @@ async function findSkillFile(skillName: string, cwd: string): Promise<string | n
       try {
         const md = await readFile(skillFile, 'utf8');
         if (parseFrontmatterName(md) === skillName) return skillFile;
-      } catch {
-        continue;
-      }
+      } catch {}
     }
   }
   return null;
@@ -74,7 +79,7 @@ export async function* execSkillStep(
   if (!step.skill) throw new Error(`step ${step.id}: 缺少 skill 字段`);
   const skillName = interpolate(step.skill, vars);
 
-  const skillFile = await findSkillFile(skillName, ctx.cwd);
+  const skillFile = await findSkillFile(skillName, effectiveWorkflowCwd(ctx));
   if (!skillFile) {
     throw new Error(
       `step ${step.id}: 未找到 skill "${skillName}"（cwd/skills/ 与 packageRoot/skills/ 双源均未命中）`,