minimal-agent 0.12.0 → 0.13.0

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

@@ -21,11 +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 字段`);
@@ -136,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` 被静默丢弃 ——
     // 于是任何「截图/看图」类工作流都拿不到产物，而且不会报错，只是后面的评估步没图可看。
@@ -160,29 +162,46 @@ export async function* execToolStep(step, vars, ctx) {
     };
 }
 /**
- * 写类 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(effectiveWorkflowCwd(ctx), 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(effectiveWorkflowCwd(ctx), args.file_path);
+    const abs = resolve(cwd, targetSafe);
     if (!existsSync(abs))
         return; // 新建文件不需要解守卫
     // 直接登记一次「完整已读」状态解除内核 pre-read 守卫——不真正 Read 内容：

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

@@ -22,6 +22,7 @@
  * ============================================================
  */
 
+import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 
@@ -37,7 +38,7 @@ import {
   buildWorkflowToolContext,
   effectiveWorkflowCwd,
 } from '../toolRuntime.js';
-import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
+import { safeArtifactPath, type RunContext, type StepDef, type StepResult, type VarStack } from '../types.js';
 
 export async function* execToolStep(
   step: StepDef,
@@ -172,7 +173,7 @@ export async function* execToolStep(
     role: 'assistant',
     content: `[workflow:${step.id}] ✅ ${tool.name} 执行完成：${summary}`,
     timestamp: Date.now(),
-    id: crypto.randomUUID(),
+    id: randomUUID(),
   });
 
   // ⚠️ 工具返回的图片**不能丢**。此前这里只取 content，`visionImages` 被静默丢弃 ——
@@ -199,11 +200,18 @@ export async function* execToolStep(
 }
 
 /**
- * 写类 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 },
@@ -214,18 +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(effectiveWorkflowCwd(ctx), 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(effectiveWorkflowCwd(ctx), 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 内容：

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

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

@@ -1,29 +1,88 @@
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
 import { chat as sdkChat, executeTool as sdkExecuteTool, } from '../../../src/plugin-sdk.js';
 import { truncate } from './agentCommon.js';
 import { extractJsonPayload } from './jsonPayload.js';
 // ============================================================
-//  工作流状态目录布局（E6 修复：按 workflow 名隔离）
+//  工作流状态目录布局（Phase 1 + 2 + 3 升级）
 // ------------------------------------------------------------
-//  <cwd>/.minimal-agent-workflow/<name>/      ← 每个工作流独立状态
-//  <cwd>/.minimal-agent-workflow/<name>.done/ ← 成功归档
-//  曾经一个 cwd 单例目录：A（如 /plan）未完成时跑不同名工作流 B，
-//  init 的 new-task 路径会清掉 A 的声明产物 + 整个状态目录，A 永久失去
-//  resume 能力——与「不同任务中间文件互不干扰」需求直接冲突。
-//  按名隔离后跨工作流互不可见，互踩从结构上消失。
-//  /new 的前缀清理（.minimal-agent*）作用于父目录，行为不变。
+//  状态根目录优先级：
+//    1. 环境变量 MINIMAL_AGENT_WORKFLOW_STATE_DIR（全局统一目录）
+//    2. <cwd>/.minimal-agent-workflow/（默认，与历史行为一致）
+//
+//  目录结构（三级：工作流名 / session 实例 / taskId 记录）：
+//    <stateRoot>/<workflowName>/<sessionId>/       ← 活动任务实例（session 即任务实例）
+//    <stateRoot>/<workflowName>/<sessionId>.done/  ← 成功完成的实例归档
+//    <stateRoot>/<workflowName>/<sessionId>.trash/ ← 清理回收（A4 归档）
+//
+//  Phase 3（session 化）：实例目录名 = sessionId（一个 session 同时只跑一个
+//  同名工作流，session 即天然的任务实例划分单元）。taskId（goal 内容 hash）
+//  降级为 current.json 里的【记录字段】——用于同 session 内识别「换主题 →
+//  new-task 归档重建 / 同主题 → resume/completed」。不同 session 完全隔离，
+//  同主题也可并行互不干扰。
+//
+//  演进历史：
+//    - 最初：<cwd>/.minimal-agent-workflow/ 单例（所有工作流共用）
+//    - E6：按 workflow 名隔离，<cwd>/.minimal-agent-workflow/<name>/
+//    - Phase 1：状态根目录可配置（环境变量指定全局位置，解决 cwd 切换找不到）
+//    - Phase 2：新增 taskId 实例层，同名 workflow 多任务并存（根治新任务清掉旧状态）
+//    - Phase 3：实例目录名改为 sessionId，taskId 降级为记录字段（多 session 真正并行）
 // ============================================================
-/** 工作流状态目录的父目录名（/new 按 .minimal-agent 前缀整体清理）。 */
+/** 工作流状态目录的父目录名（默认落在 cwd 下时使用）。 */
 export const WF_STATE_PARENT = '.minimal-agent-workflow';
-/** 把 workflow 名清洗成安全的目录名（保留字母数字._-，其余替换为 -）。 */
+/** 全局统一状态目录的环境变量名。 */
+export const WF_STATE_DIR_ENV = 'MINIMAL_AGENT_WORKFLOW_STATE_DIR';
+/** 缺省 sessionId（宿主未显式传 session 时的兜底判定值；真正落盘的 session 由 generateDefaultSessionId 自动命名）。 */
+export const DEFAULT_SESSION_ID = 'default';
+/**
+ * 工作流引擎的默认 session 自动命名：宿主未显式提供有意义 session（缺失或为
+ * DEFAULT_SESSION_ID）时，由引擎自行生成唯一可读的 session 名
+ * `YYYYMMDD-HHmmss-xxxxxx`（日期时间 + 6 位随机 hex）。
+ *
+ * 语义：每次工作流运行（CLI -p 默认 / TUI default 会话）都自动落到独立的
+ * `<out>/<workflow>/<session>/` 产物目录与 `<stateRoot>/<workflow>/<session>/`
+ * 状态目录——多 session 并行互不覆盖；时间前缀便于人识别与排序，随机后缀
+ * 防同一秒并行冲突。宿主显式传 `-s <id>`（非 default）时仍优先使用宿主 id。
+ */
+export function generateDefaultSessionId(now = new Date()) {
+    const pad = (n, w = 2) => String(n).padStart(w, '0');
+    const date = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+    const time = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const rand = randomBytes(3).toString('hex');
+    return `${date}-${time}-${rand}`;
+}
+/**
+ * 解析状态根目录（绝对路径）。
+ * 优先级：环境变量 MINIMAL_AGENT_WORKFLOW_STATE_DIR > cwd 下默认目录。
+ * 环境变量允许相对路径——基于 process.cwd() 展开（用户可能写 `.wflow` 这类相对值）。
+ * 传入 workingDir 是为了 cwd 默认模式的相对路径基准。
+ */
+export function resolveStateRoot(workingDir) {
+    const envDir = process.env[WF_STATE_DIR_ENV];
+    if (envDir && envDir.trim()) {
+        const p = envDir.trim();
+        return isAbsolute(p) ? p : resolve(p);
+    }
+    return join(workingDir, WF_STATE_PARENT);
+}
+/** 把 workflow 名 / sessionId 清洗成安全的目录名（保留字母数字._-，其余替换为 -）。 */
 export function sanitizeWorkflowDirName(name) {
     return name.replace(/[^\w.-]/g, '-');
 }
-/** 某 workflow 的状态目录绝对路径。workflowState / taskIdentity 共用唯一权威实现。 */
+/**
+ * 某 workflow 的状态目录绝对路径（workflow 级目录，下含多个 session 实例）。
+ * workflowState / taskIdentity 共用唯一权威实现。
+ */
 export function workflowStateDir(workingDir, workflowName) {
-    return join(workingDir, WF_STATE_PARENT, sanitizeWorkflowDirName(workflowName));
+    return join(resolveStateRoot(workingDir), sanitizeWorkflowDirName(workflowName));
+}
+/**
+ * 具体任务实例（= session）的状态目录。
+ * 成功后改名为 <sessionId>.done/；清理归档目录为 <sessionId>.trash/。
+ */
+export function taskInstanceDir(workingDir, workflowName, sessionId) {
+    return join(workflowStateDir(workingDir, workflowName), sanitizeWorkflowDirName(sessionId));
 }
 /**
  * 计算任务身份 hash。
@@ -41,8 +100,15 @@ export function workflowStateDir(workingDir, workflowName) {
  *   - 去除所有标点符号（保留中文、英文、数字、空格）
  *   - 去除多余空格（连续空格→单空格，首尾 trim）
  *   - 截断到 200 字符（防止超长输入导致不必要的差异）
+ *
+ * 参数：
+ *   - workingDir：不传只返回 hash（纯计算，不读盘）。
+ *   - sessionId：Phase 3 后传入——实例查找限定到「当前 session」的实例目录
+ *     （<wfDir>/<sessionId>/ 与 <sessionId>.done/），读其 current.json 的 taskId
+ *     记录与本次 hash 比较。缺省时退化为旧行为（扫 wfDir 下所有 taskId 实例），
+ *     兼容历史调用与测试。
  */
-export function computeTaskId(workflowName, inputs, workingDir) {
+export function computeTaskId(workflowName, inputs, workingDir, sessionId) {
     // 1. 提取 goal 文本（与 buildGoalAnchor 同策略）
     const rawGoal = extractGoal(inputs);
     // 2. 归一化 goal
@@ -60,8 +126,23 @@ export function computeTaskId(workflowName, inputs, workingDir) {
             reason: 'no_previous',
         };
     }
-    // 5. 尝试读取旧状态文件（按 workflow 名隔离的状态目录）
-    const stateFilePath = join(workflowStateDir(workingDir, workflowName), 'current.json');
+    // 5. 找当前任务对应的实例目录，读其 current.json 记录与本次 hash 比较
+    //    （Phase 3：session 语义——只查当前 session 的实例；taskId 是记录字段）
+    const wfDir = workflowStateDir(workingDir, workflowName);
+    const candidateDirs = findTaskInstanceDirs(wfDir, contentHash, sessionId);
+    if (candidateDirs.length === 0) {
+        // 无精确匹配。但若 wfDir 下存在其他任务实例（不同 goal / 已归档），
+        // 语义仍是「新任务 + 旧任务在场」——返回 hash_diff 而非 no_previous，
+        // 让 workflowState.init 能触发仲裁/清理旧产物（旧布局靠读 wfDir/current.json
+        // 天然得到这个信号，新布局必须显式扫描）。
+        return {
+            hash: contentHash,
+            isSameTask: false,
+            reason: hasAnyTaskInstanceInDir(wfDir, sessionId) ? 'hash_diff' : 'no_previous',
+        };
+    }
+    // 取第一个匹配的（hash 一样就是同一任务，不应有多个；有多个也只取第一个）
+    const stateFilePath = join(candidateDirs[0], 'current.json');
     if (!existsSync(stateFilePath)) {
         return {
             hash: contentHash,
@@ -70,9 +151,9 @@ export function computeTaskId(workflowName, inputs, workingDir) {
         };
     }
     try {
-        const stateContent = readFileSync(stateFilePath, 'utf-8');
+        const stateContent = readFileSync(stateFilePath, 'utf8');
         const prevState = JSON.parse(stateContent);
-        // a. 不同 workflow 名 → 不同任务
+        // a. 不同 workflow 名 → 不同任务（理论上不会发生，因为已经按目录隔离了，防御性检查）
         if (prevState.name && prevState.name !== workflowName) {
             return {
                 hash: contentHash,
@@ -104,6 +185,101 @@ export function computeTaskId(workflowName, inputs, workingDir) {
         };
     }
 }
+/**
+ * 在 workflow 级目录下，找到当前任务对应的实例目录。
+ * 支持两种布局：
+ *   - 新布局（Phase 3，传 sessionId）：<wfDir>/<sessionId>/current.json（活动）
+ *     与 <wfDir>/<sessionId>.done/current.json（已完成）
+ *   - 旧布局（Phase 2，不传 sessionId）：<wfDir>/<taskId>/current.json
+ *     与 <wfDir>/<taskId>.done/current.json
+ *   - 旧布局兼容（无 session 层）：<wfDir>/current.json —— 把整个 wfDir 当成一个实例
+ * 返回绝对路径数组。
+ */
+function findTaskInstanceDirs(wfDir, taskId, sessionId) {
+    const results = [];
+    if (sessionId) {
+        // Phase 3：session 语义 —— 只找当前 session 的实例（taskId 是记录字段，目录名是 sessionId）
+        const activeDir = join(wfDir, sanitizeWorkflowDirName(sessionId));
+        const doneDir = join(wfDir, `${sanitizeWorkflowDirName(sessionId)}.done`);
+        if (existsSync(activeDir))
+            results.push(activeDir);
+        if (existsSync(doneDir))
+            results.push(doneDir);
+    }
+    else {
+        // Phase 2 旧行为：<wfDir>/<taskId>/ 和 <wfDir>/<taskId>.done/
+        const activeDir = join(wfDir, taskId);
+        const doneDir = join(wfDir, `${taskId}.done`);
+        if (existsSync(activeDir))
+            results.push(activeDir);
+        if (existsSync(doneDir))
+            results.push(doneDir);
+    }
+    if (results.length > 0)
+        return results;
+    // 旧布局兼容：wfDir 本身就是实例目录（current.json 直接在 wfDir 下）
+    // 检测方法：wfDir/current.json 存在且 wfDir 下没有子目录是 taskId 格式
+    if (existsSync(join(wfDir, 'current.json'))) {
+        // 确认这是旧布局（不是某个子实例目录）
+        try {
+            const entries = readdirSync(wfDir, { withFileTypes: true });
+            const hasInstanceSubdir = entries.some((e) => e.isDirectory() && /^[0-9a-f]{16}$/.test(e.name));
+            if (!hasInstanceSubdir) {
+                results.push(wfDir);
+            }
+        }
+        catch {
+            // 读不到就当旧布局
+            results.push(wfDir);
+        }
+    }
+    return results;
+}
+/**
+ * 检查 wfDir 下是否存在任何任务实例（活动态 / .done 归档态 / 旧布局 current.json）。
+ * 不含 .trash 回收目录。用于 computeTaskId 在无精确匹配时区分
+ * hash_diff（有其他旧任务）与 no_previous（从未跑过）。
+ * 传 sessionId 时只统计当前 session 的实例（Phase 3）。
+ */
+function hasAnyTaskInstanceInDir(wfDir, sessionId) {
+    if (!existsSync(wfDir))
+        return false;
+    try {
+        if (sessionId) {
+            // Phase 3：只看当前 session 的实例
+            const active = join(wfDir, sanitizeWorkflowDirName(sessionId));
+            const done = join(wfDir, `${sanitizeWorkflowDirName(sessionId)}.done`);
+            if (existsSync(active))
+                return true;
+            if (existsSync(done))
+                return true;
+            // 旧布局：wfDir 本身就是实例目录
+            if (existsSync(join(wfDir, 'current.json')))
+                return true;
+            if (existsSync(join(wfDir + '.done', 'current.json')))
+                return true;
+            return false;
+        }
+        const entries = readdirSync(wfDir, { withFileTypes: true });
+        for (const e of entries) {
+            if (!e.isDirectory())
+                continue;
+            if (/^[0-9a-f]{16}$/.test(e.name))
+                return true; // 活动实例
+            if (/^[0-9a-f]{16}\.done$/.test(e.name))
+                return true; // 归档实例
+        }
+        // 旧布局：wfDir 本身就是实例目录
+        if (existsSync(join(wfDir, 'current.json')))
+            return true;
+        if (existsSync(join(wfDir + '.done', 'current.json')))
+            return true;
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * 从 inputs 中提取 goal 文本
  *
@@ -225,7 +401,7 @@ async function llmArbitrate(deps, actx) {
     for await (const ev of chatFn({
         provider: deps.provider,
         messages: [
-            { role: 'user', content: prompt, timestamp: Date.now(), id: crypto.randomUUID() },
+            { role: 'user', content: prompt, timestamp: Date.now(), id: randomUUID() },
         ],
         tools: [],
         signal: deps.signal,