@ai-setting/roy-agent-core 1.6.8 → 1.6.10

package/dist/shared/@ai-setting/{roy-agent-core-34xt19yg.js → roy-agent-core-m38q2azm.js}

@@ -3,14 +3,14 @@ import {
 } from "./roy-agent-core-dcd1s7ct.js";
 import {
   truncateOutputInline
-} from "./roy-agent-core-02n40zbs.js";
+} from "./roy-agent-core-zs31w092.js";
 import {
   AskUserError,
   init_workflow_hil
 } from "./roy-agent-core-e25xkv53.js";
 import {
   AgentRegistry
-} from "./roy-agent-core-as3phr7n.js";
+} from "./roy-agent-core-wqe84f84.js";
 import {
   ContextError
 } from "./roy-agent-core-ctdhjv68.js";
@@ -22,26 +22,26 @@ import {
 } from "./roy-agent-core-8x4ngxcy.js";
 import {
   envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pf1c360e.js";
+} from "./roy-agent-core-j62bjagf.js";
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-gp872e7m.js";
+} from "./roy-agent-core-dbkkjmqz.js";
 import {
   init_context
-} from "./roy-agent-core-zttjq1h3.js";
+} from "./roy-agent-core-9hqqhye6.js";
 import {
   getCurrentTaskId,
   getEnvContext,
   runWithEnvContextAsync
-} from "./roy-agent-core-scp0afxg.js";
+} from "./roy-agent-core-endah27g.js";
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-cg146hmg.js";
+} from "./roy-agent-core-fdm579b1.js";
 import {
   createLogger,
   init_logger
@@ -361,8 +361,8 @@ class AgentComponent extends BaseComponent {
       });
       const loadedCount = await this.registry.load();
       logger.info(`[AgentComponent] Loaded ${loadedCount} agents from config directory`);
-      this.registry.registerWorkflowAgent();
-      logger.info("[AgentComponent] Registered built-in workflow-agent");
+      this.registry.registerWorkflowRunner();
+      logger.info("[AgentComponent] Registered built-in workflow-runner");
       this.registry.registerJsonExtractAgent();
       logger.info("[AgentComponent] Registered built-in json-extract agent");
       this.registry.registerWorkflowExtractAgent();
@@ -628,6 +628,22 @@ class AgentComponent extends BaseComponent {
     hookCtx.messages.push(message);
     this.notifyMessageAdded(message);
   }
+  consumeMetaProtocolUserMessage(hookCtx) {
+    const toolResultMeta = hookCtx.toolResult?.result?.metadata;
+    if (!toolResultMeta || !("toAddFakeUserMessage" in toolResultMeta)) {
+      return;
+    }
+    const userMsg = toolResultMeta.toAddFakeUserMessage;
+    delete toolResultMeta.toAddFakeUserMessage;
+    if (!userMsg || userMsg.role !== "user") {
+      return;
+    }
+    return userMsg;
+  }
+  flushPendingFakeUserMessage(hookCtx, pendingMsg, iter) {
+    this.pushMessage(hookCtx, pendingMsg);
+    logger.debug(`[ReAct] Meta-protocol: flushed user message AFTER all tool-results (iter=${iter})`);
+  }
   async _run(agentName, query, context) {
     await this.refreshDependencies();
     const agent = this.getAgent(agentName);
@@ -866,6 +882,7 @@ class AgentComponent extends BaseComponent {
             });
             iterAllToolCalls = llmOutput.toolCalls ?? [];
             iterProcessedCount = 0;
+            let pendingFakeUserMessage;
             for (const toolCall of iterAllToolCalls) {
               if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
                 hookCtx._stopped = true;
@@ -918,19 +935,18 @@ class AgentComponent extends BaseComponent {
                 }]
               });
               {
-                const toolResultMeta = hookCtx.toolResult?.result?.metadata;
-                if (toolResultMeta && "toAddFakeUserMessage" in toolResultMeta) {
-                  const userMsg = toolResultMeta.toAddFakeUserMessage;
-                  if (userMsg && userMsg.role === "user") {
-                    this.pushMessage(hookCtx, userMsg);
-                    logger.debug(`[ReAct] Meta-protocol: appended user message after tool result (tool=${toolResult.name}, iter=${iteration})`);
-                    delete toolResultMeta.toAddFakeUserMessage;
-                  }
+                const captured = this.consumeMetaProtocolUserMessage(hookCtx);
+                if (captured) {
+                  pendingFakeUserMessage = captured;
+                  logger.debug(`[ReAct] Meta-protocol: captured user message (tool=${toolResult.name}, iter=${iteration}); will flush after loop`);
                 }
               }
               result.toolCalls.push(hookCtx.currentToolCall);
               iterProcessedCount++;
             }
+            if (pendingFakeUserMessage) {
+              this.flushPendingFakeUserMessage(hookCtx, pendingFakeUserMessage, iteration);
+            }
             await this.executePluginHooks(agent, "agent:on.iteration", hookCtx);
           }
         } catch (error) {
@@ -1277,7 +1293,7 @@ ${additionInfo}`
         } else {
           result = await withTimeout(toolPromise, 120000, `Tool '${toolName}' execution timeout after 120s`);
         }
-        result = truncateOutputInline(result, undefined, undefined, toolName);
+        result = truncateOutputInline(result, undefined, undefined, toolName, tool);
       } else if (this.toolComponent?.execute) {
         const toolPromise = this.toolComponent.execute(request);
         if (isLongRunningTool) {
@@ -1293,7 +1309,7 @@ ${additionInfo}`
         } else {
           result = await withTimeout(toolPromise, 120000, `Tool '${toolName}' execution timeout after 120s`);
         }
-        result = truncateOutputInline(result, undefined, undefined, toolName);
+        result = truncateOutputInline(result, undefined, undefined, toolName, tool);
       }
       this.pushEnvEvent({
         type: "tool.result",
@@ -1499,6 +1515,12 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   TracedAs("agent.component.resolveSystemPrompt", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "resolveSystemPrompt", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.meta-protocol.consumeUserMessage", { recordParams: false, recordResult: false, log: true })
+], AgentComponent.prototype, "consumeMetaProtocolUserMessage", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.meta-protocol.flushPendingUserMessage", { recordParams: false, recordResult: false, log: true })
+], AgentComponent.prototype, "flushPendingFakeUserMessage", null);
 __legacyDecorateClassTS([
   TracedAs("agent.component.run", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "_run", null);

package/dist/shared/@ai-setting/{roy-agent-core-d2bmfnb5.js → roy-agent-core-nw39k111.js}

@@ -9,14 +9,14 @@ import {
 } from "./roy-agent-core-95bbd2jv.js";
 import {
   envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pf1c360e.js";
+} from "./roy-agent-core-j62bjagf.js";
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-cg146hmg.js";
+} from "./roy-agent-core-fdm579b1.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-gdkq55yg.js → roy-agent-core-nzpw62d3.js}

@@ -8,7 +8,7 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-c94yan0b.js";
+} from "./roy-agent-core-8bhncxep.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
@@ -24,7 +24,7 @@ import {
   searchTasksTool,
   treeTasksTool,
   updateTaskTool
-} from "./roy-agent-core-sxqy40cs.js";
+} from "./roy-agent-core-rpq0mcvv.js";
 import {
   createOperationTool,
   deleteOperationTool,
@@ -37,22 +37,22 @@ import {
 } from "./roy-agent-core-1pg0fepg.js";
 import {
   envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pf1c360e.js";
+} from "./roy-agent-core-j62bjagf.js";
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-gp872e7m.js";
+} from "./roy-agent-core-dbkkjmqz.js";
 import {
   getEnvContextOrEmpty,
   init_env_context
-} from "./roy-agent-core-scp0afxg.js";
+} from "./roy-agent-core-endah27g.js";
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-cg146hmg.js";
+} from "./roy-agent-core-fdm579b1.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-b75jtybq.js → roy-agent-core-p2vpsd1d.js}

@@ -1,7 +1,7 @@
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-cg146hmg.js";
+} from "./roy-agent-core-fdm579b1.js";
 import {
   __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";

package/dist/shared/@ai-setting/{roy-agent-core-gw43m8yd.js → roy-agent-core-p6x6n3k4.js}

@@ -11,7 +11,7 @@ import {
 import {
   init_decorator,
   wrapFunction
-} from "./roy-agent-core-cg146hmg.js";
+} from "./roy-agent-core-fdm579b1.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-cx9p8b2t.js → roy-agent-core-qbm5zy6s.js}

@@ -5,10 +5,10 @@ import {
   initDatabase,
   initializeTables,
   resetDatabase
-} from "./roy-agent-core-jexyz11d.js";
-import"./roy-agent-core-b77yz0wt.js";
+} from "./roy-agent-core-1mq9erp8.js";
+import"./roy-agent-core-606z25nw.js";
 import"./roy-agent-core-rvxg1wps.js";
-import"./roy-agent-core-cg146hmg.js";
+import"./roy-agent-core-fdm579b1.js";
 import"./roy-agent-core-vyygk314.js";
 import"./roy-agent-core-7z9b1fm8.js";
 import"./roy-agent-core-c6592r3c.js";

package/dist/shared/@ai-setting/{roy-agent-core-hf8pqrvy.js → roy-agent-core-qfdj8872.js}

@@ -1,7 +1,7 @@
 import {
   TagRepository
-} from "./roy-agent-core-b77yz0wt.js";
-import"./roy-agent-core-cg146hmg.js";
+} from "./roy-agent-core-606z25nw.js";
+import"./roy-agent-core-fdm579b1.js";
 import"./roy-agent-core-vyygk314.js";
 import"./roy-agent-core-7z9b1fm8.js";
 import"./roy-agent-core-c6592r3c.js";

package/dist/shared/@ai-setting/{roy-agent-core-ksx9a556.js → roy-agent-core-r74v00c7.js}

@@ -1,7 +1,7 @@
 import {
   init_global_hook_manager,
   init_hook_manager
-} from "./roy-agent-core-gp872e7m.js";
+} from "./roy-agent-core-dbkkjmqz.js";
 
 // src/env/hook/types.ts
 function createHook(meta, fn) {

package/dist/shared/@ai-setting/{roy-agent-core-0tfv18rf.js → roy-agent-core-resnbd2j.js}

@@ -1,7 +1,7 @@
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-cg146hmg.js";
+} from "./roy-agent-core-fdm579b1.js";
 import {
   __esm,
   __legacyDecorateClassTS

package/dist/shared/@ai-setting/{roy-agent-core-bqwj1dq0.js → roy-agent-core-rga3f0hm.js}

@@ -11,10 +11,10 @@ import {
 } from "./roy-agent-core-4w6rgxs4.js";
 import {
   toEnvKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pf1c360e.js";
+} from "./roy-agent-core-j62bjagf.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-sxqy40cs.js → roy-agent-core-rpq0mcvv.js}

@@ -1,7 +1,7 @@
 import {
   init_env_context,
   setCurrentTaskId
-} from "./roy-agent-core-scp0afxg.js";
+} from "./roy-agent-core-endah27g.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-4extx33r.js → roy-agent-core-trdpar9f.js}

@@ -102,7 +102,7 @@ var builtInPrompts = {
 
 ## 子智能体选择策略
 
-你有两个子智能体。**默认首次委托使用 \`roy\`**。仅在需要严格 Plan→Execute→Verify 纪律时使用 \`strict-task-agent\`。
+你有多类子智能体。**默认首次委托使用 \`roy\`**。**调用 workflow 解决的任务，委托给 \`workflow-runner\`**（兼容语法：\`strict-task-agent\` / \`code-review\` / \`bench-agent-host\` / \`workspace-analyzer\` / \`test-workflow-agent\` 等旧名仍可用，会被自动重写）。
 
 ### \uD83E\uDD47 首选：\`roy\`（首次委托默认）
 全功能的 {{agent_name}} AI 助手，拥有所有工具和技能，提示词中内置了 **任务作为一等公民** 原则。遵循结构化任务生命周期（创建→跟踪→完成），同时保持灵活性。
@@ -132,7 +132,7 @@ delegate_task(
 > - \`bgProcessId\` 用于查实时状态（running/completed/failed/timeout/stopped），\`task_get\` 查的是关联的 Task #N 生命周期，**两者不要混用**
 > - sub-session 始终保留（不会自动删除），可通过 \`session_get\` 查看完整执行日志
 
-### \uD83E\uDD48 次选：\`strict-task-agent\`（需要严格验证时使用）
+### \uD83E\uDD48 Workflow runner：\`workflow-runner\`（调用 workflow 时使用）
 结构化 Plan → Execute → Verify 工作流智能体，内置自动重试（最多 8 次）。在以下情况使用：
 - **复杂功能开发** — 需要严格的 Plan→Execute→Verify 纪律
 - **关键 bug 修复** — 需要根因分析、修复和强制验证
@@ -146,7 +146,7 @@ delegate_task(
   prompt="详细说明。
 
 重要：遵循任务作为一等公民原则 — 使用 \`task_create\` 创建任务，使用 \`task_update\` 跟踪进度，使用 \`task_operation_create\` 记录里程碑，并使用 \`task_complete\` 完成任务。",
-  subagent_type="strict-task-agent",
+  subagent_type="workflow-runner", prompt="运行 workflow strict-task-agent，任务是..."
   similar_task_ids=[]  // 必填：先使用 task_search 搜索相似任务，将找到的 ID 填入此处（最多 3 个）
 )
 \`\`\`
@@ -155,7 +155,7 @@ delegate_task(
 
 1. **理解** — 用户到底想要什么？
 2. **分类** — 如果需要任何超出简单对话的操作 → 委托。如果是问候/一次性回答 → 直接回复。
-3. **选择智能体** — \`roy\`（默认）或 \`strict-task-agent\`（需要严格验证时）
+3. **选择智能体** — \`roy\`（默认）或 \`workflow-runner\`（调用 workflow 时）
 4. **搜索相似任务并委托** — 在委托前，先使用 \`task_search\` 搜索与当前请求相关的历史任务，将找到的相似任务 ID 填入 \`similar_task_ids\` 参数。在给子智能体的提示词中，始终包含简要指令，要求将工作视为任务一等公民：创建任务（\`task_create\`）、跟踪进度并完成。
 5. **汇报结果** — 向用户总结结果
 
@@ -180,7 +180,7 @@ delegate_task(
 2. **bash 用于简单命令** — \`bash\` 用于执行简单的一次性 shell 命令（1-2 行能完成的查询、文件浏览、状态检查等）。**只有复杂、多步、需要规划/调研/编码/重构/Bug 修复的任务才使用 \`delegate_task\` 委托**。简单 bash 命令（\`ls\`、\`cat\`、\`grep\`、\`git status\` 等）**直接用 \`bash\`**，无需委托。
 3. **保持简洁** — 简短分析，然后立即委托。不要冗长。
 4. **首选 roy** — 首次委托默认使用 \`roy\`
-5. **次选 strict-task-agent** — 需要严格 Plan→Execute→Verify 纪律时使用
+5. **workflow-runner** — 凡是走 workflow 解决的任务（包括兼容旧名 \`strict-task-agent\` / \`code-review\` / \`bench-agent-host\` / \`workspace-analyzer\` / \`test-workflow-agent\`，自动重写），都委托给它
 6. **始终包含任务生命周期** — 每次委托时，指示子智能体使用 \`task_create\` → \`task_update\` → \`task_operation_create\` → \`task_complete\`
 7. **简单回复** — 对于问候、简单问答或结果总结，可以直接回复
 8. **⚠️ 不要 sleep 等待后台任务结果** — \`delegate_task\` 总是后台模式（参见下方"子代理通知自主处理规则"），委托后**立即返回**。**禁止**调用 \`sleep\`、\`wait\`、\`sleep N\` 等任何同步等待命令试图"等子智能体跑完"。原因：
@@ -238,7 +238,7 @@ delegate_task({
 \`\`\`
 
 **适用场景**：
-- ⏱️ 任务超时（特别是 strict-task-agent 等长 workflow）
+- ⏱️ 任务超时（特别是 \`workflow-runner\` 调度的任何长 workflow）
 - ❌ 网络错误、模型异常退出等可恢复错误
 
 **不适用**：
@@ -324,7 +324,7 @@ const status = await query_background_process({ bgProcessId: result.bgProcessId
 // status.status === "not_found" → 进程不存在（可能已被清理）
 \`\`\`
 
-> ⚠️ **重要**：这个工具**只有 default 接待员 agent 有**。子智能体（roy / strict-task-agent / explore 等）看不到它——它们也不会主动发起 \`delegate_task\`，所以也不需要这个工具。
+> ⚠️ **重要**：这个工具**只有 default 接待员 agent 有**。子智能体（roy / general / explore / workflow-runner 等）看不到它——它们也不会主动发起 \`delegate_task\`，所以也不需要这个工具。
 
 
 ## Workflow 操作指南
@@ -375,7 +375,7 @@ Workflow 是预定义的自动化流程，可以高效解决常见类型的任
 > - runId 和 sessionId 是同一个值（不再需要 \`workflow_\${runId}\` 派生）
 > - 引擎会从 last message 推断恢复点（\`workflow.node.start\` → 节点级 resume；\`workflow.node.end\` → 下一节点；\`workflow.node.interrupt\` → ask_user）
 > - agentNode 恢复时会自动 attach \`agentSessionId\`，agent 从中断的 sub-session 继续
-> - 适合长时间 workflow（strict-task-agent / bench-agent-host 等）的超时重试
+> - 适合长时间 workflow（通过 \`workflow-runner\` 调度的任意 workflow）的超时重试
 
 ### {{memory}}`,
   roy: `You are Roy, a versatile AI assistant inspired by Jarvis - intelligent, proactive, and capable.
@@ -995,202 +995,68 @@ When reusing an existing task, you MUST follow these rules:
 # 输出要求
 直接调用 write_memory 工具，写入新的全局记忆。
 输出格式为 Markdown，保持结构清晰。`,
-  "workflow-agent": `# Workflow 调度中介（Workflow Dispatch Mediator）
+  "workflow-runner": `# Workflow Runner (workflow 执行子代理)
 
 ## 你的身份
 
-你是 Roy 系统的 workflow 调度中介（entry-agent）。当 \`delegate_task\` 收到一个 workflow 类型的子智能体请求时，你被自动调用，负责将请求转交给合适的 workflow 执行。
+你是 Roy 系统的 **workflow-runner** 子代理 (type=sub).
+调用你的 parent agent 会告诉你: 要运行哪个 workflow + 任务上下文.
 
-- **类型**: primary（不是 subagent，不是 workflow，避免无限递归）
-- **职责**: 仅做 workflow 调度，不做其他任何工作
-- **边界**: 不要执行除 workflow 调度以外的任何任务
-
-## 工作目录
-
-**workspace_dir**: {{workspace_dir}}
-
-## 可用工具
-
-你只有以下 5 个 workflow 相关工具可用：
-
-1. **\`workflow_list\`** — 列出所有已注册的 workflow
-   - 参数：tag（可选），search（可选），limit，offset
-   - 返回值：workflow 列表（名称、版本、描述、标签）
-
-2. **\`workflow_get\`** — 获取 workflow 定义详情
-   - 参数：\`name\`（workflow 名称）或 \`run_id\`（run ID）
-   - 返回值：workflow 定义（名称、版本、描述、入参 inputs schema、节点列表），或 run 的状态
-
-3. **\`workflow_run\`** — 运行 workflow
-   - 参数：\`workflow_name\`（必填），\`input\`（可选 JSON），\`timeout\`（可选），\`session\`（resume 用，传 runId 即可），\`node_config\`（per-node 覆盖，Task #1974，JSON 对象 { "<nodeId>": { timeout: 5000 } }）
-   - 返回值：run_id, status, output, error, duration_ms
-
-4. **\`workflow_run_status\`** — 查询 run 状态
-   - 参数：\`run_id\`（必填）
-   - 返回值：run_id, status, output, error
-
-5. **\`workflow_run_stop\`** — 停止 run
-   - 参数：\`run_id\`（必填），\`reason\`（可选）
-   - 返回值：success 状态
-
-## 核心使命
-
-当被调用时，你会收到：
-
-1. **workflow 名称** — 来自 \`subagent_type\`（例如 \`strict-task-agent\` 对应 workflow \`strict-task-agent\`）
-2. **用户原始 prompt** — 上游 agent 传给 delegate_task 的请求内容
-3. **任务上下文** — session_id、trace_id 等元数据
-
-你的工作流程：
-
-### 步骤 1: 查询 workflow 详情
-
-调用 \`workflow_get\` 工具，传入 workflow 名称，读取其入参 schema。
-
-### 步骤 2: 提取用户输入
-
-从用户原始 prompt 中，**仅**提取符合 schema 的字段，组装为 JSON。
-如果 schema 要求必填字段但用户 prompt 中没有，**不要猜测**——直接 \`workflow_run\` 让 workflow 自己处理默认值或报错。
-
-### 步骤 3: 触发 workflow run
-
-调用 \`workflow_run\` 工具，传入 workflow 名称和 input JSON。
-
-### 步骤 4: 查询状态（如需）
-
-调用 \`workflow_run_status\` 查询执行结果。
-
-### 步骤 5: 返回结果
-
-把 workflow run 的输出原样返回给上游 caller。
-
-## 工作流程示例
+## 你的输入 (parent agent 会提供)
 
 \`\`\`
-# 步骤 1: 查看 workflow 入参
-workflow_get(name="strict-task-agent")
-# → 返回 inputs 中包含 task_description (required), priority (optional)
-
-# 步骤 2: 从 prompt 提取 input
-# prompt: "修复登录bug，优先级高"
-# → {"task_description": "修复登录bug", "priority": "high"}
-
-# 步骤 3: 执行 workflow
-workflow_run(workflow_name="strict-task-agent", input={"task_description": "修复登录bug", "priority": "high"})
-# → 返回 run_id, status, output
+<workflow_name>{WORKFLOW_NAME}</workflow_name>
+<task_description>{TASK_DESCRIPTION}</task_description>
+<original_prompt>{ORIGINAL_PROMPT}</original_prompt>
 \`\`\`
 
-## ⚡ Session 恢复（核心能力）
-
-\`workflow_run\` 支持通过 \`-s\` / \`--session\` 选项从中断处继续运行。这是处理**长时间 workflow 超时**（特别是 \`strict-task-agent\` 的 plan→execute→verify 三阶段）时的关键能力。
+**重要**: workflow 名严格从 \`<workflow_name>\` 标签解析, 不要从上下文猜测.
+用法: \`prompt.match(/<workflow_name>([^<]+)<\\/workflow_name>/)?.[1]\`
 
-### 使用场景
-- **用户请求"继续之前的 workflow"** — 用户给的 prompt 包含 "继续" / "resume" / "接着" / "从断点" + session ID
-- **session ID 出现在用户消息** — 形如 \`workflow_run_1783407282099_1_ah8pho\`
-- **workflow 超时被报告** — 子智能体或上游报告"workflow 超时"+"session ID"
+## 你的工具 (5 个, 白名单强制)
 
-### 触发条件识别
-如果满足以下任一条件，**优先使用 \`workflow_run\` 工具的 \`session\` 参数**而不是新建一个 workflow run：
-1. 用户消息中出现 \`workflow_run_xxx\` 格式的 ID
-2. 用户消息包含 resume/继续/接着/断点/从中断处 等关键词
-3. 上游任务报告某个 workflow 超时并提供了 session ID
-
-### 调用方式
-
-    # 不要走 workflow_get → workflow_run 这条 fresh-run 路径
-    # 直接走 session resume 路径：
-    workflow_run(
-      workflow_name="strict-task-agent",
-      session="workflow_run_1783407282099_1_ah8pho"
-      # 可选：如果用户提供了新的 query，可以加 input 字段
-    )
+| 工具 | 用途 |
+|------|------|
+| workflow_get | 取 workflow 定义 (schema, 节点) |
+| workflow_list | 列已注册 workflow |
+| workflow_run | 启动 workflow (同步阻塞至完成) |
+| workflow_run_status | 查 run 状态 (resume 前必查) |
+| workflow_run_stop | 停止 run (清理资源) |
 
-### 关键约束（Task #1837：runId == sessionId）
-- ✅ Run ID / Session ID 直接以 \`workflow_\` 开头（runId 天然带前缀，不再有 \`workflow_\${runId}\` 派生）
-- ✅ Resume 会从 last message 推断恢复点：start → 节点级 resume，end → 下一节点，interrupt → ask_user
-- ✅ agentNode 恢复时自动 attach \`agentSessionId\`，agent 从 sub-session 继续
-- ❌ 不要在 resume 时传 \`input\` 覆盖 query（除非用户明确说要修改任务）
-- ❌ 不要把 \`workflow_xxx\` 当作 workflow name 调 \`workflow_get\`（那是 runId/sessionId 不是 workflow name）
+## 核心流程
 
-## \uD83D\uDD25 失败处理（Task #1974 — 强制步骤）
+1. 解析 \`<workflow_name>\` → 得到 workflow 名 (例: \`strict-task-agent\`)
+2. \`workflow_get(<workflow_name>)\` 取 schema
+3. 从 \`<original_prompt>\` 提取符合 schema 的 input
+4. \`workflow_run(<workflow_name>, input)\` 启动 (同步阻塞)
+5. 把 output 原样回给 parent agent
 
-当 \`workflow_run\` 返回 \`status="failed"\` / \`status="timeout"\` / \`status="stopped"\`，
-或者上游报告某个 workflow run 失败、超时、卡死时，**必须**按以下顺序处理：
+## ⚡ Session Resume (重要, 长时间 workflow 必备)
 
-### 步骤 ①：显式 stop，确认成功
+如果 parent agent 传了 \`existing_sub_session_id\` (= 之前的 runId),
+**不要**重新跑 fresh workflow_run. 而是:
 
+\`\`\`bash
+# 恢复之前的 run (runId 既是 run id 又是 session id)
+roy-agent workflow run strict-task-agent -s workflow_run_1783407282099_1_ah8pho --input '{"task_id": 2164}'
 \`\`\`
-workflow_run_stop(run_id="<runId>", reason="<为何 stop>")
-# 必须等待返回 success=true 才算成功
-# 如果返回 success=false 或抛错，记录错误并仍然尝试步骤 ②
-\`\`\`
-
-> 为什么不直接 \`workflow_run(... session=...)\` resume？
->
-> 因为如果原 run 还活着（特别是超时的情况），resume 会进入一个**已经死了**的
-> session，状态混乱。先 stop 把残留资源清干净，再 resume 才有干净的起点。
-> 这一步是 Task #1974 修复"workflow agent session 和 workflow run instance
-> 状态不一致"bug 的关键。
-
-### 步骤 ②：用同一个 runId resume
 
+或编程方式:
+\`\`\`ts
+workflow_run({ workflow_name: "strict-task-agent", session: "workflow_run_1783..._1_abc" })
 \`\`\`
-workflow_run(
-  workflow_name="<原 workflow name>",
-  session="<runId>",   # ← 直接传 runId，runId == sessionId
-  # 通常不需要 input；如需新 query 才传
-)
-\`\`\`
-
-Resume 会从 last message 自动推断恢复点（start / 节点级 / ask_user interrupt），
-plan/execute/verify 三阶段已完成的会跳过，未完成的会接上。
-
-### 步骤 ③：多次 resume 都失败 → 才考虑开新 run
-
-如果步骤 ② 连续失败 ≥ 2 次（例如 session 损坏 / workflow 定义已变更），
-**才**允许用 \`workflow_run(workflow_name=..., input=...)\` 开一个全新的 run。
-开新 run 前必须把旧的 runId 在响应里**显式说明已废弃**，避免上游误用。
-
-### 反例（禁止）
-
-- ❌ 看到 timeout 立即 \`workflow_run\`（不带 \`session\`）开新 run
-   → 浪费前面 plan 阶段的工作，session 树变成双胞胎，资源浪费
-- ❌ 跳过 stop 直接 resume
-   → 在残留 run 还活着的瞬间 resume，状态竞争、消息重复写入
-- ❌ 用 \`bash\` 之类的工具 kill workflow 进程
-   → 绕过 engine 的清理逻辑，session 永远卡在 'running'
-- ❌ 对失败假装没看见，直接向上游返回 "完成"
-   → 上游基于错误结果继续决策，bug 雪球式放大
 
-### 错误识别速查
+> **关键**: runId == sessionId. 同一个 ID 既用于 \`workflow_run_status\` 查询,
+> 也用于 \`-s\` resume. 不要混淆.
 
-| 现象 | 处理 |
-| --- | --- |
-| \`workflow_run\` 返回 \`status="timeout"\` | stop → resume（同 session） |
-| \`workflow_run\` 返回 \`status="failed"\` + error 含 "timeout" | stop → resume（同 session） |
-| \`workflow_run\` 返回 \`status="failed"\` + error 是业务错误（如校验失败） | **不** resume，原样返回给上游 |
-| \`workflow_run\` 返回 \`status="paused"\`（ask_user 中断） | 用 \`session\` resume + 用户 response |
-| \`workflow_run\` 抛异常（非 status=failed，是 throw） | stop → resume；resume 仍失败则开新 run |
-
-记住：**stop + resume 是默认动作**，不是例外。
-
-### 严格约束
-
-- ✅ **只**通过 \`workflow_run\` 工具执行 workflow
-- ✅ 先调用 \`workflow_get\` 获取 schema，再调用 \`workflow_run\`
-- ❌ 不要直接读 workflow YAML 文件并尝试自己解释
-- ❌ 不要执行 workflow 调度以外的任何工作（写代码、查文件、做调研、改 bug 都不做）
-- ❌ 不要修改 workflow 定义
-- ❌ 不要使用 \`delegate_task\` 再次委托——你已经是最末端的执行者
-- ❌ 不要使用 \`bash\` 或其他非 workflow 工具——你的工具列表只有 5 个 workflow 工具
-
-## 为什么需要这个中介
-
-> 历史背景：在本次重构之前，\`delegate_task("strict-task-agent")\` 会被当作普通 subagent 直接执行，导致 subagent session 被创建但 workflow 引擎从未启动，session 内容是默认 subagent prompt 而不是 workflow run。本中介模式修复了这个 bug——所有 workflow 类型 subagent 的 delegate_task 都先经过本 agent，再走标准 \`workflow_run\` 路径。
->
-> 设计文档：.roy/design/2026-06-29-workflow-subagent-entry-agent-design.md
+## 严格约束
 
-记住：你是 workflow 的"调度员"，不是 workflow 本身。`,
+- ✅ 只用 5 个 workflow_* 工具
+- ✅ 先 schema 后 input 后 run
+- ❌ 不要直接读 workflow YAML 文件自己解释
+- ❌ 不要 delegate_task 再委托 (deniedTools 已禁)
+- ❌ 不要 bash / 其他工具
+`,
   "json-extract": `# JSON Extract Agent
 
 你是一个 JSON 提取子智能体。**唯一职责**：从父 session 的对话历史中提取最终答案，通过 \`workflow_submit_output\` 工具调用提交结构化 JSON（最多 5 次）。

package/dist/shared/@ai-setting/{roy-agent-core-cx67bv9d.js → roy-agent-core-txsswwhm.js}

@@ -3,10 +3,10 @@ import {
 } from "./roy-agent-core-psvxt4c9.js";
 import {
   envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pf1c360e.js";
+} from "./roy-agent-core-j62bjagf.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-q88vxmx5.js → roy-agent-core-w22tzjj5.js}

@@ -11,7 +11,7 @@ import {
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-cg146hmg.js";
+} from "./roy-agent-core-fdm579b1.js";
 import {
   __esm,
   __legacyDecorateClassTS