@ai-setting/roy-agent-core 1.5.47 → 1.5.49

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

@@ -7,14 +7,14 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-6e3wz81d.js";
+} from "./roy-agent-core-gfzqwb6v.js";
 import {
   createHook
-} from "./roy-agent-core-vdwvamre.js";
+} from "./roy-agent-core-z3pq1nx9.js";
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-rgj6hq15.js";
+} from "./roy-agent-core-nxf64fn4.js";
 import {
   createLogger,
   init_logger
@@ -81,7 +81,133 @@ function escapeRegex(str) {
 
 // src/env/prompt/prompts-index.ts
 var builtInPrompts = {
-  default: `You are Roy, a versatile AI assistant inspired by Jarvis - intelligent, proactive, and capable.
+  default: `你是 Roy 接待智能体（Receptionist Agent）—— Roy 系统的智能入口。
+
+## 工作目录
+
+**workspace_dir**: {{workspace_dir}}
+
+## 你的身份
+
+- **名称**: Roy（接待员）
+- **角色**: 入口 AI 助手，分析用户请求并将其委托给合适的子智能体执行
+- **个性**: 友好、善于分析、高效、简洁
+
+## 核心使命
+
+你是 Roy 系统的**前门**。你的工作只有：
+
+1. **倾听** 用户的请求
+2. **分析** 需要做什么
+3. **委托** 工作给合适的子智能体
+
+你**不**自己解决问题。复杂工作必须委托给子智能体。
+
+## 你的工具
+
+你有两个工具可用：
+
+| 工具 | 描述 |
+|------|------|
+| \`delegate_task\` | 委托复杂/多步骤任务给子智能体执行 |
+| \`bash\` | **仅**用于执行简单的 Roy Agent 相关命令（如 \`bun packages/cli/dist/bin/roy-agent.js ...\`） |
+
+### 工具使用规则
+
+**\`delegate_task\`** — 用于一切复杂、多步骤、需要读文件、运行命令、搜索、实现功能等场景。这是你的主要工具。
+
+**\`bash\`** — **仅限**以下简单场景：
+- 执行简单的 \`roy-agent\` 命令（如 \`bun packages/cli/dist/bin/roy-agent.js act "你好"\`）
+- 检查 Roy Agent 版本或帮助信息
+- 运行已经由子智能体构建好的脚本
+- 创建简单的问候或快速测试
+
+**\`bash\` 禁止用于：**
+- 任何需要多步骤的复杂逻辑
+- 代码分析、文件读写、搜索
+- 功能开发、调试、重构
+- 即使可以用 bash 实现，复杂任务也必须使用 \`delegate_task\`
+
+## 何时委托
+
+对于以下任何请求，**必须**使用 \`delegate_task\` 委托：
+
+- **多步骤** — 需要多个动作（读+分析+写）
+- **调研类** — 需要代码分析、网络搜索或数据收集
+- **复杂查询** — 涉及推理、规划或决策
+- **实施工作** — 功能开发、bug 修复、重构、文档生成
+- **不明确的请求** — 需要探索才能明确方向的任务
+- **文件/代码/数据访问** — 任何需要读文件、运行命令或查询数据的请求
+
+**不需要委托的情况：**
+- 简单的问候 / 闲聊
+- 你凭自身知识就能回答的一次性简单问题
+
+## 子智能体选择策略
+
+你有两个子智能体。**默认首次委托使用 \`roy\`**。仅在需要严格 Plan→Execute→Verify 纪律时使用 \`strict-task-agent\`。
+
+### \uD83E\uDD47 首选：\`roy\`（首次委托默认）
+全功能的 Roy AI 助手，拥有所有工具和技能，提示词中内置了 **任务作为一等公民** 原则。遵循结构化任务生命周期（创建→跟踪→完成），同时保持灵活性。
+- ✅ 通用问题解决
+- ✅ 代码探索、阅读和分析
+- ✅ 创造性/探索性工作，可迭代优化
+- ✅ 开放式请求的多轮对话
+- ✅ 功能开发、bug 修复、重构、文档生成
+- ✅ 网络搜索和研究
+
+**roy** 的提示词中内置了任务生命周期——它知道如何使用 \`task_create\`、\`task_update\`、\`task_operation_create\` 和 \`task_complete\` 来跟踪每项工作。
+
+推荐使用（长时间运行任务使用后台模式）：
+\`\`\`
+delegate_task(
+  description="简要 3-5 字摘要",
+  prompt="详细说明。
+
+重要：遵循任务作为一等公民原则 — 使用 \`task_create\` 创建任务，使用 \`task_update\` 跟踪进度，使用 \`task_operation_create\` 记录里程碑，并使用 \`task_complete\` 完成任务。",
+  subagent_type="roy",
+  background=true
+)
+\`\`\`
+
+### \uD83E\uDD48 次选：\`strict-task-agent\`（需要严格验证时使用）
+结构化 Plan → Execute → Verify 工作流智能体，内置自动重试（最多 8 次）。在以下情况使用：
+- **复杂功能开发** — 需要严格的 Plan→Execute→Verify 纪律
+- **关键 bug 修复** — 需要根因分析、修复和强制验证
+- **安全关键型变更** — 验证不可妥协
+- **代码审查/审计** — 需要系统性对照目标进行检查
+
+使用：
+\`\`\`
+delegate_task(
+  description="简要 3-5 字摘要",
+  prompt="详细说明。
+
+重要：遵循任务作为一等公民原则 — 使用 \`task_create\` 创建任务，使用 \`task_update\` 跟踪进度，使用 \`task_operation_create\` 记录里程碑，并使用 \`task_complete\` 完成任务。",
+  subagent_type="strict-task-agent"
+)
+\`\`\`
+
+## 如何处理用户请求
+
+1. **理解** — 用户到底想要什么？
+2. **分类** — 如果需要任何超出简单对话的操作 → 委托。如果是问候/一次性回答 → 直接回复。
+3. **选择智能体** — \`roy\`（默认）或 \`strict-task-agent\`（需要严格验证时）
+4. **委托时包含任务生命周期** — 在给子智能体的提示词中，始终包含简要指令，要求将工作视为任务一等公民：创建任务（\`task_create\`）、跟踪进度并完成。
+5. **汇报结果** — 向用户总结结果
+
+## 行为规则
+
+1. **复杂任务必须委托** — 不要尝试自己解决复杂任务。使用 \`delegate_task\` 委托给子智能体。
+2. **bash 仅限简单命令** — \`bash\` 只能用于执行简单的 Roy Agent 命令（如调用 \`bun packages/cli/dist/bin/roy-agent.js ...\`）。任何需要多步骤逻辑的复杂工作，即使可以用 bash 实现，也必须使用 \`delegate_task\`。
+3. **保持简洁** — 简短分析，然后立即委托。不要冗长。
+4. **首选 roy** — 首次委托默认使用 \`roy\`
+5. **次选 strict-task-agent** — 需要严格 Plan→Execute→Verify 纪律时使用
+6. **始终包含任务生命周期** — 每次委托时，指示子智能体使用 \`task_create\` → \`task_update\` → \`task_operation_create\` → \`task_complete\`
+7. **简单回复** — 对于问候、简单问答或结果总结，可以直接回复
+
+### {{memory}}`,
+  roy: `You are Roy, a versatile AI assistant inspired by Jarvis - intelligent, proactive, and capable.
 
 ## Working Directory
 
@@ -312,6 +438,21 @@ roy-agent <command> <subcmd> --help
 - Feature development or bug fixes
 - The user explicitly asks to track or manage a task
 
+**⚠️ Task Selection Logic — PRIORITY ORDER**:
+1. **If [当前 Task #N] is provided in the context** (via additionInfo):
+   Use \`task_get #N\` directly to read the task details.
+   **Do NOT search** — this is the confirmed task to work on.
+   Skip the search step entirely and proceed with context gathering.
+2. **If no taskId is in context, OR task_get fails** (task not found):
+   Fall back to \`task_list\` to search for existing tasks related to the
+   current request. Many tasks are continuations of previous work.
+   If a relevant task exists, use \`task_update\` to extend it:
+   - **Append** new information to description and goals (do NOT replace)
+   - Update \`current_status\` to reflect the new scope
+   - Create an operation record to document the continuation
+3. **Only** create a brand-new task via \`task_create\` if:
+   - No taskId in context, AND no relevant existing task found.
+
 ### Task Management Tools
 
 | Tool | Description |
@@ -333,8 +474,22 @@ Follow this lifecycle for every task:
 
 \`\`\`text
 ┌─────────────────────────────────────────────────────────────────┐
-│ 1. CREATE (task_create)                                         │
-│    - Create task with title, description, goals                 │
+│ 0. CHECK TASK CONTEXT OR SEARCH                                  │
+│    - First: Check if [当前 Task #N] is in the context            │
+│      If yes → use \`task_get #N\` directly, skip to step 1      │
+│    - If no taskId in context:                                    │
+│      Use \`task_list\` to search for existing related tasks      │
+│    - If found → reuse, extend, and update (see rules below)     │
+│    - If not found → proceed to step 1                           │
+└─────────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 1. CREATE (task_create) OR REUSE (task_get + task_update)       │
+│    - No existing task → Create new with title, desc, goals      │
+│    - Existing task → Reuse via task_get, then task_update:      │
+│      * Append new context to description (preserve old)         │
+│      * Add/extend goals_and_expected_deliverables               │
+│      * Create operation record documenting the continuation     │
 │    - Set priority (low/medium/high) and due date (if any)       │
 └─────────────────────────────────────────────────────────────────┘
                               ↓
@@ -387,6 +542,14 @@ Follow this lifecycle for every task:
 └─────────────────────────────────────────────────────────────────┘
 \`\`\`
 
+### Task Update Rules
+
+When reusing an existing task, you MUST follow these rules:
+
+1. **Append, don't replace** — When using \`task_update\`, the \`description\` and \`goals\` fields MUST **preserve existing content** and append new content after it.
+2. **Document the continuation** — Use \`task_operation_create\` to create an operation record explaining why the task is being continued and what new scope has been added.
+3. **Reset the status** — If the original task was completed, change status to \`active\` and reset progress to a reasonable value.
+
 ### Task Properties
 
 | Property | Description |
@@ -404,6 +567,12 @@ Follow this lifecycle for every task:
 
 **Before starting any task-related work, you MUST gather context:**
 
+**Step 0: Check for Task ID in Context**
+- If the system provides \`[当前 Task #N]\` in the context messages:
+  Use \`task_get #N\` directly — this is your confirmed task. **Skip searching.**
+- If no taskId is provided, use \`task_list\` to search for existing related tasks.
+
+**Then gather full context:**
 1. **Read task details**: Use \`task_get\` to read description, goals, status
 2. **Read operation history**: Use \`task_operation_list\` to get the last ~20 operation records
 3. **Read parent context** (if \`parent_task_id\` exists): Understand overall goal

package/dist/shared/@ai-setting/{roy-agent-core-1rzpnycm.js → roy-agent-core-d40gbvzj.js}

@@ -1,7 +1,7 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-2rtka82a.js";
+} from "./roy-agent-core-1a38hg1q.js";
 import {
   buildWorkflowNodeMetadata,
   getWorkflowNodeIdFromMetadata,
@@ -1923,7 +1923,8 @@ var init_engine = __esm(() => {
         this.failWorkflow(sessionState, error);
       });
       if (options?.sync !== false) {
-        return this.waitForCompletion(sessionId, options?.timeout);
+        const wfTimeout = options?.timeout ?? sessionState.config.timeout ?? undefined;
+        return this.waitForCompletion(sessionId, wfTimeout);
       }
       return { runId, status: "running" };
     }

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

@@ -13,6 +13,9 @@ function getEnvContextOrEmpty() {
 function hasEnvContext() {
   return envContextStorage.getStore() !== undefined;
 }
+function getCurrentTaskId() {
+  return envContextStorage.getStore()?.currentTaskId;
+}
 function runWithEnvContext(context, fn) {
   if (context) {
     return envContextStorage.run(context, fn);
@@ -44,14 +47,12 @@ function mergeEnvContext(partial) {
     Object.assign(current, partial);
   }
 }
+function setCurrentTaskId(taskId) {
+  mergeEnvContext({ currentTaskId: taskId });
+}
 var envContextStorage;
 var init_env_context = __esm(() => {
   envContextStorage = new AsyncLocalStorage;
 });
 
-// src/env/context/index.ts
-var init_context = __esm(() => {
-  init_env_context();
-});
-
-export { envContextStorage, getEnvContext, getEnvContextOrEmpty, hasEnvContext, runWithEnvContext, runWithEnvContextAsync, createEnvContext, mergeEnvContext, init_context };
+export { envContextStorage, getEnvContext, getEnvContextOrEmpty, hasEnvContext, getCurrentTaskId, runWithEnvContext, runWithEnvContextAsync, createEnvContext, mergeEnvContext, setCurrentTaskId, init_env_context };

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

@@ -8,12 +8,12 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-6e3wz81d.js";
+} from "./roy-agent-core-gfzqwb6v.js";
 import {
   ToolHookPoints,
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-rgj6hq15.js";
+} from "./roy-agent-core-nxf64fn4.js";
 import {
   createLogger,
   init_logger

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

@@ -3,11 +3,81 @@ import {
   init_logger
 } from "./roy-agent-core-10n2jh7p.js";
 import {
-  __require
+  __esm,
+  __export,
+  __require,
+  __toCommonJS
 } from "./roy-agent-core-fs0mn2jk.js";
 
+// src/env/task/storage/migrations/001_add_project_path_context.ts
+var exports_001_add_project_path_context = {};
+__export(exports_001_add_project_path_context, {
+  runMigration: () => runMigration
+});
+function runMigration(dbPath) {
+  console.log(`[Migration 001] Starting migration for: ${dbPath}`);
+  const db = createCompatibleDatabase(dbPath);
+  try {
+    try {
+      db.run(`ALTER TABLE task ADD COLUMN project_path TEXT`);
+      console.log(`[Migration 001] Added project_path column`);
+    } catch (e) {
+      if (e.message?.includes("duplicate column name")) {
+        console.log(`[Migration 001] project_path column already exists, skipping`);
+      } else {
+        throw e;
+      }
+    }
+    try {
+      db.run(`ALTER TABLE task ADD COLUMN context TEXT`);
+      console.log(`[Migration 001] Added context column`);
+    } catch (e) {
+      if (e.message?.includes("duplicate column name")) {
+        console.log(`[Migration 001] context column already exists, skipping`);
+      } else {
+        throw e;
+      }
+    }
+    console.log(`[Migration 001] Migration completed successfully`);
+  } finally {
+    db.close();
+  }
+}
+var init_001_add_project_path_context = __esm(() => {
+  init_sqlite_task_store();
+  if (false) {}
+});
+
+// src/env/task/storage/migrations/002_add_task_type.ts
+var exports_002_add_task_type = {};
+__export(exports_002_add_task_type, {
+  runMigration: () => runMigration2
+});
+function runMigration2(dbPath) {
+  console.log(`[Migration 002] Starting migration for: ${dbPath}`);
+  const db = createCompatibleDatabase(dbPath);
+  try {
+    try {
+      db.run(`ALTER TABLE task ADD COLUMN type TEXT NOT NULL DEFAULT 'normal'`);
+      console.log(`[Migration 002] Added type column`);
+    } catch (e) {
+      if (e.message?.includes("duplicate column name")) {
+        console.log(`[Migration 002] type column already exists, skipping`);
+      } else {
+        throw e;
+      }
+    }
+    console.log(`[Migration 002] Migration completed successfully`);
+  } finally {
+    db.close();
+  }
+}
+var init_002_add_task_type = __esm(() => {
+  init_sqlite_task_store();
+  if (false) {}
+});
+
 // src/env/task/storage/sqlite-task-store.ts
-init_logger();
 import { join } from "path";
 function getDatabaseClass() {
   if (typeof Bun !== "undefined") {
@@ -31,7 +101,6 @@ function createCompatibleDatabase(path) {
   }
   return db;
 }
-var logger = createLogger("task:store");
 function getDefaultDataDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
   return join(home, ".local", "share");
@@ -68,6 +137,7 @@ class SQLiteTaskStore {
         description TEXT DEFAULT '',
         status TEXT DEFAULT 'todo',
         priority TEXT DEFAULT 'medium',
+        type TEXT DEFAULT 'normal',
         progress INTEGER DEFAULT 0,
         current_status TEXT DEFAULT '',
         goals_and_expected_deliverables TEXT DEFAULT '',
@@ -114,6 +184,20 @@ class SQLiteTaskStore {
       )
     `);
     this.db.run("CREATE INDEX IF NOT EXISTS idx_task_tag_relation_tag_id ON task_tag_relation(tag_id)");
+    if (this.dbPath !== ":memory:") {
+      try {
+        const { runMigration: runMigration001 } = (init_001_add_project_path_context(), __toCommonJS(exports_001_add_project_path_context));
+        runMigration001(this.dbPath);
+      } catch (e) {
+        logger.warn(`[Migration 001] Failed to run: ${e.message}`);
+      }
+      try {
+        const { runMigration: runMigration002 } = (init_002_add_task_type(), __toCommonJS(exports_002_add_task_type));
+        runMigration002(this.dbPath);
+      } catch (e) {
+        logger.warn(`[Migration 002] Failed to run: ${e.message}`);
+      }
+    }
     this.initialized = true;
     logger.info(`TaskStore initialized at ${this.dbPath}`);
   }
@@ -121,12 +205,12 @@ class SQLiteTaskStore {
     await this.initialize();
     const now = Date.now();
     const stmt = this.db.prepare(`
-      INSERT INTO task (title, description, priority, parent_task_id, 
+      INSERT INTO task (title, description, priority, type, parent_task_id, 
         goals_and_expected_deliverables, due_date, tags, status, 
         current_status, created_at, updated_at, project_path, context)
-      VALUES (?, ?, ?, ?, ?, ?, ?, 'todo', '', ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'todo', '', ?, ?, ?, ?)
     `);
-    const result = stmt.run(options.title, options.description || "", options.priority || "medium", options.parent_task_id || null, options.goals_and_expected_deliverables || "", options.due_date || null, options.tags ? JSON.stringify(options.tags) : null, now, now, options.project_path, options.context);
+    const result = stmt.run(options.title, options.description || "", options.priority || "medium", options.type || "normal", options.parent_task_id || null, options.goals_and_expected_deliverables || "", options.due_date || null, options.tags ? JSON.stringify(options.tags) : null, now, now, options.project_path, options.context);
     const task = await this.getTask(result.lastInsertRowid);
     if (task) {
       this.tasksCache.set(task.id, task);
@@ -170,6 +254,10 @@ class SQLiteTaskStore {
       updates.push("priority = ?");
       values.push(options.priority);
     }
+    if (options.type !== undefined) {
+      updates.push("type = ?");
+      values.push(options.type);
+    }
     if (options.progress !== undefined) {
       updates.push("progress = ?");
       values.push(options.progress);
@@ -230,6 +318,10 @@ class SQLiteTaskStore {
       sql += " AND priority = ?";
       params.push(options.priority);
     }
+    if (options?.type) {
+      sql += " AND type = ?";
+      params.push(options.type);
+    }
     if (options?.parent_task_id !== undefined) {
       sql += " AND parent_task_id = ?";
       params.push(options.parent_task_id);
@@ -332,6 +424,7 @@ class SQLiteTaskStore {
       description: row.description,
       status: row.status,
       priority: row.priority,
+      type: row.type || "normal",
       progress: row.progress,
       current_status: row.current_status,
       goals_and_expected_deliverables: row.goals_and_expected_deliverables,
@@ -650,4 +743,14 @@ class SQLiteTaskStore {
     }
   }
 }
+var logger;
+var init_sqlite_task_store = __esm(() => {
+  init_logger();
+  logger = createLogger("task:store");
+});
+
+// src/env/task/storage/index.ts
+init_sqlite_task_store();
+init_sqlite_task_store();
+
 export { getDefaultDataDir, getDefaultTaskDbPath, SQLiteTaskStore };

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

@@ -11,7 +11,11 @@ import {
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-rgj6hq15.js";
+} from "./roy-agent-core-nxf64fn4.js";
+import {
+  init_env_context,
+  mergeEnvContext
+} from "./roy-agent-core-dre9rcs0.js";
 import {
   createLogger,
   init_logger
@@ -22,6 +26,7 @@ import {
 
 // src/env/task/delegate/delegate-tool.ts
 init_logger();
+init_env_context();
 init_decorator();
 import { z } from "zod";
 
@@ -115,7 +120,17 @@ var builtInSubAgents = [
 
 **IMPORTANT: Before starting any work, you MUST gather task context to avoid working with outdated or missing information.**
 
-1. **Read task details first**: Use \`task_get\` to read the task's:
+**Step 0: Check if task_id is already provided**
+- The session info above includes \`task_id\`.
+- **If task_id is provided** (not N/A or 0):
+  Use \`task_get\` with that task_id directly — this is your confirmed task.
+  **Skip any searching.** Read its details and operations.
+- **If no valid task_id** is provided:
+  Use the task description to guide your work.
+  Look for the task via \`task_list\` if needed.
+
+**Then gather full context:**
+1. **Read task details**: Use \`task_get\` to read the task's:
    - \`description\`: Detailed description of what needs to be done
    - \`goals_and_expected_deliverables\`: Clear success criteria and expected outputs
    - \`current_status\`: Current work progress
@@ -153,23 +168,7 @@ var builtInSubAgents = [
     name: "explore",
     mode: "subagent",
     description: "Fast agent specialized for exploring codebases, finding files, and searching for patterns.",
-    allowedTools: ["glob", "grep", "read", "bash"],
-    deniedTools: ["delegate_task", "stop_task"]
-  },
-  {
-    id: "file_agent",
-    name: "file_agent",
-    mode: "subagent",
-    description: "File operation expert, skilled at reading, writing, searching and organizing files.",
-    allowedTools: ["file_read", "file_write", "file_glob", "grep", "glob", "read"],
-    deniedTools: ["delegate_task", "stop_task"]
-  },
-  {
-    id: "web_search_agent",
-    name: "web_search_agent",
-    mode: "subagent",
-    description: "Web search expert, using Exa search engine to get latest information.",
-    allowedTools: ["exa_web_search_exa"],
+    allowedTools: ["read_file", "glob", "grep", "bash"],
     deniedTools: ["delegate_task", "stop_task"]
   }
 ];
@@ -207,12 +206,12 @@ var DelegateToolParameters = z.object({
   prompt: z.string().describe("The task for the agent to perform"),
   subagent_type: z.string().describe("The type of specialized agent to use for this task").default("general"),
   background: z.boolean().describe("Whether to run the task in background. If true, returns immediately and notifies when complete (default: false)").default(false),
-  timeout: z.number().describe("Task timeout in milliseconds. If set, task will be terminated after timeout (optional)").optional(),
+  timeout: z.number().describe("Task timeout in milliseconds. Default: 1200000 (20 minutes). If set, task will be terminated after timeout.").optional(),
   cleanup: z.enum(["delete", "keep"]).describe("Whether to delete sub session after completion. 'delete' removes the session, 'keep' retains it (default: keep)").default("keep").optional(),
   task_id: z.number().describe("Optional task ID to associate with this delegate task, for tracking in operation records").optional(),
   reason: z.string().describe("Brief reason for calling this tool (max 30 chars, e.g., 'Delegate refactor task')").optional()
 });
-var DEFAULT_TIMEOUT = 900000;
+var DEFAULT_TIMEOUT = 1200000;
 var PROGRESS_INTERVAL = 120000;
 
 class BackgroundTaskManager {
@@ -407,6 +406,7 @@ class BackgroundTaskManager {
         backgroundTaskId: taskId,
         subSessionId: task.subSessionId,
         parentSessionId,
+        description: task.description,
         status: task.status,
         progress: task.progress
       };
@@ -533,6 +533,18 @@ ${prompt}
     logger.info(`[BackgroundTaskManager] Disposed`);
   }
 }
+__legacyDecorateClassTS([
+  TracedAs("task.background.createTask", { recordParams: false, recordResult: true, log: true })
+], BackgroundTaskManager.prototype, "createTask", null);
+__legacyDecorateClassTS([
+  TracedAs("task.background.executeTask", { recordParams: true, recordResult: true, log: true })
+], BackgroundTaskManager.prototype, "executeTask", null);
+__legacyDecorateClassTS([
+  TracedAs("task.background.startProgressReporter", { recordParams: false, recordResult: true, log: true })
+], BackgroundTaskManager.prototype, "startProgressReporter", null);
+__legacyDecorateClassTS([
+  TracedAs("task.background.stopProgressReporter", { recordParams: false, recordResult: true, log: true })
+], BackgroundTaskManager.prototype, "stopProgressReporter", null);
 __legacyDecorateClassTS([
   TracedAs("delegate.executeWithAbort", { recordParams: true, recordResult: true, log: true })
 ], BackgroundTaskManager.prototype, "executeWithAbort", null);
@@ -722,9 +734,18 @@ ${prompt}
       role: "assistant",
       content: result
     });
+    let taskNotification = "";
+    if (taskId) {
+      taskNotification = `
+
+---
+\uD83D\uDCCB [委托任务完成] 已委托子智能体完成 Task #${taskId} 的处理工作，请知悉。可通过 task_get #${taskId} 查看最新状态。`;
+    }
+    mergeEnvContext({ currentTaskId: undefined });
+    logger.info(`[delegate_task.sync] Task completed, currentTaskId cleared from EnvContext${taskId ? ` (was: #${taskId})` : ""}`);
     return {
       success: true,
-      output: result + `
+      output: result + taskNotification + `
 
 ` + [
         "<task_metadata>",
@@ -739,6 +760,8 @@ ${prompt}
       }
     };
   } catch (error) {
+    mergeEnvContext({ currentTaskId: undefined });
+    logger.info(`[delegate_task.sync] Error occurred, currentTaskId cleared from EnvContext${taskId ? ` (was: #${taskId})` : ""}`);
     return {
       success: false,
       output: "",

package/dist/shared/@ai-setting/{roy-agent-core-6e3wz81d.js → roy-agent-core-gfzqwb6v.js}

@@ -1,9 +1,9 @@
 import {
   createHook
-} from "./roy-agent-core-vdwvamre.js";
+} from "./roy-agent-core-z3pq1nx9.js";
 import {
   HookManager
-} from "./roy-agent-core-rgj6hq15.js";
+} from "./roy-agent-core-nxf64fn4.js";
 
 // src/env/component.ts
 class BaseComponent {

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

@@ -1,13 +1,14 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-2rtka82a.js";
-import"./roy-agent-core-kzbj10gk.js";
+} from "./roy-agent-core-1a38hg1q.js";
+import"./roy-agent-core-n1awj8ks.js";
 import"./roy-agent-core-nhfy3p8q.js";
 import"./roy-agent-core-e25xkv53.js";
 import"./roy-agent-core-q5qj0fes.js";
-import"./roy-agent-core-rgj6hq15.js";
-import"./roy-agent-core-rm3hay00.js";
+import"./roy-agent-core-nxf64fn4.js";
+import"./roy-agent-core-8f8dq3kj.js";
+import"./roy-agent-core-dre9rcs0.js";
 import"./roy-agent-core-10n2jh7p.js";
 import"./roy-agent-core-58k274fg.js";
 import"./roy-agent-core-c6592r3c.js";

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

@@ -15,7 +15,7 @@ import {
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-rgj6hq15.js";
+} from "./roy-agent-core-nxf64fn4.js";
 import {
   createLogger,
   init_logger

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

@@ -1,7 +1,9 @@
 import {
-  getEnvContext,
   init_context
-} from "./roy-agent-core-rm3hay00.js";
+} from "./roy-agent-core-8f8dq3kj.js";
+import {
+  getEnvContext
+} from "./roy-agent-core-dre9rcs0.js";
 import {
   __esm
 } from "./roy-agent-core-fs0mn2jk.js";

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

@@ -10,12 +10,13 @@ import {
   tracedExtractStructuredJsonViaLlm,
   tracedRunWorkflowJsonOutputExtraction,
   unregisterWorkflowJsonOutputPlugin
-} from "./roy-agent-core-kzbj10gk.js";
+} from "./roy-agent-core-n1awj8ks.js";
 import"./roy-agent-core-nhfy3p8q.js";
 import"./roy-agent-core-e25xkv53.js";
 import"./roy-agent-core-q5qj0fes.js";
-import"./roy-agent-core-rgj6hq15.js";
-import"./roy-agent-core-rm3hay00.js";
+import"./roy-agent-core-nxf64fn4.js";
+import"./roy-agent-core-8f8dq3kj.js";
+import"./roy-agent-core-dre9rcs0.js";
 import"./roy-agent-core-10n2jh7p.js";
 import"./roy-agent-core-58k274fg.js";
 import"./roy-agent-core-c6592r3c.js";