minimal-agent 0.11.0 → 0.13.0

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

@@ -21,10 +21,13 @@
  *    - `{ args.<任意字段>: var_name }` 绑入参的具名字段
  * ============================================================
  */
+import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { executeTool, getToolByName, recordRead, } from '../../../../src/plugin-sdk.js';
 import { interpolateDeep } from '../expressions.js';
+import { buildWorkflowToolContext, effectiveWorkflowCwd, } from '../toolRuntime.js';
+import { safeArtifactPath } from '../types.js';
 export async function* execToolStep(step, vars, ctx) {
     if (!step.tool)
         throw new Error(`step ${step.id}: 缺少 tool 字段`);
@@ -56,8 +59,8 @@ export async function* execToolStep(step, vars, ctx) {
         argsFriendly: friendlyToolDesc(tool.name, args),
     };
     // ════ 声明产物覆盖判定（解 Write/Edit 的 pre-read 守卫） ════
-    // 内核写类工具有「文件已存在必须先 Read」守卫（fileState 进程级 Map，
-    // 跨进程 / resume / 残留旧产物时必空）。确定性 tool 步的 args 是 yaml 作者
+    // 内核写类工具有「文件已存在必须先 Read」守卫（fileState 按会话隔离，
+    // 跨进程 / resume / 残留旧产物时可能为空）。确定性 tool 步的 args 是 yaml 作者
     // 写死的，模型没有机会先 Read —— 目标文件若是工作流**声明的产物**
     // （def 级 + step 级 artifacts:，= 工作流自己拥有、本就要覆盖的文件），
     // 这里自动 pre-Read 一次解除守卫（管线动作，不 yield 事件、结果丢弃）。
@@ -65,16 +68,60 @@ export async function* execToolStep(step, vars, ctx) {
     await preReadDeclaredArtifact(tool, args, step, ctx);
     // 宿主能力按 `uses:` 切片后转发。`executeTool` 的第四参此前从未传过 ——
     // 这正是「workflow 里 ComputerUse 恒失败」的末端表现。
-    const hostSlice = hostContextFor(step, ctx);
-    if ('error' in hostSlice)
-        throw new Error(`step ${step.id}: ${hostSlice.error}`);
-    const result = await executeTool(tool.name, argsJson, ctx.signal, hostSlice.ctx);
+    const pendingProgress = [];
+    let wakeProgress;
+    const toolContext = buildWorkflowToolContext(step, ctx, toolCallId, (message, detail) => {
+        pendingProgress.push({
+            type: 'tool_progress',
+            toolName: tool.name,
+            toolCallId,
+            message,
+            detail,
+        });
+        wakeProgress?.();
+    });
+    if ('error' in toolContext) {
+        throw new Error(`step ${step.id}: ${toolContext.error}`);
+    }
+    const dispatch = ctx.executeTool ?? executeTool;
+    let settled = false;
+    let result;
+    void dispatch(tool.name, argsJson, ctx.signal, toolContext)
+        .then((value) => {
+        result = value;
+    })
+        .catch((error) => {
+        result = {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    })
+        .finally(() => {
+        settled = true;
+        wakeProgress?.();
+    });
+    while (!settled || pendingProgress.length > 0) {
+        const progress = pendingProgress.shift();
+        if (progress) {
+            yield progress;
+            continue;
+        }
+        await new Promise((resolveWake) => {
+            wakeProgress = resolveWake;
+            if (settled || pendingProgress.length > 0)
+                resolveWake();
+        });
+        wakeProgress = undefined;
+    }
+    if (!result)
+        throw new Error(`step ${step.id}: 工具执行未返回结果`);
     yield {
         type: 'tool_end',
         toolName: tool.name,
         toolCallId,
         ok: result.ok,
         content: result.ok ? result.content : result.error,
+        metadata: result.metadata,
     };
     if (!result.ok) {
         throw new Error(result.error);
@@ -91,7 +138,7 @@ export async function* execToolStep(step, vars, ctx) {
         role: 'assistant',
         content: `[workflow:${step.id}] ✅ ${tool.name} 执行完成：${summary}`,
         timestamp: Date.now(),
-        id: crypto.randomUUID(),
+        id: randomUUID(),
     });
     // ⚠️ 工具返回的图片**不能丢**。此前这里只取 content，`visionImages` 被静默丢弃 ——
     // 于是任何「截图/看图」类工作流都拿不到产物，而且不会报错，只是后面的评估步没图可看。
@@ -101,77 +148,60 @@ export async function* execToolStep(step, vars, ctx) {
         .map((image) => (typeof image.source === 'string' ? image.source : ''))
         .filter((path) => path.length > 0);
     return {
-        raw: { content, result: content, args, images },
+        raw: {
+            content,
+            result: content,
+            args,
+            images,
+            metadata: result.metadata,
+            recovery: result.recovery,
+            sensitivity: result.sensitivity,
+            visionNote: result.visionNote,
+        },
         preview: content.length > 200 ? `${content.slice(0, 200)}...` : content,
     };
 }
 /**
- * 按 `step.uses` 从宿主上下文里切出这一步该拿到的那片。
- *
- * 三条语义，缺一条这个机制就退化：
- *   · 未声明 `uses` → 返回**空上下文**（不是 undefined，`toolGate` 这类与能力无关的
- *     宿主策略仍要生效）。工具因此走自己的清晰报错，不会静默降级；
- *   · 声明了但宿主没提供 → **响亮报错**。yaml 说了要用电脑，而这次运行根本没开
- *     `--computer-use`，那是配置错误，应该在这一步就停，不是跑到一半才发现；
- *   · 只转发声明过的那一片 —— 声明 `[computer]` 的步拿不到 `browserRun`。
- *
- * 单一出处：切片逻辑只在这里，runner / 其它 executor 都不许自己拼。
- */
-function hostContextFor(step, ctx) {
-    // toolGate 是宿主的通用策略缝（与具体能力无关），任何步都该受它约束。
-    const base = ctx.host?.toolGate
-        ? { toolGate: ctx.host.toolGate }
-        : {};
-    const uses = step.uses ?? [];
-    if (uses.length === 0)
-        return { ctx: base };
-    const out = { ...base };
-    for (const capability of uses) {
-        if (capability === 'computer') {
-            if (!ctx.host?.computerRun) {
-                return {
-                    error: 'uses:[computer] 声明了需要电脑操控能力，但本次运行的宿主没有提供 —— '
-                        + '请用 `--computer-use interactive` 启动，或去掉该步的 uses 声明。',
-                };
-            }
-            out.computerRun = ctx.host.computerRun;
-            // 人工接管通道与能力同进退：没有它，遇到验证/密码只能硬失败。
-            if (ctx.host.computerIntervention)
-                out.computerIntervention = ctx.host.computerIntervention;
-        }
-        else if (capability === 'browser') {
-            if (!ctx.host?.browserRun) {
-                return {
-                    error: 'uses:[browser] 声明了需要浏览器授权上下文，但本次运行的宿主没有提供。'
-                        + '（基础浏览操作不声明 uses 也能用；upload/submit 这类才需要它。）',
-                };
-            }
-            out.browserRun = ctx.host.browserRun;
-        }
-    }
-    return { ctx: out };
-}
-/**
- * 写类 tool 步的目标文件若命中声明产物且已存在 → pre-Read 解除内核守卫。
+ * 写类 tool 步的目标文件若命中【安全的声明产物】且已存在 → pre-Read 解除内核守卫。
  *
  * 路径归一化：artifacts 声明相对 cwd；args.file_path 可能是 ./相对 或 绝对，
  * 双方都 resolve(cwd, …) 后比较（win32 文件系统大小写不敏感 → lowercase 比较；
  * 其余平台保持大小写敏感，避免 Plan.md / plan.md 误判同文件）。
+ *
+ * 安全守卫（修复路径遍历）：
+ *   · 声明的 artifacts 路径先经 safeArtifactPath 校验【必须落在 cwd 内】，
+ *     越界声明直接从命中列表移除——不解守卫，让内核写保护照常生效（fail-closed）。
+ *   · args.file_path 目标自身也做 cwd 内校验：目标越界（工作流步骤想写 cwd 外）
+ *     → 同样不解守卫，让写工具在执行时自己报错（通常是权限/文件不存在提示，
+ *        而不是静默放行盲写，双重保险）。
  */
 async function preReadDeclaredArtifact(tool, args, step, ctx) {
     if (tool.isReadOnly !== false)
         return; // 只对写类工具生效
     if (typeof args.file_path !== 'string')
         return;
+    const cwd = effectiveWorkflowCwd(ctx);
     const norm = (p) => {
-        const abs = resolve(ctx.cwd, p);
+        const abs = resolve(cwd, p);
         return process.platform === 'win32' ? abs.toLowerCase() : abs;
     };
-    const target = norm(args.file_path);
-    const declared = [...(ctx.declaredArtifacts ?? []), ...(step.artifacts ?? [])];
-    if (!declared.some((a) => norm(a) === target))
+    // 1. 目标文件先过 cwd 安全关（越界直接不解守卫）
+    const targetRaw = String(args.file_path);
+    const targetSafe = safeArtifactPath(cwd, targetRaw);
+    if (targetSafe === null)
+        return;
+    const target = norm(targetSafe);
+    // 2. 声明产物过 cwd 安全关（过滤掉越界的声明）
+    const rawDeclared = [...(ctx.declaredArtifacts ?? []), ...(step.artifacts ?? [])];
+    const declaredAbs = [];
+    for (const raw of rawDeclared) {
+        const safe = safeArtifactPath(cwd, raw);
+        if (safe !== null)
+            declaredAbs.push(norm(safe));
+    }
+    if (!declaredAbs.some((a) => a === target))
         return;
-    const abs = resolve(ctx.cwd, args.file_path);
+    const abs = resolve(cwd, targetSafe);
     if (!existsSync(abs))
         return; // 新建文件不需要解守卫
     // 直接登记一次「完整已读」状态解除内核 pre-read 守卫——不真正 Read 内容：
@@ -182,7 +212,7 @@ async function preReadDeclaredArtifact(tool, args, step, ctx) {
     //      （首轮新建 PLAN.md 不存在直接放行，审批反馈后回写已存在的大 PLAN.md 被挡死）。
     //   两道守卫（never-read + truncated）必须一并解除，声明产物的整体覆盖才算真正授权。
     // recordRead 内部自带 statSync 失败兜底（返回 1、不抛），无需再包 try/catch。
-    recordRead(abs, { truncated: false });
+    recordRead(abs, { truncated: false }, ctx.sessionState?.fileReads);
 }
 /**
  * 给 tool_start 生成人话描述（LiveArea spinner 行用）。

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

@@ -22,18 +22,23 @@
  * ============================================================
  */
 
+import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 import {
+  type LoopEvent,
+  type ToolResult,
   executeTool,
   getToolByName,
   recordRead,
-  type LoopEvent,
-  type ToolCallContext,
 } from '../../../../src/plugin-sdk.js';
 import { interpolateDeep } from '../expressions.js';
-import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
+import {
+  buildWorkflowToolContext,
+  effectiveWorkflowCwd,
+} from '../toolRuntime.js';
+import { safeArtifactPath, type RunContext, type StepDef, type StepResult, type VarStack } from '../types.js';
 
 export async function* execToolStep(
   step: StepDef,
@@ -74,19 +79,73 @@ export async function* execToolStep(
   };
 
   // ════ 声明产物覆盖判定（解 Write/Edit 的 pre-read 守卫） ════
-  // 内核写类工具有「文件已存在必须先 Read」守卫（fileState 进程级 Map，
-  // 跨进程 / resume / 残留旧产物时必空）。确定性 tool 步的 args 是 yaml 作者
+  // 内核写类工具有「文件已存在必须先 Read」守卫（fileState 按会话隔离，
+  // 跨进程 / resume / 残留旧产物时可能为空）。确定性 tool 步的 args 是 yaml 作者
   // 写死的，模型没有机会先 Read —— 目标文件若是工作流**声明的产物**
   // （def 级 + step 级 artifacts:，= 工作流自己拥有、本就要覆盖的文件），
   // 这里自动 pre-Read 一次解除守卫（管线动作，不 yield 事件、结果丢弃）。
   // 非声明产物的盲写保护原样生效；pre-Read 失败也不拦，让写工具自己报错。
-  await preReadDeclaredArtifact(tool, args as Record<string, unknown>, step, ctx);
+  await preReadDeclaredArtifact(
+    tool,
+    args as Record<string, unknown>,
+    step,
+    ctx,
+  );
 
   // 宿主能力按 `uses:` 切片后转发。`executeTool` 的第四参此前从未传过 ——
   // 这正是「workflow 里 ComputerUse 恒失败」的末端表现。
-  const hostSlice = hostContextFor(step, ctx);
-  if ('error' in hostSlice) throw new Error(`step ${step.id}: ${hostSlice.error}`);
-  const result = await executeTool(tool.name, argsJson, ctx.signal, hostSlice.ctx);
+  const pendingProgress: LoopEvent[] = [];
+  let wakeProgress: (() => void) | undefined;
+  const toolContext = buildWorkflowToolContext(
+    step,
+    ctx,
+    toolCallId,
+    (message, detail) => {
+      pendingProgress.push({
+        type: 'tool_progress',
+        toolName: tool.name,
+        toolCallId,
+        message,
+        detail,
+      });
+      wakeProgress?.();
+    },
+  );
+  if ('error' in toolContext) {
+    throw new Error(`step ${step.id}: ${toolContext.error}`);
+  }
+
+  const dispatch = ctx.executeTool ?? executeTool;
+  let settled = false;
+  let result: ToolResult | undefined;
+  void dispatch(tool.name, argsJson, ctx.signal, toolContext)
+    .then((value) => {
+      result = value;
+    })
+    .catch((error: unknown) => {
+      result = {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    })
+    .finally(() => {
+      settled = true;
+      wakeProgress?.();
+    });
+
+  while (!settled || pendingProgress.length > 0) {
+    const progress = pendingProgress.shift();
+    if (progress) {
+      yield progress;
+      continue;
+    }
+    await new Promise<void>((resolveWake) => {
+      wakeProgress = resolveWake;
+      if (settled || pendingProgress.length > 0) resolveWake();
+    });
+    wakeProgress = undefined;
+  }
+  if (!result) throw new Error(`step ${step.id}: 工具执行未返回结果`);
 
   yield {
     type: 'tool_end',
@@ -94,6 +153,7 @@ export async function* execToolStep(
     toolCallId,
     ok: result.ok,
     content: result.ok ? result.content : result.error,
+    metadata: result.metadata,
   };
 
   if (!result.ok) {
@@ -105,14 +165,15 @@ export async function* execToolStep(
   // 后续 agent/llm/skill 步骤走 runQuery() 时，LLM 能在上下文中看到
   // 这步做了什么（与正常 TAOR 循环中 tool_call → tool_result 的记录方式一致）。
   // 只记录精简摘要（不把完整工具回执塞入 history，避免 token 浪费）。
-  const summary = content.length > 500
-    ? `${content.slice(0, 500)}…（已截断，共 ${content.length} 字符）`
-    : content;
+  const summary =
+    content.length > 500
+      ? `${content.slice(0, 500)}…（已截断，共 ${content.length} 字符）`
+      : content;
   ctx.history.push({
     role: 'assistant',
     content: `[workflow:${step.id}] ✅ ${tool.name} 执行完成：${summary}`,
     timestamp: Date.now(),
-    id: crypto.randomUUID(),
+    id: randomUUID(),
   });
 
   // ⚠️ 工具返回的图片**不能丢**。此前这里只取 content，`visionImages` 被静默丢弃 ——
@@ -124,67 +185,33 @@ export async function* execToolStep(
     .filter((path) => path.length > 0);
 
   return {
-    raw: { content, result: content, args, images },
+    raw: {
+      content,
+      result: content,
+      args,
+      images,
+      metadata: result.metadata,
+      recovery: result.recovery,
+      sensitivity: result.sensitivity,
+      visionNote: result.visionNote,
+    },
     preview: content.length > 200 ? `${content.slice(0, 200)}...` : content,
   };
 }
 
 /**
- * 按 `step.uses` 从宿主上下文里切出这一步该拿到的那片。
- *
- * 三条语义，缺一条这个机制就退化：
- *   · 未声明 `uses` → 返回**空上下文**（不是 undefined，`toolGate` 这类与能力无关的
- *     宿主策略仍要生效）。工具因此走自己的清晰报错，不会静默降级；
- *   · 声明了但宿主没提供 → **响亮报错**。yaml 说了要用电脑，而这次运行根本没开
- *     `--computer-use`，那是配置错误，应该在这一步就停，不是跑到一半才发现；
- *   · 只转发声明过的那一片 —— 声明 `[computer]` 的步拿不到 `browserRun`。
- *
- * 单一出处：切片逻辑只在这里，runner / 其它 executor 都不许自己拼。
- */
-function hostContextFor(
-  step: StepDef,
-  ctx: RunContext,
-): { ctx: ToolCallContext } | { error: string } {
-  // toolGate 是宿主的通用策略缝（与具体能力无关），任何步都该受它约束。
-  const base: ToolCallContext = ctx.host?.toolGate
-    ? { toolGate: ctx.host.toolGate }
-    : {};
-  const uses = step.uses ?? [];
-  if (uses.length === 0) return { ctx: base };
-
-  const out: ToolCallContext = { ...base };
-  for (const capability of uses) {
-    if (capability === 'computer') {
-      if (!ctx.host?.computerRun) {
-        return {
-          error:
-            'uses:[computer] 声明了需要电脑操控能力，但本次运行的宿主没有提供 —— '
-            + '请用 `--computer-use interactive` 启动，或去掉该步的 uses 声明。',
-        };
-      }
-      out.computerRun = ctx.host.computerRun;
-      // 人工接管通道与能力同进退：没有它，遇到验证/密码只能硬失败。
-      if (ctx.host.computerIntervention) out.computerIntervention = ctx.host.computerIntervention;
-    } else if (capability === 'browser') {
-      if (!ctx.host?.browserRun) {
-        return {
-          error:
-            'uses:[browser] 声明了需要浏览器授权上下文，但本次运行的宿主没有提供。'
-            + '（基础浏览操作不声明 uses 也能用；upload/submit 这类才需要它。）',
-        };
-      }
-      out.browserRun = ctx.host.browserRun;
-    }
-  }
-  return { ctx: out };
-}
-
-/**
- * 写类 tool 步的目标文件若命中声明产物且已存在 → pre-Read 解除内核守卫。
+ * 写类 tool 步的目标文件若命中【安全的声明产物】且已存在 → pre-Read 解除内核守卫。
  *
  * 路径归一化：artifacts 声明相对 cwd；args.file_path 可能是 ./相对 或 绝对，
  * 双方都 resolve(cwd, …) 后比较（win32 文件系统大小写不敏感 → lowercase 比较；
  * 其余平台保持大小写敏感，避免 Plan.md / plan.md 误判同文件）。
+ *
+ * 安全守卫（修复路径遍历）：
+ *   · 声明的 artifacts 路径先经 safeArtifactPath 校验【必须落在 cwd 内】，
+ *     越界声明直接从命中列表移除——不解守卫，让内核写保护照常生效（fail-closed）。
+ *   · args.file_path 目标自身也做 cwd 内校验：目标越界（工作流步骤想写 cwd 外）
+ *     → 同样不解守卫，让写工具在执行时自己报错（通常是权限/文件不存在提示，
+ *        而不是静默放行盲写，双重保险）。
  */
 async function preReadDeclaredArtifact(
   tool: { name: string; isReadOnly?: boolean },
@@ -195,15 +222,28 @@ async function preReadDeclaredArtifact(
   if (tool.isReadOnly !== false) return; // 只对写类工具生效
   if (typeof args.file_path !== 'string') return;
 
+  const cwd = effectiveWorkflowCwd(ctx);
   const norm = (p: string): string => {
-    const abs = resolve(ctx.cwd, p);
+    const abs = resolve(cwd, p);
     return process.platform === 'win32' ? abs.toLowerCase() : abs;
   };
-  const target = norm(args.file_path);
-  const declared = [...(ctx.declaredArtifacts ?? []), ...(step.artifacts ?? [])];
-  if (!declared.some((a) => norm(a) === target)) return;
 
-  const abs = resolve(ctx.cwd, args.file_path);
+  // 1. 目标文件先过 cwd 安全关（越界直接不解守卫）
+  const targetRaw = String(args.file_path);
+  const targetSafe = safeArtifactPath(cwd, targetRaw);
+  if (targetSafe === null) return;
+  const target = norm(targetSafe);
+
+  // 2. 声明产物过 cwd 安全关（过滤掉越界的声明）
+  const rawDeclared = [...(ctx.declaredArtifacts ?? []), ...(step.artifacts ?? [])];
+  const declaredAbs: string[] = [];
+  for (const raw of rawDeclared) {
+    const safe = safeArtifactPath(cwd, raw);
+    if (safe !== null) declaredAbs.push(norm(safe));
+  }
+  if (!declaredAbs.some((a) => a === target)) return;
+
+  const abs = resolve(cwd, targetSafe);
   if (!existsSync(abs)) return; // 新建文件不需要解守卫
 
   // 直接登记一次「完整已读」状态解除内核 pre-read 守卫——不真正 Read 内容：
@@ -214,7 +254,7 @@ async function preReadDeclaredArtifact(
   //      （首轮新建 PLAN.md 不存在直接放行，审批反馈后回写已存在的大 PLAN.md 被挡死）。
   //   两道守卫（never-read + truncated）必须一并解除，声明产物的整体覆盖才算真正授权。
   // recordRead 内部自带 statSync 失败兜底（返回 1、不抛），无需再包 try/catch。
-  recordRead(abs, { truncated: false });
+  recordRead(abs, { truncated: false }, ctx.sessionState?.fileReads);
 }
 
 /**

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

@@ -12,7 +12,8 @@
  */
 import { parseCheckString, runVerification } from '../../../../src/plugin-sdk.js';
 import { interpolate } from '../expressions.js';
-export async function execVerifyStep(step, vars) {
+import { effectiveWorkflowCwd } from '../toolRuntime.js';
+export async function execVerifyStep(step, vars, ctx) {
     // 兼容两种格式：YAML 数组 或逗号分隔字符串。
     // 关键：【先插值再按逗号分割】。checks 可能是 "${verify_checks}" 这类模板，插值后才
     // 展开成逗号分隔的多项（如 "shell:bun test,file_exists:x"）。若先分割再插值，整段模板
@@ -43,8 +44,10 @@ export async function execVerifyStep(step, vars) {
         }
         checks.push(check);
     }
-    // 执行所有检查
-    const result = await runVerification(checks);
+    // 执行所有检查。
+    // cwd 必须和写入侧同源：会话进了 session worktree 时产物落在 worktree 里，
+    // 验收若锚原 workspace 会在空目录找文件，恒判失败并触发无意义的重试。
+    const result = await runVerification(checks, effectiveWorkflowCwd(ctx));
     if (!result.passed) {
         const msg = step.onFail
             ? interpolate(step.onFail, vars)

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

@@ -13,11 +13,13 @@
 
 import { parseCheckString, runVerification, type Check } from '../../../../src/plugin-sdk.js';
 import { interpolate } from '../expressions.js';
-import type { StepDef, StepResult, VarStack } from '../types.js';
+import { effectiveWorkflowCwd } from '../toolRuntime.js';
+import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
 
 export async function execVerifyStep(
   step: StepDef,
   vars: VarStack,
+  ctx: RunContext,
 ): Promise<StepResult> {
   // 兼容两种格式：YAML 数组 或逗号分隔字符串。
   // 关键：【先插值再按逗号分割】。checks 可能是 "${verify_checks}" 这类模板，插值后才
@@ -51,8 +53,10 @@ export async function execVerifyStep(
     checks.push(check);
   }
 
-  // 执行所有检查
-  const result = await runVerification(checks);
+  // 执行所有检查。
+  // cwd 必须和写入侧同源：会话进了 session worktree 时产物落在 worktree 里，
+  // 验收若锚原 workspace 会在空目录找文件，恒判失败并触发无意义的重试。
+  const result = await runVerification(checks, effectiveWorkflowCwd(ctx));
 
   if (!result.passed) {
     const msg = step.onFail