minimal-agent 0.12.0 → 0.13.0

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

@@ -30,17 +30,13 @@
 
 import { createHash } from 'node:crypto';
 import { mkdir, writeFile, appendFile, rm, rename, readFile, readdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import {
-  computeTaskId,
-  extractGoal,
-  workflowStateDir,
-  type TaskArbitrator,
-} from './taskIdentity.js';
-import type { StepDef } from './types.js';
+import { existsSync, readdirSync, type Dirent } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { computeTaskId, extractGoal, sanitizeWorkflowDirName, workflowStateDir, type TaskArbitrator } from './taskIdentity.js';
+import { safeArtifactPath, type StepDef } from './types.js';
 
 const DONE_SUFFIX = '.done';
+const TRASH_SUFFIX = '.trash';
 const CHECKPOINTS_DIR = 'checkpoints';
 const SUPPLEMENTS_FILE = 'supplements.json';
 
@@ -55,6 +51,18 @@ export function loopCheckpointName(loopId: string, iteration: number, stepId: st
   return `${loopId}${LOOP_CP_SEP}${iteration}${LOOP_CP_SEP}${stepId}`;
 }
 
+/**
+ * glob 段（路径中的一节，不含分隔符）转正则源：`*` -> `[^/]*`、`?` -> `[^/]`，
+ * 其余字符全部转义（`[` `]` 按字面处理，不支持字符类--声明产物用 `*`/`?` 足够，
+ * 少一种语法就少一类转义事故面）。
+ */
+function artifactSegToPattern(seg: string): string {
+  return seg
+    .replace(/[.+^${}()|[\]\\!,$^-]/g, '\\$&')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '[^/]');
+}
+
 /** 解析复合 checkpoint 文件名；非复合名（普通顶层步）返回 null。 */
 function parseLoopCheckpointName(
   name: string,
@@ -117,8 +125,20 @@ export interface TaskResumeInfo {
   mode: TaskResumeMode;
   /** fresh/new-task/resume: 从第几个 step 索引开始执行 */
   startFrom?: number;
-  /** new-task: 被清理的旧产物文件路径列表 */
+  /**
+   * fresh/new-task: 被 rm 直接删除的残留产物路径（展开 glob 后的实际文件）。
+   * 注意：正常路径清理先归档（archivedTo）再 rm 兜底，归档成功的文件已移走、
+   * 不在本列表里--本列表非空通常意味着归档失败的兜底删除。
+   */
   cleanedArtifacts?: string[];
+  /**
+   * fresh/new-task: 清理前旧产物被归档到的目录（相对 cwd，如
+   * .minimal-agent-workflow/plan.trash/1712...-ab12cd34/）。清理不再直接
+   * 删除而是先移入回收目录--LLM 仲裁误判 new-task 时用户成果可找回
+   * （实战事故：同主题重跑被仲裁判新任务，11 个声明产物被直接 rm）。
+   * 没有可归档文件或归档全部失败时缺省。
+   */
+  archivedTo?: string;
   /**
    * new-task: 同任务但工作流定义结构已变更（或 legacy 状态无指纹无从验证）
    * → 旧断点作废、全新开始。runner 据此向用户明示原因（不是静默重头跑）。
@@ -182,13 +202,24 @@ interface CurrentState {
 }
 
 export class WorkflowState {
-  readonly dir: string;
+  /** 任务实例目录（绝对路径），init 阶段确定 session 后设置 = <wfDir>/<sessionId>/ */
+  dir: string;
+  /** workflow 级目录（下含多个 session 实例） */
+  readonly wfDir: string;
   readonly workingDir: string;
+  readonly workflowName: string;
+  /** 当前 session 的实例标识（一个 session 同时只跑一个同名工作流，即任务实例） */
+  readonly sessionId: string;
 
-  constructor(workingDir: string, workflowName: string) {
+  constructor(workingDir: string, workflowName: string, sessionId = 'default') {
     this.workingDir = workingDir;
-    // 按 workflow 名隔离（与 taskIdentity.computeTaskId 读的是同一权威路径）
-    this.dir = workflowStateDir(workingDir, workflowName);
+    this.workflowName = workflowName;
+    // Phase 3：session 即任务实例——实例目录 = <wfDir>/<sessionId>/
+    this.sessionId = sanitizeWorkflowDirName(sessionId);
+    // workflow 级目录（与 taskIdentity.computeTaskId 读的是同一权威路径）
+    this.wfDir = workflowStateDir(workingDir, workflowName);
+    // 实例目录暂空占位，init 中确定后赋值
+    this.dir = '';
   }
 
   /**
@@ -217,49 +248,129 @@ export class WorkflowState {
   ): Promise<TaskResumeInfo> {
     // 1. 计算当前任务的 identity（goal 内容 hash 是唯一权威信号）
     // 与本次定义的结构指纹（resume 兼容性信号：yaml 结构变了旧断点即作废）
-    const identity = computeTaskId(name, inputs, this.workingDir);
+    // Phase 3：传 sessionId，实例查找限定到当前 session（taskId 降级为记录字段）
+    const identity = computeTaskId(name, inputs, this.workingDir, this.sessionId);
     const fp = computeDefFingerprint(steps);
 
-    // 2. 尝试读取活动目录的 current.json
+    // 2. 确定本任务的实例目录（Phase 3：session 即实例目录 = <wfDir>/<sessionId>/）
+    //    resume/completed：沿用当前 session 的实例目录；fresh/new-task：建/重建它
+    this.dir = this.resolveTaskDir(identity.hash, identity.isSameTask);
+
+    // 3. 读取活动态 current.json
     const oldState = await this.readCurrentState();
 
-    if (!oldState) {
-      // 活动目录无状态 —— 可能是「上次成功已归档到 .done」。读归档判定 completed / 不同 goal 新任务。
-      const archived = await this.readArchivedState();
-      if (archived && archived.name === name) {
-        if (archived.taskId === identity.hash) {
-          // 模式 3: completed —— 同任务此前已成功（报实际存在的声明产物）
-          return {
-            mode: 'completed',
-            artifacts: this.existingArtifacts(archived.artifacts ?? declaredArtifacts),
-          };
+    if (oldState) {
+      // ---- 有活动状态 ----
+      if (identity.isSameTask) {
+        // 同任务 → resume / recovery（下面有公共分支处理）
+      } else {
+        // 不同任务 + 旧任务未完成 → new-task（下面 oldState 非空分支处理）
+      }
+    } else {
+      // ---- 活动态为空 ----
+      // 先看是否有同 taskId 的归档（同一个任务之前成功完成了）
+      const archived = identity.isSameTask
+        ? await this.findArchivedStateByTaskId(identity.hash)
+        : null;
+
+      if (archived && archived.taskId === identity.hash) {
+        // 模式 3: completed —— 同任务此前已成功
+        // 把 this.dir 指向归档目录（后续读产物等基于它）
+        this.dir = join(this.wfDir, `${this.sessionId}${DONE_SUFFIX}`);
+        return {
+          mode: 'completed',
+          artifacts: await this.existingArtifactsAsync(
+            archived.artifacts ?? declaredArtifacts,
+          ),
+        };
+      }
+
+      // 有其他任务实例（不同 goal）→ 先仲裁二审，再决定 new-task / resume
+      if (this.hasAnyTaskInstance()) {
+        let arbitratedResume = false;
+        if (
+          arbitrate &&
+          identity.reason === 'hash_diff' &&
+          identity.isSameTask === false
+        ) {
+          const latestActive = await this.findLatestActiveState();
+          if (
+            latestActive &&
+            latestActive.state.name === name &&
+            latestActive.state.status !== 'done' &&
+            latestActive.state.defFingerprint === fp
+          ) {
+            // 临时切换 this.dir 到旧任务目录，以便 scanCheckpoints / readInputs 工作
+            const prevDir = this.dir;
+            this.dir = latestActive.dir;
+            try {
+              const prevGoal = extractGoal((await this.readInputs()) ?? {});
+              const newGoal = extractGoal(inputs);
+              let verdict: 'resume' | 'new' = 'new';
+              try {
+                verdict = await arbitrate({
+                  workflowName: name,
+                  prevGoal,
+                  newGoal,
+                  completedStepIds: await this.scanCheckpoints(steps),
+                  totalSteps: steps.length,
+                  artifacts: latestActive.state.artifacts ?? [],
+                });
+              } catch {
+                verdict = 'new';
+              }
+              if (verdict === 'resume') {
+                // 先置位再 return：finally 不再把 this.dir 改回新任务目录，
+                // 延续旧实例目录。否则后续 readSupplements / recordCheckpoint
+                // 全部写到错误位置，resume 的断点续跑静默失效
+                // （实测：supplements 读空、checkpoint 写丢、current.json 停在旧值）。
+                arbitratedResume = true;
+                const info = await this.buildResumeInfo(
+                  latestActive.state,
+                  steps,
+                  selfHealBackoff,
+                );
+                info.prevGoal = prevGoal;
+                info.supplementaryGoal = newGoal;
+                return info;
+              }
+            } finally {
+              // 仲裁判 new → 恢复 this.dir 为新任务目录（除非 resume 已 return）
+              if (!arbitratedResume) this.dir = prevDir;
+            }
+          }
         }
-        // 同名 workflow 但 goal 不同 → 全新任务：清旧归档声明产物后 fresh
-        // （legacy 归档无 artifacts 字段时用本次声明清单兜底——同名 workflow 的声明产物
-        //   语义稳定，旧任务的产物路径与本次一致的概率极高，残留比误删危害大）
-        const cleaned = await this.cleanupDeclaredArtifacts(
-          archived.artifacts ?? declaredArtifacts,
+
+        // 模式 2: new-task —— 不同任务，清旧声明产物 + 旧状态后全新开始
+        const oldArtifacts = await this.collectAllInstanceArtifacts(name, declaredArtifacts);
+        const sweep = await this.archiveThenClean(
+          oldArtifacts.length > 0 ? oldArtifacts : declaredArtifacts,
+          `${Date.now()}-stale`,
+        );
+        const sweepOrphan = await this.archiveThenClean(
+          declaredArtifacts,
+          `${Date.now()}-orphan-${identity.hash.slice(0, 8)}`,
         );
         await this.cleanSlate(name, inputs, identity.hash, declaredArtifacts, fp);
         return {
           mode: 'new-task',
           startFrom: 0,
-          cleanedArtifacts: [
-            ...cleaned,
-            ...(await this.cleanupStaleDeclared(declaredArtifacts)),
-          ],
+          cleanedArtifacts: [...sweep.cleaned, ...sweepOrphan.cleaned],
+          archivedTo: sweep.archivedTo ?? sweepOrphan.archivedTo,
         };
       }
-      // 模式 1: fresh —— 活动 + 归档都没有，首次运行。
-      // 声明产物若已存在于磁盘 = 残留孤儿（如 /new 删状态目录后的旧 PLAN.md，
-      // artifacts 清单随 current.json 一起被删，引擎无从知道它属于谁）。
-      // 用户约定：全新任务开始时清理残留与中间文件——删除范围**仅限本工作流
-      // 声明的产物**（与运行自身对它们的覆盖写权限一致，不碰用户其他文件）。
+
+      // 模式 1: fresh —— 完全没有任何任务实例，首次运行
+      const sweepF = await this.archiveThenClean(
+        declaredArtifacts,
+        `${Date.now()}-orphan`,
+      );
       await this.cleanSlate(name, inputs, identity.hash, declaredArtifacts, fp);
       return {
         mode: 'fresh',
         startFrom: 0,
-        cleanedArtifacts: await this.cleanupStaleDeclared(declaredArtifacts),
+        cleanedArtifacts: sweepF.cleaned,
+        archivedTo: sweepF.archivedTo,
       };
     }
 
@@ -306,17 +417,20 @@ export class WorkflowState {
       // 模式 2: new-task —— 不同任务，清旧声明产物 + 旧状态后全新开始。
       // legacy 状态文件无 artifacts 字段时：仅当同名 workflow 用本次声明清单兜底
       //（不同名 workflow 的产物不是我们的，不能殃及）。
-      const cleaned = await this.cleanupDeclaredArtifacts(
+      const sweep = await this.archiveThenClean(
         oldState.artifacts ?? (oldState.name === name ? declaredArtifacts : []),
+        `${Date.now()}-${oldState.taskId.slice(0, 8)}`,
+      );
+      const sweepStale = await this.archiveThenClean(
+        declaredArtifacts,
+        `${Date.now()}-orphan-${identity.hash.slice(0, 8)}`,
       );
       await this.cleanSlate(name, inputs, identity.hash, declaredArtifacts, fp);
       return {
         mode: 'new-task',
         startFrom: 0,
-        cleanedArtifacts: [
-          ...cleaned,
-          ...(await this.cleanupStaleDeclared(declaredArtifacts)),
-        ],
+        cleanedArtifacts: [...sweep.cleaned, ...sweepStale.cleaned],
+        archivedTo: sweep.archivedTo ?? sweepStale.archivedTo,
       };
     }
 
@@ -324,7 +438,9 @@ export class WorkflowState {
     if (oldState.status === 'done') {
       return {
         mode: 'completed',
-        artifacts: this.existingArtifacts(oldState.artifacts ?? declaredArtifacts),
+        artifacts: await this.existingArtifactsAsync(
+          oldState.artifacts ?? declaredArtifacts,
+        ),
       };
     }
 
@@ -335,18 +451,21 @@ export class WorkflowState {
     // runner 经 defChanged 旗标向用户明示。legacy 状态（无 defFingerprint
     // 字段）无从验证兼容性，同样按变更处理（一次性升级成本，安全优先）。
     if (oldState.defFingerprint !== fp) {
-      const cleaned = await this.cleanupDeclaredArtifacts(
+      const sweep = await this.archiveThenClean(
         oldState.artifacts ?? declaredArtifacts,
+        `${Date.now()}-${oldState.taskId.slice(0, 8)}`,
+      );
+      const sweepStale = await this.archiveThenClean(
+        declaredArtifacts,
+        `${Date.now()}-orphan-${identity.hash.slice(0, 8)}`,
       );
       await this.cleanSlate(name, inputs, identity.hash, declaredArtifacts, fp);
       return {
         mode: 'new-task',
         startFrom: 0,
         defChanged: true,
-        cleanedArtifacts: [
-          ...cleaned,
-          ...(await this.cleanupStaleDeclared(declaredArtifacts)),
-        ],
+        cleanedArtifacts: [...sweep.cleaned, ...sweepStale.cleaned],
+        archivedTo: sweep.archivedTo ?? sweepStale.archivedTo,
       };
     }
 
@@ -624,27 +743,351 @@ export class WorkflowState {
 
   // ---- 私有方法：声明式产物生命周期 ----
 
+  /**
+   * 把声明产物里的 glob 模式（`research/04-deep-dive-*.md`）展开成 cwd 下实际
+   * 匹配的文件相对路径列表；非 glob 路径原样保留。越界路径被过滤（fail-closed）。
+   * 支持段内 `*` / `?`（不跨目录分隔符）；声明里写 glob 却一个文件都不匹配时
+   * 该声明被丢弃（与旧行为一致：不存在的产物不参与清理/报告）。
+   */
+  private async expandDeclaredArtifacts(paths: string[]): Promise<string[]> {
+    const out: string[] = [];
+    for (const p of paths) {
+      const safe = safeArtifactPath(this.workingDir, p);
+      if (safe === null) continue;
+      if (!/[*?]/.test(safe)) {
+        out.push(safe);
+        continue;
+      }
+      const norm = safe.replace(/\\/g, '/');
+      const segs = norm.split('/');
+      const fullRe = new RegExp(`^${segs.map(artifactSegToPattern).join('/')}$`);
+      out.push(...(await this.walkGlob(this.workingDir, segs, fullRe, '')));
+    }
+    return out;
+  }
+
+  /** 逐段匹配目录树收集文件；dir 读失败（不存在/无权限）返回空。 */
+  private async walkGlob(
+    absDir: string,
+    segs: string[],
+    fullRe: RegExp,
+    relPrefix: string,
+  ): Promise<string[]> {
+    const [head, ...rest] = segs;
+    if (!head) return [];
+    let entries: Dirent[];
+    try {
+      entries = await readdir(absDir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const headRe = new RegExp(`^${artifactSegToPattern(head)}$`);
+    const results: string[] = [];
+    for (const e of entries) {
+      if (!headRe.test(e.name)) continue;
+      const rel = relPrefix ? `${relPrefix}/${e.name}` : e.name;
+      if (rest.length === 0) {
+        if (e.isFile() && fullRe.test(rel)) results.push(rel);
+      } else if (e.isDirectory()) {
+        results.push(...(await this.walkGlob(join(absDir, e.name), rest, fullRe, rel)));
+      }
+    }
+    return results;
+  }
+
+  /**
+   * 清理前把【实际存在】的声明产物移入回收目录 `<状态目录>.trash/<stamp>/`（保留
+   * 相对路径结构），返回回收目录（相对 cwd 表示，便于 UI 展示）；无可归档文件或
+   * 一个都没归档成功时返回 undefined（此时后续 rm 兜底直接删，不能谎报归档位置--
+   * 用户会按提示去回收站找文件）。单个 move 失败不阻断（残留交给 rm 兜底）。
+   * 回收目录是状态目录的 sibling：cleanSlate/cleanup 只重建 `<name>/`，
+   * `.trash/` 跨任务留存，直到用户手动清理（如保留最近 N 次的淘汰策略，暂未实现）。
+   */
+  private async archiveDeclaredArtifacts(
+    existingRels: string[],
+    stamp: string,
+  ): Promise<string | undefined> {
+    if (existingRels.length === 0) return undefined;
+    const trashRoot = join(this.dir + TRASH_SUFFIX, stamp);
+    let archived = 0;
+    for (const rel of existingRels) {
+      const dest = join(trashRoot, rel);
+      try {
+        await mkdir(dirname(dest), { recursive: true });
+        await rename(join(this.workingDir, rel), dest);
+        archived++;
+      } catch {
+        // 单个归档失败不阻断，残留交给后续 rm 兜底
+      }
+    }
+    if (archived === 0) return undefined;
+    const display = relative(this.workingDir, trashRoot);
+    return display.startsWith('..') ? trashRoot : display;
+  }
+
   /** 删除工作流【声明】的产物文件（相对 cwd），用于 new-task 清理旧任务残留（如旧 PLAN.md）。
-   *  仅删工作流自己声明的产物、仅 force-rm 文件，scoped 安全。返回清理过的路径列表。 */
+   *  仅删工作流自己声明的产物（glob 声明先展开为实际文件）、仅 force-rm 文件，
+   *  **并强制路径在 cwd 内（防 ../ 跳出删用户家目录）**。
+   *  返回真正执行清理的路径列表（展开后的实际文件相对路径；越界路径被过滤掉，fail-closed）。 */
   private async cleanupDeclaredArtifacts(paths: string[]): Promise<string[]> {
-    for (const p of paths) {
-      await rm(join(this.workingDir, p), { force: true }).catch(() => {});
+    const done: string[] = [];
+    for (const rel of await this.expandDeclaredArtifacts(paths)) {
+      const abs = join(this.workingDir, rel);
+      if (!existsSync(abs)) continue;
+      try {
+        await rm(abs, { force: true });
+        done.push(rel);
+      } catch {
+        // 单个删除失败不影响整体（与原实现 .catch(() => {}) 一致）
+      }
     }
-    return paths;
+    return done;
   }
 
-  /** 从声明产物路径里过滤出 cwd 下【实际存在】的文件（completed 报真实产物用）。 */
-  private existingArtifacts(paths: string[]): string[] {
-    return paths.filter((p) => existsSync(join(this.workingDir, p)));
+  /** 从声明产物路径里过滤出 cwd 下【实际存在且路径安全落在 cwd 内】的文件
+   *  （completed 报真实产物用；glob 声明先展开；越界声明不报告，视为不存在）。 */
+  private async existingArtifactsAsync(paths: string[]): Promise<string[]> {
+    const expanded = await this.expandDeclaredArtifacts(paths);
+    return expanded.filter((rel) => existsSync(join(this.workingDir, rel)));
   }
 
-  /** 清理【实际存在】的本次声明产物（fresh/new-task 启动时清残留孤儿），返回真正删掉的路径。 */
-  private async cleanupStaleDeclared(declaredArtifacts: string[]): Promise<string[]> {
-    return this.cleanupDeclaredArtifacts(this.existingArtifacts(declaredArtifacts));
+  /**
+   * 「先归档再清理」组合：把【实际存在】的声明产物移入 .trash 回收目录，
+   * 归档后残留（rename 失败者）由 cleanup 兜底 rm。返回清理列表与回收目录。
+   * fresh/new-task 启动清理统一走这里--直接 rm 旧产物曾在实战中造成不可找回的损失
+   * （LLM 仲裁误判 new-task，同主题调研的全部报告被静默删除）。
+   */
+  private async archiveThenClean(
+    paths: string[],
+    stamp: string,
+  ): Promise<{ cleaned: string[]; archivedTo?: string }> {
+    const existing = await this.existingArtifactsAsync(paths);
+    const archivedTo = await this.archiveDeclaredArtifacts(existing, stamp);
+    const cleaned = await this.cleanupDeclaredArtifacts(paths);
+    return { cleaned, archivedTo };
   }
 
   // ---- 公共方法：归档与清理（保持原有签名兼容） ----
 
+  /**
+   * 确定当前任务的实例目录路径。
+   * Phase 3：实例目录 = <wfDir>/<sessionId>/（session 即任务实例）。
+   * isSameTask=true 时若旧布局（wfDir 本身）存在则沿用（兼容升级前状态）。
+   */
+  private resolveTaskDir(_taskId: string, isSameTask: boolean): string {
+    if (isSameTask) {
+      const existing = this.findExistingTaskDir(_taskId);
+      if (existing) return existing;
+    }
+    return join(this.wfDir, this.sessionId);
+  }
+
+  /**
+   * 找当前 session 对应的现存活动实例目录（含旧布局兼容）。
+   * 找不到返回 null。
+   */
+  private findExistingTaskDir(_taskId: string): string | null {
+    // Phase 3：当前 session 的实例目录
+    const sessionDir = join(this.wfDir, this.sessionId);
+    if (existsSync(sessionDir)) return sessionDir;
+
+    // 旧布局兼容：wfDir 本身就是实例目录
+    if (existsSync(join(this.wfDir, 'current.json'))) {
+      try {
+        const entries = readdirSync(this.wfDir, { withFileTypes: true });
+        const hasInstanceSubdir = entries.some(
+          (e) => e.isDirectory() && /^[0-9a-f]{16}$/.test(e.name),
+        );
+        if (!hasInstanceSubdir) return this.wfDir;
+      } catch {
+        return this.wfDir;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 扫描当前 session 是否有任何任务实例（活动态或 .done 归档态，不包括 .trash）。
+   * 用于 isSameTask=false 时区分 fresh（从未跑过）和 new-task（有其他旧任务）。
+   */
+  private hasAnyTaskInstance(): boolean {
+    if (!existsSync(this.wfDir)) return false;
+    // Phase 3：当前 session 的实例（活动 / .done）
+    if (existsSync(join(this.wfDir, this.sessionId))) return true;
+    if (existsSync(join(this.wfDir, `${this.sessionId}${DONE_SUFFIX}`))) return true;
+    // 旧布局：wfDir 本身就是实例（current.json 直接在 wfDir 下）
+    if (existsSync(join(this.wfDir, 'current.json'))) return true;
+    if (existsSync(join(this.wfDir + DONE_SUFFIX, 'current.json'))) return true;
+    return false;
+  }
+
+  /**
+   * 扫描 wfDir 下所有 .done 归档，返回第一个（也是最新的，按修改时间排序）的 current.json。
+   * 用于 completed 检测的兜底——当 hash 不匹配但 wfDir 下有归档时，判断是否是同名 workflow 的旧归档。
+   */
+  private findLatestArchivedState(): Promise<CurrentState | null> {
+    return this.findArchivedState(() => true);
+  }
+
+  /**
+   * 在 wfDir 下找当前 session 对应的归档目录（.done）里的 current.json。
+   * 支持新布局（wfDir/<sessionId>.done/）和旧布局（wfDir.done/）。
+   */
+  private findArchivedStateByTaskId(_taskId: string): Promise<CurrentState | null> {
+    return this.findArchivedState(
+      (name, isLegacy) => isLegacy || name === `${this.sessionId}${DONE_SUFFIX}`,
+    );
+  }
+
+  private async findArchivedState(
+    predicate: (dirName: string, isLegacy: boolean) => boolean,
+  ): Promise<CurrentState | null> {
+    // 旧布局：wfDir.done/current.json
+    const legacyDone = this.wfDir + DONE_SUFFIX;
+    if (existsSync(join(legacyDone, 'current.json')) && predicate('', true)) {
+      try {
+        const raw = await readFile(join(legacyDone, 'current.json'), 'utf-8');
+        return JSON.parse(raw) as CurrentState;
+      } catch {
+        // fall through
+      }
+    }
+
+    // 新布局：wfDir/<taskId>.done/current.json
+    if (!existsSync(this.wfDir)) return null;
+    try {
+      const entries = readdirSync(this.wfDir, { withFileTypes: true });
+      const doneDirs = entries
+        .filter((e) => e.isDirectory() && e.name.endsWith(DONE_SUFFIX))
+        .map((e) => e.name)
+        .filter((name) => predicate(name, false))
+        .sort();
+      for (const name of doneDirs) {
+        try {
+          const raw = await readFile(join(this.wfDir, name, 'current.json'), 'utf-8');
+          return JSON.parse(raw) as CurrentState;
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      // ignore
+    }
+    return null;
+  }
+
+  /**
+   * 收集【当前 session】的任务实例（活动态 + .done 归档态）的声明产物路径，
+   * 用于 new-task 时归档+清理旧任务的产物。去重后返回。
+   * Phase 3：只收集当前 session 的实例产物——不同 session 的产物各归各，
+   * new-task 绝不殃及其他 session 的产出。
+   */
+  private async collectAllInstanceArtifacts(
+    workflowName: string,
+    fallback: string[],
+  ): Promise<string[]> {
+    const seen = new Set<string>();
+    const allArtifacts: string[] = [];
+    const pushAll = (arr: string[] | undefined) => {
+      for (const a of arr ?? []) {
+        if (!seen.has(a)) {
+          seen.add(a);
+          allArtifacts.push(a);
+        }
+      }
+    };
+
+    // Phase 3：当前 session 的活动实例与 .done 归档
+    for (const dirName of [this.sessionId, `${this.sessionId}${DONE_SUFFIX}`]) {
+      const dir = join(this.wfDir, dirName);
+      if (!existsSync(dir)) continue;
+      try {
+        const raw = await readFile(join(dir, 'current.json'), 'utf-8');
+        const s = JSON.parse(raw) as CurrentState;
+        if (s.name === workflowName) pushAll(s.artifacts);
+      } catch {
+        // ignore
+      }
+    }
+
+    // 旧布局兼容：wfDir 本身有 current.json（且无子实例目录）或 wfDir.done/
+    if (!existsSync(this.wfDir)) {
+      const legacyDone = this.wfDir + DONE_SUFFIX;
+      try {
+        const raw = await readFile(join(legacyDone, 'current.json'), 'utf-8');
+        const s = JSON.parse(raw) as CurrentState;
+        if (s.name === workflowName) pushAll(s.artifacts);
+      } catch {
+        // ignore
+      }
+    } else {
+      try {
+        const entries = readdirSync(this.wfDir, { withFileTypes: true });
+        const hasInstanceSubdir = entries.some(
+          (e) => e.isDirectory() && /^[0-9a-f]{16}/.test(e.name),
+        );
+        if (!hasInstanceSubdir && existsSync(join(this.wfDir, 'current.json'))) {
+          try {
+            const raw = await readFile(join(this.wfDir, 'current.json'), 'utf-8');
+            const s = JSON.parse(raw) as CurrentState;
+            if (s.name === workflowName) pushAll(s.artifacts);
+          } catch {
+            // ignore
+          }
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    return allArtifacts.length > 0 ? allArtifacts : fallback;
+  }
+
+  /**
+   * 找当前 session 的活动态实例（未完成），返回其目录 + current.json。
+   * 用于 isSameTask=false 时的仲裁——拿到旧任务的 state 做二审。
+   * 找不到返回 null。
+   */
+  private async findLatestActiveState(): Promise<{
+    dir: string;
+    state: CurrentState;
+  } | null> {
+    // Phase 3：当前 session 的活动实例 <wfDir>/<sessionId>/
+    const sessionDir = join(this.wfDir, this.sessionId);
+    if (existsSync(sessionDir)) {
+      try {
+        const raw = await readFile(join(sessionDir, 'current.json'), 'utf-8');
+        const state = JSON.parse(raw) as CurrentState;
+        if (state.status !== 'done') {
+          return { dir: sessionDir, state };
+        }
+      } catch {
+        // fall through
+      }
+    }
+
+    // 旧布局兼容：wfDir 本身是实例目录（current.json 直接在其下）
+    if (existsSync(join(this.wfDir, 'current.json'))) {
+      try {
+        const entries = readdirSync(this.wfDir, { withFileTypes: true });
+        const hasInstanceSubdir = entries.some(
+          (e) => e.isDirectory() && /^[0-9a-f]{16}/.test(e.name),
+        );
+        if (!hasInstanceSubdir) {
+          const raw = await readFile(join(this.wfDir, 'current.json'), 'utf-8');
+          const state = JSON.parse(raw) as CurrentState;
+          if (state.status !== 'done') {
+            return { dir: this.wfDir, state };
+          }
+        }
+      } catch {
+        // fall through
+      }
+    }
+
+    return null;
+  }
+
   /**
    * 归档（成功完成时调用）：重命名状态目录为 .done 后缀，保留所有中间产物。
    * vars.json / progress.md / inputs.json / checkpoints/ 全部保留——供后续对话 Read 回溯。
@@ -663,7 +1106,9 @@ export class WorkflowState {
     }
   }
 
-  /** 强制清理（/new 或新任务 init 时调用）：删除状态目录（含 .done 归档） */
+  /** 强制清理（/new 或新任务 init 时调用）：删除当前任务实例目录（含 .done 归档）。
+   *  注意：.trash 回收目录不在这里删——它是产物清理前的归档安全网，
+   *  跨任务保留，由用户或后续淘汰策略管理。 */
   async cleanup(): Promise<void> {
     await rm(this.dir, { recursive: true, force: true }).catch(() => {});
     await rm(this.dir + DONE_SUFFIX, { recursive: true, force: true }).catch(() => {});