minimal-agent 0.9.0 → 0.10.0

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

@@ -1,17 +1,40 @@
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-/**
- * 默认时间窗口：30 分钟内同名 workflow 视为同任务（毫秒）
- */
-const DEFAULT_TIME_WINDOW_MS = 30 * 60 * 1000;
+import { chat as sdkChat, executeTool as sdkExecuteTool, } from '../../../src/plugin-sdk.js';
+import { truncate } from './agentCommon.js';
+import { extractJsonPayload } from './jsonPayload.js';
+// ============================================================
+//  工作流状态目录布局（E6 修复：按 workflow 名隔离）
+// ------------------------------------------------------------
+//  <cwd>/.minimal-agent-workflow/<name>/      ← 每个工作流独立状态
+//  <cwd>/.minimal-agent-workflow/<name>.done/ ← 成功归档
+//  曾经一个 cwd 单例目录：A（如 /plan）未完成时跑不同名工作流 B，
+//  init 的 new-task 路径会清掉 A 的声明产物 + 整个状态目录，A 永久失去
+//  resume 能力——与「不同任务中间文件互不干扰」需求直接冲突。
+//  按名隔离后跨工作流互不可见，互踩从结构上消失。
+//  /new 的前缀清理（.minimal-agent*）作用于父目录，行为不变。
+// ============================================================
+/** 工作流状态目录的父目录名（/new 按 .minimal-agent 前缀整体清理）。 */
+export const WF_STATE_PARENT = '.minimal-agent-workflow';
+/** 把 workflow 名清洗成安全的目录名（保留字母数字._-，其余替换为 -）。 */
+export function sanitizeWorkflowDirName(name) {
+    return name.replace(/[^\w.-]/g, '-');
+}
+/** 某 workflow 的状态目录绝对路径。workflowState / taskIdentity 共用唯一权威实现。 */
+export function workflowStateDir(workingDir, workflowName) {
+    return join(workingDir, WF_STATE_PARENT, sanitizeWorkflowDirName(workflowName));
+}
 /**
  * 计算任务身份 hash。
  *
- * 策略（双重信号）：
- *   1. 内容 hash：对 goal 做归一化后 SHA256 → 取前 16 位
- *   2. 时间窗口：读取 .minimal-agent-workflow/current.json 的 startedAt，
- *      如果在窗口期内且 workflow 名相同 → 强制视为同一任务（覆盖 hash 差异）
+ * 策略（内容 hash 是【唯一权威信号】）：
+ *   - 对「workflow 名 + 归一化 goal」做 SHA256 → 取前 16 位 = taskId。
+ *   - 同 hash → 同一任务（无论隔了多久）；hash 不同 → 不同任务。
+ *   - recency（上次 startedAt 的时间窗口）【不】参与身份判定：30 分钟内换一个
+ *     完全不同的 goal 重跑同名 workflow，必须判「全新任务」清理重开，而不是
+ *     错误地 resume 旧任务把旧变量混进新目标（需求 3.2「不相关新任务自动清理重开」）。
+ *     旧版「时间窗口覆盖 hash 差异」是 bug，已移除。
  *
  * 归一化规则：
  *   - 转小写
@@ -37,8 +60,8 @@ export function computeTaskId(workflowName, inputs, workingDir) {
             reason: 'no_previous',
         };
     }
-    // 5. 尝试读取旧状态文件
-    const stateFilePath = join(workingDir, '.minimal-agent-workflow', 'current.json');
+    // 5. 尝试读取旧状态文件（按 workflow 名隔离的状态目录）
+    const stateFilePath = join(workflowStateDir(workingDir, workflowName), 'current.json');
     if (!existsSync(stateFilePath)) {
         return {
             hash: contentHash,
@@ -49,7 +72,7 @@ export function computeTaskId(workflowName, inputs, workingDir) {
     try {
         const stateContent = readFileSync(stateFilePath, 'utf-8');
         const prevState = JSON.parse(stateContent);
-        // a. 不同 workflow → 不同任务
+        // a. 不同 workflow 名 → 不同任务
         if (prevState.name && prevState.name !== workflowName) {
             return {
                 hash: contentHash,
@@ -57,21 +80,7 @@ export function computeTaskId(workflowName, inputs, workingDir) {
                 reason: 'different_workflow',
             };
         }
-        // b. 检查时间窗口
-        if (prevState.startedAt) {
-            const startedAt = new Date(prevState.startedAt).getTime();
-            const now = Date.now();
-            const timeDiff = now - startedAt;
-            // 在时间窗口内 → 强制视为同一任务（即使 hash 不同）
-            if (timeDiff >= 0 && timeDiff <= DEFAULT_TIME_WINDOW_MS) {
-                return {
-                    hash: contentHash,
-                    isSameTask: true,
-                    reason: 'time_window',
-                };
-            }
-        }
-        // c. 时间窗口过期但 taskId 与当前 hash 匹配
+        // b. 内容 hash 一致 → 同一任务（唯一权威信号，与时间无关）
         if (prevState.taskId === contentHash) {
             return {
                 hash: contentHash,
@@ -79,14 +88,14 @@ export function computeTaskId(workflowName, inputs, workingDir) {
                 reason: 'hash_match',
             };
         }
-        // d. 时间窗口过期且 hash 不匹配
+        // c. hash 不一致 → 不同任务（goal 变了）。recency 不覆盖此判定（见函数头注）。
         return {
             hash: contentHash,
             isSameTask: false,
-            reason: 'expired',
+            reason: 'hash_diff',
         };
     }
-    catch (error) {
+    catch {
         // 解析失败时返回默认结果
         return {
             hash: contentHash,
@@ -103,7 +112,7 @@ export function computeTaskId(workflowName, inputs, workingDir) {
  * - 其次第一个 length > 2 的 string 值
  * - 最后 JSON.stringify 整个 inputs
  */
-function extractGoal(inputs) {
+export function extractGoal(inputs) {
     // 优先级1：直接使用 inputs.goal
     if (typeof inputs.goal === 'string') {
         return inputs.goal;
@@ -117,6 +126,152 @@ function extractGoal(inputs) {
     // 优先级3：JSON 序列化整个 inputs
     return JSON.stringify(inputs);
 }
+/** 延续短语白名单（归一化后精确匹配；短输入再放宽到前缀匹配）。 */
+const CONTINUATION_PHRASES = new Set([
+    '继续',
+    '继续吧',
+    '继续执行',
+    '继续任务',
+    '继续上次',
+    '继续刚才',
+    '接着',
+    '接着做',
+    '接着干',
+    '接着来',
+    '做完它',
+    '接着执行',
+    'continue',
+    'resume',
+    'go on',
+    'keep going',
+    'carry on',
+]);
+/** 新输入是否是「延续上次任务」的指令（仲裁快路径，不花 LLM）。 */
+export function isContinuationPhrase(rawGoal) {
+    const norm = normalizeGoal(rawGoal);
+    if (!norm)
+        return false;
+    if (CONTINUATION_PHRASES.has(norm))
+        return true;
+    // 短输入且以延续词开头（如「继续干活」「continue please」）也算
+    if (norm.length <= 12 &&
+        (norm.startsWith('继续') ||
+            norm.startsWith('接着') ||
+            norm.startsWith('continue') ||
+            norm.startsWith('resume'))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * 构建复合仲裁器（短语快路径 → LLM 单轮仲裁 → AskUserQuestion → 兜底 new）。
+ * runner 在 state.init 前构建并传入；任何一级抛错都降级到下一级，绝不让仲裁本身 halt 工作流。
+ */
+export function buildTaskArbitrator(deps) {
+    const note = (m) => {
+        deps.notes?.push(m);
+    };
+    return async (actx) => {
+        // a. 延续短语快路径
+        if (isContinuationPhrase(actx.newGoal)) {
+            note(`任务仲裁：新输入「${truncate(actx.newGoal, 40)}」命中延续短语 → 继续旧任务（目标：${truncate(actx.prevGoal, 60)}）`);
+            return 'resume';
+        }
+        // b. LLM 单轮仲裁
+        try {
+            const verdict = await llmArbitrate(deps, actx);
+            if (verdict !== 'unsure') {
+                note(`任务仲裁：LLM 判定新输入${verdict === 'resume' ? '是旧任务的延续 → 续跑' : '是全新任务 → 清理旧产物重开'}`);
+                return verdict;
+            }
+        }
+        catch {
+            // LLM 不可用 → 降级到提问
+        }
+        // c. AskUserQuestion（TUI 弹界面；非交互宿主 askBridge 自动选推荐项=全新开始）
+        try {
+            const verdict = await askUserArbitrate(deps, actx);
+            note(`任务仲裁：经用户确认 → ${verdict === 'resume' ? '继续旧任务' : '全新开始'}`);
+            return verdict;
+        }
+        catch {
+            // 提问被取消/不可用 → 兜底
+        }
+        // d. 兜底 = 旧红线行为（hash 不等 → new-task），最小惊讶
+        note('任务仲裁：无法判定（LLM 与提问均不可用）→ 按全新任务处理');
+        return 'new';
+    };
+}
+/** LLM 单轮仲裁：旧 goal + 新输入 + 进度摘要 → {verdict, reason}。解析失败按 unsure。 */
+async function llmArbitrate(deps, actx) {
+    const chatFn = deps.chat ?? sdkChat;
+    const progress = `${actx.completedStepIds.length}/${actx.totalSteps}`;
+    const prompt = [
+        `你是工作流引擎的任务身份仲裁器。同名工作流「${actx.workflowName}」存在一个未完成的旧任务，`,
+        `用户刚发起了一次新调用，新输入的文本与旧任务目标不同。请判断新输入是「旧任务的延续指令」还是「全新任务」。`,
+        '',
+        `旧任务目标：${truncate(actx.prevGoal, 300)}`,
+        `旧任务进度：已完成 ${progress} 步${actx.completedStepIds.length ? `（${actx.completedStepIds.join(', ')}）` : ''}`,
+        actx.artifacts.length ? `旧任务产物：${actx.artifacts.join(', ')}` : '',
+        `新输入：${truncate(actx.newGoal, 300)}`,
+        '',
+        '判断标准：新输入若是「继续 / 接着做 / 把它做完 / 对旧任务的补充修改意见」类延续语义 → resume；',
+        '若是与旧目标无关的新需求 → new；真不确定 → unsure。',
+        '只输出一行 JSON（不要 markdown 代码块、不要解释）：{"verdict":"resume"|"new"|"unsure","reason":"一句话"}',
+    ]
+        .filter((l) => l !== '')
+        .join('\n');
+    let text = '';
+    for await (const ev of chatFn({
+        provider: deps.provider,
+        messages: [
+            { role: 'user', content: prompt, timestamp: Date.now(), id: crypto.randomUUID() },
+        ],
+        tools: [],
+        signal: deps.signal,
+    })) {
+        if (ev.type === 'text_delta')
+            text += ev.delta;
+    }
+    try {
+        const parsed = JSON.parse(extractJsonPayload(text.trim()));
+        if (parsed.verdict === 'resume' || parsed.verdict === 'new') {
+            return parsed.verdict;
+        }
+    }
+    catch {
+        // 解析失败按 unsure
+    }
+    return 'unsure';
+}
+/** 经 AskUserQuestion 问用户（推荐项=全新开始，与兜底语义一致；非交互自动按推荐项）。 */
+async function askUserArbitrate(deps, actx) {
+    const exec = deps.executeTool ?? sdkExecuteTool;
+    const progress = `${actx.completedStepIds.length}/${actx.totalSteps}`;
+    const args = {
+        questions: [
+            {
+                question: `检测到工作流「${actx.workflowName}」有一个未完成的任务（目标：${truncate(actx.prevGoal, 80)}，` +
+                    `进度 ${progress} 步）。本次输入「${truncate(actx.newGoal, 80)}」是要继续该任务，还是开始全新任务？`,
+                header: '任务仲裁',
+                options: [
+                    {
+                        label: '全新开始 (推荐)',
+                        description: '清理旧任务的中间产物，按本次输入重新规划执行',
+                    },
+                    {
+                        label: '继续上次任务',
+                        description: '从断点续跑旧任务，本次输入作为补充指令',
+                    },
+                ],
+            },
+        ],
+    };
+    const r = await exec('AskUserQuestion', JSON.stringify(args), deps.signal);
+    if (!r.ok)
+        throw new Error(r.error);
+    return r.content.includes('继续上次任务') ? 'resume' : 'new';
+}
 /**
  * 归一化 goal 字符串
  *

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

@@ -1,6 +1,6 @@
 /**
  * ============================================================
- *  src/workflows/types.ts —— workflow runner 核心类型
+ *  plugins/workflow-runner/src/types.ts —— workflow runner 核心类型
  * ------------------------------------------------------------
  *  外层确定性 step 列表驱动执行，LLM 只在 llm: / skill: / agent: 节点出场。
  *  后的内存形态（WorkflowDef / StepDef），以及运行时上下文（VarStack /
@@ -51,14 +51,25 @@ export class VarStack {
         if (this.frames.length > 1)
             this.frames.pop();
     }
-    /** ADR-05: parallel 用——给子 fork 一份深拷贝栈；子 fork 的 set/push/pop 不污染父栈。 */
-    fork() {
-        const child = new VarStack();
-        child.frames = this.frames.map((f) => ({ ...f }));
-        return child;
-    }
     /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件 */
     snapshot() {
         return Object.assign({}, ...this.frames);
     }
 }
+/**
+ * 把 yaml 的 capture 归一化成 { resultField: varName } map。支持两种写法
+ * （通用 DSL，根治「裸字符串 capture 被 Object.entries/values 迭代成单字符」的静默 footgun）：
+ *   - map 形式：   capture: { text: foo, args.content: bar }
+ *   - 简写字符串： capture: foo  ≡  capture: { result: foo }
+ *     绑 StepResult.raw.result —— llm/agent=文本、tool=回执，各 executor 都提供 result 别名。
+ *
+ * 放在 types.ts（零依赖）供 runner.ts（bindCapture）与 agentCommon.ts（describeCaptureContract）
+ * 共用，避免 runner↔agentCommon 循环引用。
+ */
+export function normalizeCapture(cap) {
+    if (cap == null)
+        return {};
+    if (typeof cap === 'string')
+        return { result: cap };
+    return cap;
+}