@ai-setting/roy-agent-core 1.6.1 → 1.6.2

package/dist/shared/@ai-setting/{roy-agent-core-8cwb4fmp.js → roy-agent-core-9378eq5y.js}

@@ -24,7 +24,7 @@ var builtInPrompts = {
 
 ## 你的工具
 
-你有一组任务查询工具和两个执行工具可用：
+你有一组任务查询工具和三个执行工具可用：
 
 | 工具 | 类别 | 描述 |
 |------|------|------|
@@ -32,7 +32,8 @@ var builtInPrompts = {
 | \`task_get\` | **查询** | 获取单个任务详情（含 operations） |
 | \`task_list\` | **查询** | 按 status/priority/type/depth 列出任务，支持分页 |
 | \`task_operation_list\` | **查询** | 查看任务的操作记录 |
-| \`delegate_task\` | **执行** | 委托复杂/多步骤任务给子智能体执行 |
+| \`delegate_task\` | **执行** | 委托复杂/多步骤任务给子智能体执行（后台模式，立即返回） |
+| \`query_background_process\` | **执行** | 查询由 \`delegate_task\` 启动的后台进程当前状态（仅 default agent 可见） |
 | \`bash\` | **执行** | 仅用于执行一行简单的 shell 命令 |
 
 ### 查询工具（可直接使用）
@@ -116,8 +117,9 @@ delegate_task(
 )
 \`\`\`
 
-> **提示**：\`delegate_task\` 现在**总是后台模式**，立即返回。父 agent 通过返回的 \`task_id\` 用 \`task_get\` 查询进度。
+> **提示**：\`delegate_task\` 现在**总是后台模式**，立即返回。父 agent 通过返回的 \`bgProcessId\` 用 \`query_background_process\` 查询后台进程**实时状态**。
 > - delegate_task 内部自动创建关联 Task，调用方无需传入 \`task_id\`
+> - \`bgProcessId\` 用于查实时状态（running/completed/failed/timeout/stopped），\`task_get\` 查的是关联的 Task #N 生命周期，**两者不要混用**
 > - sub-session 始终保留（不会自动删除），可通过 \`session_get\` 查看完整执行日志
 
 ### \uD83E\uDD48 次选：\`strict-task-agent\`（需要严格验证时使用）
@@ -177,6 +179,7 @@ delegate_task(
    - 父 agent 收到通知后**自主处理**（见下一节），无需主动 sleep 轮询
    - 错误做法：\`sleep 60 && task_get <id>\`、\`while !task_complete; do sleep 5; done\`
    - 正确做法：\`delegate_task(...)\` → 立即返回 → 等待系统通知 → 收到通知后自主处理
+9. **⚠️ 不要轮询 \`task_get\` / \`task_search\` 检查后台任务** — 这两个工具是用来查"Task #"（人工任务管理）的，不是用来跟踪 \`delegate_task\` 后台进程的。如果你怀疑某个后台进程**没有按时收到通知**或**卡住了**，**应该用 \`query_background_process\` 工具**（见下方"7. 主动查询后台进程"），而不是用 \`task_get\` / \`task_search\` 反复查 Task 状态。
 
 ## 子代理通知自主处理规则
 
@@ -244,6 +247,75 @@ delegate_task({
 - 遇到阻塞：尝试绕过或选替代方案，无法绕过的暂停任务等用户回来
 - 任务完成：记录完整结果，用户回来时统一汇报
 
+### 7. 主动查询后台进程（query_background_process，2026-07 新增）
+
+如果你委托了一个后台任务，但**迟迟没有收到任何通知**（completed / failed / progress / timeout），可能的原因有：
+- 后台任务还在运行（正常，可能耗时较长）
+- 后台任务卡住了（外部资源阻塞、模型僵死、网络挂起等）
+- 后台任务崩溃了但通知消息丢失
+- 通知机制本身出问题了
+
+**此时不要 sleep 轮询，也不要反复调 task_get**。使用专门的 \`query_background_process\` 工具查询后台进程**实时状态**。
+
+#### 何时使用 query_background_process
+
+✅ **应该用**：
+- 委托了一个**长任务**（timeout ≥ 5 分钟），过去 5+ 分钟还没收到任何通知，主动确认是否还活着
+- 用户**主动问**"那个任务进展怎么样了？"——需要最新快照而不是等通知
+- 怀疑后台任务**卡住**（最后一条 progress 通知是较久以前、子任务明显应该推进但没动静）
+- 收到 timeout / failed 通知，但需要确认**真实状态**（避免误判 timeout 后又被通知说完成了）
+- 准备做关键决策（如复用 sub session 重试）前，需要先确认原 task 真的已经结束
+
+❌ **不应该用**：
+- 委托后**几秒就查**——99% 的情况下根本不需要这么急，等通知就行
+- 每隔 30 秒就查一次——这就是 sleep 轮询的变种，浪费 token
+- 每次 ReAct 迭代都查——同理，浪费 token
+
+#### 查询频率建议
+
+- **委托后 5 分钟内**：完全不需要查，等通知
+- **5-15 分钟无通知**：可以查一次确认 alive 状态，然后继续等
+- **15+ 分钟无通知**：可以每 5 分钟查一次，关注 status 是否仍为 "running"
+- **收到 timeout 通知后**：立刻查一次，确认最终状态再决定下一步
+
+#### 返回值结构
+
+工具返回 JSON 字符串：
+
+\`\`\`json
+{
+  "alive": true,            // status 为 pending/running 时为 true，否则 false
+  "status": "running",      // pending | running | completed | failed | stopped | timeout | not_found
+  "createdAt": 1721000000000,        // 启动时间戳（ms）
+  "lastUpdatedAt": 1721000060000,    // 最后状态更新时间戳（ms）
+  "description": "实现加法函数",     // delegate_task 传入的 description
+  "result": "已完成，实现代码在 ...",  // 仅 completed 状态有
+  "error": "..."                   // 仅 failed 状态有
+}
+\`\`\`
+
+#### 示例
+
+\`\`\`typescript
+// 委托任务（拿 bgProcessId）
+const result = await delegate_task({
+  description: "实现加法函数",
+  prompt: "...",
+  subagent_type: "roy",
+  similar_task_ids: [],
+});
+// result.bgProcessId 形如 "process_1721000000000_abc12345"
+
+// ...等 10 分钟没收到通知，主动查询
+const status = await query_background_process({ bgProcessId: result.bgProcessId });
+// status.alive === true  → 还在跑，继续等
+// status.alive === false && status.status === "completed" → 任务已完成，看 status.result
+// status.alive === false && status.status === "timeout" → 已超时，考虑用 subSessionId 重试
+// status.status === "not_found" → 进程不存在（可能已被清理）
+\`\`\`
+
+> ⚠️ **重要**：这个工具**只有 default 接待员 agent 有**。子智能体（roy / strict-task-agent / explore 等）看不到它——它们也不会主动发起 \`delegate_task\`，所以也不需要这个工具。
+
 
 ## Workflow 操作指南
 
@@ -933,7 +1005,7 @@ When reusing an existing task, you MUST follow these rules:
    - 返回值：workflow 定义（名称、版本、描述、入参 inputs schema、节点列表），或 run 的状态
 
 3. **\`workflow_run\`** — 运行 workflow
-   - 参数：\`workflow_name\`（必填），\`input\`（可选 JSON），\`sync\`（是否等待完成，默认 true），\`timeout\`（可选）
+   - 参数：\`workflow_name\`（必填），\`input\`（可选 JSON），\`sync\`（是否等待完成，默认 true），\`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 状态
@@ -1023,6 +1095,69 @@ workflow_run(workflow_name="strict-task-agent", input={"task_description": "修
 - ❌ 不要在 resume 时传 \`input\` 覆盖 query（除非用户明确说要修改任务）
 - ❌ 不要把 \`workflow_xxx\` 当作 workflow name 调 \`workflow_get\`（那是 runId/sessionId 不是 workflow name）
 
+## \uD83D\uDD25 失败处理（Task #1974 — 强制步骤）
+
+当 \`workflow_run\` 返回 \`status="failed"\` / \`status="timeout"\` / \`status="stopped"\`，
+或者上游报告某个 workflow run 失败、超时、卡死时，**必须**按以下顺序处理：
+
+### 步骤 ①：显式 stop，确认成功
+
+\`\`\`
+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
+
+\`\`\`
+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 雪球式放大
+
+### 错误识别速查
+
+| 现象 | 处理 |
+| --- | --- |
+| \`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="running"\` 但实际卡死很久 | 先 \`workflow_run_status\` 确认；仍是 running 则 stop → resume |
+| \`workflow_run\` 抛异常（非 status=failed，是 throw） | stop → resume；resume 仍失败则开新 run |
+
+记住：**stop + resume 是默认动作**，不是例外。
+
 ### 严格约束
 
 - ✅ **只**通过 \`workflow_run\` 工具执行 workflow

package/dist/shared/@ai-setting/{roy-agent-core-vrn9qj8y.js → roy-agent-core-97x9ymda.js}

@@ -1,6 +1,6 @@
 import {
   createAutoTaskPlugin
-} from "./roy-agent-core-8cezq5x9.js";
+} from "./roy-agent-core-gexpbexm.js";
 import {
   ContextError,
   ErrorCodes

package/dist/shared/@ai-setting/roy-agent-core-amkqnyzy.js

@@ -0,0 +1,145 @@
+// src/env/tool/built-in/query-background-process-tool.ts
+import { z } from "zod";
+var QueryBackgroundProcessParameters = z.object({
+  bgProcessId: z.string().min(1, "bgProcessId must not be empty").describe("The background process ID returned by delegate_task " + "(format: process_<timestamp>_<random>).")
+});
+function backgroundTaskToOutput(task) {
+  return {
+    alive: task.status === "pending" || task.status === "running",
+    status: task.status,
+    createdAt: task.createdAt,
+    lastUpdatedAt: task.lastUpdatedAt ?? task.completedAt ?? task.startedAt ?? task.createdAt,
+    description: task.description,
+    ...task.result !== undefined ? { result: task.result } : {},
+    ...task.error !== undefined ? { error: task.error } : {}
+  };
+}
+function notFoundOutput(bgProcessId) {
+  const now = Date.now();
+  return {
+    alive: false,
+    status: "not_found",
+    createdAt: now,
+    lastUpdatedAt: now,
+    description: `No background process found with id '${bgProcessId}'.`
+  };
+}
+var queryBackgroundProcessTool = {
+  name: "query_background_process",
+  description: `Query the status of a background process previously launched via delegate_task.
+
+` + `Use this tool when:
+` + `  - You delegated a long-running task but have NOT received any notification after a reasonable wait (5+ minutes), and want to confirm whether the process is still alive.
+` + `  - The user asks about the progress of a delegated task and you need a current snapshot.
+` + `  - You suspect a delegated task got stuck (no progress messages, no completion notification).
+
+` + `DO NOT poll this tool on every turn — it is meant for diagnostic checks at a reasonable cadence (e.g. every few minutes, or when you genuinely suspect the task is stuck).
+
+` + `Returns a JSON object with:
+` + `  - alive: boolean — true if status is 'pending' or 'running'
+` + `  - status: 'pending' | 'running' | 'completed' | 'failed' | 'stopped' | 'timeout' | 'not_found'
+` + `  - createdAt, lastUpdatedAt: timestamps (ms)
+` + `  - description: the task description you passed to delegate_task
+` + `  - result: present when status is 'completed'
+` + `  - error: present when status is 'failed'
+
+` + "Only the default receptionist agent has this tool. Sub-agents (roy, strict-task-agent, etc.) cannot see it because they do not need to query background tasks they themselves launched.",
+  parameters: QueryBackgroundProcessParameters,
+  permission: {
+    level: "safe",
+    requireConfirmation: false
+  },
+  metadata: {
+    category: "task",
+    tags: ["background", "delegate", "query", "status", "diagnostic"],
+    version: "1.0.0",
+    allowedAgentTypes: ["default"]
+  },
+  execute: async (args, ctx) => createQueryBackgroundProcessTool(null).execute(args, ctx)
+};
+function createQueryBackgroundProcessTool(manager = null) {
+  return {
+    name: "query_background_process",
+    description: `Query the status of a background process previously launched via delegate_task.
+
+` + `Use this tool when:
+` + `  - You delegated a long-running task but have NOT received any notification after a reasonable wait (5+ minutes), and want to confirm whether the process is still alive.
+` + `  - The user asks about the progress of a delegated task and you need a current snapshot.
+` + `  - You suspect a delegated task got stuck (no progress messages, no completion notification).
+
+` + `DO NOT poll this tool on every turn — it is meant for diagnostic checks at a reasonable cadence (e.g. every few minutes, or when you genuinely suspect the task is stuck).
+
+` + `Returns a JSON object with:
+` + `  - alive: boolean — true if status is 'pending' or 'running'
+` + `  - status: 'pending' | 'running' | 'completed' | 'failed' | 'stopped' | 'timeout' | 'not_found'
+` + `  - createdAt, lastUpdatedAt: timestamps (ms)
+` + `  - description: the task description you passed to delegate_task
+` + `  - result: present when status is 'completed'
+` + `  - error: present when status is 'failed'
+
+` + "Only the default receptionist agent has this tool. Sub-agents (roy, strict-task-agent, etc.) cannot see it because they do not need to query background tasks they themselves launched.",
+    parameters: QueryBackgroundProcessParameters,
+    permission: {
+      level: "safe",
+      requireConfirmation: false
+    },
+    metadata: {
+      category: "task",
+      tags: ["background", "delegate", "query", "status", "diagnostic"],
+      version: "1.0.0",
+      allowedAgentTypes: ["default"]
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const params = QueryBackgroundProcessParameters.parse(args);
+      const { bgProcessId } = params;
+      if (!manager) {
+        return {
+          success: false,
+          output: "",
+          error: "query_background_process is not initialized: no BackgroundTaskManager " + "has been bound. TaskComponent should call " + "createQueryBackgroundProcessTool(manager) and register the tool " + "during startup.",
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      let task;
+      try {
+        task = manager.getTask(bgProcessId);
+      } catch (err) {
+        return {
+          success: false,
+          output: "",
+          error: `failed to query background task: ${err.message}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      if (task) {
+        const currentSessionId = ctx.session_id;
+        if (!currentSessionId || task.parentSessionId !== currentSessionId) {
+          return {
+            success: true,
+            output: JSON.stringify(notFoundOutput(bgProcessId), null, 2),
+            metadata: {
+              execution_time_ms: Date.now() - startTime,
+              bgProcessId,
+              status: "not_found",
+              alive: false
+            }
+          };
+        }
+      }
+      const output = task ? backgroundTaskToOutput(task) : notFoundOutput(bgProcessId);
+      return {
+        success: true,
+        output: JSON.stringify(output, null, 2),
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          bgProcessId,
+          status: output.status,
+          alive: output.alive
+        }
+      };
+    }
+  };
+}
+
+export { queryBackgroundProcessTool, createQueryBackgroundProcessTool };

package/dist/shared/@ai-setting/{roy-agent-core-9gde0s9d.js → roy-agent-core-ba6243hr.js}

@@ -103,7 +103,7 @@ var init_tool_node = __esm(() => {
               nodeId: context.nodeId
             }
           };
-          const toolTimeoutMs = getToolTimeoutMs(input, this.definition.config);
+          const toolTimeoutMs = getToolTimeoutMs(input, config);
           const executePromise = tool.execute(input, toolContext);
           let timeoutHandle;
           const timeoutPromise = new Promise((_, reject) => {

package/dist/shared/@ai-setting/{roy-agent-core-2vhsccvz.js → roy-agent-core-caevk7xd.js}

@@ -28,6 +28,16 @@ function inferNextNode(messages, definition) {
       };
     case "workflow.node.end":
     case "workflow.node.result":
+      if (metadata?.success === false) {
+        const failedNodeId = getWorkflowNodeIdFromMetadata(metadata);
+        if (failedNodeId) {
+          return {
+            type: "resume_node",
+            nodeId: failedNodeId,
+            agentSessionId: metadata.agentSessionId
+          };
+        }
+      }
       return getNextNodes(getWorkflowNodeIdFromMetadata(metadata), definition);
     default:
       const lastStart = findLastStartMessage(messages);

package/dist/shared/@ai-setting/{roy-agent-core-84ex7khq.js → roy-agent-core-ekptge19.js}

@@ -6,7 +6,7 @@ import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-415rxkzy.js";
+} from "./roy-agent-core-gzzvcmg3.js";
 import {
   askUserTool,
   createRunWorkflowTool,
@@ -18,7 +18,7 @@ import {
   createWorkflowSearchTool,
   createWorkflowTagListTool,
   createWorkflowValidateTool
-} from "./roy-agent-core-txk4gcwm.js";
+} from "./roy-agent-core-xnga0ksx.js";
 import {
   WorkflowService
 } from "./roy-agent-core-b75jtybq.js";
@@ -141,7 +141,7 @@ class WorkflowComponent extends BaseComponent {
     if (!agentRunner && this._workflowEnv) {
       const agentComponent = this._workflowEnv.getComponent("agent");
       if (agentComponent) {
-        const { AgentComponentAdapter } = await import("./roy-agent-core-57bmm0a1.js");
+        const { AgentComponentAdapter } = await import("./roy-agent-core-y1m7c2v7.js");
         agentRunner = new AgentComponentAdapter(agentComponent, {}, this.sessionComponent);
       }
     }

package/dist/shared/@ai-setting/{roy-agent-core-8cezq5x9.js → roy-agent-core-gexpbexm.js}

@@ -6,7 +6,7 @@ import {
 } from "./roy-agent-core-8wd3qwx5.js";
 import {
   WORKFLOW_EXTRACT_PROMPT
-} from "./roy-agent-core-8cwb4fmp.js";
+} from "./roy-agent-core-9378eq5y.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";

package/dist/shared/@ai-setting/{roy-agent-core-415rxkzy.js → roy-agent-core-gzzvcmg3.js}

@@ -7,7 +7,7 @@ import {
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-q8n1s1pb.js";
+} from "./roy-agent-core-vf72n6qn.js";
 import {
   TemplateResolver,
   init_template_resolver
@@ -19,7 +19,7 @@ import {
   init_skill_node,
   init_tool_node,
   init_workflow_node
-} from "./roy-agent-core-9gde0s9d.js";
+} from "./roy-agent-core-ba6243hr.js";
 import {
   WorkflowError,
   createWorkflowEvent,
@@ -416,14 +416,17 @@ var init_executor = __esm(() => {
       await this.writeNodeStart(context.sessionId, nodeId, nodeType, context.input, agentSessionId);
       const abortController = new AbortController;
       this.abortControllers.set(nodeId, abortController);
-      const timeout = definition.timeout ?? this.options.globalTimeout ?? undefined;
+      context.abortSignal ??= abortController.signal;
+      const ctxCfg = context.config;
+      const cfgTimeout = ctxCfg && typeof ctxCfg.timeout === "number" && ctxCfg.timeout > 0 ? ctxCfg.timeout : undefined;
+      const timeout = definition.timeout ?? cfgTimeout ?? this.options.globalTimeout ?? undefined;
       const retryConfig = definition.retry ?? this.options.globalRetry;
       try {
         let result;
         if (retryConfig && retryConfig.max_attempts > 1) {
-          result = await this.executeWithRetry(definition, context, abortController.signal, timeout);
+          result = await this.executeWithRetry(definition, context, abortController, timeout);
         } else {
-          result = await this.executeWithTimeout(definition, context, abortController.signal, timeout);
+          result = await this.executeWithTimeout(definition, context, abortController, timeout);
         }
         if (result.error instanceof AskUserError) {
           const interruptEvent = createNodeInterruptEvent(context.runId, nodeId, nodeType, result.error.query, result.error.agentSessionId || agentSessionId);
@@ -455,7 +458,7 @@ var init_executor = __esm(() => {
         this.abortControllers.delete(nodeId);
       }
     }
-    async executeWithTimeout(definition, context, signal, timeout) {
+    async executeWithTimeout(definition, context, abortController, timeout) {
       const startTime = Date.now();
       const nodeContext = {
         runId: context.runId,
@@ -464,9 +467,13 @@ var init_executor = __esm(() => {
         debug: context.debug
       };
       const node = this.nodeRegistry.createNode(definition, nodeContext);
+      const signal = abortController.signal;
       if (timeout) {
         const timeoutPromise = new Promise((_, reject) => {
           const handle = setTimeout(() => {
+            if (!abortController.signal.aborted) {
+              abortController.abort(new Error(`Node execution timeout: ${timeout}ms`));
+            }
             reject(new Error(`Node execution timeout: ${timeout}ms`));
           }, timeout);
           signal.addEventListener("abort", () => clearTimeout(handle));
@@ -510,10 +517,11 @@ var init_executor = __esm(() => {
         }
       }
     }
-    async executeWithRetry(definition, context, signal, timeout) {
+    async executeWithRetry(definition, context, abortController, timeout) {
       const retryConfig = definition.retry;
       let lastError;
       let delay = retryConfig.initial_delay;
+      const signal = abortController.signal;
       for (let attempt = 1;attempt <= retryConfig.max_attempts; attempt++) {
         if (signal.aborted) {
           return {
@@ -524,8 +532,25 @@ var init_executor = __esm(() => {
         }
         const attemptAbort = new AbortController;
         const combinedSignal = this.combineAbortSignals(signal, attemptAbort.signal);
+        const combinedController = new AbortController;
+        combinedSignal.addEventListener("abort", () => {
+          if (!combinedController.signal.aborted) {
+            combinedController.abort(combinedSignal.reason);
+          }
+        });
+        const attemptAbortController = {
+          get signal() {
+            return combinedSignal;
+          },
+          abort: (reason) => {
+            attemptAbort.abort(reason);
+            if (!combinedController.signal.aborted) {
+              combinedController.abort(reason);
+            }
+          }
+        };
         try {
-          const result = await this.executeWithTimeout(definition, context, combinedSignal, timeout);
+          const result = await this.executeWithTimeout(definition, context, attemptAbortController, timeout);
           if (!result.error) {
             return result;
           }
@@ -991,6 +1016,8 @@ var init_agent_node = __esm(() => {
         const agentName = config.agent_name || undefined;
         const options = config.options || {};
         const outputConfig = parseAgentOutputConfig(config);
+        const flatTimeout = typeof config.timeout === "number" && config.timeout > 0 ? config.timeout : undefined;
+        const resolvedTimeout = flatTimeout ?? options.timeout;
         let resolvedPrompt;
         if (context.resolvedConfig && context.templateResolver) {
           resolvedPrompt = config.prompt || "";
@@ -1044,7 +1071,7 @@ var init_agent_node = __esm(() => {
           type: resolvedAgentType,
           prompt: resolvedPrompt,
           options: {
-            timeout: options.timeout,
+            timeout: resolvedTimeout,
             model: effectiveModel,
             allowedTools: effectiveAllowedTools,
             deniedTools: effectiveDeniedTools,
@@ -1058,7 +1085,12 @@ var init_agent_node = __esm(() => {
           userQuery,
           agentSessionId
         };
-        const result = await this.agentRunner.run(agentConfig, resumeOptions);
+        let result;
+        if (context.abortSignal) {
+          result = await this.agentRunner.run(agentConfig, resumeOptions, context.abortSignal);
+        } else {
+          result = await this.agentRunner.run(agentConfig, resumeOptions);
+        }
         const duration = Date.now() - startTime;
         return {
           output: buildAgentNodeOutput(result, outputConfig),
@@ -1433,9 +1465,6 @@ var init_engine = __esm(() => {
       if (metadata.status === "completed") {
         return { runId: this.getRunIdFromSessionId(sessionId), status: "completed" };
       }
-      if (metadata.status === "failed") {
-        return { runId: this.getRunIdFromSessionId(sessionId), status: "failed" };
-      }
       if (options?.input && this.sessionComponent) {
         const hasNewInput = typeof options.input === "string" ? options.input !== undefined && options.input !== "" : Object.keys(options.input).length > 0;
         if (hasNewInput) {
@@ -1457,7 +1486,7 @@ var init_engine = __esm(() => {
         extractResumeInfo,
         enrichResumeInfoWithAgentSessions,
         enrichResumePointWithAgentSessions
-      } = await import("./roy-agent-core-2vhsccvz.js");
+      } = await import("./roy-agent-core-caevk7xd.js");
       const entry = workflowDef.entry;
       const entryNode = Array.isArray(entry) ? entry[0] : entry;
       const agentSessions = metadata.agentSessions ?? [];
@@ -1496,7 +1525,7 @@ var init_engine = __esm(() => {
           persistedInput = rest;
         }
       }
-      const { stripEphemeralResumeInput } = await import("./roy-agent-core-2vhsccvz.js");
+      const { stripEphemeralResumeInput } = await import("./roy-agent-core-caevk7xd.js");
       const { workflowInput: runtimeInput } = stripEphemeralResumeInput(rawRuntimeInput);
       const defaultsFromSchema = {};
       if (definition.inputs) {
@@ -1515,7 +1544,8 @@ var init_engine = __esm(() => {
         strict: options?.strict ?? definition.config?.strict ?? false,
         maxIterations: options?.maxIterations ?? definition.config?.maxIterations ?? 100,
         loopEnabled,
-        workflowInput
+        workflowInput,
+        nodeConfig: options?.nodeConfig ?? {}
       };
       const abortController = new AbortController;
       let resolveCompleted;
@@ -1691,6 +1721,8 @@ var init_engine = __esm(() => {
               status: "paused",
               pendingNodeId: event.node_id,
               pauseReason: "ask_user",
+              pendingAskUserQuery: event.query,
+              pendingAskUserAgentSessionId: event.agent_session_id,
               agentSessions
             }
           });
@@ -1712,7 +1744,7 @@ var init_engine = __esm(() => {
     async scheduleAndExecute(sessionState, options) {
       const { scheduler, executor, eventBus, abortController, nodeOutputs } = sessionState;
       const { input: globalInput, pendingNodeId, agentSessionId, restoredOutputs } = options || {};
-      const { stripEphemeralResumeInput } = await import("./roy-agent-core-2vhsccvz.js");
+      const { stripEphemeralResumeInput } = await import("./roy-agent-core-caevk7xd.js");
       const { workflowInput: inputToPersist, userQuery: resumeUserQuery } = stripEphemeralResumeInput(globalInput);
       if (inputToPersist) {
         sessionState.config.workflowInput = {
@@ -1854,7 +1886,7 @@ var init_engine = __esm(() => {
       if (!agentSessionId && this.sessionComponent) {
         const session = await this.sessionComponent.get(sessionId);
         const agentSessions = session?.metadata?.agentSessions;
-        const { resolveAgentSessionId } = await import("./roy-agent-core-2vhsccvz.js");
+        const { resolveAgentSessionId } = await import("./roy-agent-core-caevk7xd.js");
         agentSessionId = resolveAgentSessionId(nodeId, undefined, agentSessions);
       }
       await sessionState.executor.writeNodeResume(sessionId, nodeId, nodeDef.type, options?.userQuery ?? "", agentSessionId);
@@ -1996,6 +2028,8 @@ var init_engine = __esm(() => {
       const askUser = (query) => {
         throw new AskUserError(runId, sessionState.sessionId, nodeId, nodeDef.type, query);
       };
+      const nodeConfigOverride = sessionState.config.nodeConfig?.[nodeId];
+      const effectiveConfig = nodeConfigOverride ? { ...nodeDef.config ?? {}, ...nodeConfigOverride } : nodeDef.config ?? {};
       const context = {
         runId,
         sessionId: sessionState.sessionId,
@@ -2003,7 +2037,7 @@ var init_engine = __esm(() => {
         nodeId,
         input,
         previousOutputs: sessionState.nodeOutputs,
-        config: nodeDef.config ?? {},
+        config: effectiveConfig,
         debug: sessionState.config.debug,
         eventBus: sessionState.eventBus,
         nodeOutputs: sessionState.nodeOutputs,
@@ -2015,7 +2049,7 @@ var init_engine = __esm(() => {
         },
         workflowInput,
         templateResolver,
-        resolvedConfig: templateResolver.resolveValue(nodeDef.config ?? {})
+        resolvedConfig: templateResolver.resolveValue(effectiveConfig)
       };
       return context;
     }

package/dist/shared/@ai-setting/{roy-agent-core-84aqc5c0.js → roy-agent-core-j25z80xr.js}

@@ -1,3 +1,6 @@
+import {
+  createQueryBackgroundProcessTool
+} from "./roy-agent-core-amkqnyzy.js";
 import {
   TaskEntityEventTypes
 } from "./roy-agent-core-8gxth0eh.js";
@@ -5,7 +8,7 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-mnc0hy7j.js";
+} from "./roy-agent-core-te3hf26b.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
@@ -314,6 +317,8 @@ class TaskComponent extends BaseComponent {
     this.toolComponent = this.env?.getComponent("tool");
     if (this.toolComponent) {
       await this.registerTools();
+      this.toolComponent.register(createQueryBackgroundProcessTool(this.backgroundTaskManager), "built-in");
+      logger2.debug("[TaskComponent] Injected BackgroundTaskManager into query_background_process tool (factory pattern)");
     } else {
       logger2.warn("[TaskComponent] ToolComponent not found, skipping tool registration");
     }
@@ -323,8 +328,17 @@ class TaskComponent extends BaseComponent {
       this.configWatcher();
       this.configWatcher = undefined;
     }
+    if (this.toolComponent) {
+      try {
+        this.toolComponent.register(createQueryBackgroundProcessTool(null), "built-in");
+        logger2.debug("[TaskComponent] Reset query_background_process tool to no-manager default (cleanup)");
+      } catch (err) {
+        logger2.warn(`[TaskComponent] Failed to reset query_background_process tool: ${err.message}`);
+      }
+    }
     if (this.backgroundTaskManager) {
       this.backgroundTaskManager.dispose();
+      this.backgroundTaskManager = undefined;
     }
     if (this.store) {
       await this.store.close();