minimal-agent 0.11.0 → 0.13.0

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,

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

@@ -1,6 +1,6 @@
-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,
@@ -12,28 +12,96 @@ import { extractJsonPayload } from './jsonPayload.js';
 import type { RunContext } from './types.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()): string {
+  const pad = (n: number, w = 2): string => 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: string): string {
+  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: string): string {
   return name.replace(/[^\w.-]/g, '-');
 }
 
-/** 某 workflow 的状态目录绝对路径。workflowState / taskIdentity 共用唯一权威实现。 */
+/**
+ * 某 workflow 的状态目录绝对路径（workflow 级目录，下含多个 session 实例）。
+ * workflowState / taskIdentity 共用唯一权威实现。
+ */
 export function workflowStateDir(workingDir: string, workflowName: string): string {
-  return join(workingDir, WF_STATE_PARENT, sanitizeWorkflowDirName(workflowName));
+  return join(resolveStateRoot(workingDir), sanitizeWorkflowDirName(workflowName));
+}
+
+/**
+ * 具体任务实例（= session）的状态目录。
+ * 成功后改名为 <sessionId>.done/；清理归档目录为 <sessionId>.trash/。
+ */
+export function taskInstanceDir(
+  workingDir: string,
+  workflowName: string,
+  sessionId: string,
+): string {
+  return join(workflowStateDir(workingDir, workflowName), sanitizeWorkflowDirName(sessionId));
 }
 
 /**
@@ -64,11 +132,19 @@ export interface TaskIdentityResult {
  *   - 去除所有标点符号（保留中文、英文、数字、空格）
  *   - 去除多余空格（连续空格→单空格，首尾 trim）
  *   - 截断到 200 字符（防止超长输入导致不必要的差异）
+ *
+ * 参数：
+ *   - workingDir：不传只返回 hash（纯计算，不读盘）。
+ *   - sessionId：Phase 3 后传入——实例查找限定到「当前 session」的实例目录
+ *     （<wfDir>/<sessionId>/ 与 <sessionId>.done/），读其 current.json 的 taskId
+ *     记录与本次 hash 比较。缺省时退化为旧行为（扫 wfDir 下所有 taskId 实例），
+ *     兼容历史调用与测试。
  */
 export function computeTaskId(
   workflowName: string,
   inputs: Record<string, unknown>,
   workingDir?: string,
+  sessionId?: string,
 ): TaskIdentityResult {
   // 1. 提取 goal 文本（与 buildGoalAnchor 同策略）
   const rawGoal = extractGoal(inputs);
@@ -91,9 +167,25 @@ export function computeTaskId(
     };
   }
 
-  // 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,
@@ -103,14 +195,14 @@ export function computeTaskId(
   }
 
   try {
-    const stateContent = readFileSync(stateFilePath, 'utf-8');
+    const stateContent = readFileSync(stateFilePath, 'utf8');
     const prevState = JSON.parse(stateContent) as {
       taskId?: string;
       name?: string;
       startedAt?: string;
     };
 
-    // a. 不同 workflow 名 → 不同任务
+    // a. 不同 workflow 名 → 不同任务（理论上不会发生，因为已经按目录隔离了，防御性检查）
     if (prevState.name && prevState.name !== workflowName) {
       return {
         hash: contentHash,
@@ -144,6 +236,95 @@ export function computeTaskId(
   }
 }
 
+/**
+ * 在 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: string,
+  taskId: string,
+  sessionId?: string,
+): string[] {
+  const results: string[] = [];
+
+  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: string, sessionId?: string): boolean {
+  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 文本
  *
@@ -326,7 +507,7 @@ async function llmArbitrate(
   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,

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

@@ -0,0 +1,48 @@
+/**
+ * The workflow identity stays anchored to the registered workspace, while file
+ * and process tools follow a session worktree as soon as EnterWorktree creates
+ * one. Keeping this decision in one helper prevents executors from drifting.
+ */
+export function effectiveWorkflowCwd(ctx) {
+    return ctx.sessionState?.activeWorktree?.path ?? ctx.cwd;
+}
+export function buildWorkflowToolContext(step, ctx, toolCallId, reportProgress) {
+    const context = {
+        ...ctx.toolContext,
+        history: ctx.history,
+        sessionState: ctx.sessionState,
+        provider: ctx.provider,
+        toolGate: ctx.host?.toolGate ?? ctx.toolContext?.toolGate,
+        promptCache: ctx.promptCache ?? ctx.toolContext?.promptCache,
+        workspaceId: ctx.runtimeContext?.workspaceId ?? ctx.toolContext?.workspaceId,
+        sessionId: ctx.runtimeContext?.sessionId ?? ctx.toolContext?.sessionId,
+        memoryAccess: ctx.runtimeContext?.memoryAccess ?? ctx.toolContext?.memoryAccess,
+        cwd: effectiveWorkflowCwd(ctx),
+        toolCallId,
+        reportProgress,
+    };
+    for (const capability of step.uses ?? []) {
+        if (capability === 'computer') {
+            if (!ctx.host?.computerRun) {
+                return {
+                    error: 'uses:[computer] 声明了需要电脑操控能力，但本次运行的宿主没有提供 —— ' +
+                        '请在支持 Computer Use 的宿主启动，或去掉该步的 uses 声明。',
+                };
+            }
+            context.computerRun = ctx.host.computerRun;
+            if (ctx.host.computerIntervention) {
+                context.computerIntervention = ctx.host.computerIntervention;
+            }
+            continue;
+        }
+        if (capability === 'browser') {
+            if (!ctx.host?.browserRun) {
+                return {
+                    error: 'uses:[browser] 声明了需要浏览器授权上下文，但本次运行的宿主没有提供。',
+                };
+            }
+            context.browserRun = ctx.host.browserRun;
+        }
+    }
+    return context;
+}

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

@@ -0,0 +1,64 @@
+import type { ToolCallContext } from '../../../src/plugin-sdk.js';
+import type { RunContext, StepDef } from './types.js';
+
+/**
+ * The workflow identity stays anchored to the registered workspace, while file
+ * and process tools follow a session worktree as soon as EnterWorktree creates
+ * one. Keeping this decision in one helper prevents executors from drifting.
+ */
+export function effectiveWorkflowCwd(ctx: RunContext): string {
+  return ctx.sessionState?.activeWorktree?.path ?? ctx.cwd;
+}
+
+export function buildWorkflowToolContext(
+  step: StepDef,
+  ctx: RunContext,
+  toolCallId: string,
+  reportProgress: NonNullable<ToolCallContext['reportProgress']>,
+): ToolCallContext | { error: string } {
+  const context: ToolCallContext = {
+    ...ctx.toolContext,
+    history: ctx.history,
+    sessionState: ctx.sessionState,
+    provider: ctx.provider,
+    toolGate: ctx.host?.toolGate ?? ctx.toolContext?.toolGate,
+    promptCache: ctx.promptCache ?? ctx.toolContext?.promptCache,
+    workspaceId:
+      ctx.runtimeContext?.workspaceId ?? ctx.toolContext?.workspaceId,
+    sessionId: ctx.runtimeContext?.sessionId ?? ctx.toolContext?.sessionId,
+    memoryAccess:
+      ctx.runtimeContext?.memoryAccess ?? ctx.toolContext?.memoryAccess,
+    cwd: effectiveWorkflowCwd(ctx),
+    toolCallId,
+    reportProgress,
+  };
+
+  for (const capability of step.uses ?? []) {
+    if (capability === 'computer') {
+      if (!ctx.host?.computerRun) {
+        return {
+          error:
+            'uses:[computer] 声明了需要电脑操控能力，但本次运行的宿主没有提供 —— ' +
+            '请在支持 Computer Use 的宿主启动，或去掉该步的 uses 声明。',
+        };
+      }
+      context.computerRun = ctx.host.computerRun;
+      if (ctx.host.computerIntervention) {
+        context.computerIntervention = ctx.host.computerIntervention;
+      }
+      continue;
+    }
+
+    if (capability === 'browser') {
+      if (!ctx.host?.browserRun) {
+        return {
+          error:
+            'uses:[browser] 声明了需要浏览器授权上下文，但本次运行的宿主没有提供。',
+        };
+      }
+      context.browserRun = ctx.host.browserRun;
+    }
+  }
+
+  return context;
+}