minimal-agent 0.9.0 → 0.10.0

package/plugins/cron-runner/src/store.js

@@ -0,0 +1,298 @@
+import { randomUUID } from 'node:crypto';
+import { constants, copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { cronToHuman } from './cronTime.js';
+import { intervalToHuman, nextScheduleRunMs } from './scheduleEngine.js';
+import { schedulerLockFile } from './lock.js';
+import { appendMissed as appendMissedRecord, appendRun as appendRunRecord, listMissed as listMissedRecords, markMissedRead as markMissedRecordsRead, markRunsRead as markRunRecordsRead, recentRuns as readRecentRuns } from './runs.js';
+import { normalizeTask } from './schema.js';
+function root() {
+    return process.env.MINIMAL_AGENT_CRON_RUNNER_HOME
+        ? join(process.env.MINIMAL_AGENT_CRON_RUNNER_HOME, 'cron-runner')
+        : join(homedir(), '.minimal-agent', 'plugins', 'cron-runner');
+}
+function tasksFile() {
+    return join(root(), 'tasks.json');
+}
+function runsDir() {
+    return join(root(), 'runs');
+}
+function missedFile() {
+    return join(root(), 'missed.jsonl');
+}
+let mutationQueue = Promise.resolve();
+const taskChangeListeners = new Set();
+function notifyTaskChanges() {
+    for (const listener of taskChangeListeners)
+        listener();
+}
+export function subscribeTaskChanges(listener) {
+    taskChangeListeners.add(listener);
+    return () => taskChangeListeners.delete(listener);
+}
+export function cronDataRoot() {
+    return root();
+}
+export function cronLockFile() {
+    return schedulerLockFile(root());
+}
+/** Upgrade legacy fresh/hidden-session tasks once, keeping an immutable pre-migration backup. */
+export async function migrateCronTasks() {
+    return await enqueueMutation(async () => {
+        let raw;
+        try {
+            raw = await readFile(tasksFile(), 'utf8');
+        }
+        catch {
+            return false;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return false;
+        }
+        if (!Array.isArray(parsed.tasks))
+            return false;
+        const needsMigration = parsed.tasks.some((value) => {
+            const task = value;
+            return !task.schedule || !('type' in task.schedule) || !task.runtime?.bindingStatus || task.runtime.sessionMode === 'fresh' || task.runtime.sessionId?.startsWith('cron-');
+        });
+        if (!needsMigration)
+            return false;
+        await mkdir(root(), { recursive: true });
+        try {
+            await copyFile(tasksFile(), join(root(), 'tasks.pre-session-binding.backup.json'), constants.COPYFILE_EXCL);
+        }
+        catch { /* existing backup is intentionally retained */ }
+        const migrated = parsed.tasks.map(normalizeTask).filter((task) => Boolean(task));
+        await writeTasksFile(migrated);
+        notifyTaskChanges();
+        return true;
+    });
+}
+async function readTasks(fromMs = Date.now()) {
+    try {
+        const raw = await readFile(tasksFile(), 'utf8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.tasks)
+            ? parsed.tasks
+                .map(normalizeTask)
+                .filter((task) => Boolean(task))
+                // 注意：不能写成 .map(refreshNextRun)——Array.map 会把 (element, index, array)
+                // 全传进去，第二个实参 index(0,1,2...) 会顶掉 refreshNextRun 的 fromMs=Date.now()
+                // 默认值，导致 nextRunAt/expired 全按 Unix 纪元(≈0ms)计算（真机 e2e 抓到
+                // nextRunAt 恒为 1970-01-01）。必须用箭头包一层只透传 task。
+                .map((task) => refreshNextRun(task, fromMs))
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function listTasks() {
+    return await readTasks();
+}
+async function writeTasksFile(tasks) {
+    const file = tasksFile();
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmp, JSON.stringify({ tasks: tasks.map((task) => refreshNextRun(task)) }, null, 2), 'utf8');
+    await rename(tmp, file);
+}
+function enqueueMutation(mutate) {
+    const operation = mutationQueue.then(mutate, mutate);
+    mutationQueue = operation.then(() => undefined, () => undefined);
+    return operation;
+}
+export async function writeTasks(tasks) {
+    await enqueueMutation(async () => {
+        await writeTasksFile(tasks);
+        notifyTaskChanges();
+    });
+}
+export async function upsertTask(task) {
+    return await enqueueMutation(async () => {
+        const tasks = await readTasks();
+        const idx = tasks.findIndex((t) => t.id === task.id);
+        const saved = refreshNextRun({ ...task, updatedAt: new Date().toISOString() });
+        if (idx >= 0)
+            tasks[idx] = saved;
+        else
+            tasks.push(saved);
+        await writeTasksFile(tasks);
+        notifyTaskChanges();
+        return saved;
+    });
+}
+export async function updateTask(id, updater) {
+    return await enqueueMutation(async () => {
+        const tasks = await readTasks();
+        const idx = tasks.findIndex((task) => task.id === id);
+        if (idx < 0)
+            return undefined;
+        const saved = refreshNextRun({
+            ...updater(tasks[idx]),
+            updatedAt: new Date().toISOString(),
+        });
+        tasks[idx] = saved;
+        await writeTasksFile(tasks);
+        notifyTaskChanges();
+        return saved;
+    });
+}
+export async function deleteTask(id) {
+    return await enqueueMutation(async () => {
+        const tasks = await readTasks();
+        const next = tasks.filter((t) => t.id !== id);
+        if (next.length === tasks.length)
+            return false;
+        await writeTasksFile(next);
+        notifyTaskChanges();
+        return true;
+    });
+}
+export async function getTask(idOrPrefix) {
+    const tasks = await listTasks();
+    return tasks.find((t) => t.id === idOrPrefix) ?? tasks.find((t) => t.id.startsWith(idOrPrefix));
+}
+export async function appendRun(record) {
+    await appendRunRecord(runsDir(), record);
+}
+export async function recentRuns(taskId, limit = 5) {
+    return await readRecentRuns(runsDir(), taskId, limit);
+}
+export async function markRunsRead(taskId) {
+    await markRunRecordsRead(runsDir(), taskId);
+}
+export async function appendMissed(record) {
+    await appendMissedRecord(missedFile(), record);
+}
+export async function listMissed(limit = 20) {
+    return await listMissedRecords(missedFile(), limit);
+}
+export async function markMissedRead(taskId) {
+    await markMissedRecordsRead(missedFile(), taskId);
+}
+export function createTask(input) {
+    const now = new Date().toISOString();
+    const id = `cron-${randomUUID().slice(0, 8)}`;
+    if (!input.cron && !input.intervalMs) {
+        throw new Error('createTask requires cron or intervalMs');
+    }
+    const schedule = input.intervalMs
+        ? {
+            type: 'interval',
+            intervalMs: input.intervalMs,
+            anchorAt: input.anchorAt ?? now,
+            human: intervalToHuman(input.intervalMs),
+            jitterMs: input.jitterMs ?? 0,
+        }
+        : {
+            type: 'cron',
+            cron: input.cron,
+            timezone: input.timezone,
+            human: cronToHuman(input.cron),
+            jitterMs: input.jitterMs ?? 0,
+        };
+    return refreshNextRun({
+        id,
+        name: input.name,
+        ...(input.description ? { description: input.description } : {}),
+        status: 'active',
+        kind: input.kind ?? 'recurring',
+        ...(input.permanent ? { permanent: true } : {}),
+        ...(input.expiresAt ? { expiresAt: input.expiresAt } : {}),
+        ...(input.maxRuns ? { maxRuns: input.maxRuns } : {}),
+        schedule,
+        action: input.action,
+        runtime: {
+            cwd: input.cwd,
+            environment: 'project',
+            sessionId: input.sessionId ?? 'default',
+            sessionMode: input.sessionMode ?? 'persistent',
+            bindingStatus: (!input.sessionId || !input.sessionId.startsWith('cron-')) && input.sessionMode !== 'fresh'
+                ? 'bound'
+                : 'needs_binding',
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.maxTurns ? { maxTurns: input.maxTurns } : {}),
+        },
+        stats: {
+            runCount: 0,
+            successCount: 0,
+            failureCount: 0,
+            skippedCount: 0,
+        },
+        createdAt: now,
+        updatedAt: now,
+    });
+}
+export function refreshNextRun(task, fromMs = Date.now()) {
+    const expired = task.expiresAt && !task.permanent && Date.parse(task.expiresAt) <= fromMs;
+    const next = task.status === 'active' && !expired
+        ? nextScheduleRunMs(task.schedule, fromMs)
+        : null;
+    return {
+        ...task,
+        ...(expired ? { status: 'completed' } : {}),
+        schedule: {
+            ...task.schedule,
+            human: task.schedule.type === 'cron'
+                ? cronToHuman(task.schedule.cron)
+                : intervalToHuman(task.schedule.intervalMs),
+            jitterMs: typeof task.schedule.jitterMs === 'number' ? task.schedule.jitterMs : 0,
+            ...(next ? { nextRunAt: new Date(next).toISOString() } : { nextRunAt: undefined }),
+        },
+    };
+}
+/** Update only user-editable fields while preserving scheduler cursors, stats and creation time. */
+export async function patchTask(patch) {
+    return await updateTask(patch.id, (current) => {
+        const nextSchedule = patch.schedule
+            ? patch.schedule.type === 'cron'
+                ? {
+                    ...current.schedule,
+                    type: 'cron',
+                    cron: patch.schedule.cron,
+                    timezone: patch.schedule.timezone,
+                    jitterMs: patch.schedule.jitterMs ?? 0,
+                    human: cronToHuman(patch.schedule.cron),
+                }
+                : {
+                    ...current.schedule,
+                    type: 'interval',
+                    intervalMs: patch.schedule.intervalMs,
+                    anchorAt: patch.schedule.anchorAt ?? new Date().toISOString(),
+                    jitterMs: patch.schedule.jitterMs ?? 0,
+                    human: intervalToHuman(patch.schedule.intervalMs),
+                }
+            : current.schedule;
+        const runtime = patch.runtime
+            ? {
+                ...current.runtime,
+                ...patch.runtime,
+                sessionMode: 'persistent',
+                bindingStatus: patch.runtime.sessionId && !patch.runtime.sessionId.startsWith('cron-')
+                    ? 'bound'
+                    : current.runtime.bindingStatus,
+            }
+            : current.runtime;
+        return {
+            ...current,
+            ...(patch.name !== undefined ? { name: patch.name.trim() } : {}),
+            ...(patch.description !== undefined
+                ? patch.description.trim() ? { description: patch.description.trim() } : { description: undefined }
+                : {}),
+            ...(patch.status !== undefined ? { status: patch.status } : {}),
+            ...(patch.kind !== undefined ? { kind: patch.kind } : {}),
+            ...(patch.permanent !== undefined ? { permanent: patch.permanent || undefined } : {}),
+            ...(patch.expiresAt !== undefined ? { expiresAt: patch.expiresAt || undefined } : {}),
+            ...(patch.maxRuns !== undefined ? { maxRuns: patch.maxRuns || undefined } : {}),
+            schedule: nextSchedule,
+            ...(patch.action ? { action: patch.action } : {}),
+            runtime,
+        };
+    });
+}

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

@@ -0,0 +1 @@
+export {};

package/plugins/workflow-runner/commands/workflow.md

@@ -45,10 +45,10 @@ steps:
 - `allowed_tools: [Read, Write]` —— 收窄它能用的工具；**缺省给全量工具**（要真 agency）。
 - `output_schema: {...}` —— 要求结构化产出（provider-native JSON Schema），按字段 `capture`。
 - `context_files: [{ path, hint }]` —— 列出可读文件让它按需 Read（不 inline 内容）。
-- `maxTurns: <n>` —— 子循环最大轮数，默认 12。
+- `maxTurns: <n>` —— 子循环最大轮数，默认 25。
 - `capture` / `when` / `onError` —— 与其它动作 step 一致（agent 节点也能 `onError: recover` 被再救一次）。
 
-`agent` vs `skill`：`agent` 是 **inline、一次性**的有界子循环（miniReAct，轻、收敛快、产出受验证闸门把关）；
+`agent` vs `skill`：`agent` 是 **inline、一次性**的有界 TAOR 子循环（委托 runQuery，轻、收敛快、产出受验证闸门把关）；
 `skill` 是跑一个**外部 SKILL.md 定义、可复用**的完整 agent（runQuery）。需要复用同一套能力用 `skill`，
 临时让某步「自己想办法」用 `agent`。
 
@@ -75,7 +75,7 @@ steps:
 
 - `recover_hint: "<提示>"` —— 给恢复 agent 的提示（支持 `${var}` 插值），如 `"端口被占就换 3001 重试"`。
 - `allowed_tools: [Read, Bash]` —— 收窄恢复 agent 能用的工具；**缺省给全量工具**。
-- `maxTurns: <n>` —— 恢复子循环最大轮数，默认 12（够「诊断 + 探查 + 动手 + 验证」一圈）。
+- `maxTurns: <n>` —— 恢复子循环最大轮数，默认 25（够「诊断 + 探查 + 动手 + 验证」一圈）。
 
 示例：
 
@@ -91,7 +91,7 @@ steps:
 
 注意事项：
 
-- `onError` **只作用于动作 step**。控制流节点（branch / loop / vote / parallel 的条件或结构错误、
+- `onError` **只作用于动作 step**。控制流节点（branch / loop 的条件或结构错误、
   以及 `when` 表达式错误）**始终 halt** —— 那类是「作者写错了」，不是「运行期意外」，不走恢复。
 - `continue` vs `recover`：前者「放弃这步、盲目往下」，后者「想办法把这步做成、保住下游」。
   要扛住「预料之外」的情况，用 `recover`。

package/plugins/workflow-runner/commands/workflows.md

@@ -5,6 +5,6 @@ description: 列出当前 cwd 与插件包内可用的 YAML 工作流
 # /workflows
 
 由 workflow-runner 插件接管（plugin.ts.runCommand），扫描 cwd/workflows/ 与
-plugin 自带 examples/ 下的 *.yaml，把名称 + 一行描述列出来。
+packageRoot/workflows/（getResourceSearchPaths 双源，cwd 优先）下的 *.yaml，把名称 + 一行描述列出来。
 
 提示：用 `agent:` 节点可把开放式的一步交给有界 TAOR 子 agent 随机应变完成；用 `onError: recover` 可让失败节点交给恢复 agent 自适应救回（而非整条崩停）。二者共用同一套「自我验证 / 不伪造」纪律——详见 `/workflow` 命令说明。

package/plugins/workflow-runner/plugin.js

@@ -21,12 +21,13 @@ const api = {
             return;
         }
         if (commandName === 'workflow') {
+            const cwd = getWorkingDir();
             yield* runWorkflowFromCommand(args, {
                 provider: ctx.provider,
                 history: ctx.history,
                 signal: ctx.signal,
                 sessionState: ctx.sessionState,
-                cwd: getWorkingDir(),
+                cwd,
                 tools: ALL_TOOLS,
             });
             return;

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

@@ -19,6 +19,8 @@
  *       ③ 检测逻辑增加内容长度启发式（reason > 80 字符视为误报）
  * ============================================================
  */
+import { runQuery, stripThinkBlocks, } from '../../../src/plugin-sdk.js';
+import { normalizeCapture, } from './types.js';
 /**
  * agent 显式放弃的唯一标记；recover 与 agent 节点共用。
  *
@@ -28,13 +30,11 @@
  *   - 使用 [bracket] 格式而非 ⟨angle⟩（避免 Unicode 字符在 Bun indexOf 中行为不一致）
  */
 export const GIVEUP_MARKER = '[wf-internal-abort-do-not-generate]';
-/** agent 步骤的角色开场白（与 recovery 的 RECOVER_OPENING 对称） */
-export const AGENT_OPENING = '你是一名资深工程师，被一个确定性工作流临时调来「自主完成一步开放任务」。';
-/** 把 step.capture 翻成「下游会把你的结果存成哪些变量」，让 agent 产出对得上形状。 */
+/** 把 step.capture 翻成「下游会把你的结果存成哪些变量」，让 agent 产出对得上形状。
+ *  经 normalizeCapture：裸字符串 capture（capture: design_doc）不再被拆成单字符
+ *  【d、e、s…】，而是正确显示为【design_doc】。 */
 export function describeCaptureContract(step) {
-    if (!step.capture)
-        return '';
-    const names = Object.values(step.capture);
+    const names = Object.values(normalizeCapture(step.capture));
     if (names.length === 0)
         return '';
     return `\n\n下游契约：工作流会把你的结果保存为变量【${names.join('、')}】供后续步骤引用，请确保你的产出能填好这些变量。`;
@@ -42,6 +42,168 @@ export function describeCaptureContract(step) {
 export function truncate(s, n) {
     return s.length > n ? `${s.slice(0, n)}…` : s;
 }
+// stripThinkBlocks 已上移内核 src/utils/stripThink.ts（Agent 子任务工具同样需要，
+// 内核不能 import 插件）——顶部 import 供本模块使用，此处 re-export 保持插件内
+// 既有 import 路径不变。
+export { stripThinkBlocks };
+/**
+ * 组合「原始目标锚 + 累积的用户补充要求」为本步实际注入的锚定文本。
+ * agent / llm / skill / recovery 四个执行器统一经此取锚——补充要求
+ * （pause 审批反馈 / goal_supplement 步产出 / 仲裁延续的新指令）与原始目标
+ * 同等贯穿每一步，不再只活在被修订的文件或某个变量里。
+ * 返回空串 = 无锚（执行器跳过注入，行为同旧 ctx.goalAnchor 为空）。
+ */
+export function effectiveGoalAnchor(ctx) {
+    const base = ctx.goalAnchor ?? '';
+    const supps = (ctx.goalSupplements ?? []).filter((s) => s.trim());
+    if (supps.length === 0)
+        return base;
+    const lines = supps.map((s) => `> 📌 用户补充要求：${s}`).join('\n');
+    return base ? `${base}\n${lines}` : `${lines}\n> ⚠️ 以上补充要求与原始目标同等约束所有操作。`;
+}
+/** 把 llm_error 细节拼进可重试失败的抛错文案（无细节时退化为原样文案）。 */
+export function describeLlmFailure(stepId, detail) {
+    const base = `step ${stepId}: LLM 调用失败且无产出（触发重试）`;
+    return detail ? `${base}—— ${truncate(detail, 300)}` : base;
+}
+function cloneMessage(msg) {
+    if (msg.role === 'user' && Array.isArray(msg.content)) {
+        return { ...msg, content: msg.content.map((part) => ({ ...part })) };
+    }
+    return { ...msg };
+}
+function createStepHistory(step, ctx) {
+    if (step.history_mode !== 'isolated')
+        return ctx.history;
+    return ctx.history.filter((msg) => msg.role === 'system').map(cloneMessage);
+}
+/**
+ * agent / llm / skill 三个执行器共享的 runQuery 消费层。
+ *
+ * 为什么不能各自 `yield*` 直透（曾经的三份拷贝、agent.ts 漏同步酿成误报）：
+ *   runQuery 遇 LLM 超时/网络错是 yield error 后 return（不 throw），直透会让
+ *   执行器拿到空 history → 静默返回空文本 → runner 的 in-run retry 不触发
+ *   （只对抛异常的 step 重试）。这里统一显式消费、侦测终结错误，把
+ *   「拿产出 + 记旗标」收敛成一份；**空产出 + sawLlmError 时抛不抛错的语义
+ *   差异保留在各执行器**（agent 还要过验证闸门，llm/skill 不过）。
+ *
+ * 事件透传逐字节等价于重构前：
+ *   - error / interrupted 照常冒泡（红字照常显示，retry 交给 runner）
+ *   - 'compact_failed' 非致命，不计为失败
+ *   - suppressTurnDone（仅 skill 传 true）：turn_done 是 runQuery 单次调用的
+ *     终结标记，不是 workflow 终结，外泄会让 gateway broker / -p json 误判
+ */
+export async function* runStepQuery(prompt, step, ctx, opts) {
+    const activeHistory = createStepHistory(step, ctx);
+    // 记录 runQuery 开始前的 history 长度，用于之后提取本步的 assistant 输出
+    const historyLenBefore = activeHistory.length;
+    let aborted = false;
+    let sawLlmError = false;
+    let sawMaxTurns = false;
+    let llmErrorDetail = '';
+    let sawToolCall = false;
+    let toolOkCount = 0;
+    let toolFailCount = 0;
+    const toolNames = [];
+    for await (const ev of runQuery(prompt, {
+        provider: ctx.provider,
+        history: activeHistory,
+        signal: ctx.signal,
+        maxTurns: opts.maxTurns,
+        allowedTools: step.allowed_tools,
+        chat: ctx.chat,
+        executeTool: ctx.executeTool,
+        sessionState: ctx.sessionState,
+        imageInputs: opts.imageInputs,
+        parseInlineImages: opts.parseInlineImages,
+        imageDetail: opts.imageDetail,
+        imageMaxLongSidePixel: opts.imageMaxLongSidePixel,
+    })) {
+        if (ev.type === 'error') {
+            if (ev.code === 'aborted') {
+                aborted = true;
+            }
+            else if (ev.code === 'llm_error') {
+                sawLlmError = true;
+                llmErrorDetail = ev.error; // 留住 provider 真实报错，供执行器抛错时附带
+                // 🚫 不原样把这条 raw error 事件漏给顶层消费者（2026-07-04 真机事故：-p 模式
+                // 收到任意 type:'error' 就 handleEvent→exitCode:1→process.exit()，把整个 -p 进程
+                // 杀死在这里——比 runner.ts 的 in-run retry（max_retries/onError:continue）先一步
+                // 判定「终结」，等于跳过了整套设计好的重试/降级机制。这条信号已被上面两行转成
+                // sawLlmError/llmErrorDetail，稍后由本函数调用方（agent.ts 等）转成规范的可重试
+                // Error 抛出，交给 runner.ts 的 catch 块按 max_retries/onError 决定真正要不要终结、
+                // 要终结时也是由 runner.ts 在恰当时机重新 yield 一条 warning/error，不需要这条 raw 事件。
+                continue;
+            }
+            else if (ev.code === 'max_turns') {
+                sawMaxTurns = true;
+                // 同上：max_turns 截断本是「可续跑」信号（isMaxTurnsCutoff），必须留给 runner.ts
+                // 的 in-run retry 先处理，不能原样漏给顶层当成终结。
+                continue;
+            }
+        }
+        else if (ev.type === 'warning' &&
+            ev.message.includes('finish_reason=length')) {
+            sawMaxTurns = true;
+        }
+        else if (ev.type === 'tool_start') {
+            sawToolCall = true;
+            if (!toolNames.includes(ev.toolName))
+                toolNames.push(ev.toolName);
+        }
+        else if (ev.type === 'tool_end') {
+            sawToolCall = true;
+            if (!toolNames.includes(ev.toolName))
+                toolNames.push(ev.toolName);
+            if (ev.ok)
+                toolOkCount++;
+            else
+                toolFailCount++;
+        }
+        if (opts.suppressTurnDone && ev.type === 'turn_done')
+            continue;
+        yield ev;
+    }
+    // 从 history 提取本步产生的最后一条非空 assistant 消息。
+    // 经 stripThinkBlocks 净化：最后一条若是纯 <think> 块（模型收尾只剩思考），
+    // 继续向前回退到真正有内容的消息——capture/补充要求拿到的必须是交付文本。
+    let rawText = '';
+    for (let i = activeHistory.length - 1; i >= historyLenBefore; i--) {
+        const msg = activeHistory[i];
+        if (msg.role === 'assistant' && typeof msg.content === 'string') {
+            const cleaned = stripThinkBlocks(msg.content);
+            if (cleaned) {
+                rawText = cleaned;
+                break;
+            }
+        }
+    }
+    return {
+        rawText,
+        sawToolCall,
+        toolNames,
+        toolOkCount,
+        toolFailCount,
+        aborted,
+        sawLlmError,
+        sawMaxTurns,
+        llmErrorDetail,
+    };
+}
+/** maxTurns 截断失败文案的稳定标记（producer/detector 同源，防 runner 侧 delay 判定漂移）。 */
+export const MAX_TURNS_CUTOFF_MARKER = '达到最大轮数';
+/** maxTurns 截断的可重试失败文案（重试 = 在共享 history 上续作，再给一份轮数预算）。 */
+export function describeMaxTurnsCutoff(stepId, maxTurns) {
+    return `step ${stepId}: ${MAX_TURNS_CUTOFF_MARKER} ${maxTurns} 被截断（可续跑）`;
+}
+/**
+ * 该错误是否是 maxTurns 截断（续作语义）。runner 的 in-run retry 用它区分延时：
+ * maxTurns 截断默认立即续作，不套用普通 retry_delay_ms；长文档/PPT 类工作流
+ * 可显式配置 max_turns_retry_delay_ms 给截断续作增加等待窗口。
+ */
+export function isMaxTurnsCutoff(errMsg) {
+    return errMsg.includes(MAX_TURNS_CUTOFF_MARKER) && errMsg.includes('被截断');
+}
 /**
  * 解析非 schema 模式下 agent 最终文本里的放弃标记。
  *   - 命中 GIVEUP_MARKER → 返回原因字符串（可能为空串）
@@ -117,10 +279,11 @@ export function interpretMiniReActResult(result, hasSchema) {
         // v0.9.3: 误报过滤 —— 如果 "放弃原因" 太长或太结构化，
         // 说明 LLM 是在正常输出中碰巧触发了标记，不应判为放弃
         if (isLikelyFalsePositive(giveup)) {
-            // 降级为成功交付：去掉误触发的标记部分，保留实质内容
+            // 降级为成功交付：去掉误触发的标记部分（replaceAll：标记可能被 LLM
+            // 误触发多次，replace 只删首个会让残留标记流进 capture 污染下游）
             const cleanText = trimmed
-                .replace(GIVEUP_MARKER, '')
-                .replace(LEGACY_GIVEUP_MARKER, '')
+                .replaceAll(GIVEUP_MARKER, '')
+                .replaceAll(LEGACY_GIVEUP_MARKER, '')
                 .trim();
             const raw = {
                 text: cleanText,

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

@@ -0,0 +1,72 @@
+import { ACTION_KINDS, CONTROL_FLOW_TYPES, ON_ERROR_VALUES, VALID_STEP_TYPES } from './loader.js';
+const llmAgentOnly = ['llm', 'agent'];
+const llmAgentSkillOnly = ['llm', 'agent', 'skill'];
+export const WORKFLOW_DSL_MANIFEST = {
+    version: '1.0.0',
+    actionKinds: [...ACTION_KINDS],
+    controlFlowTypes: [...CONTROL_FLOW_TYPES],
+    validStepTypes: [...VALID_STEP_TYPES],
+    onErrorValues: [...ON_ERROR_VALUES],
+    exclusiveActionFields: [...ACTION_KINDS, 'type'],
+    stepKinds: [
+        { kind: 'tool', group: 'action', label: 'Tool', description: 'Call one deterministic tool.', primaryFields: ['tool', 'args'] },
+        { kind: 'llm', group: 'action', label: 'LLM', description: 'Single LLM step.', primaryFields: ['llm', 'output_schema', 'context_files', 'allowed_tools'] },
+        { kind: 'skill', group: 'action', label: 'Skill', description: 'Run one SKILL.md workflow agent.', primaryFields: ['skill', 'input', 'maxTurns'] },
+        { kind: 'agent', group: 'action', label: 'Agent', description: 'Run an inline bounded TAOR agent.', primaryFields: ['agent', 'maxTurns', 'done_when', 'output_schema', 'context_files', 'allowed_tools'] },
+        { kind: 'assert', group: 'quality', label: 'Assert', description: 'Halt when a condition is false.', primaryFields: ['condition', 'onFail'] },
+        { kind: 'verify', group: 'quality', label: 'Verify', description: 'Run deterministic checks before continuing.', primaryFields: ['checks', 'onFail'] },
+        { kind: 'set', group: 'control', label: 'Set', description: 'Set workflow variables deterministically.', primaryFields: ['set'] },
+        { kind: 'branch', group: 'control', label: 'Branch', description: 'Route into then/else child steps.', primaryFields: ['condition'], childCollections: ['then', 'else'] },
+        { kind: 'loop', group: 'control', label: 'Loop', description: 'For-each or bounded while loop.', primaryFields: ['over', 'as', 'max_iterations', 'fresh_context'], childCollections: ['do'] },
+        { kind: 'break', group: 'control', label: 'Break', description: 'Exit the nearest (or target) loop.', primaryFields: ['when', 'target'] },
+        { kind: 'continue', group: 'control', label: 'Continue', description: 'Skip to the next iteration of the nearest (or target) loop.', primaryFields: ['when', 'target'] },
+        { kind: 'echo', group: 'control', label: 'Echo', description: 'Deterministically print an interpolated message (no LLM).', primaryFields: ['message'] },
+        { kind: 'pause', group: 'control', label: 'Pause', description: 'Human approval gate.', primaryFields: ['prompt', 'free_text'] },
+    ],
+    commonStepFields: [
+        { name: 'id', type: 'string', ui: 'text', required: true, label: 'id' },
+        { name: 'title', type: 'string', ui: 'text', label: 'title', description: 'Human-readable progress label (supports ${} interpolation); when set, the status line shows it instead of block-relative step numbers.' },
+        { name: 'when', type: 'string', ui: 'text', label: 'when', description: 'Optional execution condition.' },
+        { name: 'onError', type: 'enum', ui: 'select', enum: [...ON_ERROR_VALUES], label: 'onError' },
+        { name: 'recover_hint', type: 'string', ui: 'text', label: 'recover_hint', description: 'Hint for onError=recover.' },
+    ],
+    stepFields: [
+        { name: 'tool', type: 'string', ui: 'text', appliesTo: ['tool'] },
+        { name: 'args', type: 'object', ui: 'json', appliesTo: ['tool'] },
+        { name: 'llm', type: 'string', ui: 'textarea', appliesTo: ['llm'] },
+        { name: 'skill', type: 'string', ui: 'text', appliesTo: ['skill'] },
+        { name: 'agent', type: 'string', ui: 'textarea', appliesTo: ['agent'] },
+        { name: 'input', type: 'string', ui: 'textarea', appliesTo: ['skill'] },
+        { name: 'capture', type: 'object', ui: 'json' },
+        { name: 'maxTurns', type: 'number', ui: 'number', appliesTo: ['llm', 'skill', 'agent'] },
+        { name: 'max_retries', type: 'number', ui: 'number' },
+        { name: 'artifacts', type: 'string[]', ui: 'string[]' },
+        { name: 'condition', type: 'string', ui: 'text', appliesTo: ['assert', 'branch'] },
+        { name: 'onFail', type: 'string', ui: 'textarea', appliesTo: ['assert', 'verify'] },
+        { name: 'set', type: 'object', ui: 'json', required: true, appliesTo: ['set'] },
+        { name: 'checks', type: 'string[]', ui: 'string[]', required: true, appliesTo: ['verify'] },
+        { name: 'over', type: 'string', ui: 'text', appliesTo: ['loop'] },
+        { name: 'as', type: 'string', ui: 'text', appliesTo: ['loop'] },
+        { name: 'max_iterations', type: 'number', ui: 'number', appliesTo: ['loop'] },
+        { name: 'fresh_context', type: 'boolean', ui: 'boolean', appliesTo: ['loop'] },
+        { name: 'prompt', type: 'string', ui: 'textarea', appliesTo: ['pause'] },
+        { name: 'free_text', type: 'enum', ui: 'select', enum: ['halt', 'approve'], appliesTo: ['pause'] },
+        { name: 'target', type: 'string', ui: 'text', appliesTo: ['break', 'continue'], description: 'Target loop id (label semantics; default = nearest loop).' },
+        { name: 'message', type: 'string', ui: 'textarea', required: true, appliesTo: ['echo'] },
+        { name: 'goal_supplement', type: 'boolean', ui: 'boolean', appliesTo: ['tool', 'skill', 'agent', 'llm', 'pause'], description: 'Append this step output to the goal anchor as a user supplement.' },
+        { name: 'done_when', type: 'string', ui: 'text', appliesTo: ['agent'], description: 'Deterministic completion condition (whitelist expression, e.g. fileExists(...)); engine nudges the agent to keep working until it holds.' },
+        { name: 'output_schema', type: 'object', ui: 'json', appliesTo: llmAgentOnly },
+        { name: 'context_files', type: 'object[]', ui: 'object[]', appliesTo: llmAgentOnly },
+        { name: 'allowed_tools', type: 'string[]', ui: 'string[]', appliesTo: llmAgentOnly },
+        { name: 'history_mode', type: 'enum', ui: 'select', enum: ['shared', 'isolated'], appliesTo: llmAgentSkillOnly, description: 'Use shared workflow history or run this llm/agent/skill step in an isolated history (system prompt + current step only).' },
+        // 多模态（视觉）：仅 llm/agent 生效。images 喂图给模型识图/打分（如 illustrate 配图工作流）。
+        { name: 'images', type: 'array', ui: 'json', appliesTo: llmAgentOnly, description: 'Multimodal image inputs (paths/URLs, supports ${} interpolation). Array of strings or { source, detail, max_long_side_pixel }.' },
+        { name: 'image_detail', type: 'enum', ui: 'select', enum: ['low', 'high', 'auto'], appliesTo: llmAgentOnly, description: 'Default vision detail for this step (per-image override allowed inside images[]).' },
+        { name: 'image_max_long_side_pixel', type: 'number', ui: 'number', appliesTo: llmAgentOnly, description: 'Default max long-side pixels for downscaling images before sending.' },
+        { name: 'parse_inline_images', type: 'boolean', ui: 'boolean', appliesTo: llmAgentOnly, description: 'Parse @./img.png or image URLs found in the prompt text.' },
+    ],
+    workflowFields: [
+        { name: 'artifacts', type: 'string[]', ui: 'string[]', label: 'workflow artifacts' },
+        { name: 'self_heal', type: 'object', ui: 'json', label: 'self_heal' },
+    ],
+};