minimal-agent 0.11.0 → 0.13.0

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

@@ -29,10 +29,12 @@
  */
 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, } from './taskIdentity.js';
+import { existsSync, readdirSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { computeTaskId, extractGoal, sanitizeWorkflowDirName, workflowStateDir } from './taskIdentity.js';
+import { safeArtifactPath } from './types.js';
 const DONE_SUFFIX = '.done';
+const TRASH_SUFFIX = '.trash';
 const CHECKPOINTS_DIR = 'checkpoints';
 const SUPPLEMENTS_FILE = 'supplements.json';
 /**
@@ -44,6 +46,17 @@ export const LOOP_CP_SEP = '@@';
 export function loopCheckpointName(loopId, iteration, stepId) {
     return `${loopId}${LOOP_CP_SEP}${iteration}${LOOP_CP_SEP}${stepId}`;
 }
+/**
+ * glob 段（路径中的一节，不含分隔符）转正则源：`*` -> `[^/]*`、`?` -> `[^/]`，
+ * 其余字符全部转义（`[` `]` 按字面处理，不支持字符类--声明产物用 `*`/`?` 足够，
+ * 少一种语法就少一类转义事故面）。
+ */
+function artifactSegToPattern(seg) {
+    return seg
+        .replace(/[.+^${}()|[\]\\!,$^-]/g, '\\$&')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]');
+}
 /** 解析复合 checkpoint 文件名；非复合名（普通顶层步）返回 null。 */
 function parseLoopCheckpointName(name) {
     const parts = name.split(LOOP_CP_SEP);
@@ -77,12 +90,23 @@ export function computeDefFingerprint(steps) {
         .slice(0, 16);
 }
 export class WorkflowState {
+    /** 任务实例目录（绝对路径），init 阶段确定 session 后设置 = <wfDir>/<sessionId>/ */
     dir;
+    /** workflow 级目录（下含多个 session 实例） */
+    wfDir;
     workingDir;
-    constructor(workingDir, workflowName) {
+    workflowName;
+    /** 当前 session 的实例标识（一个 session 同时只跑一个同名工作流，即任务实例） */
+    sessionId;
+    constructor(workingDir, workflowName, 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 = '';
     }
     /**
      * 初始化工作流状态 —— 核心入口，返回恢复信息。
@@ -106,45 +130,108 @@ export class WorkflowState {
     arbitrate) {
         // 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 = '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,
             };
         }
         // 3. 有活动状态（上次中断 / 失败 / 进行中，未归档）—— 用 hash 判同/异任务
@@ -188,22 +275,21 @@ export class WorkflowState {
             // 模式 2: new-task —— 不同任务，清旧声明产物 + 旧状态后全新开始。
             // legacy 状态文件无 artifacts 字段时：仅当同名 workflow 用本次声明清单兜底
             //（不同名 workflow 的产物不是我们的，不能殃及）。
-            const cleaned = await this.cleanupDeclaredArtifacts(oldState.artifacts ?? (oldState.name === name ? declaredArtifacts : []));
+            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,
             };
         }
         // 4. 同一任务 —— 检查完成状态（兜底：正常成功会 archive，故活动目录 done 少见）
         if (oldState.status === 'done') {
             return {
                 mode: 'completed',
-                artifacts: this.existingArtifacts(oldState.artifacts ?? declaredArtifacts),
+                artifacts: await this.existingArtifactsAsync(oldState.artifacts ?? declaredArtifacts),
             };
         }
         // 4.5 定义结构变更守卫：同任务但 yaml 结构改过（增删步/换 id/调嵌套）——
@@ -213,16 +299,15 @@ export class WorkflowState {
         // runner 经 defChanged 旗标向用户明示。legacy 状态（无 defFingerprint
         // 字段）无从验证兼容性，同样按变更处理（一次性升级成本，安全优先）。
         if (oldState.defFingerprint !== fp) {
-            const cleaned = await this.cleanupDeclaredArtifacts(oldState.artifacts ?? declaredArtifacts);
+            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,
             };
         }
         // 5. 模式 4: resume —— 同一任务未完成，扫描 checkpoint 决定恢复点。
@@ -462,23 +547,337 @@ export class WorkflowState {
         return result;
     }
     // ---- 私有方法：声明式产物生命周期 ----
+    /**
+     * 把声明产物里的 glob 模式（`research/04-deep-dive-*.md`）展开成 cwd 下实际
+     * 匹配的文件相对路径列表；非 glob 路径原样保留。越界路径被过滤（fail-closed）。
+     * 支持段内 `*` / `?`（不跨目录分隔符）；声明里写 glob 却一个文件都不匹配时
+     * 该声明被丢弃（与旧行为一致：不存在的产物不参与清理/报告）。
+     */
+    async expandDeclaredArtifacts(paths) {
+        const out = [];
+        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 读失败（不存在/无权限）返回空。 */
+    async walkGlob(absDir, segs, fullRe, relPrefix) {
+        const [head, ...rest] = segs;
+        if (!head)
+            return [];
+        let entries;
+        try {
+            entries = await readdir(absDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const headRe = new RegExp(`^${artifactSegToPattern(head)}$`);
+        const results = [];
+        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 次的淘汰策略，暂未实现）。
+     */
+    async archiveDeclaredArtifacts(existingRels, stamp) {
+        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）。 */
     async cleanupDeclaredArtifacts(paths) {
-        for (const p of paths) {
-            await rm(join(this.workingDir, p), { force: true }).catch(() => { });
+        const done = [];
+        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 报真实产物用）。 */
-    existingArtifacts(paths) {
-        return paths.filter((p) => existsSync(join(this.workingDir, p)));
+    /** 从声明产物路径里过滤出 cwd 下【实际存在且路径安全落在 cwd 内】的文件
+     *  （completed 报真实产物用；glob 声明先展开；越界声明不报告，视为不存在）。 */
+    async existingArtifactsAsync(paths) {
+        const expanded = await this.expandDeclaredArtifacts(paths);
+        return expanded.filter((rel) => existsSync(join(this.workingDir, rel)));
     }
-    /** 清理【实际存在】的本次声明产物（fresh/new-task 启动时清残留孤儿），返回真正删掉的路径。 */
-    async cleanupStaleDeclared(declaredArtifacts) {
-        return this.cleanupDeclaredArtifacts(this.existingArtifacts(declaredArtifacts));
+    /**
+     * 「先归档再清理」组合：把【实际存在】的声明产物移入 .trash 回收目录，
+     * 归档后残留（rename 失败者）由 cleanup 兜底 rm。返回清理列表与回收目录。
+     * fresh/new-task 启动清理统一走这里--直接 rm 旧产物曾在实战中造成不可找回的损失
+     * （LLM 仲裁误判 new-task，同主题调研的全部报告被静默删除）。
+     */
+    async archiveThenClean(paths, stamp) {
+        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 本身）存在则沿用（兼容升级前状态）。
+     */
+    resolveTaskDir(_taskId, isSameTask) {
+        if (isSameTask) {
+            const existing = this.findExistingTaskDir(_taskId);
+            if (existing)
+                return existing;
+        }
+        return join(this.wfDir, this.sessionId);
+    }
+    /**
+     * 找当前 session 对应的现存活动实例目录（含旧布局兼容）。
+     * 找不到返回 null。
+     */
+    findExistingTaskDir(_taskId) {
+        // 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（有其他旧任务）。
+     */
+    hasAnyTaskInstance() {
+        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 的旧归档。
+     */
+    findLatestArchivedState() {
+        return this.findArchivedState(() => true);
+    }
+    /**
+     * 在 wfDir 下找当前 session 对应的归档目录（.done）里的 current.json。
+     * 支持新布局（wfDir/<sessionId>.done/）和旧布局（wfDir.done/）。
+     */
+    findArchivedStateByTaskId(_taskId) {
+        return this.findArchivedState((name, isLegacy) => isLegacy || name === `${this.sessionId}${DONE_SUFFIX}`);
+    }
+    async findArchivedState(predicate) {
+        // 旧布局：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);
+            }
+            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);
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        return null;
+    }
+    /**
+     * 收集【当前 session】的任务实例（活动态 + .done 归档态）的声明产物路径，
+     * 用于 new-task 时归档+清理旧任务的产物。去重后返回。
+     * Phase 3：只收集当前 session 的实例产物——不同 session 的产物各归各，
+     * new-task 绝不殃及其他 session 的产出。
+     */
+    async collectAllInstanceArtifacts(workflowName, fallback) {
+        const seen = new Set();
+        const allArtifacts = [];
+        const pushAll = (arr) => {
+            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);
+                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);
+                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);
+                        if (s.name === workflowName)
+                            pushAll(s.artifacts);
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        return allArtifacts.length > 0 ? allArtifacts : fallback;
+    }
+    /**
+     * 找当前 session 的活动态实例（未完成），返回其目录 + current.json。
+     * 用于 isSameTask=false 时的仲裁——拿到旧任务的 state 做二审。
+     * 找不到返回 null。
+     */
+    async findLatestActiveState() {
+        // 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);
+                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);
+                    if (state.status !== 'done') {
+                        return { dir: this.wfDir, state };
+                    }
+                }
+            }
+            catch {
+                // fall through
+            }
+        }
+        return null;
+    }
     /**
      * 归档（成功完成时调用）：重命名状态目录为 .done 后缀，保留所有中间产物。
      * vars.json / progress.md / inputs.json / checkpoints/ 全部保留——供后续对话 Read 回溯。
@@ -498,7 +897,9 @@ export class WorkflowState {
             // rename 失败时静默（某些文件系统/权限问题），保留原目录
         }
     }
-    /** 强制清理（/new 或新任务 init 时调用）：删除状态目录（含 .done 归档） */
+    /** 强制清理（/new 或新任务 init 时调用）：删除当前任务实例目录（含 .done 归档）。
+     *  注意：.trash 回收目录不在这里删——它是产物清理前的归档安全网，
+     *  跨任务保留，由用户或后续淘汰策略管理。 */
     async cleanup() {
         await rm(this.dir, { recursive: true, force: true }).catch(() => { });
         await rm(this.dir + DONE_SUFFIX, { recursive: true, force: true }).catch(() => { });