minimal-agent 0.10.0 → 0.12.0

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

@@ -0,0 +1,405 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import {
+  chat as sdkChat,
+  executeTool as sdkExecuteTool,
+} from '../../../src/plugin-sdk.js';
+import type { Provider } from '../../../src/plugin-sdk.js';
+import { truncate } from './agentCommon.js';
+import { extractJsonPayload } from './jsonPayload.js';
+import type { RunContext } from './types.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: string): string {
+  return name.replace(/[^\w.-]/g, '-');
+}
+
+/** 某 workflow 的状态目录绝对路径。workflowState / taskIdentity 共用唯一权威实现。 */
+export function workflowStateDir(workingDir: string, workflowName: string): string {
+  return join(workingDir, WF_STATE_PARENT, sanitizeWorkflowDirName(workflowName));
+}
+
+/**
+ * 任务身份判定结果
+ */
+export interface TaskIdentityResult {
+  /** 归一化后的 hash（16 位 hex） */
+  hash: string;
+  /** 是否与磁盘上记录的 taskId 匹配 */
+  isSameTask: boolean;
+  /** 判定依据：'hash_match' | 'hash_diff' | 'different_workflow' | 'no_previous' */
+  reason: string;
+}
+
+/**
+ * 计算任务身份 hash。
+ *
+ * 策略（内容 hash 是【唯一权威信号】）：
+ *   - 对「workflow 名 + 归一化 goal」做 SHA256 → 取前 16 位 = taskId。
+ *   - 同 hash → 同一任务（无论隔了多久）；hash 不同 → 不同任务。
+ *   - recency（上次 startedAt 的时间窗口）【不】参与身份判定：30 分钟内换一个
+ *     完全不同的 goal 重跑同名 workflow，必须判「全新任务」清理重开，而不是
+ *     错误地 resume 旧任务把旧变量混进新目标（需求 3.2「不相关新任务自动清理重开」）。
+ *     旧版「时间窗口覆盖 hash 差异」是 bug，已移除。
+ *
+ * 归一化规则：
+ *   - 转小写
+ *   - 去除所有标点符号（保留中文、英文、数字、空格）
+ *   - 去除多余空格（连续空格→单空格，首尾 trim）
+ *   - 截断到 200 字符（防止超长输入导致不必要的差异）
+ */
+export function computeTaskId(
+  workflowName: string,
+  inputs: Record<string, unknown>,
+  workingDir?: string,
+): TaskIdentityResult {
+  // 1. 提取 goal 文本（与 buildGoalAnchor 同策略）
+  const rawGoal = extractGoal(inputs);
+
+  // 2. 归一化 goal
+  const normalizedGoal = normalizeGoal(rawGoal);
+
+  // 3. 计算 contentHash = SHA256(`${workflowName}::${normalizedGoal}`)[:16]
+  const contentHash = createHash('sha256')
+    .update(`${workflowName}::${normalizedGoal}`)
+    .digest('hex')
+    .slice(0, 16);
+
+  // 4. 如果没有提供 workingDir，只返回 hash，不做比较
+  if (!workingDir) {
+    return {
+      hash: contentHash,
+      isSameTask: false,
+      reason: 'no_previous',
+    };
+  }
+
+  // 5. 尝试读取旧状态文件（按 workflow 名隔离的状态目录）
+  const stateFilePath = join(workflowStateDir(workingDir, workflowName), 'current.json');
+
+  if (!existsSync(stateFilePath)) {
+    return {
+      hash: contentHash,
+      isSameTask: false,
+      reason: 'no_previous',
+    };
+  }
+
+  try {
+    const stateContent = readFileSync(stateFilePath, 'utf-8');
+    const prevState = JSON.parse(stateContent) as {
+      taskId?: string;
+      name?: string;
+      startedAt?: string;
+    };
+
+    // a. 不同 workflow 名 → 不同任务
+    if (prevState.name && prevState.name !== workflowName) {
+      return {
+        hash: contentHash,
+        isSameTask: false,
+        reason: 'different_workflow',
+      };
+    }
+
+    // b. 内容 hash 一致 → 同一任务（唯一权威信号，与时间无关）
+    if (prevState.taskId === contentHash) {
+      return {
+        hash: contentHash,
+        isSameTask: true,
+        reason: 'hash_match',
+      };
+    }
+
+    // c. hash 不一致 → 不同任务（goal 变了）。recency 不覆盖此判定（见函数头注）。
+    return {
+      hash: contentHash,
+      isSameTask: false,
+      reason: 'hash_diff',
+    };
+  } catch {
+    // 解析失败时返回默认结果
+    return {
+      hash: contentHash,
+      isSameTask: false,
+      reason: 'no_previous',
+    };
+  }
+}
+
+/**
+ * 从 inputs 中提取 goal 文本
+ *
+ * 策略：
+ * - 优先 inputs.goal
+ * - 其次第一个 length > 2 的 string 值
+ * - 最后 JSON.stringify 整个 inputs
+ */
+export function extractGoal(inputs: Record<string, unknown>): string {
+  // 优先级1：直接使用 inputs.goal
+  if (typeof inputs.goal === 'string') {
+    return inputs.goal;
+  }
+
+  // 优先级2：查找第一个长度 > 2 的字符串值
+  for (const value of Object.values(inputs)) {
+    if (typeof value === 'string' && value.length > 2) {
+      return value;
+    }
+  }
+
+  // 优先级3：JSON 序列化整个 inputs
+  return JSON.stringify(inputs);
+}
+
+// ============================================================
+//  任务身份语义仲裁层（hash 不等 + 旧任务未完成时的二审）
+// ------------------------------------------------------------
+//  hash 仍是「同任务」的权威信号（相等 → resume/completed，与时间无关）。
+//  但 hash 不等不再一票否决：用户输入「继续」这类延续指令，goal 文本必然
+//  与旧任务不同，按旧规则会被误判 new-task 把没做完的产物清掉重开。
+//  仲裁链（逐级降级，零 yaml 耦合，所有工作流自动获益）：
+//    a. 延续短语快路径（继续/接着/continue/resume…）→ resume，不花 LLM
+//    b. LLM 单轮仲裁（旧 goal + 新输入 + 进度摘要 → JSON verdict）
+//    c. verdict=unsure / LLM 不可用 → AskUserQuestion 问用户
+//       （TUI 弹界面；-p/gateway 由 askBridge 自动选推荐项，不挂起）
+//    d. 提问也失败 → 兜底 new-task（= 旧红线行为，最小惊讶）
+// ============================================================
+
+/** 仲裁输入：引擎已有信息，不依赖任何具体 yaml。 */
+export interface TaskArbitrationContext {
+  workflowName: string;
+  /** 旧任务的原始 goal（来自状态目录 inputs.json） */
+  prevGoal: string;
+  /** 本次调用的新 goal 文本 */
+  newGoal: string;
+  /** 旧任务已完成的步骤 id（按顺序） */
+  completedStepIds: string[];
+  totalSteps: number;
+  /** 旧任务声明的产物路径 */
+  artifacts: string[];
+}
+
+/** 仲裁器：'resume' = 新输入是旧任务的延续；'new' = 全新任务（清理重开）。 */
+export type TaskArbitrator = (
+  actx: TaskArbitrationContext,
+) => Promise<'resume' | 'new'>;
+
+/** 延续短语白名单（归一化后精确匹配；短输入再放宽到前缀匹配）。 */
+const CONTINUATION_PHRASES = new Set([
+  '继续',
+  '继续吧',
+  '继续执行',
+  '继续任务',
+  '继续上次',
+  '继续刚才',
+  '接着',
+  '接着做',
+  '接着干',
+  '接着来',
+  '做完它',
+  '接着执行',
+  'continue',
+  'resume',
+  'go on',
+  'keep going',
+  'carry on',
+]);
+
+/** 新输入是否是「延续上次任务」的指令（仲裁快路径，不花 LLM）。 */
+export function isContinuationPhrase(rawGoal: string): boolean {
+  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;
+}
+
+/** 仲裁器依赖（chat/executeTool 走 DI 优先、plugin-sdk 真实现兜底，同 RunContext 约定）。 */
+export interface TaskArbitratorDeps {
+  provider: Provider;
+  chat?: RunContext['chat'];
+  executeTool?: RunContext['executeTool'];
+  signal?: AbortSignal;
+  /** 仲裁过程的人话记录（runner 在 init 返回后统一 yield warning，因 init 非 generator） */
+  notes?: string[];
+}
+
+/**
+ * 构建复合仲裁器（短语快路径 → LLM 单轮仲裁 → AskUserQuestion → 兜底 new）。
+ * runner 在 state.init 前构建并传入；任何一级抛错都降级到下一级，绝不让仲裁本身 halt 工作流。
+ */
+export function buildTaskArbitrator(deps: TaskArbitratorDeps): TaskArbitrator {
+  const note = (m: string): void => {
+    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: TaskArbitratorDeps,
+  actx: TaskArbitrationContext,
+): Promise<'resume' | 'new' | 'unsure'> {
+  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())) as {
+      verdict?: unknown;
+    };
+    if (parsed.verdict === 'resume' || parsed.verdict === 'new') {
+      return parsed.verdict;
+    }
+  } catch {
+    // 解析失败按 unsure
+  }
+  return 'unsure';
+}
+
+/** 经 AskUserQuestion 问用户（推荐项=全新开始，与兜底语义一致；非交互自动按推荐项）。 */
+async function askUserArbitrate(
+  deps: TaskArbitratorDeps,
+  actx: TaskArbitrationContext,
+): Promise<'resume' | 'new'> {
+  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 字符串
+ *
+ * 规则：
+ * - toLowerCase()
+ * - 去除所有标点符号（保留中文、英文、数字、空格）
+ * - 去除多余空格（连续空格→单空格）
+ * - 首尾 trim
+ * - 截断到 200 字符
+ */
+function normalizeGoal(raw: string): string {
+  return (
+    raw
+      .toLowerCase()
+      // 保留中文、英文、数字、空格，去除其他字符（标点等）
+      .replace(/[^\p{L}\p{N}\s]/gu, '')
+      // 连续空格替换为单空格
+      .replace(/\s+/g, ' ')
+      // 首尾去空格
+      .trim()
+      // 截断到 200 字符
+      .slice(0, 200)
+  );
+}

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;
+}

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

@@ -23,7 +23,36 @@
  */
 export class VarStack {
     frames = [{}];
+    /**
+     * 哪些帧是「循环迭代帧」—— 只为装 `as` / `as_idx` 这类**每轮重置**的迭代变量而生。
+     *
+     * ⚠️ 区分这个的原因是一个真实 bug：loop 每轮 `push()`…`pop()`，于是循环体里
+     * `capture` 出来的变量**随迭代帧一起被弹掉**，循环一结束就没了。
+     * 实测代价：seek 循环一路把书翻到第 12 页、`cur_page` 明明是「PAGE=12 13」，
+     * 循环外的 `guard_landing` 读到的却是空串，于是报「没能翻到第 12 页（最后读到的
+     * 页码：）」—— 一个刚刚成功的任务被判成失败，而且报错文案完全指不向真因。
+     *
+     * 正确的语义分界：**迭代变量按帧作用域，作者显式命名的变量不按**。
+     * yaml 作者写 `capture: { text: cur_page }` 时期待的是「cur_page 存着最后读到的值」，
+     * 而不是「它只在这一轮迭代里活着」。
+     */
+    iterationFrames = new Set();
+    /**
+     * 写一个**作者命名**的变量（capture / set 步 / 引擎内部状态）。
+     *
+     * 穿透所有迭代帧，落到最近的非迭代帧上 —— 这样它在循环结束后依然存在。
+     */
     set(key, val) {
+        for (let i = this.frames.length - 1; i >= 0; i--) {
+            if (!this.iterationFrames.has(i)) {
+                this.frames[i][key] = val;
+                return;
+            }
+        }
+        this.frames[0][key] = val;
+    }
+    /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。 */
+    setIteration(key, val) {
         this.frames[this.frames.length - 1][key] = val;
     }
     /** 写到栈底（root frame），用于 inputs / 全局常量 */
@@ -47,9 +76,16 @@ export class VarStack {
     push() {
         this.frames.push({});
     }
+    /** 压一个迭代帧：只有 `setIteration` 写进来的东西会随 `pop` 消失。 */
+    pushIteration() {
+        this.frames.push({});
+        this.iterationFrames.add(this.frames.length - 1);
+    }
     pop() {
-        if (this.frames.length > 1)
+        if (this.frames.length > 1) {
+            this.iterationFrames.delete(this.frames.length - 1);
             this.frames.pop();
+        }
     }
     /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件 */
     snapshot() {